diff options
Diffstat (limited to 'src')
69 files changed, 8415 insertions, 8523 deletions
diff --git a/src/libmdsserver/client-list.c b/src/libmdsserver/client-list.c index 19eaf5a..02d555e 100644 --- a/src/libmdsserver/client-list.c +++ b/src/libmdsserver/client-list.c @@ -27,7 +27,7 @@ * The default initial capacity */ #ifndef CLIENT_LIST_DEFAULT_INITIAL_CAPACITY -#define CLIENT_LIST_DEFAULT_INITIAL_CAPACITY 8 +# define CLIENT_LIST_DEFAULT_INITIAL_CAPACITY 8 #endif @@ -38,19 +38,19 @@ * @param value The value to be rounded up to a power of two * @return The nearest, but not smaller, power of two */ -__attribute__((const)) -static size_t to_power_of_two(size_t value) +static size_t __attribute__((const)) +to_power_of_two(size_t value) { - value -= 1; - value |= value >> 1; - value |= value >> 2; - value |= value >> 4; - value |= value >> 8; - value |= value >> 16; + value -= 1; + value |= value >> 1; + value |= value >> 2; + value |= value >> 4; + value |= value >> 8; + value |= value >> 16; #if SIZE_MAX == UINT64_MAX - value |= value >> 32; + value |= value >> 32; #endif - return value + 1; + return value + 1; } @@ -61,21 +61,22 @@ static size_t to_power_of_two(size_t value) * @param capacity The minimum initial capacity of the client list, 0 for default * @return Non-zero on error, `errno` will have been set accordingly */ -int client_list_create(client_list_t* restrict this, size_t capacity) +int +client_list_create(client_list_t *restrict this, size_t capacity) { - /* Use default capacity of zero is specified. */ - if (capacity == 0) - capacity = CLIENT_LIST_DEFAULT_INITIAL_CAPACITY; - - /* Initialise the client list. */ - this->capacity = capacity = to_power_of_two(capacity); - this->size = 0; - this->clients = NULL; - fail_if (xmalloc(this->clients, capacity, uint64_t)); - - return 0; - fail: - return -1; + /* Use default capacity of zero is specified. */ + if (!capacity) + capacity = CLIENT_LIST_DEFAULT_INITIAL_CAPACITY; + + /* Initialise the client list. */ + this->capacity = capacity = to_power_of_two(capacity); + this->size = 0; + this->clients = NULL; + fail_if (xmalloc(this->clients, capacity, uint64_t)); + + return 0; +fail: + return -1; } @@ -85,10 +86,11 @@ int client_list_create(client_list_t* restrict this, size_t capacity) * * @param this The client list */ -void client_list_destroy(client_list_t* restrict this) +void +client_list_destroy(client_list_t *restrict this) { - free(this->clients); - this->clients = NULL; + free(this->clients); + this->clients = NULL; } @@ -99,17 +101,18 @@ void client_list_destroy(client_list_t* restrict this) * @param out Memory slot in which to store the new client list * @return Non-zero on error, `errno` will have been set accordingly */ -int client_list_clone(const client_list_t* restrict this, client_list_t* restrict out) +int +client_list_clone(const client_list_t *restrict this, client_list_t *restrict out) { - fail_if (xmemdup(out->clients, this->clients, this->capacity, uint64_t)); - - out->capacity = this->capacity; - out->size = this->size; - - return 0; - - fail: - return -1; + fail_if (xmemdup(out->clients, this->clients, this->capacity, uint64_t)); + + out->capacity = this->capacity; + out->size = this->size; + + return 0; + +fail: + return -1; } @@ -120,23 +123,23 @@ int client_list_clone(const client_list_t* restrict this, client_list_t* restric * @param client The client to add * @return Non-zero on error, `errno` will be set accordingly */ -int client_list_add(client_list_t* restrict this, uint64_t client) +int +client_list_add(client_list_t *restrict this, uint64_t client) { - if (this->size == this->capacity) - { - uint64_t* old = this->clients; - if (xrealloc(old, this->capacity <<= 1, uint64_t)) - { - this->capacity >>= 1; - this->clients = old; - fail_if (1); + uint64_t* old; + if (this->size == this->capacity) { + old = this->clients; + if (xrealloc(old, this->capacity <<= 1, uint64_t)) { + this->capacity >>= 1; + this->clients = old; + fail_if (1); + } } - } - - this->clients[this->size++] = client; - return 0; - fail: - return -1; + + this->clients[this->size++] = client; + return 0; +fail: + return -1; } @@ -146,29 +149,27 @@ int client_list_add(client_list_t* restrict this, uint64_t client) * @param this The list * @param client The client to remove */ -void client_list_remove(client_list_t* restrict this, uint64_t client) +void +client_list_remove(client_list_t *restrict this, uint64_t client) { - size_t i; - for (i = 0; i < this->size; i++) - { - if (this->clients[i] == client) - { - size_t n = (--(this->size) - i) * sizeof(uint64_t); - memmove(this->clients + i, this->clients + i + 1, n); - - if (this->size << 1 <= this->capacity) - { - uint64_t* old = this->clients; - if (xrealloc(old, this->capacity >>= 1, uint64_t)) - { - this->capacity <<= 1; - this->clients = old; + size_t i, n; + uint64_t *old; + for (i = 0; i < this->size; i++) { + if (this->clients[i] == client) { + n = (--(this->size) - i) * sizeof(uint64_t); + memmove(this->clients + i, this->clients + i + 1, n); + + if (this->size << 1 <= this->capacity) { + old = this->clients; + if (xrealloc(old, this->capacity >>= 1, uint64_t)) { + this->capacity <<= 1; + this->clients = old; + } + } + + return; } - } - - return; } - } } @@ -178,9 +179,10 @@ void client_list_remove(client_list_t* restrict this, uint64_t client) * @param this The list * @return The number of bytes to allocate to the output buffer */ -size_t client_list_marshal_size(const client_list_t* restrict this) +size_t +client_list_marshal_size(const client_list_t *restrict this) { - return 2 * sizeof(size_t) + this->size * sizeof(uint64_t) + sizeof(int); + return 2 * sizeof(size_t) + this->size * sizeof(uint64_t) + sizeof(int); } @@ -190,13 +192,14 @@ size_t client_list_marshal_size(const client_list_t* restrict this) * @param this The list * @param data Output buffer for the marshalled data */ -void client_list_marshal(const client_list_t* restrict this, char* restrict data) +void +client_list_marshal(const client_list_t *restrict this, char *restrict data) { - buf_set_next(data, int, CLIENT_LIST_T_VERSION); - buf_set_next(data, size_t, this->capacity); - buf_set_next(data, size_t, this->size); - - memcpy(data, this->clients, this->size * sizeof(uint64_t)); + buf_set_next(data, int, CLIENT_LIST_T_VERSION); + buf_set_next(data, size_t, this->capacity); + buf_set_next(data, size_t, this->size); + + memcpy(data, this->clients, this->size * sizeof(uint64_t)); } @@ -208,21 +211,21 @@ void client_list_marshal(const client_list_t* restrict this, char* restrict data * @return Non-zero on error, `errno` will be set accordingly. * Destroy the list on error. */ -int client_list_unmarshal(client_list_t* restrict this, char* restrict data) +int +client_list_unmarshal(client_list_t *restrict this, char *restrict data) { - /* buf_get(data, int, 0, CLIENT_LIST_T_VERSION); */ - buf_next(data, int, 1); - - this->clients = NULL; - - buf_get_next(data, size_t, this->capacity); - buf_get_next(data, size_t, this->size); - - fail_if (xmalloc(this->clients, this->capacity, uint64_t)); - memcpy(this->clients, data, this->size * sizeof(uint64_t)); - - return 0; - fail: - return -1; -} + /* buf_get(data, int, 0, CLIENT_LIST_T_VERSION); */ + buf_next(data, int, 1); + + this->clients = NULL; + + buf_get_next(data, size_t, this->capacity); + buf_get_next(data, size_t, this->size); + fail_if (xmalloc(this->clients, this->capacity, uint64_t)); + memcpy(this->clients, data, this->size * sizeof(uint64_t)); + + return 0; +fail: + return -1; +} diff --git a/src/libmdsserver/client-list.h b/src/libmdsserver/client-list.h index 4d2bfa7..ffe828a 100644 --- a/src/libmdsserver/client-list.h +++ b/src/libmdsserver/client-list.h @@ -30,8 +30,7 @@ /** * Dynamic array of client ID:s */ -typedef struct client_list -{ +typedef struct client_list { /** * The size of the array */ @@ -46,7 +45,6 @@ typedef struct client_list * Stored client ID:s */ uint64_t *clients; - } client_list_t; diff --git a/src/libmdsserver/fd-table.c b/src/libmdsserver/fd-table.c index 1db2d87..fafaa65 100644 --- a/src/libmdsserver/fd-table.c +++ b/src/libmdsserver/fd-table.c @@ -31,29 +31,30 @@ * @param initial_capacity The initial capacity of the table * @return Non-zero on error, `errno` will have been set accordingly */ -int fd_table_create_tuned(fd_table_t* restrict this, size_t initial_capacity) +int +fd_table_create_tuned(fd_table_t *restrict this, size_t initial_capacity) { - size_t bitcap; - - this->capacity = initial_capacity ? initial_capacity : 1; - this->size = 0; - - this->values = NULL; - this->used = NULL; - this->value_comparator = NULL; - - /* It is important that both allocations are done with calloc: - `this->used` must set all keys as unused at the initial state, - `this->values` must be initialised for marshaling and it helps - the time overhead of `fd_table_contains_value`. */ - - bitcap = (this->capacity + 63) / 64; - fail_if (xcalloc(this->used, bitcap, size_t)); - fail_if (xcalloc(this->values, this->capacity, size_t)); - - return 0; - fail: - return -1; + size_t bitcap; + + this->capacity = initial_capacity ? initial_capacity : 1; + this->size = 0; + + this->values = NULL; + this->used = NULL; + this->value_comparator = NULL; + + /* It is important that both allocations are done with calloc: + `this->used` must set all keys as unused at the initial state, + `this->values` must be initialised for marshaling and it helps + the time overhead of `fd_table_contains_value`. */ + + bitcap = (this->capacity + 63) / 64; + fail_if (xcalloc(this->used, bitcap, size_t)); + fail_if (xcalloc(this->values, this->capacity, size_t)); + + return 0; +fail: + return -1; } @@ -65,20 +66,20 @@ int fd_table_create_tuned(fd_table_t* restrict this, size_t initial_capacity) * @param keys_freer Function that frees a key, `NULL` if keys should not be freed * @param values_freer Function that frees a value, `NULL` if value should not be freed */ -void fd_table_destroy(fd_table_t* restrict this, free_func* key_freer, free_func* value_freer) +void +fd_table_destroy(fd_table_t *restrict this, free_func *key_freer, free_func *value_freer) { - if (((key_freer != NULL) || (value_freer != NULL)) && (this->used != NULL) && (this->values != NULL)) - { - size_t i; - for (i = 0; i < this->capacity; i++) - if (this->used[i / 64] & ((uint64_t)1 << (i % 64))) - { - if (key_freer != NULL) key_freer(i); - if (value_freer != NULL) value_freer(this->values[i]); - } - } - free(this->values); - free(this->used); + size_t i; + if ((key_freer || value_freer) && this->used && this->values) { + for (i = 0; i < this->capacity; i++) { + if (this->used[i / 64] & ((uint64_t)1 << (i % 64))) { + if (key_freer) key_freer(i); + if (value_freer) value_freer(this->values[i]); + } + } + } + free(this->values); + free(this->used); } @@ -89,24 +90,22 @@ void fd_table_destroy(fd_table_t* restrict this, free_func* key_freer, free_func * @param value The value * @return Whether the value is stored in the table */ -int fd_table_contains_value(const fd_table_t* restrict this, size_t value) +int +fd_table_contains_value(const fd_table_t *restrict this, size_t value) { - size_t i; - if (this->value_comparator == NULL) - { - for (i = 0; i < this->capacity; i++) - if (this->values[i] == value) - if (this->used[i / 64] & ((uint64_t)1 << (i % 64))) - return 1; - } - else - { - for (i = 0; i < this->capacity; i++) - if (this->used[i / 64] & ((uint64_t)1 << (i % 64))) - if (this->value_comparator(this->values[i], value)) - return 1; - } - return 0; + size_t i; + if (!this->value_comparator) { + for (i = 0; i < this->capacity; i++) + if (this->values[i] == value) + if (this->used[i / 64] & ((uint64_t)1 << (i % 64))) + return 1; + } else { + for (i = 0; i < this->capacity; i++) + if (this->used[i / 64] & ((uint64_t)1 << (i % 64))) + if (this->value_comparator(this->values[i], value)) + return 1; + } + return 0; } @@ -117,9 +116,10 @@ int fd_table_contains_value(const fd_table_t* restrict this, size_t value) * @param key The key * @return Whether the key is used */ -int fd_table_contains_key(const fd_table_t* restrict this, int key) +int +fd_table_contains_key(const fd_table_t *restrict this, int key) { - return ((size_t)key < this->capacity) && (this->used[key / 64] & ((uint64_t)1 << (key % 64))); + return (size_t)key < this->capacity && (this->used[key / 64] & ((uint64_t)1 << (key % 64))); } @@ -130,11 +130,10 @@ int fd_table_contains_key(const fd_table_t* restrict this, int key) * @param key The key associated with the value * @return The value associated with the key, 0 if the key was not used */ -size_t fd_table_get(const fd_table_t* restrict this, int key) +size_t +fd_table_get(const fd_table_t *restrict this, int key) { - if (fd_table_contains_key(this, key) == 0) - return 0; - return this->values[key]; + return fd_table_contains_key(this, key) ? this->values[key] : 0; } @@ -147,55 +146,53 @@ size_t fd_table_get(const fd_table_t* restrict this, int key) * @return The previous value associated with the key, 0 if the key was not used. * 0 will also be returned on error, check the `errno` variable. */ -size_t fd_table_put(fd_table_t* restrict this, int key, size_t value) +size_t +fd_table_put(fd_table_t *restrict this, int key, size_t value) { - /* Override current value if the key is already used. */ - if (fd_table_contains_key(this, key)) - { - size_t rc = fd_table_get(this, key); - this->values[key] = value; - return rc; - } - - /* Grow the table if it is too small. */ - errno = 0; - if ((size_t)key >= this->capacity) - { - size_t* old_values = this->values; - size_t old_bitcap, new_bitcap; - if (xrealloc(this->values, this->capacity << 1, size_t)) - { - this->values = old_values; - fail_if (1); + size_t rc, old_bitcap, new_bitcap, *old_values; + uint64_t *old_used; + + /* Override current value if the key is already used. */ + if (fd_table_contains_key(this, key)) { + rc = fd_table_get(this, key); + this->values[key] = value; + return rc; } + + /* Grow the table if it is too small. */ + errno = 0; + if ((size_t)key >= this->capacity) { + old_values = this->values; + if (xrealloc(this->values, this->capacity << 1, size_t)) { + this->values = old_values; + fail_if (1); + } + + memset(this->values + this->capacity, 0, this->capacity * sizeof(size_t)); - memset(this->values + this->capacity, 0, this->capacity * sizeof(size_t)); - - old_bitcap = (this->capacity + 63) / 64; - this->capacity <<= 1; - new_bitcap = (this->capacity + 63) / 64; - - if (new_bitcap > old_bitcap) - { - uint64_t* old_used = this->used; - if (xrealloc(this->used, new_bitcap, size_t)) - { - this->used = old_used; - this->capacity >>= 1; - fail_if (1); - } - - memset(this->used + old_bitcap, 0, (new_bitcap - old_bitcap) * sizeof(uint64_t)); + old_bitcap = (this->capacity + 63) / 64; + this->capacity <<= 1; + new_bitcap = (this->capacity + 63) / 64; + + if (new_bitcap > old_bitcap) { + old_used = this->used; + if (xrealloc(this->used, new_bitcap, size_t)) { + this->used = old_used; + this->capacity >>= 1; + fail_if (1); + } + + memset(this->used + old_bitcap, 0, (new_bitcap - old_bitcap) * sizeof(uint64_t)); + } } - } - - /* Store the entry. */ - this->used[key / 64] |= (uint64_t)1 << (key % 64); - this->values[key] = value; - this->size++; - return 0; - fail: - return 0; + + /* Store the entry. */ + this->used[key / 64] |= (uint64_t)1 << (key % 64); + this->values[key] = value; + this->size++; + return 0; +fail: + return 0; } @@ -206,15 +203,15 @@ size_t fd_table_put(fd_table_t* restrict this, int key, size_t value) * @param key The key of the entry to remove * @return The previous value associated with the key, 0 if the key was not used */ -size_t fd_table_remove(fd_table_t* restrict this, int key) +size_t +fd_table_remove(fd_table_t *restrict this, int key) { - size_t rc = fd_table_get(this, key); - if (rc && fd_table_contains_key(this, key)) - { - this->used[key / 64] &= ~((uint64_t)1 << (key % 64)); - this->size--; - } - return rc; + size_t rc = fd_table_get(this, key); + if (rc && fd_table_contains_key(this, key)) { + this->used[key / 64] &= ~((uint64_t)1 << (key % 64)); + this->size--; + } + return rc; } @@ -223,12 +220,13 @@ size_t fd_table_remove(fd_table_t* restrict this, int key) * * @param this The fd table */ -void fd_table_clear(fd_table_t* restrict this) +void +fd_table_clear(fd_table_t *restrict this) { - size_t bitcap; - this->size = 0; - bitcap = (this->capacity + 63) / 64; - memset(this->used, 0, bitcap * sizeof(uint64_t)); + size_t bitcap; + this->size = 0; + bitcap = (this->capacity + 63) / 64; + memset(this->used, 0, bitcap * sizeof(uint64_t)); } @@ -238,10 +236,11 @@ void fd_table_clear(fd_table_t* restrict this) * @param this The fd table * @return The number of bytes to allocate to the output buffer */ -size_t fd_table_marshal_size(const fd_table_t* restrict this) +size_t +fd_table_marshal_size(const fd_table_t *restrict this) { - size_t bitcap = (this->capacity + 63) / 64; - return (this->capacity + 2) * sizeof(size_t) + bitcap * sizeof(uint64_t) + sizeof(int); + size_t bitcap = (this->capacity + 63) / 64; + return (this->capacity + 2) * sizeof(size_t) + bitcap * sizeof(uint64_t) + sizeof(int); } @@ -251,18 +250,19 @@ size_t fd_table_marshal_size(const fd_table_t* restrict this) * @param this The fd table * @param data Output buffer for the marshalled data */ -void fd_table_marshal(const fd_table_t* restrict this, char* restrict data) +void +fd_table_marshal(const fd_table_t *restrict this, char *restrict data) { - size_t bitcap = (this->capacity + 63) / 64; - - buf_set_next(data, int, FD_TABLE_T_VERSION); - buf_set_next(data, size_t, this->capacity); - buf_set_next(data, size_t, this->size); - - memcpy(data, this->values, this->capacity * sizeof(size_t)); - buf_next(data, size_t, this->capacity); - - memcpy(data, this->used, bitcap * sizeof(uint64_t)); + size_t bitcap = (this->capacity + 63) / 64; + + buf_set_next(data, int, FD_TABLE_T_VERSION); + buf_set_next(data, size_t, this->capacity); + buf_set_next(data, size_t, this->size); + + memcpy(data, this->values, this->capacity * sizeof(size_t)); + buf_next(data, size_t, this->capacity); + + memcpy(data, this->used, bitcap * sizeof(uint64_t)); } @@ -275,38 +275,38 @@ void fd_table_marshal(const fd_table_t* restrict this, char* restrict data) * @return Non-zero on error, `errno` will be set accordingly. * Destroy the table on error. */ -int fd_table_unmarshal(fd_table_t* restrict this, char* restrict data, remap_func* remapper) +int +fd_table_unmarshal(fd_table_t *restrict this, char *restrict data, remap_func *remapper) { - size_t bitcap; - size_t i; - - /* buf_get(data, int, 0, FD_TABLE_T_VERSION) */ - buf_next(data, int, 1); - - buf_get_next(data, size_t, this->capacity); - buf_get_next(data, size_t, this->size); - - this->values = NULL; - this->used = NULL; - this->value_comparator = NULL; - - fail_if (xmalloc(this->values, this->capacity, size_t)); - - bitcap = (this->capacity + 63) / 64; - fail_if (xmalloc(this->used, bitcap, size_t)); - - memcpy(this->values, data, this->capacity * sizeof(size_t)); - buf_next(data, size_t, this->capacity); - - memcpy(this->used, data, bitcap * sizeof(uint64_t)); - - if (remapper != NULL) - for (i = 0; i < this->capacity; i++) - if (this->used[i / 64] & ((uint64_t)1 << (i % 64))) - this->values[i] = remapper(this->values[i]); - - return 0; - fail: - return -1; -} + size_t bitcap; + size_t i; + + /* buf_get(data, int, 0, FD_TABLE_T_VERSION) */ + buf_next(data, int, 1); + + buf_get_next(data, size_t, this->capacity); + buf_get_next(data, size_t, this->size); + this->values = NULL; + this->used = NULL; + this->value_comparator = NULL; + + fail_if (xmalloc(this->values, this->capacity, size_t)); + + bitcap = (this->capacity + 63) / 64; + fail_if (xmalloc(this->used, bitcap, size_t)); + + memcpy(this->values, data, this->capacity * sizeof(size_t)); + buf_next(data, size_t, this->capacity); + + memcpy(this->used, data, bitcap * sizeof(uint64_t)); + + if (remapper) + for (i = 0; i < this->capacity; i++) + if (this->used[i / 64] & ((uint64_t)1 << (i % 64))) + this->values[i] = remapper(this->values[i]); + + return 0; +fail: + return -1; +} diff --git a/src/libmdsserver/fd-table.h b/src/libmdsserver/fd-table.h index e0b3a09..e484937 100644 --- a/src/libmdsserver/fd-table.h +++ b/src/libmdsserver/fd-table.h @@ -30,8 +30,7 @@ /** * Value lookup table optimised for file descriptors as keys */ -typedef struct fd_table -{ +typedef struct fd_table { /** * The table's capacity, i.e. how many entries that can be stored, * in total, before its internal table needs to grow @@ -61,7 +60,6 @@ typedef struct fd_table * Be aware, this variable cannot be marshalled */ compare_func *value_comparator; - } fd_table_t; diff --git a/src/libmdsserver/hash-list.h b/src/libmdsserver/hash-list.h index abcbb74..2087bce 100644 --- a/src/libmdsserver/hash-list.h +++ b/src/libmdsserver/hash-list.h @@ -34,7 +34,7 @@ * The default initial capacity */ #ifndef HASH_LIST_DEFAULT_INITIAL_CAPACITY -# define HASH_LIST_DEFAULT_INITIAL_CAPACITY 128 +# define HASH_LIST_DEFAULT_INITIAL_CAPACITY 128 #endif /** @@ -61,15 +61,15 @@ * that is, have the value `__VA_ARGS__`. */ #ifndef HASH_LIST_EXPECTED -# define HASH_LIST_EXPECTED(...) __builtin_expect((__VA_ARGS__), 1) +# define HASH_LIST_EXPECTED(...) __builtin_expect((__VA_ARGS__), 1) #endif -#define HASH_LIST_HASH(key) (this->hasher != NULL ? this->hasher(key) : (size_t)key) +#define HASH_LIST_HASH(key) (this->hasher ? this->hasher(key) : (size_t)key) -#define HASH_LIST_T_VERSION 0 +#define HASH_LIST_T_VERSION 0 /** @@ -105,7 +105,7 @@ typedef VALUE_T T##_value_t;\ * * @param entry The entry, will never be `NULL`, any only used entries will be passed */\ -typedef void T##_entry_free_func(struct T##_entry* entry);\ +typedef void T##_entry_free_func(struct T##_entry *entry);\ \ /** * Function-type for the function responsible for hashing keys @@ -134,7 +134,7 @@ static inline int T##_key_comparer(CKEY_T key_a, CKEY_T key_b);\ * @return The marshal-size of the entry's key and value */\ __attribute__((pure, nonnull))\ -static inline size_t T##_submarshal_size(const struct T##_entry* entry);\ +static inline size_t T##_submarshal_size(const struct T##_entry *entry);\ \ /** * Marshal an entry's key and value @@ -144,7 +144,7 @@ static inline size_t T##_submarshal_size(const struct T##_entry* entry);\ * @return The marshal-size of the entry's key and value */\ __attribute__((pure, nonnull))\ -static inline size_t T##_submarshal(const struct T##_entry* entry, char* restrict data);\ +static inline size_t T##_submarshal(const struct T##_entry *entry, char *restrict data);\ \ /** * Unmarshal an entry's key and value @@ -154,7 +154,7 @@ static inline size_t T##_submarshal(const struct T##_entry* entry, char* restric * @return The number of read bytes, zero on error */\ __attribute__((pure, nonnull))\ -static inline size_t T##_subunmarshal(struct T##_entry* entry, char* restrict data);\ +static inline size_t T##_subunmarshal(struct T##_entry *entry, char *restrict data);\ \ \ \ @@ -163,21 +163,21 @@ static inline size_t T##_subunmarshal(struct T##_entry* entry, char* restrict da */\ typedef struct T##_entry\ {\ - /** - * The key of the entry, `NULL` if the slot is unused - */\ - KEY_T key;\ - \ - /** - * Hash of `key`, undefined but initialised if the slot is unused - */\ - size_t key_hash;\ - \ - /** - * The value of the entry - */\ - T##_value_t value;\ - \ + /** + * The key of the entry, `NULL` if the slot is unused + */\ + KEY_T key;\ + \ + /** + * Hash of `key`, undefined but initialised if the slot is unused + */\ + size_t key_hash;\ + \ + /** + * The value of the entry + */\ + T##_value_t value;\ + \ } T##_entry_t;\ \ \ @@ -186,55 +186,55 @@ typedef struct T##_entry\ */\ typedef struct T\ {\ - /** - * The number of allocated slots - */\ - size_t allocated;\ - \ - /** - * The number of unused slot that - * has previously be used - */\ - size_t unused;\ - \ - /** - * The number of slots that have - * been used, even if no longer used - */\ - size_t used;\ - \ - /** - * This variable is used for optimisation, any - * time `hash_list_get` finds an element, its - * will be stored, and it will be the first - * inspected element by `hash_list_put` and - * `hash_list_remove` - */\ - size_t last;\ - \ - /** - * The slots - */\ - T##_entry_t* slots;\ - \ - /** - * Function used to free keys and values of entries - * - * The freeing is not used if this function pointer is `NULL` - * - * Be aware, this variable cannot be marshalled - */\ - T##_entry_free_func* freer;\ - \ - /** - * Function used to calculate the hash of a key - * - * If this function pointer is `NULL`, the identity hash is used - * - * Be aware, this variable cannot be marshalled - */\ - T##_key_hash_func* hasher;\ - \ + /** + * The number of allocated slots + */\ + size_t allocated;\ + \ + /** + * The number of unused slot that + * has previously be used + */\ + size_t unused;\ + \ + /** + * The number of slots that have + * been used, even if no longer used + */\ + size_t used;\ + \ + /** + * This variable is used for optimisation, any + * time `hash_list_get` finds an element, its + * will be stored, and it will be the first + * inspected element by `hash_list_put` and + * `hash_list_remove` + */\ + size_t last;\ + \ + /** + * The slots + */\ + T##_entry_t *slots;\ + \ + /** + * Function used to free keys and values of entries + * + * The freeing is not used if this function pointer is `NULL` + * + * Be aware, this variable cannot be marshalled + */\ + T##_entry_free_func *freer;\ + \ + /** + * Function used to calculate the hash of a key + * + * If this function pointer is `NULL`, the identity hash is used + * + * Be aware, this variable cannot be marshalled + */\ + T##_key_hash_func *hasher;\ + \ } T##_t;\ \ \ @@ -247,24 +247,24 @@ typedef struct T\ * @return Non-zero on error, `errno` will have been set accordingly */\ static inline int __attribute__((unused, nonnull))\ -T##_create(T##_t* restrict this, size_t capacity)\ +T##_create(T##_t *restrict this, size_t capacity)\ {\ - if (capacity == 0)\ - capacity = HASH_LIST_DEFAULT_INITIAL_CAPACITY;\ - \ - this->freer = NULL;\ - this->hasher = NULL;\ - this->allocated = 0;\ - this->unused = 0;\ - this->used = 0;\ - this->last = 0;\ - \ - this->slots = malloc(capacity * sizeof(T##_t));\ - if (this->slots == NULL)\ - return -1;\ - \ - this->allocated = capacity;\ - return 0;\ + if (!capacity)\ + capacity = HASH_LIST_DEFAULT_INITIAL_CAPACITY;\ + \ + this->freer = NULL;\ + this->hasher = NULL;\ + this->allocated = 0;\ + this->unused = 0;\ + this->used = 0;\ + this->last = 0;\ + \ + this->slots = malloc(capacity * sizeof(T##_t));\ + if (!this->slots)\ + return -1;\ + \ + this->allocated = capacity;\ + return 0;\ }\ \ \ @@ -274,19 +274,19 @@ T##_create(T##_t* restrict this, size_t capacity)\ * @param this The hash list */\ static inline void __attribute__((unused, nonnull))\ -T##_destroy(T##_t* restrict this)\ +T##_destroy(T##_t *restrict this)\ {\ - size_t i, n;\ - if (this->freer != NULL)\ - for (i = 0, n = this->used; i < n; i++)\ - if (this->slots[i].key)\ - this->freer(this->slots + i);\ - this->used = 0;\ - this->unused = 0;\ - this->allocated = 0;\ - this->last = 0;\ - free(this->slots);\ - this->slots = NULL;\ + size_t i, n;\ + if (this->freer)\ + for (i = 0, n = this->used; i < n; i++)\ + if (this->slots[i].key)\ + this->freer(this->slots + i);\ + this->used = 0;\ + this->unused = 0;\ + this->allocated = 0;\ + this->last = 0;\ + free(this->slots);\ + this->slots = NULL;\ }\ \ \ @@ -298,14 +298,14 @@ T##_destroy(T##_t* restrict this)\ * @return Non-zero on error, `errno` will have been set accordingly */\ static inline int __attribute__((unused, nonnull))\ -T##_clone(const T##_t* restrict this, T##_t* restrict out)\ +T##_clone(const T##_t *restrict this, T##_t *restrict out)\ {\ - if (T##_create(out, this->allocated) < 0)\ - return -1;\ - out->used = this->used;\ - out->unused = this->unused;\ - out->last = this->last;\ - memcpy(out->slots, this->slots, this->used * sizeof(T##_entry_t));\ + if (T##_create(out, this->allocated) < 0)\ + return -1;\ + out->used = this->used;\ + out->unused = this->unused;\ + out->last = this->last;\ + memcpy(out->slots, this->slots, this->used * sizeof(T##_entry_t));\ }\ \ \ @@ -321,32 +321,30 @@ T##_clone(const T##_t* restrict this, T##_t* restrict out)\ * been set accordingly. Errors are non-fatal. */\ static inline int __attribute__((unused, nonnull))\ -T##_pack(T##_t* restrict this)\ +T##_pack(T##_t *restrict this)\ {\ - size_t i, j, n;\ - T##_entry_t* slots = this->slots;\ - \ - if (this->unused > 0)\ - {\ - for (i = 0, j = 0, n = this->used; i < n; i++)\ - if (slots[i].key != NULL)\ - slots[j++] = slots[i];\ - \ - this->used -= this->unused;\ - this->unused = 0;\ - this->last = 0;\ - }\ - \ - if (this->used < this->allocated)\ - {\ - slots = realloc(slots, this->used * sizeof(T##_entry_t));\ - if (slots == NULL)\ - return -1;\ - this->slots = slots;\ - this->allocated = this->used;\ - }\ - \ - return 0;\ + size_t i, j, n;\ + T##_entry_t *slots = this->slots;\ + \ + if (this->unused > 0) {\ + for (i = 0, j = 0, n = this->used; i < n; i++)\ + if (slots[i].key)\ + slots[j++] = slots[i];\ + \ + this->used -= this->unused;\ + this->unused = 0;\ + this->last = 0;\ + }\ + \ + if (this->used < this->allocated) {\ + slots = realloc(slots, this->used * sizeof(T##_entry_t));\ + if (!slots)\ + return -1;\ + this->slots = slots;\ + this->allocated = this->used;\ + }\ + \ + return 0;\ }\ \ \ @@ -359,14 +357,14 @@ T##_pack(T##_t* restrict this)\ * @return Whether the key was found, error is impossible */\ static inline int __attribute__((unused, nonnull))\ -T##_get(T##_t* restrict this, CKEY_T key, T##_value_t* restrict value)\ +T##_get(T##_t *restrict this, CKEY_T key, T##_value_t *restrict value)\ {\ - size_t i, n, hash = HASH_LIST_HASH(key);\ - for (i = 0, n = this->used; i < n; i++)\ - if ((this->slots[i].key_hash == hash) && this->slots[i].key)\ - if (T##_key_comparer(this->slots[i].key, key))\ - return *value = this->slots[this->last = i].value, 1;\ - return this->last = 0, 0;\ + size_t i, n, hash = HASH_LIST_HASH(key);\ + for (i = 0, n = this->used; i < n; i++)\ + if (this->slots[i].key_hash == hash && this->slots[i].key)\ + if (T##_key_comparer(this->slots[i].key, key))\ + return *value = this->slots[this->last = i].value, 1;\ + return this->last = 0, 0;\ }\ \ \ @@ -377,39 +375,39 @@ T##_get(T##_t* restrict this, CKEY_T key, T##_value_t* restrict value)\ * @param key The key of the entry to remove, must not be `NULL` */\ static inline void __attribute__((unused, nonnull))\ -T##_remove(T##_t* restrict this, CKEY_T key)\ +T##_remove(T##_t *restrict this, CKEY_T key)\ {\ - size_t i = this->last, n, hash = HASH_LIST_HASH(key);\ - T##_entry_t* slots = this->slots;\ - \ - /* First, try cached index. */\ - if (HASH_LIST_EXPECTED(i && (slots[i].key_hash == hash) && (slots[i].key != NULL)))\ - if (HASH_LIST_EXPECTED(T##_key_comparer(slots[i].key, key)))\ - goto do_remove;\ - /* It is discouraged to use put or remove without - * doing a get before it, otherwise you do not know - * what is happening. So we do not expect to get - * get to the next line. However, if do not expect to - * run get before put or remove, you should modify the - * `HASH_LIST_EXPECTED` macro. However, this is single - * case where will will get to the next line, when the - * index of the item is zero. */\ - \ - /* Then, search. */\ - for (i = 0, n = this->used; i < n; i++)\ - if ((slots[i].key_hash == hash) && (slots[i].key != NULL))\ - if (T##_key_comparer(slots[i].key, key))\ - goto do_remove;\ - \ - return;\ - do_remove:\ - if (this->freer != NULL)\ - this->freer(slots + i);\ - slots[i].key = NULL;\ - this->unused++;\ - if ((this->unused >> 1) >= this->used)\ - T##_pack(this);\ - this->last = 0;\ + size_t i = this->last, n, hash = HASH_LIST_HASH(key);\ + T##_entry_t *slots = this->slots;\ + \ + /* First, try cached index. */\ + if (HASH_LIST_EXPECTED(i && slots[i].key_hash == hash && slots[i].key))\ + if (HASH_LIST_EXPECTED(T##_key_comparer(slots[i].key, key)))\ + goto do_remove;\ + /* It is discouraged to use put or remove without + * doing a get before it, otherwise you do not know + * what is happening. So we do not expect to get + * get to the next line. However, if do not expect to + * run get before put or remove, you should modify the + * `HASH_LIST_EXPECTED` macro. However, this is single + * case where will will get to the next line, when the + * index of the item is zero. */\ + \ + /* Then, search. */\ + for (i = 0, n = this->used; i < n; i++)\ + if (slots[i].key_hash == hash && slots[i].key)\ + if (T##_key_comparer(slots[i].key, key))\ + goto do_remove;\ + \ + return;\ +do_remove:\ + if (this->freer)\ + this->freer(slots + i);\ + slots[i].key = NULL;\ + this->unused++;\ + if (this->unused >> 1 >= this->used)\ + T##_pack(this);\ + this->last = 0;\ }\ \ \ @@ -423,66 +421,66 @@ T##_remove(T##_t* restrict this, CKEY_T key)\ * @return Non-zero on error, `errno` will have been set accordingly */\ static inline int __attribute__((unused, nonnull(1, 2)))\ -T##_put(T##_t* restrict this, KEY_T key, const T##_value_t* restrict value)\ +T##_put(T##_t *restrict this, KEY_T key, const T##_value_t *restrict value)\ {\ - size_t i = this->last, n, empty = this->used, hash;\ - T##_entry_t* slots = this->slots;\ - \ - /* Remove entry if no value is passed. */\ - if (value == NULL)\ - {\ - T##_remove(this, key);\ - return 0;\ - }\ - \ - /* Hash the input key. */\ - hash = HASH_LIST_HASH(key);\ - \ - /* Try cached index. */\ - if (HASH_LIST_EXPECTED(i && (slots[i].key != NULL)))\ - if (HASH_LIST_EXPECTED(slots[i].key_hash == hash))\ - if (HASH_LIST_EXPECTED(T##_key_comparer(slots[i].key, key)))\ - goto put;\ - /* It is discouraged to use put or remove without - * doing a get before it, otherwise you do not know - * what is happening. So we do not expect to get - * get to the next line. However, if do not expect to - * run get before put or remove, you should modify the - * `HASH_LIST_EXPECTED` macro. However, this is single - * case where will will get to the next line, when the - * index of the item is zero. */\ - \ - /* Find an unused slot or the current slot. */\ - for (i = 0, n = this->used; i < n; i++)\ - if (slots[i].key == NULL)\ - empty = i;\ - else if (slots[i].key_hash == hash)\ - if (T##_key_comparer(slots[i].key, key))\ - goto put;\ - \ - /* Grow slot allocation is required. */\ - if (empty == this->allocated)\ - {\ - if (empty >= SIZE_MAX >> 1)\ - return errno = ENOMEM, -1;\ - slots = realloc(slots, (empty << 1) * sizeof(T##_entry_t));\ - if (slots == NULL)\ - return -1;\ - this->slots = slots;\ - this->allocated <<= 1;\ - }\ - \ - /* Store entry. */\ - i = empty;\ - goto put_no_free;\ - put:\ - if (this->freer != NULL)\ - this->freer(slots + i);\ - put_no_free:\ - slots[i].key = key;\ - slots[i].key_hash = hash;\ - slots[i].value = *value;\ - return 0;\ + size_t i = this->last, n, empty = this->used, hash;\ + T##_entry_t* slots = this->slots;\ + \ + /* Remove entry if no value is passed. */\ + if (!value) {\ + T##_remove(this, key);\ + return 0;\ + }\ + \ + /* Hash the input key. */\ + hash = HASH_LIST_HASH(key);\ + \ + /* Try cached index. */\ + if (HASH_LIST_EXPECTED(i && slots[i].key))\ + if (HASH_LIST_EXPECTED(slots[i].key_hash == hash))\ + if (HASH_LIST_EXPECTED(T##_key_comparer(slots[i].key, key)))\ + goto put;\ + /* It is discouraged to use put or remove without + * doing a get before it, otherwise you do not know + * what is happening. So we do not expect to get + * get to the next line. However, if do not expect to + * run get before put or remove, you should modify the + * `HASH_LIST_EXPECTED` macro. However, this is single + * case where will will get to the next line, when the + * index of the item is zero. */\ + \ + /* Find an unused slot or the current slot. */\ + for (i = 0, n = this->used; i < n; i++) {\ + if (!slots[i].key) {\ + empty = i;\ + } else if (slots[i].key_hash == hash) {\ + if (T##_key_comparer(slots[i].key, key))\ + goto put;\ + }\ + }\ + \ + /* Grow slot allocation is required. */\ + if (empty == this->allocated) {\ + if (empty >= SIZE_MAX >> 1)\ + return errno = ENOMEM, -1;\ + slots = realloc(slots, (empty << 1) * sizeof(T##_entry_t));\ + if (!slots)\ + return -1;\ + this->slots = slots;\ + this->allocated <<= 1;\ + }\ + \ + /* Store entry. */\ + i = empty;\ + goto put_no_free;\ +put:\ + if (this->freer)\ + this->freer(slots + i);\ +put_no_free:\ + slots[i].key = key;\ + slots[i].key_hash = hash;\ + slots[i].value = *value;\ + return 0;\ }\ \ \ @@ -493,14 +491,14 @@ T##_put(T##_t* restrict this, KEY_T key, const T##_value_t* restrict value)\ * @return The number of bytes to allocate to the output buffer */\ static inline size_t __attribute__((unused, pure, nonnull))\ -T##_marshal_size(const T##_t* restrict this)\ +T##_marshal_size(const T##_t *restrict this)\ {\ - size_t i, n = this->used;\ - size_t rc = sizeof(int) + 4 * sizeof(size_t);\ - for (i = 0; i < n; i++)\ - if (this->slots[i].key != NULL)\ - rc += T##_submarshal_size(this->slots + i);\ - return rc + n * sizeof(char) + (n - this->unused) * sizeof(size_t);\ + size_t i, n = this->used;\ + size_t rc = sizeof(int) + 4 * sizeof(size_t);\ + for (i = 0; i < n; i++)\ + if (this->slots[i].key)\ + rc += T##_submarshal_size(this->slots + i);\ + return rc + n * sizeof(char) + (n - this->unused) * sizeof(size_t);\ }\ \ \ @@ -511,26 +509,26 @@ T##_marshal_size(const T##_t* restrict this)\ * @param data Output buffer for the marshalled data */\ static inline void __attribute__((unused, nonnull))\ -T##_marshal(const T##_t* restrict this, char* restrict data)\ +T##_marshal(const T##_t *restrict this, char *restrict data)\ {\ - size_t wrote, i, n = this->used;\ - \ - buf_set_next(data, int, HASH_LIST_T_VERSION);\ - buf_set_next(data, size_t, this->allocated);\ - buf_set_next(data, size_t, this->unused);\ - buf_set_next(data, size_t, this->used);\ - buf_set_next(data, size_t, this->last);\ - \ - for (i = 0; i < n; i++)\ - if (this->slots[i].key != NULL)\ - {\ - buf_set_next(data, char, 1);\ - buf_set_next(data, size_t, this->slots[i].key_hash);\ - wrote = T##_submarshal(this->slots + i, data);\ - data += wrote / sizeof(char);\ - }\ - else\ - buf_set_next(data, char, 0);\ + size_t wrote, i, n = this->used;\ + \ + buf_set_next(data, int, HASH_LIST_T_VERSION);\ + buf_set_next(data, size_t, this->allocated);\ + buf_set_next(data, size_t, this->unused);\ + buf_set_next(data, size_t, this->used);\ + buf_set_next(data, size_t, this->last);\ + \ + for (i = 0; i < n; i++) {\ + if (this->slots[i].key) {\ + buf_set_next(data, char, 1);\ + buf_set_next(data, size_t, this->slots[i].key_hash);\ + wrote = T##_submarshal(this->slots + i, data);\ + data += wrote / sizeof(char);\ + } else {\ + buf_set_next(data, char, 0);\ + }\ + }\ }\ \ \ @@ -543,39 +541,38 @@ T##_marshal(const T##_t* restrict this, char* restrict data)\ * Destroy the table on error. */\ static inline int __attribute__((unused, nonnull))\ -T##_unmarshal(T##_t* restrict this, char* restrict data)\ +T##_unmarshal(T##_t *restrict this, char *restrict data)\ {\ - size_t i, n, got;\ - char used;\ - \ - this->freer = NULL;\ - this->hasher = NULL;\ - \ - /* buf_get(data, int, 0, HASH_LIST_T_VERSION); */\ - buf_next(data, int, 1);\ - \ - buf_get_next(data, size_t, this->allocated);\ - buf_get_next(data, size_t, this->unused);\ - buf_get_next(data, size_t, this->used);\ - buf_get_next(data, size_t, this->last);\ - \ - this->slots = calloc(this->allocated, sizeof(T##_entry_t));\ - if (this->slots == NULL)\ - return -1;\ - \ - for (i = 0, n = this->used; i < n; i++)\ - {\ - buf_get_next(data, char, used);\ - if (used == 0)\ - continue;\ - buf_set_next(data, size_t, this->slots[i].key_hash);\ - got = T##_subunmarshal(this->slots + i, data);\ - if (got == 0)\ - return -1;\ - data += got / sizeof(char);\ - }\ - \ - return 0;\ + size_t i, n, got;\ + char used;\ + \ + this->freer = NULL;\ + this->hasher = NULL;\ + \ + /* buf_get(data, int, 0, HASH_LIST_T_VERSION); */\ + buf_next(data, int, 1);\ + \ + buf_get_next(data, size_t, this->allocated);\ + buf_get_next(data, size_t, this->unused);\ + buf_get_next(data, size_t, this->used);\ + buf_get_next(data, size_t, this->last);\ + \ + this->slots = calloc(this->allocated, sizeof(T##_entry_t));\ + if (!this->slots)\ + return -1;\ + \ + for (i = 0, n = this->used; i < n; i++) {\ + buf_get_next(data, char, used);\ + if (!used)\ + continue;\ + buf_set_next(data, size_t, this->slots[i].key_hash);\ + got = T##_subunmarshal(this->slots + i, data);\ + if (!got)\ + return -1;\ + data += got / sizeof(char);\ + }\ + \ + return 0;\ } @@ -586,9 +583,9 @@ T##_unmarshal(T##_t* restrict this, char* restrict data)\ * @param i:size_t The variable to store the buckey index in at each iteration * @param entry:hash_list_enty_t* The variable to store the entry in at each iteration */ -#define foreach_hash_list_entry(this, i, entry) \ - for (i = 0; i < (this).used; i++) \ - if (entry = (this).slots, entry->key != NULL) +#define foreach_hash_list_entry(this, i, entry)\ + for (i = 0; i < (this).used; i++)\ + if ((entry = (this).slots)->key) #endif diff --git a/src/libmdsserver/hash-table.c b/src/libmdsserver/hash-table.c index 000bd20..2a7bc3c 100644 --- a/src/libmdsserver/hash-table.c +++ b/src/libmdsserver/hash-table.c @@ -31,8 +31,8 @@ * @param K The key * @param H The hash of the key */ -#define TEST_KEY(T, B, K, H) \ - ((B->key == K) || (T->key_comparator && (B->hash == H) && T->key_comparator(B->key, K))) +#define TEST_KEY(T, B, K, H)\ + ((B)->key == (K) || ((T)->key_comparator && (B)->hash == (H) && (T)->key_comparator((B)->key, (K)))) /** @@ -42,10 +42,10 @@ * @param key The key to hash * @return The hash of the key */ -__attribute__((pure, nonnull)) -static inline size_t hash(const hash_table_t* restrict this, size_t key) +static inline size_t __attribute__((pure, nonnull)) +hash(const hash_table_t *restrict this, size_t key) { - return this->hasher ? this->hasher(key) : key; + return this->hasher ? this->hasher(key) : key; } @@ -56,10 +56,10 @@ static inline size_t hash(const hash_table_t* restrict this, size_t key) * @param key The key to hash * @return A non-negative value less the the table's capacity */ -__attribute__((pure, nonnull)) -static inline size_t truncate_hash(const hash_table_t* restrict this, size_t hash) +static inline size_t __attribute__((pure, nonnull)) +truncate_hash(const hash_table_t *restrict this, size_t hash) { - return hash % this->capacity; + return hash % this->capacity; } @@ -69,49 +69,42 @@ static inline size_t truncate_hash(const hash_table_t* restrict this, size_t has * @param this The hash table * @return Non-zero on error, `errno` will be set accordingly */ -__attribute__((nonnull)) -static int rehash(hash_table_t* restrict this) +static int __attribute__((nonnull)) +rehash(hash_table_t *restrict this) { - hash_entry_t** old_buckets = this->buckets; - size_t old_capacity = this->capacity; - size_t i = old_capacity, index; - hash_entry_t* bucket; - hash_entry_t* destination; - hash_entry_t* next; - - fail_if (xcalloc(this->buckets, old_capacity * 2 + 1, hash_entry_t*)); - this->capacity = old_capacity * 2 + 1; - this->threshold = (size_t)((float)(this->capacity) * this->load_factor); - - while (i) - { - bucket = this->buckets[--i]; - while (bucket) - { - index = truncate_hash(this, bucket->hash); - if ((destination = this->buckets[index])) - { - next = destination->next; - while (next) - { - destination = next; - next = destination->next; + hash_entry_t **old_buckets = this->buckets; + size_t old_capacity = this->capacity; + size_t i = old_capacity, index; + hash_entry_t *bucket; + hash_entry_t *destination; + hash_entry_t *next; + + fail_if (xcalloc(this->buckets, old_capacity * 2 + 1, hash_entry_t*)); + this->capacity = old_capacity * 2 + 1; + this->threshold = (size_t)((float)(this->capacity) * this->load_factor); + + while (i--) { + bucket = this->buckets[i]; + while (bucket) { + index = truncate_hash(this, bucket->hash); + if ((destination = this->buckets[index])) { + while ((next = destination->next)) + destination = next; + destination->next = bucket; + } else { + this->buckets[index] = bucket; + } + + next = bucket->next; + bucket->next = NULL; + bucket = next; } - destination->next = bucket; - } - else - this->buckets[index] = bucket; - - next = bucket->next; - bucket->next = NULL; - bucket = next; } - } - - free(old_buckets); - return 0; - fail: - return -1; + + free(old_buckets); + return 0; +fail: + return -1; } @@ -123,22 +116,23 @@ static int rehash(hash_table_t* restrict this) * @param load_factor The load factor of the table, i.e. when to grow the table * @return Non-zero on error, `errno` will have been set accordingly */ -int hash_table_create_fine_tuned(hash_table_t* restrict this, size_t initial_capacity, float load_factor) +int +hash_table_create_fine_tuned(hash_table_t *restrict this, size_t initial_capacity, float load_factor) { - this->buckets = NULL; - - this->capacity = initial_capacity ? initial_capacity : 1; - fail_if (xcalloc(this->buckets, this->capacity, hash_entry_t*)); - this->load_factor = load_factor; - this->threshold = (size_t)((float)(this->capacity) * load_factor); - this->size = 0; - this->value_comparator = NULL; - this->key_comparator = NULL; - this->hasher = NULL; - - return 0; - fail: - return -1; + this->buckets = NULL; + + this->capacity = initial_capacity ? initial_capacity : 1; + fail_if (xcalloc(this->buckets, this->capacity, hash_entry_t*)); + this->load_factor = load_factor; + this->threshold = (size_t)((float)(this->capacity) * load_factor); + this->size = 0; + this->value_comparator = NULL; + this->key_comparator = NULL; + this->hasher = NULL; + + return 0; +fail: + return -1; } @@ -150,27 +144,24 @@ int hash_table_create_fine_tuned(hash_table_t* restrict this, size_t initial_cap * @param keys_freer Function that frees a key, `NULL` if keys should not be freed * @param values_freer Function that frees a value, `NULL` if value should not be freed */ -void hash_table_destroy(hash_table_t* restrict this, free_func* key_freer, free_func* value_freer) +void +hash_table_destroy(hash_table_t *restrict this, free_func *key_freer, free_func *value_freer) { - size_t i = this->capacity; - hash_entry_t* bucket; - hash_entry_t* last; - - if (this->buckets != NULL) - { - while (i) - { - bucket = this->buckets[--i]; - while (bucket) - { - if (key_freer != NULL) key_freer(bucket->key); - if (value_freer != NULL) value_freer(bucket->value); - bucket = (last = bucket)->next; - free(last); - } + size_t i = this->capacity; + hash_entry_t *bucket, *last; + + if (this->buckets) { + while (i) { + bucket = this->buckets[--i]; + while (bucket) { + if (key_freer) key_freer(bucket->key); + if (value_freer) value_freer(bucket->value); + bucket = (last = bucket)->next; + free(last); + } + } + free(this->buckets); } - free(this->buckets); - } } @@ -181,25 +172,24 @@ void hash_table_destroy(hash_table_t* restrict this, free_func* key_freer, free_ * @param value The value * @return Whether the value is stored in the table */ -int hash_table_contains_value(const hash_table_t* restrict this, size_t value) +int +hash_table_contains_value(const hash_table_t *restrict this, size_t value) { - size_t i = this->capacity; - hash_entry_t* restrict bucket; - - while (i) - { - bucket = this->buckets[--i]; - while (bucket != NULL) - { - if (bucket->value == value) - return 1; - if (this->value_comparator && this->value_comparator(bucket->value, value)) - return 1; - bucket = bucket->next; + size_t i = this->capacity; + hash_entry_t *restrict bucket; + + while (i--) { + bucket = this->buckets[i]; + while (bucket) { + if (bucket->value == value) + return 1; + if (this->value_comparator && this->value_comparator(bucket->value, value)) + return 1; + bucket = bucket->next; + } } - } - - return 0; + + return 0; } @@ -210,20 +200,20 @@ int hash_table_contains_value(const hash_table_t* restrict this, size_t value) * @param key The key * @return Whether the key is used */ -int hash_table_contains_key(const hash_table_t* restrict this, size_t key) +int +hash_table_contains_key(const hash_table_t *restrict this, size_t key) { - size_t key_hash = hash(this, key); - size_t index = truncate_hash(this, key_hash); - hash_entry_t* restrict bucket = this->buckets[index]; - - while (bucket) - { - if (TEST_KEY(this, bucket, key, key_hash)) - return 1; - bucket = bucket->next; - } - - return 0; + size_t key_hash = hash(this, key); + size_t index = truncate_hash(this, key_hash); + hash_entry_t *restrict bucket = this->buckets[index]; + + while (bucket) { + if (TEST_KEY(this, bucket, key, key_hash)) + return 1; + bucket = bucket->next; + } + + return 0; } @@ -234,20 +224,20 @@ int hash_table_contains_key(const hash_table_t* restrict this, size_t key) * @param key The key associated with the value * @return The value associated with the key, 0 if the key was not used */ -size_t hash_table_get(const hash_table_t* restrict this, size_t key) +size_t +hash_table_get(const hash_table_t *restrict this, size_t key) { - size_t key_hash = hash(this, key); - size_t index = truncate_hash(this, key_hash); - hash_entry_t* restrict bucket = this->buckets[index]; - - while (bucket) - { - if (TEST_KEY(this, bucket, key, key_hash)) - return bucket->value; - bucket = bucket->next; - } - - return 0; + size_t key_hash = hash(this, key); + size_t index = truncate_hash(this, key_hash); + hash_entry_t *restrict bucket = this->buckets[index]; + + while (bucket) { + if (TEST_KEY(this, bucket, key, key_hash)) + return bucket->value; + bucket = bucket->next; + } + + return 0; } @@ -258,20 +248,20 @@ size_t hash_table_get(const hash_table_t* restrict this, size_t key) * @param key The key associated with the value * @return The entry associated with the key, `NULL` if the key was not used */ -hash_entry_t* hash_table_get_entry(const hash_table_t* restrict this, size_t key) +hash_entry_t * +hash_table_get_entry(const hash_table_t *restrict this, size_t key) { - size_t key_hash = hash(this, key); - size_t index = truncate_hash(this, key_hash); - hash_entry_t* restrict bucket = this->buckets[index]; - - while (bucket) - { - if (TEST_KEY(this, bucket, key, key_hash)) - return bucket; - bucket = bucket->next; - } - - return NULL; + size_t key_hash = hash(this, key); + size_t index = truncate_hash(this, key_hash); + hash_entry_t *restrict bucket = this->buckets[index]; + + while (bucket) { + if (TEST_KEY(this, bucket, key, key_hash)) + return bucket; + bucket = bucket->next; + } + + return NULL; } @@ -284,41 +274,41 @@ hash_entry_t* hash_table_get_entry(const hash_table_t* restrict this, size_t key * @return The previous value associated with the key, 0 if the key was not used. * 0 will also be returned on error, check the `errno` variable. */ -size_t hash_table_put(hash_table_t* restrict this, size_t key, size_t value) +size_t +hash_table_put(hash_table_t *restrict this, size_t key, size_t value) { - size_t key_hash = hash(this, key); - size_t index = truncate_hash(this, key_hash); - hash_entry_t* restrict bucket = this->buckets[index]; - size_t rc; - - while (bucket) - if (TEST_KEY(this, bucket, key, key_hash)) - { - rc = bucket->value; + size_t key_hash = hash(this, key); + size_t index = truncate_hash(this, key_hash); + hash_entry_t *restrict bucket = this->buckets[index]; + size_t rc; + + while (bucket) { + if (TEST_KEY(this, bucket, key, key_hash)) { + rc = bucket->value; + bucket->value = value; + return rc; + } else { + bucket = bucket->next; + } + } + + if (++(this->size) > this->threshold) { + errno = 0; + fail_if (rehash(this)); + index = truncate_hash(this, key_hash); + } + + errno = 0; + fail_if (xmalloc(bucket, 1, hash_entry_t)); bucket->value = value; - return rc; - } - else - bucket = bucket->next; - - if (++(this->size) > this->threshold) - { - errno = 0; - fail_if (rehash(this)); - index = truncate_hash(this, key_hash); - } - - errno = 0; - fail_if (xmalloc(bucket, 1, hash_entry_t)); - bucket->value = value; - bucket->key = key; - bucket->hash = key_hash; - bucket->next = this->buckets[index]; - this->buckets[index] = bucket; - - return 0; - fail: - return 0; + bucket->key = key; + bucket->hash = key_hash; + bucket->next = this->buckets[index]; + this->buckets[index] = bucket; + + return 0; +fail: + return 0; } @@ -329,32 +319,31 @@ size_t hash_table_put(hash_table_t* restrict this, size_t key, size_t value) * @param key The key of the entry to remove * @return The previous value associated with the key, 0 if the key was not used */ -size_t hash_table_remove(hash_table_t* restrict this, size_t key) +size_t +hash_table_remove(hash_table_t *restrict this, size_t key) { - size_t key_hash = hash(this, key); - size_t index = truncate_hash(this, key_hash); - hash_entry_t* bucket = this->buckets[index]; - hash_entry_t* last = NULL; - size_t rc; - - while (bucket) - { - if (TEST_KEY(this, bucket, key, key_hash)) - { - if (last == NULL) - this->buckets[index] = bucket->next; - else - last->next = bucket->next; - this->size--; - rc = bucket->value; - free(bucket); - return rc; + size_t key_hash = hash(this, key); + size_t index = truncate_hash(this, key_hash); + hash_entry_t *bucket = this->buckets[index]; + hash_entry_t *last = NULL; + size_t rc; + + while (bucket) { + if (TEST_KEY(this, bucket, key, key_hash)) { + if (!last) + this->buckets[index] = bucket->next; + else + last->next = bucket->next; + this->size--; + rc = bucket->value; + free(bucket); + return rc; + } + last = bucket; + bucket = bucket->next; } - last = bucket; - bucket = bucket->next; - } - - return 0; + + return 0; } @@ -363,32 +352,29 @@ size_t hash_table_remove(hash_table_t* restrict this, size_t key) * * @param this The hash table */ -void hash_table_clear(hash_table_t* restrict this) +void +hash_table_clear(hash_table_t *restrict this) { - hash_entry_t** buf; - hash_entry_t* bucket; - size_t i, ptr; - - if (this->size) - { - buf = alloca((this->size + 1) * sizeof(hash_entry_t*)); - i = this->capacity; - while (i) - { - bucket = this->buckets[--i]; - ptr = 0; - buf[ptr++] = bucket; - while (bucket) - { - bucket = bucket->next; - buf[ptr++] = bucket; - } - while (ptr) - free(buf[--ptr]); - this->buckets[i] = NULL; + hash_entry_t **buf, *bucket; + size_t i, ptr; + + if (this->size) { + buf = alloca((this->size + 1) * sizeof(hash_entry_t*)); + i = this->capacity; + while (i--) { + bucket = this->buckets[i]; + ptr = 0; + buf[ptr++] = bucket; + while (bucket) { + bucket = bucket->next; + buf[ptr++] = bucket; + } + while (ptr) + free(buf[--ptr]); + this->buckets[i] = NULL; + } + this->size = 0; } - this->size = 0; - } } @@ -398,23 +384,23 @@ void hash_table_clear(hash_table_t* restrict this) * @param this The hash table * @return The number of bytes to allocate to the output buffer */ -size_t hash_table_marshal_size(const hash_table_t* restrict this) +size_t +hash_table_marshal_size(const hash_table_t *restrict this) { - size_t n = this->capacity; - size_t rc = 3 * sizeof(size_t) + sizeof(float) + n * sizeof(size_t); - size_t i, m = 0; - - for (i = 0; i < n; i++) - { - hash_entry_t* restrict bucket = this->buckets[i]; - while (bucket != NULL) - { - bucket = bucket->next; - m++; + size_t n = this->capacity; + size_t rc = 3 * sizeof(size_t) + sizeof(float) + n * sizeof(size_t); + size_t i, m = 0; + hash_entry_t *restrict bucket; + + for (i = 0; i < n; i++) { + bucket = this->buckets[i]; + while (bucket) { + bucket = bucket->next; + m++; + } } - } - - return rc + m * 3 * sizeof(size_t) + sizeof(int); + + return rc + m * 3 * sizeof(size_t) + sizeof(int); } @@ -424,31 +410,31 @@ size_t hash_table_marshal_size(const hash_table_t* restrict this) * @param this The hash table * @param data Output buffer for the marshalled data */ -void hash_table_marshal(const hash_table_t* restrict this, char* restrict data) +void +hash_table_marshal(const hash_table_t *restrict this, char *restrict data) { - size_t i, n = this->capacity; - - buf_set_next(data, int, HASH_TABLE_T_VERSION); - buf_set_next(data, size_t, this->capacity); - buf_set_next(data, float, this->load_factor); - buf_set_next(data, size_t, this->threshold); - buf_set_next(data, size_t, this->size); - - for (i = 0; i < n; i++) - { - hash_entry_t* restrict bucket = this->buckets[i]; - size_t m = 0; - while (bucket != NULL) - { - buf_set(data, size_t, 1 + m * 3 + 0, bucket->key); - buf_set(data, size_t, 1 + m * 3 + 1, bucket->value); - buf_set(data, size_t, 1 + m * 3 + 2, bucket->hash); - bucket = bucket->next; - m++; + size_t i, n = this->capacity, m; + hash_entry_t *restrict bucket; + + buf_set_next(data, int, HASH_TABLE_T_VERSION); + buf_set_next(data, size_t, this->capacity); + buf_set_next(data, float, this->load_factor); + buf_set_next(data, size_t, this->threshold); + buf_set_next(data, size_t, this->size); + + for (i = 0; i < n; i++) { + bucket = this->buckets[i]; + m = 0; + while (bucket) { + buf_set(data, size_t, 1 + m * 3 + 0, bucket->key); + buf_set(data, size_t, 1 + m * 3 + 1, bucket->value); + buf_set(data, size_t, 1 + m * 3 + 2, bucket->hash); + bucket = bucket->next; + m++; + } + buf_set(data, size_t, 0, m); + buf_next(data, size_t, 1 + m * 3); } - buf_set(data, size_t, 0, m); - buf_next(data, size_t, 1 + m * 3); - } } @@ -461,48 +447,45 @@ void hash_table_marshal(const hash_table_t* restrict this, char* restrict data) * @return Non-zero on error, `errno` will be set accordingly. * Destroy the table on error. */ -int hash_table_unmarshal(hash_table_t* restrict this, char* restrict data, remap_func* remapper) +int +hash_table_unmarshal(hash_table_t *restrict this, char *restrict data, remap_func *remapper) { - size_t i, n; - - /* buf_get(data, int, 0, HASH_TABLE_T_VERSION); */ - buf_next(data, int, 1); - - this->value_comparator = NULL; - this->key_comparator = NULL; - this->hasher = NULL; - - buf_get_next(data, size_t, this->capacity = n); - buf_get_next(data, float, this->load_factor); - buf_get_next(data, size_t, this->threshold); - buf_get_next(data, size_t, this->size); - - fail_if (xcalloc(this->buckets, this->capacity, hash_entry_t*)); - - for (i = 0; i < n; i++) - { - size_t m; - hash_entry_t* restrict bucket; - buf_get_next(data, size_t, m); - - fail_if (xmalloc(this->buckets[i] = bucket, 1, hash_entry_t)); - - while (m--) - { - if (m == 0) - bucket->next = NULL; - else - fail_if (xmalloc(bucket->next, 1, hash_entry_t)); - buf_get_next(data, size_t, bucket->key); - buf_get_next(data, size_t, bucket->value); - if (remapper != NULL) - bucket->value = remapper(bucket->value); - buf_get_next(data, size_t, bucket->hash); + size_t i, n, m; + hash_entry_t *restrict bucket; + + /* buf_get(data, int, 0, HASH_TABLE_T_VERSION); */ + buf_next(data, int, 1); + + this->value_comparator = NULL; + this->key_comparator = NULL; + this->hasher = NULL; + + buf_get_next(data, size_t, this->capacity = n); + buf_get_next(data, float, this->load_factor); + buf_get_next(data, size_t, this->threshold); + buf_get_next(data, size_t, this->size); + + fail_if (xcalloc(this->buckets, this->capacity, hash_entry_t*)); + + for (i = 0; i < n; i++) { + buf_get_next(data, size_t, m); + + fail_if (xmalloc(this->buckets[i] = bucket, 1, hash_entry_t)); + + while (m--) { + if (!m) + bucket->next = NULL; + else + fail_if (xmalloc(bucket->next, 1, hash_entry_t)); + buf_get_next(data, size_t, bucket->key); + buf_get_next(data, size_t, bucket->value); + if (remapper) + bucket->value = remapper(bucket->value); + buf_get_next(data, size_t, bucket->hash); + } } - } - - return 0; - fail: - return -1; -} + return 0; +fail: + return -1; +} diff --git a/src/libmdsserver/linked-list.c b/src/libmdsserver/linked-list.c index 401a726..954c6fe 100644 --- a/src/libmdsserver/linked-list.c +++ b/src/libmdsserver/linked-list.c @@ -27,7 +27,7 @@ * The default initial capacity */ #ifndef LINKED_LIST_DEFAULT_INITIAL_CAPACITY -# define LINKED_LIST_DEFAULT_INITIAL_CAPACITY 128 +# define LINKED_LIST_DEFAULT_INITIAL_CAPACITY 128 #endif @@ -38,19 +38,19 @@ * @param value The value to be rounded up to a power of two * @return The nearest, but not smaller, power of two */ -__attribute__((const)) -static size_t to_power_of_two(size_t value) +static size_t __attribute__((const)) +to_power_of_two(size_t value) { - value -= 1; - value |= value >> 1; - value |= value >> 2; - value |= value >> 4; - value |= value >> 8; - value |= value >> 16; + value -= 1; + value |= value >> 1; + value |= value >> 2; + value |= value >> 4; + value |= value >> 8; + value |= value >> 16; #if SIZE_MAX == UINT64_MAX - value |= value >> 32; + value |= value >> 32; #endif - return value + 1; + return value + 1; } @@ -61,32 +61,33 @@ static size_t to_power_of_two(size_t value) * @param capacity The minimum initial capacity of the linked list, 0 for default * @return Non-zero on error, `errno` will have been set accordingly */ -int linked_list_create(linked_list_t* restrict this, size_t capacity) +int +linked_list_create(linked_list_t *restrict this, size_t capacity) { - /* Use default capacity of zero is specified. */ - if (capacity == 0) - capacity = LINKED_LIST_DEFAULT_INITIAL_CAPACITY; - - /* Initialise the linked list. */ - this->capacity = capacity = to_power_of_two(capacity); - this->edge = 0; - this->end = 1; - this->reuse_head = 0; - this->reusable = NULL; - this->values = NULL; - this->next = NULL; - this->previous = NULL; - fail_if (xmalloc(this->reusable, capacity, ssize_t)); - fail_if (xmalloc(this->values, capacity, size_t)); - fail_if (xmalloc(this->next, capacity, ssize_t)); - fail_if (xmalloc(this->previous, capacity, ssize_t)); - this->values[this->edge] = 0; - this->next[this->edge] = this->edge; - this->previous[this->edge] = this->edge; - - return 0; - fail: - return -1; + /* Use default capacity of zero is specified. */ + if (!capacity) + capacity = LINKED_LIST_DEFAULT_INITIAL_CAPACITY; + + /* Initialise the linked list. */ + this->capacity = capacity = to_power_of_two(capacity); + this->edge = 0; + this->end = 1; + this->reuse_head = 0; + this->reusable = NULL; + this->values = NULL; + this->next = NULL; + this->previous = NULL; + fail_if (xmalloc(this->reusable, capacity, ssize_t)); + fail_if (xmalloc(this->values, capacity, size_t)); + fail_if (xmalloc(this->next, capacity, ssize_t)); + fail_if (xmalloc(this->previous, capacity, ssize_t)); + this->values[this->edge] = 0; + this->next[this->edge] = this->edge; + this->previous[this->edge] = this->edge; + + return 0; +fail: + return -1; } @@ -96,12 +97,13 @@ int linked_list_create(linked_list_t* restrict this, size_t capacity) * * @param this The linked list */ -void linked_list_destroy(linked_list_t* restrict this) +void +linked_list_destroy(linked_list_t *restrict this) { - free(this->reusable), this->reusable = NULL; - free(this->values), this->values = NULL; - free(this->next), this->next = NULL; - free(this->previous), this->previous = NULL; + free(this->reusable), this->reusable = NULL; + free(this->values), this->values = NULL; + free(this->next), this->next = NULL; + free(this->previous), this->previous = NULL; } @@ -112,22 +114,23 @@ void linked_list_destroy(linked_list_t* restrict this) * @param out Memory slot in which to store the new linked list * @return Non-zero on error, `errno` will have been set accordingly */ -int linked_list_clone(const linked_list_t* restrict this, linked_list_t* restrict out) +int +linked_list_clone(const linked_list_t *restrict this, linked_list_t *restrict out) { - fail_if (xmemdup(out->values, this->values, this->capacity, size_t)); - fail_if (xmemdup(out->next, this->next, this->capacity, ssize_t)); - fail_if (xmemdup(out->previous, this->previous, this->capacity, ssize_t)); - fail_if (xmemdup(out->reusable, this->reusable, this->capacity, ssize_t)); - - out->capacity = this->capacity; - out->end = this->end; - out->reuse_head = this->reuse_head; - out->edge = this->edge; - - return 0; - - fail: - return -1; + fail_if (xmemdup(out->values, this->values, this->capacity, size_t)); + fail_if (xmemdup(out->next, this->next, this->capacity, ssize_t)); + fail_if (xmemdup(out->previous, this->previous, this->capacity, ssize_t)); + fail_if (xmemdup(out->reusable, this->reusable, this->capacity, ssize_t)); + + out->capacity = this->capacity; + out->end = this->end; + out->reuse_head = this->reuse_head; + out->edge = this->edge; + + return 0; + +fail: + return -1; } @@ -145,64 +148,64 @@ int linked_list_clone(const linked_list_t* restrict this, linked_list_t* restric * @param this The list * @return Non-zero on error, `errno` will have been set accordingly */ -int linked_list_pack(linked_list_t* restrict this) +int +linked_list_pack(linked_list_t *restrict this) { - ssize_t* restrict new_next = NULL; - ssize_t* restrict new_previous = NULL; - ssize_t* restrict new_reusable = NULL; - size_t size = this->end - this->reuse_head; - size_t cap = to_power_of_two(size); - ssize_t head = 0; - size_t i = 0; - ssize_t node; - size_t* restrict vals; - int saved_errno; - - fail_if (xmalloc(vals, cap, size_t)); - while (((size_t)head != this->end) && (this->next[head] == LINKED_LIST_UNUSED)) - head++; - if ((size_t)head != this->end) - for (node = head; (node != head) || (i == 0); i++) - { - vals[i] = this->values[node]; - node = this->next[node]; - } - - if (cap != this->capacity) - { - fail_if (xmalloc(new_next, cap, ssize_t)); - fail_if (xmalloc(new_previous, cap, ssize_t)); - fail_if (xmalloc(new_reusable, cap, ssize_t)); - - free(this->next); - free(this->previous); - free(this->reusable); - - this->next = new_next; - this->previous = new_previous; - this->reusable = new_reusable; - } - - for (i = 0; i < size; i++) - this->next[i] = (ssize_t)(i + 1); - this->next[size - 1] = 0; - - for (i = 1; i < size; i++) - this->previous[i] = (ssize_t)(i - 1); - this->previous[0] = (ssize_t)(size - 1); - - this->values = vals; - this->end = size; - this->reuse_head = 0; - - return 0; - - fail: - saved_errno = errno; - free(vals); - free(new_next); - free(new_previous); - return errno = saved_errno, -1; + ssize_t *restrict new_next = NULL; + ssize_t *restrict new_previous = NULL; + ssize_t *restrict new_reusable = NULL; + size_t size = this->end - this->reuse_head; + size_t cap = to_power_of_two(size); + ssize_t head = 0; + size_t i = 0; + ssize_t node; + size_t *restrict vals; + int saved_errno; + + fail_if (xmalloc(vals, cap, size_t)); + while ((size_t)head != this->end && this->next[head] == LINKED_LIST_UNUSED) + head++; + if ((size_t)head != this->end) { + for (node = head; (node != head) || (i == 0); i++) { + vals[i] = this->values[node]; + node = this->next[node]; + } + } + + if (cap != this->capacity) { + fail_if (xmalloc(new_next, cap, ssize_t)); + fail_if (xmalloc(new_previous, cap, ssize_t)); + fail_if (xmalloc(new_reusable, cap, ssize_t)); + + free(this->next); + free(this->previous); + free(this->reusable); + + this->next = new_next; + this->previous = new_previous; + this->reusable = new_reusable; + } + + for (i = 0; i < size; i++) + this->next[i] = (ssize_t)(i + 1); + this->next[size - 1] = 0; + + for (i = 1; i < size; i++) + this->previous[i] = (ssize_t)(i - 1); + this->previous[0] = (ssize_t)(size - 1); + + this->values = vals; + this->end = size; + this->reuse_head = 0; + + return 0; + +fail: + saved_errno = errno; + free(vals); + free(new_next); + free(new_previous); + return errno = saved_errno, -1; } @@ -215,29 +218,28 @@ int linked_list_pack(linked_list_t* restrict this) * @return The next free position, * `LINKED_LIST_UNUSED` on error, `errno` will be set accordingly */ -__attribute__((nonnull)) -static ssize_t linked_list_get_next(linked_list_t* restrict this) +static ssize_t __attribute__((nonnull)) +linked_list_get_next(linked_list_t *restrict this) { - size_t* tmp_values; - ssize_t* tmp; - - if (this->reuse_head > 0) - return this->reusable[--(this->reuse_head)]; - if (this->end == this->capacity) - { - if ((ssize_t)(this->end) < 0) - fail_if ((errno = ENOMEM)); - - this->capacity <<= 1; - - fail_if (yrealloc(tmp_values, this->values, this->capacity, size_t)); - fail_if (yrealloc(tmp, this->next, this->capacity, ssize_t)); - fail_if (yrealloc(tmp, this->previous, this->capacity, ssize_t)); - fail_if (yrealloc(tmp, this->reusable, this->capacity, ssize_t)); - } - return (ssize_t)(this->end++); - fail: - return LINKED_LIST_UNUSED; + size_t *tmp_values; + ssize_t *tmp; + + if (this->reuse_head > 0) + return this->reusable[--(this->reuse_head)]; + if (this->end == this->capacity) { + if ((ssize_t)(this->end) < 0) + fail_if ((errno = ENOMEM)); + + this->capacity <<= 1; + + fail_if (yrealloc(tmp_values, this->values, this->capacity, size_t)); + fail_if (yrealloc(tmp, this->next, this->capacity, ssize_t)); + fail_if (yrealloc(tmp, this->previous, this->capacity, ssize_t)); + fail_if (yrealloc(tmp, this->reusable, this->capacity, ssize_t)); + } + return (ssize_t)(this->end++); +fail: + return LINKED_LIST_UNUSED; } @@ -248,15 +250,15 @@ static ssize_t linked_list_get_next(linked_list_t* restrict this) * @param node The position * @return The position */ -__attribute__((nonnull)) -static ssize_t linked_list_unuse(linked_list_t* restrict this, ssize_t node) +static ssize_t __attribute__((nonnull)) +linked_list_unuse(linked_list_t *restrict this, ssize_t node) { - if (node < 0) - return node; - this->reusable[this->reuse_head++] = node; - this->next[node] = LINKED_LIST_UNUSED; - this->previous[node] = LINKED_LIST_UNUSED; - return node; + if (node < 0) + return node; + this->reusable[this->reuse_head++] = node; + this->next[node] = LINKED_LIST_UNUSED; + this->previous[node] = LINKED_LIST_UNUSED; + return node; } @@ -269,18 +271,19 @@ static ssize_t linked_list_unuse(linked_list_t* restrict this, ssize_t node) * @return The node that has been created and inserted, * `LINKED_LIST_UNUSED` on error, `errno` will be set accordingly */ -ssize_t linked_list_insert_after(linked_list_t* this, size_t value, ssize_t predecessor) +ssize_t +linked_list_insert_after(linked_list_t *this, size_t value, ssize_t predecessor) { - ssize_t node = linked_list_get_next(this); - fail_if (node == LINKED_LIST_UNUSED); - this->values[node] = value; - this->next[node] = this->next[predecessor]; - this->next[predecessor] = node; - this->previous[node] = predecessor; - this->previous[this->next[node]] = node; - return node; - fail: - return LINKED_LIST_UNUSED; + ssize_t node = linked_list_get_next(this); + fail_if (node == LINKED_LIST_UNUSED); + this->values[node] = value; + this->next[node] = this->next[predecessor]; + this->next[predecessor] = node; + this->previous[node] = predecessor; + this->previous[this->next[node]] = node; + return node; +fail: + return LINKED_LIST_UNUSED; } @@ -291,12 +294,13 @@ ssize_t linked_list_insert_after(linked_list_t* this, size_t value, ssize_t pred * @param predecessor The reference node * @return The node that has been removed */ -ssize_t linked_list_remove_after(linked_list_t* restrict this, ssize_t predecessor) +ssize_t +linked_list_remove_after(linked_list_t *restrict this, ssize_t predecessor) { - ssize_t node = this->next[predecessor]; - this->next[predecessor] = this->next[node]; - this->previous[this->next[node]] = predecessor; - return linked_list_unuse(this, node); + ssize_t node = this->next[predecessor]; + this->next[predecessor] = this->next[node]; + this->previous[this->next[node]] = predecessor; + return linked_list_unuse(this, node); } @@ -309,18 +313,19 @@ ssize_t linked_list_remove_after(linked_list_t* restrict this, ssize_t predecess * @return The node that has been created and inserted, * `LINKED_LIST_UNUSED` on error, `errno` will be set accordingly */ -ssize_t linked_list_insert_before(linked_list_t* restrict this, size_t value, ssize_t successor) +ssize_t +linked_list_insert_before(linked_list_t *restrict this, size_t value, ssize_t successor) { - ssize_t node = linked_list_get_next(this); - fail_if (node == LINKED_LIST_UNUSED); - this->values[node] = value; - this->previous[node] = this->previous[successor]; - this->previous[successor] = node; - this->next[node] = successor; - this->next[this->previous[node]] = node; - return node; - fail: - return LINKED_LIST_UNUSED; + ssize_t node = linked_list_get_next(this); + fail_if (node == LINKED_LIST_UNUSED); + this->values[node] = value; + this->previous[node] = this->previous[successor]; + this->previous[successor] = node; + this->next[node] = successor; + this->next[this->previous[node]] = node; + return node; +fail: + return LINKED_LIST_UNUSED; } @@ -331,12 +336,13 @@ ssize_t linked_list_insert_before(linked_list_t* restrict this, size_t value, ss * @param successor The reference node * @return The node that has been removed */ -ssize_t linked_list_remove_before(linked_list_t* restrict this, ssize_t successor) +ssize_t +linked_list_remove_before(linked_list_t *restrict this, ssize_t successor) { - ssize_t node = this->previous[successor]; - this->previous[successor] = this->previous[node]; - this->next[this->previous[node]] = successor; - return linked_list_unuse(this, node); + ssize_t node = this->previous[successor]; + this->previous[successor] = this->previous[node]; + this->next[this->previous[node]] = successor; + return linked_list_unuse(this, node); } @@ -346,11 +352,12 @@ ssize_t linked_list_remove_before(linked_list_t* restrict this, ssize_t successo * @param this The list * @param node The node to remove */ -void linked_list_remove(linked_list_t* restrict this, ssize_t node) +void +linked_list_remove(linked_list_t *restrict this, ssize_t node) { - this->next[this->previous[node]] = this->next[node]; - this->previous[this->next[node]] = this->previous[node]; - linked_list_unuse(this, node); + this->next[this->previous[node]] = this->next[node]; + this->previous[this->next[node]] = this->previous[node]; + linked_list_unuse(this, node); } @@ -360,9 +367,10 @@ void linked_list_remove(linked_list_t* restrict this, ssize_t node) * @param this The list * @return The number of bytes to allocate to the output buffer */ -size_t linked_list_marshal_size(const linked_list_t* restrict this) +size_t +linked_list_marshal_size(const linked_list_t *restrict this) { - return sizeof(size_t) * (4 + this->reuse_head + 3 * this->end) + sizeof(int); + return sizeof(size_t) * (4 + this->reuse_head + 3 * this->end) + sizeof(int); } @@ -372,27 +380,28 @@ size_t linked_list_marshal_size(const linked_list_t* restrict this) * @param this The list * @param data Output buffer for the marshalled data */ -void linked_list_marshal(const linked_list_t* restrict this, char* restrict data) +void +linked_list_marshal(const linked_list_t *restrict this, char *restrict data) { - buf_set(data, int, 0, LINKED_LIST_T_VERSION); - buf_next(data, int, 1); - - buf_set(data, size_t, 0, this->capacity); - buf_set(data, size_t, 1, this->end); - buf_set(data, size_t, 2, this->reuse_head); - buf_set(data, ssize_t, 3, this->edge); - buf_next(data, size_t, 4); - - memcpy(data, this->reusable, this->reuse_head * sizeof(ssize_t)); - buf_next(data, ssize_t, this->reuse_head); - - memcpy(data, this->values, this->end * sizeof(size_t)); - buf_next(data, size_t, this->end); - - memcpy(data, this->next, this->end * sizeof(ssize_t)); - buf_next(data, ssize_t, this->end); - - memcpy(data, this->previous, this->end * sizeof(ssize_t)); + buf_set(data, int, 0, LINKED_LIST_T_VERSION); + buf_next(data, int, 1); + + buf_set(data, size_t, 0, this->capacity); + buf_set(data, size_t, 1, this->end); + buf_set(data, size_t, 2, this->reuse_head); + buf_set(data, ssize_t, 3, this->edge); + buf_next(data, size_t, 4); + + memcpy(data, this->reusable, this->reuse_head * sizeof(ssize_t)); + buf_next(data, ssize_t, this->reuse_head); + + memcpy(data, this->values, this->end * sizeof(size_t)); + buf_next(data, size_t, this->end); + + memcpy(data, this->next, this->end * sizeof(ssize_t)); + buf_next(data, ssize_t, this->end); + + memcpy(data, this->previous, this->end * sizeof(ssize_t)); } @@ -404,41 +413,42 @@ void linked_list_marshal(const linked_list_t* restrict this, char* restrict data * @return Non-zero on error, `errno` will be set accordingly. * Destroy the list on error. */ -int linked_list_unmarshal(linked_list_t* restrict this, char* restrict data) +int +linked_list_unmarshal(linked_list_t *restrict this, char *restrict data) { - /* buf_get(data, int, 0, LINKED_LIST_T_VERSION); */ - buf_next(data, int, 1); - - this->reusable = NULL; - this->values = NULL; - this->next = NULL; - this->previous = NULL; - - buf_get(data, size_t, 0, this->capacity); - buf_get(data, size_t, 1, this->end); - buf_get(data, size_t, 2, this->reuse_head); - buf_get(data, ssize_t, 3, this->edge); - buf_next(data, size_t, 4); - - fail_if (xmalloc(this->reusable, this->capacity, size_t)); - fail_if (xmalloc(this->values, this->capacity, size_t)); - fail_if (xmalloc(this->next, this->capacity, size_t)); - fail_if (xmalloc(this->previous, this->capacity, size_t)); - - memcpy(this->reusable, data, this->reuse_head * sizeof(ssize_t)); - buf_next(data, ssize_t, this->reuse_head); - - memcpy(this->values, data, this->end * sizeof(size_t)); - buf_next(data, size_t, this->end); - - memcpy(this->next, data, this->end * sizeof(ssize_t)); - buf_next(data, ssize_t, this->end); - - memcpy(this->previous, data, this->end * sizeof(ssize_t)); - - return 0; - fail: - return -1; + /* buf_get(data, int, 0, LINKED_LIST_T_VERSION); */ + buf_next(data, int, 1); + + this->reusable = NULL; + this->values = NULL; + this->next = NULL; + this->previous = NULL; + + buf_get(data, size_t, 0, this->capacity); + buf_get(data, size_t, 1, this->end); + buf_get(data, size_t, 2, this->reuse_head); + buf_get(data, ssize_t, 3, this->edge); + buf_next(data, size_t, 4); + + fail_if (xmalloc(this->reusable, this->capacity, size_t)); + fail_if (xmalloc(this->values, this->capacity, size_t)); + fail_if (xmalloc(this->next, this->capacity, size_t)); + fail_if (xmalloc(this->previous, this->capacity, size_t)); + + memcpy(this->reusable, data, this->reuse_head * sizeof(ssize_t)); + buf_next(data, ssize_t, this->reuse_head); + + memcpy(this->values, data, this->end * sizeof(size_t)); + buf_next(data, size_t, this->end); + + memcpy(this->next, data, this->end * sizeof(ssize_t)); + buf_next(data, ssize_t, this->end); + + memcpy(this->previous, data, this->end * sizeof(ssize_t)); + + return 0; +fail: + return -1; } @@ -448,31 +458,31 @@ int linked_list_unmarshal(linked_list_t* restrict this, char* restrict data) * @param this The list * @param output Output file */ -void linked_list_dump(linked_list_t* restrict this, FILE* restrict output) +void +linked_list_dump(linked_list_t *restrict this, FILE *restrict output) { - ssize_t i; - size_t j; - fprintf(output, "======= LINKED LIST DUMP =======\n"); - fprintf(output, "Capacity: %zu\n", this->capacity); - fprintf(output, "End: %zu\n", this->end); - fprintf(output, "Reuse head: %zu\n", this->reuse_head); - fprintf(output, "Edge: %zi\n", this->edge); - fprintf(output, "--------------------------------\n"); - fprintf(output, "Node table (Next, Prev, Value):\n"); - i = this->edge; - fprintf(output, " %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]); - foreach_linked_list_node((*this), i) - fprintf(output, " %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]); - i = this->edge; - fprintf(output, " %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]); - fprintf(output, "--------------------------------\n"); - fprintf(output, "Raw node table:\n"); - for (j = 0; j < this->end; j++) - fprintf(output, " %zu: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]); - fprintf(output, "--------------------------------\n"); - fprintf(output, "Reuse stack:\n"); - for (j = 0; j < this->reuse_head; j++) - fprintf(output, " %zu: %zi\n", j, this->reusable[j]); - fprintf(output, "================================\n"); + ssize_t i; + size_t j; + fprintf(output, "======= LINKED LIST DUMP =======\n"); + fprintf(output, "Capacity: %zu\n", this->capacity); + fprintf(output, "End: %zu\n", this->end); + fprintf(output, "Reuse head: %zu\n", this->reuse_head); + fprintf(output, "Edge: %zi\n", this->edge); + fprintf(output, "--------------------------------\n"); + fprintf(output, "Node table (Next, Prev, Value):\n"); + i = this->edge; + fprintf(output, " %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]); + foreach_linked_list_node((*this), i) + fprintf(output, " %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]); + i = this->edge; + fprintf(output, " %zi: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]); + fprintf(output, "--------------------------------\n"); + fprintf(output, "Raw node table:\n"); + for (j = 0; j < this->end; j++) + fprintf(output, " %zu: %zi, %zi, %zu\n", i, this->next[i], this->previous[i], this->values[i]); + fprintf(output, "--------------------------------\n"); + fprintf(output, "Reuse stack:\n"); + for (j = 0; j < this->reuse_head; j++) + fprintf(output, " %zu: %zi\n", j, this->reusable[j]); + fprintf(output, "================================\n"); } - diff --git a/src/libmdsserver/macros.h b/src/libmdsserver/macros.h index d4d588c..45412b9 100644 --- a/src/libmdsserver/macros.h +++ b/src/libmdsserver/macros.h @@ -44,24 +44,22 @@ /* CLOCK_MONOTONIC_RAW is a Linux-specific bug-fix */ #ifndef CLOCK_MONOTONIC_RAW -# define CLOCK_MONOTONIC_RAW CLOCK_MONOTONIC +# define CLOCK_MONOTONIC_RAW CLOCK_MONOTONIC #endif /* Define TEMP_FAILURE_RETRY if not defined, however * this version does not return a value, it will hoever * clear `errno` if no error occurs. */ #ifndef TEMP_FAILURE_RETRY -# define TEMP_FAILURE_RETRY(expression) \ - do \ - { \ - ssize_t __result; \ - do \ - __result = (ssize_t)(expression); \ - while ((__result < 0) && (errno == EINTR)); \ - if (__result >= 0) \ - errno = 0; \ - } \ - while (0) +# define TEMP_FAILURE_RETRY(expression)\ + do {\ + ssize_t __result;\ + do\ + __result = (ssize_t)(expression);\ + while (__result < 0 && errno == EINTR);\ + if (__result >= 0)\ + errno = 0;\ + } while (0) # define MDS_LIBMDSSERVER_MACROS_DEFINED_TEMP_FAILURE_RETRY #endif @@ -118,16 +116,16 @@ * @param ...:const char*, ... The format string and arguments * @return :int Zero on success, -1 on error */ -#define xasprintf(VAR, ...) \ - (asprintf(&(VAR), __VA_ARGS__) < 0 ? (VAR = NULL, -1) : 0) +#define xasprintf(VAR, ...)\ + (asprintf(&(VAR), __VA_ARGS__) < 0 ? (VAR = NULL, -1) : 0) /* -#define xasprintf(VAR, ...) \ - ({ \ - int _x_rc = (asprintf(&(VAR), __VA_ARGS__) < 0 ? (VAR = NULL, -1) : 0); \ - fprintf(stderr, "xasprintf(%s, %s)(=%zu) @ %s:%i\n", \ - #VAR, #__VA_ARGS__, _x_rc ? 0 : (strlen(VAR) + 1), __FILE__, __LINE__); \ - _x_rc; \ - }) +#define xasprintf(VAR, ...)\ + ({\ + int _x_rc = (asprintf(&(VAR), __VA_ARGS__) < 0 ? (VAR = NULL, -1) : 0);\ + fprintf(stderr, "xasprintf(%s, %s)(=%zu) @ %s:%i\n",\ + #VAR, #__VA_ARGS__, _x_rc ? 0 : (strlen(VAR) + 1), __FILE__, __LINE__);\ + _x_rc;\ + }) */ @@ -138,8 +136,8 @@ * @param ...:const char*, ... The format string and arguments * @return :int The number of bytes written, including the NUL-termination, negative on error */ -#define xsnprintf(buffer, ...) \ - snprintf(buffer, sizeof(buffer) / sizeof(char), __VA_ARGS__) +#define xsnprintf(buffer, ...)\ + snprintf(buffer, sizeof(buffer) / sizeof(char), __VA_ARGS__) /** @@ -149,8 +147,8 @@ * @param format:const char* The format * @return :int The number of bytes written, including the NUL-termination, negative on error */ -#define eprint(format) \ - fprintf(stderr, "%s: " format "\n", *argv) +#define eprint(format)\ + fprintf(stderr, "%s: " format "\n", *argv) /** @@ -161,8 +159,8 @@ * @param ... The arguments * @return :int The number of bytes written, including the NUL-termination, negative on error */ -#define eprintf(format, ...) \ - fprintf(stderr, "%s: " format "\n", *argv, __VA_ARGS__) +#define eprintf(format, ...)\ + fprintf(stderr, "%s: " format "\n", *argv, __VA_ARGS__) /** @@ -174,8 +172,8 @@ * @param format:const char* The format * @return :int The number of bytes written, including the NUL-termination, negative on error */ -#define iprint(format) \ - fprintf(stderr, "%s: info: " format "\n", *argv) +#define iprint(format)\ + fprintf(stderr, "%s: info: " format "\n", *argv) /** @@ -188,8 +186,8 @@ * @param ... The arguments * @return :int The number of bytes written, including the NUL-termination, negative on error */ -#define iprintf(format, ...) \ - fprintf(stderr, "%s: info: " format "\n", *argv, __VA_ARGS__) +#define iprintf(format, ...)\ + fprintf(stderr, "%s: info: " format "\n", *argv, __VA_ARGS__) /** @@ -198,18 +196,14 @@ * @param mutex:pthread_mutex_t The mutex * @param instructions The instructions to run while the mutex is locked */ -#define with_mutex(mutex, instructions) \ - do \ - { \ - errno = pthread_mutex_lock(&(mutex)); \ - do \ - { \ - instructions ; \ - } \ - while (0); \ - errno = pthread_mutex_unlock(&(mutex)); \ - } \ - while (0) +#define with_mutex(mutex, instructions)\ + do {\ + errno = pthread_mutex_lock(&mutex);\ + do {\ + instructions;\ + } while (0);\ + errno = pthread_mutex_unlock(&mutex);\ + } while (0) /** * Wrapper for `pthread_mutex_lock` and `pthread_mutex_unlock` with an embedded if-statement @@ -218,19 +212,14 @@ * @parma condition The condition to test * @param instructions The instructions to run while the mutex is locked */ -#define with_mutex_if(mutex, condition, instructions) \ - do \ - { \ - errno = pthread_mutex_lock(&(mutex)); \ - if (condition) \ - do \ - { \ - instructions ; \ - } \ - while (0); \ - errno = pthread_mutex_unlock(&(mutex)); \ - } \ - while (0) +#define with_mutex_if(mutex, condition, instructions)\ + do {\ + errno = pthread_mutex_lock(&mutex);\ + if (condition) {\ + instructions;\ + }\ + errno = pthread_mutex_unlock(&mutex);\ + } while (0) /** @@ -240,8 +229,8 @@ * @param b The other one of the values * @return The maximum value */ -#define max(a, b) \ - (a < b ? b : a) +#define max(a, b)\ + ((a) < (b) ? (b) : (a)) /** @@ -251,8 +240,8 @@ * @param b The other one of the values * @return The minimum value */ -#define min(a, b) \ - (a < b ? a : b) +#define min(a, b)\ + ((a) < (b) ? (a) : (b)) /** @@ -263,8 +252,8 @@ * @param index:size_t The index of the element to address * @return [type] A slot that can be set or get */ -#define buf_cast(buffer, type, index) \ - (((type*)(buffer))[index]) +#define buf_cast(buffer, type, index)\ + (((type *)(buffer))[index]) /** @@ -276,8 +265,8 @@ * @param variable:type The new value of the element * @return variable: The new value of the element */ -#define buf_set(buffer, type, index, variable) \ - (((type*)(buffer))[index] = (variable)) +#define buf_set(buffer, type, index, variable)\ + (((type *)(buffer))[index] = (variable)) /** @@ -289,8 +278,8 @@ * @param variable:type Slot to set with the value of the element * @return variable: The value of the element */ -#define buf_get(buffer, type, index, variable) \ - (variable = ((const type*)(buffer))[index]) +#define buf_get(buffer, type, index, variable)\ + (variable = ((const type*)(buffer))[index]) /** @@ -301,8 +290,8 @@ * @param count:size_t The number elements of the data type `type` to increase the pointer with * @return buffer: The buffer */ -#define buf_next(buffer, type, count) \ - (buffer += (count) * sizeof(type) / sizeof(char)) +#define buf_next(buffer, type, count)\ + (buffer += (count) * sizeof(type) / sizeof(char)) /** @@ -313,8 +302,8 @@ * @param count:size_t The number elements of the data type `type` to decrease the pointer with * @return buffer: The buffer */ -#define buf_prev(buffer, type, count) \ - (buffer -= (count) * sizeof(type) / sizeof(char)) +#define buf_prev(buffer, type, count)\ + (buffer -= (count) * sizeof(type) / sizeof(char)) /** @@ -326,9 +315,9 @@ * @param variable:type The new value of the element * @return variable: The new value of the element */ -#define buf_set_next(buffer, type, variable) \ - (buf_set(buffer, type, 0, variable), \ - buf_next(buffer, type, 1)) +#define buf_set_next(buffer, type, variable)\ + (buf_set(buffer, type, 0, variable),\ + buf_next(buffer, type, 1)) /** @@ -340,9 +329,9 @@ * @param variable:type Slot to set with the value of the element * @return variable: The value of the element */ -#define buf_get_next(buffer, type, variable) \ - (buf_get(buffer, type, 0, variable), \ - buf_next(buffer, type, 1)) +#define buf_get_next(buffer, type, variable)\ + (buf_get(buffer, type, 0, variable),\ + buf_next(buffer, type, 1)) /** @@ -352,8 +341,8 @@ * @param b:const char* The other of the strings * @return :int Whether the strings are equal */ -#define strequals(a, b) \ - (strcmp(a, b) == 0) +#define strequals(a, b)\ + (!strcmp(a, b)) /** @@ -363,8 +352,8 @@ * @param needle:const char* The string `haystack` should start with * @return :int Whether `haystack` starts with `needle` */ -#define startswith(haystack, needle) \ - (strstr(haystack, needle) == haystack) +#define startswith(haystack, needle)\ + (strstr(haystack, needle) == haystack) /** @@ -374,9 +363,9 @@ * * @return :int Non-zero on error */ -#define drop_privileges() \ - ((getegid() == getgid() ? 0 : setegid(getgid())) || \ - (geteuid() == getuid() ? 0 : seteuid(getuid()))) +#define drop_privileges()\ + ((getegid() == getgid() ? 0 : setegid(getgid())) ||\ + (geteuid() == getuid() ? 0 : seteuid(getuid()))) /** @@ -386,8 +375,8 @@ * @param time_slot:struct timespec* Pointer to the variable in which to store the time * @return :int Zero on success, -1 on error */ -#define monotone(time_slot) \ - clock_gettime(CLOCK_MONOTONIC_RAW, time_slot) +#define monotone(time_slot)\ + clock_gettime(CLOCK_MONOTONIC_RAW, time_slot) /** @@ -397,15 +386,15 @@ * @param fd:int The file descriptor */ #if 1 /* For kernels that ensure that close(2) always closes valid file descriptors. */ -# define xclose(fd) \ - close(fd) +# define xclose(fd)\ + close(fd) #else /* For kernels that ensure that close(2) never closes valid file descriptors on interruption. */ # ifdef MDS_LIBMDSSERVER_MACROS_DEFINED_TEMP_FAILURE_RETRY -# define xclose(fd) \ - TEMP_FAILURE_RETRY(close(fd)) +# define xclose(fd)\ + TEMP_FAILURE_RETRY(close(fd)) # else -# define xclose(fd) \ - (TEMP_FAILURE_RETRY(close(fd)) < 0 ? 0 : (errno = 0)) +# define xclose(fd)\ + (TEMP_FAILURE_RETRY(close(fd)) < 0 ? 0 : (errno = 0)) # endif #endif @@ -417,15 +406,15 @@ * @param f:FILE* The stream */ #if 1 /* For kernels that ensure that close(2) always closes valid file descriptors. */ -# define xfclose(f) \ - fclose(f) +# define xfclose(f)\ + fclose(f) #else /* For kernels that ensure that close(2) never closes valid file descriptors on interruption. */ # ifdef MDS_LIBMDSSERVER_MACROS_DEFINED_TEMP_FAILURE_RETRY -# define xfclose(f) \ - TEMP_FAILURE_RETRY(fclose(f)) +# define xfclose(f)\ + TEMP_FAILURE_RETRY(fclose(f)) # else -# define xfclose(f) \ - (TEMP_FAILURE_RETRY(fclose(f)) < 0 ? 0 : (errno = 0)) +# define xfclose(f)\ + (TEMP_FAILURE_RETRY(fclose(f)) < 0 ? 0 : (errno = 0)) # endif #endif @@ -435,29 +424,27 @@ * * @param condition The condition, it should evaluate the variable `fd` */ -#define close_files(condition) \ - do \ - { \ - DIR* dir = opendir(SELF_FD); \ - struct dirent* file; \ - \ - if (dir == NULL) \ - perror(*argv); /* Well, that is just unfortunate, but we cannot really do anything. */ \ - else \ - { \ - int dfd = dirfd(dir); \ - while ((file = readdir(dir)) != NULL) \ - if (strcmp(file->d_name, ".") && strcmp(file->d_name, "..")) \ - { \ - int fd = atoi(file->d_name); \ - if (fd != dfd) \ - if (condition) \ - xclose(fd); \ - } \ - closedir(dir); \ - } \ - } \ - while (0) +#define close_files(condition)\ + do {\ + DIR *dir = opendir(SELF_FD);\ + struct dirent *file;\ + int dfd, fd;\ + \ + if (!dir) {\ + perror(*argv); /* Well, that is just unfortunate, but we cannot really do anything. */\ + } else {\ + dfd = dirfd(dir);\ + while ((file = readdir(dir))) {\ + if (strcmp(file->d_name, ".") && strcmp(file->d_name, "..")) {\ + fd = atoi(file->d_name);\ + if (fd != dfd)\ + if (condition)\ + xclose(fd);\ + }\ + }\ + closedir(dir);\ + }\ + } while (0) /** @@ -467,14 +454,13 @@ * @param elements:size_t The number of elements, in the array, to free * @scope i:size_t The variable `i` must be declared as `size_t` and avaiable for use */ -#define xfree(array, elements) \ - do \ - { \ - for (i = 0; i < (elements); i++) \ - free((array)[i]); \ - free(array), (array) = NULL; \ - } \ - while (0) +#define xfree(array, elements)\ + do {\ + for (i = 0; i < (elements); i++)\ + free((array)[i]);\ + free(array);\ + (array) = NULL;\ + } while (0) /** @@ -485,17 +471,17 @@ * @param type The data type of the elements for which to create an allocation * @return :int Evaluates to true if an only if the allocation failed */ -#define xmalloc(var, elements, type) \ - ((var = malloc((elements) * sizeof(type))) == NULL) +#define xmalloc(var, elements, type)\ + (!(var = malloc((elements) * sizeof(type)))) /* -#define xmalloc(var, elements, type) \ - ({ \ - size_t _x_elements = (elements); \ - size_t _x_size = _x_elements * sizeof(type); \ - fprintf(stderr, "xmalloc(%s, %zu, %s)(=%zu) @ %s:%i\n", \ - #var, _x_elements, #type, _x_size, __FILE__, __LINE__); \ - ((var = malloc(_x_size)) == NULL); \ - }) +#define xmalloc(var, elements, type)\ + ({\ + size_t _x_elements = (elements);\ + size_t _x_size = _x_elements * sizeof(type);\ + fprintf(stderr, "xmalloc(%s, %zu, %s)(=%zu) @ %s:%i\n",\ + #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\ + (!(var = malloc(_x_size)));\ + }) */ @@ -506,16 +492,16 @@ * @param bytes:size_t The number of bytes to allocate * @return :int Evaluates to true if an only if the allocation failed */ -#define xbmalloc(var, bytes) \ - ((var = malloc(bytes)) == NULL) +#define xbmalloc(var, bytes) \ + (!(var = malloc(bytes))) /* -#define xbmalloc(var, bytes) \ - ({ \ - size_t _x_bytes = (bytes); \ - fprintf(stderr, "xbmalloc(%s, %zu) @ %s:%i\n", \ - #var, _x_bytes, __FILE__, __LINE__); \ - ((var = malloc(_x_bytes)) == NULL); \ - }) +#define xbmalloc(var, bytes)\ + ({\ + size_t _x_bytes = (bytes);\ + fprintf(stderr, "xbmalloc(%s, %zu) @ %s:%i\n",\ + #var, _x_bytes, __FILE__, __LINE__);\ + (!(var = malloc(_x_bytes)));\ + }) */ @@ -527,17 +513,17 @@ * @param type The data type of the elements for which to create an allocation * @return :int Evaluates to true if an only if the allocation failed */ -#define xcalloc(var, elements, type) \ - ((var = calloc(elements, sizeof(type))) == NULL) +#define xcalloc(var, elements, type)\ + (!(var = calloc(elements, sizeof(type)))) /* -#define xcalloc(var, elements, type) \ - ({ \ - size_t _x_elements = (elements); \ - size_t _x_size = _x_elements * sizeof(type); \ - fprintf(stderr, "xcalloc(%s, %zu, %s)(=%zu) @ %s:%i\n", \ - #var, _x_elements, #type, _x_size, __FILE__, __LINE__); \ - ((var = calloc(_x_elements, sizeof(type))) == NULL); \ - }) +#define xcalloc(var, elements, type)\ + ({\ + size_t _x_elements = (elements);\ + size_t _x_size = _x_elements * sizeof(type);\ + fprintf(stderr, "xcalloc(%s, %zu, %s)(=%zu) @ %s:%i\n",\ + #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\ + (!(var = calloc(_x_elements, sizeof(type))));\ + }) */ @@ -548,16 +534,16 @@ * @param bytes:size_t The number of bytes to allocate * @return :int Evaluates to true if an only if the allocation failed */ -#define xbcalloc(var, bytes) \ - ((var = calloc(bytes, sizeof(char))) == NULL) +#define xbcalloc(var, bytes)\ + (!(var = calloc(bytes, sizeof(char)))) /* -#define xbcalloc(var, bytes) \ - ({ \ - size_t _x_bytes = (bytes); \ - fprintf(stderr, "xbcalloc(%s, %zu) @ %s:%i\n", \ - #var, _x_bytes, __FILE__, __LINE__); \ - ((var = calloc(_x_bytes, sizeof(char))) == NULL); \ - }) +#define xbcalloc(var, bytes)\ + ({\ + size_t _x_bytes = (bytes);\ + fprintf(stderr, "xbcalloc(%s, %zu) @ %s:%i\n",\ + #var, _x_bytes, __FILE__, __LINE__);\ + (!(var = calloc(_x_bytes, sizeof(char))));\ + }) */ @@ -570,16 +556,16 @@ * @return :int Evaluates to true if an only if the allocation failed */ #define xrealloc(var, elements, type) \ - ((var = realloc(var, (elements) * sizeof(type))) == NULL) + (!(var = realloc(var, (elements) * sizeof(type)))) /* -#define xrealloc(var, elements, type) \ - ({ \ - size_t _x_elements = (elements); \ - size_t _x_size = _x_elements * sizeof(type); \ - fprintf(stderr, "xrealloc(%s, %zu, %s)(=%zu) @ %s:%i\n", \ - #var, _x_elements, #type, _x_size, __FILE__, __LINE__); \ - ((var = realloc(var, _x_size)) == NULL); \ - }) +#define xrealloc(var, elements, type)\ + ({\ + size_t _x_elements = (elements);\ + size_t _x_size = _x_elements * sizeof(type);\ + fprintf(stderr, "xrealloc(%s, %zu, %s)(=%zu) @ %s:%i\n",\ + #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\ + (!(var = realloc(var, _x_size)));\ + }) */ @@ -593,17 +579,17 @@ * @param type The data type of the elements for which to create an allocation * @return :int Evaluates to true if an only if the allocation failed */ -#define xxrealloc(old, var, elements, type) \ - (old = var, (((var = realloc(var, (elements) * sizeof(type))) == NULL) ? 1 : (old = NULL, 0))) +#define xxrealloc(old, var, elements, type)\ + (old = var, ((!(var = realloc(var, (elements) * sizeof(type)))) ? 1 : (old = NULL, 0))) /* -#define xxrealloc(old, var, elements, type) \ - ({ \ - size_t _x_elements = (elements); \ - size_t _x_size = _x_elements * sizeof(type); \ - fprintf(stderr, "xxrealloc(%s, %s, %zu, %s)(=%zu) @ %s:%i\n", \ - #old, #var, _x_elements, #type, _x_size, __FILE__, __LINE__); \ - (old = var, (((var = realloc(var, _x_size)) == NULL) ? 1 : (old = NULL, 0))); \ - }) +#define xxrealloc(old, var, elements, type)\ + ({\ + size_t _x_elements = (elements);\ + size_t _x_size = _x_elements * sizeof(type);\ + fprintf(stderr, "xxrealloc(%s, %s, %zu, %s)(=%zu) @ %s:%i\n",\ + #old, #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\ + (old = var, ((!(var = realloc(var, _x_size))) ? 1 : (old = NULL, 0)));\ + }) */ @@ -616,19 +602,19 @@ * @param type The data type of the elements for which to create an allocation * @return :int Evaluates to true if an only if the allocation failed */ -#define yrealloc(tmp, var, elements, type) \ - ((tmp = var, (var = realloc(var, (elements) * sizeof(type))) == NULL) \ - ? (var = tmp, tmp = NULL, 1) : (tmp = NULL, 0)) +#define yrealloc(tmp, var, elements, type)\ + ((tmp = var, !(var = realloc(var, (elements) * sizeof(type))))\ + ? (var = tmp, tmp = NULL, 1) : (tmp = NULL, 0)) /* -#define yrealloc(tmp, var, elements, type) \ - ({ \ - size_t _x_elements = (elements); \ - size_t _x_size = _x_elements * sizeof(type); \ - fprintf(stderr, "yrealloc(%s, %s, %zu, %s)(=%zu) @ %s:%i\n", \ - #tmp, #var, _x_elements, #type, _x_size, __FILE__, __LINE__); \ - ((tmp = var, (var = realloc(var, _x_size)) == NULL) \ - ? (var = tmp, tmp = NULL, 1) : (tmp = NULL, 0)); \ - }) +#define yrealloc(tmp, var, elements, type)\ + ({\ + size_t _x_elements = (elements);\ + size_t _x_size = _x_elements * sizeof(type);\ + fprintf(stderr, "yrealloc(%s, %s, %zu, %s)(=%zu) @ %s:%i\n",\ + #tmp, #var, _x_elements, #type, _x_size, __FILE__, __LINE__);\ + ((tmp = var, !(var = realloc(var, _x_size)))\ + ? (var = tmp, tmp = NULL, 1) : (tmp = NULL, 0));\ + }) */ @@ -641,17 +627,17 @@ * @param type The data type of the elements for which to create an allocation * @return :int Evaluates to true if an only if the allocation failed */ -#define growalloc(old, var, elements, type) \ - (old = var, xrealloc(var, (elements) <<= 1, type) ? (var = old, (elements) >>= 1, 1) : 0) +#define growalloc(old, var, elements, type) \ + (old = var, xrealloc(var, (elements) <<= 1, type) ? (var = old, (elements) >>= 1, 1) : 0) /* -#define growalloc(old, var, elements, type) \ - ({ \ - size_t _x_elements_ = (elements); \ - size_t _x_size_ = _x_elements_ * sizeof(type); \ - fprintf(stderr, "growalloc(%s, %s, %zu, %s)(=%zu)\n--> ", \ - #old, #var, _x_elements_, #type, _x_size_, __FILE__, __LINE__); \ - (old = var, xrealloc(var, (elements) <<= 1, type) ? (var = old, (elements) >>= 1, 1) : 0); \ - }) +#define growalloc(old, var, elements, type)\ + ({\ + size_t _x_elements_ = (elements);\ + size_t _x_size_ = _x_elements_ * sizeof(type);\ + fprintf(stderr, "growalloc(%s, %s, %zu, %s)(=%zu)\n--> ",\ + #old, #var, _x_elements_, #type, _x_size_, __FILE__, __LINE__);\ + (old = var, xrealloc(var, (elements) <<= 1, type) ? (var = old, (elements) >>= 1, 1) : 0);\ + }) */ @@ -662,16 +648,16 @@ * @param original:const char* The string to duplicate, may be `NULL` * @return :int Evaluates to true if an only if the allocation failed */ -#define xstrdup(var, original) \ - (original ? ((var = strdup(original)) == NULL) : (var = NULL, 0)) +#define xstrdup(var, original)\ + (original ? !(var = strdup(original)) : (var = NULL, 0)) /* -#define xstrdup(var, original) \ - ({ \ - size_t _x_size = original ? strlen(original) : 0; \ - fprintf(stderr, "xstrdup(%s, %s(“%s”=%zu))(=%zu) @ %s:%i\n", \ - #var, #original, original, _x_size, _x_size + !!_x_size, __FILE__, __LINE__); \ - (original ? ((var = strdup(original)) == NULL) : (var = NULL, 0)); \ - }) +#define xstrdup(var, original)\ + ({\ + size_t _x_size = original ? strlen(original) : 0;\ + fprintf(stderr, "xstrdup(%s, %s(“%s”=%zu))(=%zu) @ %s:%i\n",\ + #var, #original, original, _x_size, _x_size + !!_x_size, __FILE__, __LINE__);\ + (original ? ((var = strdup(original)) == NULL) : (var = NULL, 0));\ + }) */ @@ -685,16 +671,16 @@ * @param original:const char* The string to duplicate, must not be `NULL` * @return :int Evaluates to true if an only if the allocation failed */ -#define xstrdup_nn(var, original) \ - ((var = strdup(original)) == NULL) +#define xstrdup_nn(var, original)\ + (!(var = strdup(original))) /* -#define xstrdup_nn(var, original) \ - ({ \ - size_t _x_size = strlen(original); \ - fprintf(stderr, "xstrdup_nn(%s, %s(“%s”=%zu))(=%zu) @ %s:%i\n", \ - #var, #original, original, _x_size, _x_size + !!_x_size, __FILE__, __LINE__); \ - (var = strdup(original)) == NULL; \ - }) +#define xstrdup_nn(var, original)\ + ({\ + size_t _x_size = strlen(original);\ + fprintf(stderr, "xstrdup_nn(%s, %s(“%s”=%zu))(=%zu) @ %s:%i\n",\ + #var, #original, original, _x_size, _x_size + !!_x_size, __FILE__, __LINE__);\ + !(var = strdup(original));\ + }) */ @@ -708,18 +694,18 @@ * @param type The data type of the elements to duplicate * @return :int Evaluates to true if an only if the allocation failed */ -#define xmemdup(var, original, elements, type) \ - (((var = malloc((elements) * sizeof(type))) == NULL) ? 1 : \ - (memcpy(var, original, (elements) * sizeof(type)), 0)) +#define xmemdup(var, original, elements, type)\ + (!(var = malloc((elements) * sizeof(type))) ? 1 :\ + (memcpy(var, original, (elements) * sizeof(type)), 0)) /* -#define xmemdup(var, original, elements, type) \ - ({ \ - size_t _x_elements = (elements); \ - size_t _x_size = _x_elements * sizeof(type); \ - fprintf(stderr, "xmemdup(%s, %s, %zu, %s)(=%zu) @ %s:%i\n", \ - #var, #original, _x_elements, #type, _x_size, __FILE__, __LINE__); \ - (((var = malloc(_x_size)) == NULL) ? 1 : (memcpy(var, original, _x_size), 0)); \ - }) +#define xmemdup(var, original, elements, type)\ + ({\ + size_t _x_elements = (elements);\ + size_t _x_size = _x_elements * sizeof(type);\ + fprintf(stderr, "xmemdup(%s, %s, %zu, %s)(=%zu) @ %s:%i\n",\ + #var, #original, _x_elements, #type, _x_size, __FILE__, __LINE__);\ + !(var = malloc(_x_size)) ? 1 : (memcpy(var, original, _x_size), 0);\ + }) */ diff --git a/src/libmdsserver/mds-message.c b/src/libmdsserver/mds-message.c index 4ec8142..c3d968f 100644 --- a/src/libmdsserver/mds-message.c +++ b/src/libmdsserver/mds-message.c @@ -27,7 +27,7 @@ #include <sys/socket.h> -#define try(INSTRUCTION) if ((r = INSTRUCTION) < 0) return r +#define try(INSTRUCTION) do { if ((r = INSTRUCTION) < 0) return r; } while (0) /** @@ -38,20 +38,21 @@ * @return Non-zero on error, `errno` will be set accordingly. * Destroy the message on error. */ -int mds_message_initialise(mds_message_t* restrict this) +int +mds_message_initialise(mds_message_t *restrict this) { - this->headers = NULL; - this->header_count = 0; - this->payload = NULL; - this->payload_size = 0; - this->payload_ptr = 0; - this->buffer_size = 128; - this->buffer_ptr = 0; - this->stage = 0; - fail_if (xmalloc(this->buffer, this->buffer_size, char)); - return 0; - fail: - return -1; + this->headers = NULL; + this->header_count = 0; + this->payload = NULL; + this->payload_size = 0; + this->payload_ptr = 0; + this->buffer_size = 128; + this->buffer_ptr = 0; + this->stage = 0; + fail_if (xmalloc(this->buffer, this->buffer_size, char)); + return 0; +fail: + return -1; } @@ -60,17 +61,18 @@ int mds_message_initialise(mds_message_t* restrict this) * * @param this Memory slot in which to store the new message */ -void mds_message_zero_initialise(mds_message_t* restrict this) +void +mds_message_zero_initialise(mds_message_t *restrict this) { - this->headers = NULL; - this->header_count = 0; - this->payload = NULL; - this->payload_size = 0; - this->payload_ptr = 0; - this->buffer = NULL; - this->buffer_size = 0; - this->buffer_ptr = 0; - this->stage = 0; + this->headers = NULL; + this->header_count = 0; + this->payload = NULL; + this->payload_size = 0; + this->payload_ptr = 0; + this->buffer = NULL; + this->buffer_size = 0; + this->buffer_ptr = 0; + this->stage = 0; } @@ -80,14 +82,15 @@ void mds_message_zero_initialise(mds_message_t* restrict this) * * @param this The message */ -void mds_message_destroy(mds_message_t* restrict this) +void +mds_message_destroy(mds_message_t *restrict this) { - size_t i; - if (this->headers != NULL) - xfree(this->headers, this->header_count); - - free(this->payload), this->payload = NULL; - free(this->buffer), this->buffer = NULL; + size_t i; + if (this->headers) + xfree(this->headers, this->header_count); + + free(this->payload), this->payload = NULL; + free(this->buffer), this->buffer = NULL; } @@ -98,14 +101,15 @@ void mds_message_destroy(mds_message_t* restrict this) * @param extent The number of additional entries * @return Zero on success, -1 on error */ -int mds_message_extend_headers(mds_message_t* restrict this, size_t extent) +int +mds_message_extend_headers(mds_message_t *restrict this, size_t extent) { - char** new_headers = this->headers; - fail_if (xrealloc(new_headers, this->header_count + extent, char*)); - this->headers = new_headers; - return 0; - fail: - return -1; + char **new_headers = this->headers; + fail_if (xrealloc(new_headers, this->header_count + extent, char*)); + this->headers = new_headers; + return 0; +fail: + return -1; } @@ -115,16 +119,16 @@ int mds_message_extend_headers(mds_message_t* restrict this, size_t extent) * @param this The message * @return Zero on success, -1 on error */ -__attribute__((nonnull)) -static int mds_message_extend_buffer(mds_message_t* restrict this) +static int __attribute__((nonnull)) +mds_message_extend_buffer(mds_message_t *restrict this) { - char* new_buf = this->buffer; - fail_if (xrealloc(new_buf, this->buffer_size << 1, char)); - this->buffer = new_buf; - this->buffer_size <<= 1; - return 0; - fail: - return -1; + char *new_buf = this->buffer; + fail_if (xrealloc(new_buf, this->buffer_size << 1, char)); + this->buffer = new_buf; + this->buffer_size <<= 1; + return 0; +fail: + return -1; } @@ -133,18 +137,18 @@ static int mds_message_extend_buffer(mds_message_t* restrict this) * * @param this The message */ -__attribute__((nonnull)) -static void reset_message(mds_message_t* restrict this) +static void __attribute__((nonnull)) +reset_message(mds_message_t *restrict this) { - size_t i; - if (this->headers != NULL) - xfree(this->headers, this->header_count); - this->header_count = 0; - - free(this->payload); - this->payload = NULL; - this->payload_size = 0; - this->payload_ptr = 0; + size_t i; + if (this->headers) + xfree(this->headers, this->header_count); + this->header_count = 0; + + free(this->payload); + this->payload = NULL; + this->payload_size = 0; + this->payload_ptr = 0; } @@ -154,29 +158,29 @@ static void reset_message(mds_message_t* restrict this) * @param this The message * @return Zero on success, negative on error (malformated message: unrecoverable state) */ -__attribute__((pure, nonnull)) -static int get_payload_length(mds_message_t* restrict this) +static int __attribute__((pure, nonnull)) +get_payload_length(mds_message_t *restrict this) { - char* header; - size_t i; - - for (i = 0; i < this->header_count; i++) - if (strstr(this->headers[i], "Length: ") == this->headers[i]) - { - /* Store the message length. */ - header = this->headers[i] + strlen("Length: "); - this->payload_size = atoz(header); - - /* Do not except a length that is not correctly formated. */ - for (; *header; header++) - if ((*header < '0') || ('9' < *header)) - return -2; /* Malformated value, enters unrecoverable state. */ - - /* Stop searching for the ‘Length’ header, we have found and parsed it. */ - break; - } - - return 0; + char *header; + size_t i; + + for (i = 0; i < this->header_count; i++) { + if (strstr(this->headers[i], "Length: ") == this->headers[i]) { + /* Store the message length. */ + header = this->headers[i] + strlen("Length: "); + this->payload_size = atoz(header); + + /* Do not except a length that is not correctly formated. */ + for (; *header; header++) + if (*header < '0' || '9' < *header) + return -2; /* Malformated value, enters unrecoverable state. */ + + /* Stop searching for the ‘Length’ header, we have found and parsed it. */ + break; + } + } + + return 0; } @@ -187,21 +191,21 @@ static int get_payload_length(mds_message_t* restrict this) * @param length The length of the header * @return Zero if valid, negative if invalid (malformated message: unrecoverable state) */ -__attribute__((pure, nonnull)) -static int validate_header(const char* header, size_t length) +static int __attribute__((pure, nonnull)) +validate_header(const char *header, size_t length) { - char* p = memchr(header, ':', length * sizeof(char)); - - if (verify_utf8(header, 0) < 0) - /* Either the string is not UTF-8, or your are under an UTF-8 attack, - let's just call this unrecoverable because the client will not correct. */ - return -2; - - if ((p == NULL) || /* Buck you, rawmemchr should not segfault the program. */ - (p[1] != ' ')) /* Also an invalid format. ' ' is mandated after the ':'. */ - return -2; - - return 0; + char *p = memchr(header, ':', length * sizeof(char)); + + if (verify_utf8(header, 0) < 0) + /* Either the string is not UTF-8, or your are under an UTF-8 attack, + let's just call this unrecoverable because the client will not correct. */ + return -2; + + if (!p || /* Buck you, rawmemchr should not segfault the program. */ + p[1] != ' ') /* Also an invalid format. ' ' is mandated after the ':'. */ + return -2; + + return 0; } @@ -212,12 +216,12 @@ static int validate_header(const char* header, size_t length) * @param length The number of characters to remove * @param update_ptr Whether to update the buffer pointer */ -__attribute__((nonnull)) -static void unbuffer_beginning(mds_message_t* restrict this, size_t length, int update_ptr) +static void __attribute__((nonnull)) +unbuffer_beginning(mds_message_t *restrict this, size_t length, int update_ptr) { - memmove(this->buffer, this->buffer + length, (this->buffer_ptr - length) * sizeof(char)); - if (update_ptr) - this->buffer_ptr -= length; + memmove(this->buffer, this->buffer + length, (this->buffer_ptr - length) * sizeof(char)); + if (update_ptr) + this->buffer_ptr -= length; } @@ -228,23 +232,23 @@ static void unbuffer_beginning(mds_message_t* restrict this, size_t length, int * @param this The message * @return The return value follows the rules of `mds_message_read` */ -__attribute__((nonnull)) -static int initialise_payload(mds_message_t* restrict this) +static int __attribute__((nonnull)) +initialise_payload(mds_message_t *restrict this) { - /* Remove the \n (end of empty line) we found from the buffer. */ - unbuffer_beginning(this, 1, 1); - - /* Get the length of the payload. */ - if (get_payload_length(this) < 0) - return -2; /* Malformated value, enters unrecoverable state. */ - - /* Allocate the payload buffer. */ - if (this->payload_size > 0) - fail_if (xmalloc(this->payload, this->payload_size, char)); - - return 0; - fail: - return -1; + /* Remove the \n (end of empty line) we found from the buffer. */ + unbuffer_beginning(this, 1, 1); + + /* Get the length of the payload. */ + if (get_payload_length(this) < 0) + return -2; /* Malformated value, enters unrecoverable state. */ + + /* Allocate the payload buffer. */ + if (this->payload_size > 0) + fail_if (xmalloc(this->payload, this->payload_size, char)); + + return 0; +fail: + return -1; } @@ -255,35 +259,34 @@ static int initialise_payload(mds_message_t* restrict this) * @param length The length of the header, including LF-termination * @return The return value follows the rules of `mds_message_read` */ -__attribute__((nonnull)) -static int store_header(mds_message_t* restrict this, size_t length) +static int __attribute__((nonnull)) +store_header(mds_message_t *restrict this, size_t length) { - char* header; - - /* Allocate the header. */ - fail_if (xmalloc(header, length, char)); /* Last char is a LF, which is substituted with NUL. */ - /* Copy the header data into the allocated header, */ - memcpy(header, this->buffer, length * sizeof(char)); - /* and NUL-terminate it. */ - header[length - 1] = '\0'; - - /* Remove the header data from the read buffer. */ - unbuffer_beginning(this, length, 1); - - /* Make sure the the header syntax is correct so that - the program does not need to care about it. */ - if (validate_header(header, length)) - { - free(header); - return -2; - } - - /* Store the header in the header list. */ - this->headers[this->header_count++] = header; - - return 0; - fail: - return -1; + char *header; + + /* Allocate the header. */ + fail_if (xmalloc(header, length, char)); /* Last char is a LF, which is substituted with NUL. */ + /* Copy the header data into the allocated header, */ + memcpy(header, this->buffer, length * sizeof(char)); + /* and NUL-terminate it. */ + header[length - 1] = '\0'; + + /* Remove the header data from the read buffer. */ + unbuffer_beginning(this, length, 1); + + /* Make sure the the header syntax is correct so that + the program does not need to care about it. */ + if (validate_header(header, length)) { + free(header); + return -2; + } + + /* Store the header in the header list. */ + this->headers[this->header_count++] = header; + + return 0; +fail: + return -1; } @@ -294,37 +297,36 @@ static int store_header(mds_message_t* restrict this, size_t length) * @param fd The file descriptor of the socket * @return The return value follows the rules of `mds_message_read` */ -__attribute__((nonnull)) -static int continue_read(mds_message_t* restrict this, int fd) +static int __attribute__((nonnull)) +continue_read(mds_message_t *restrict this, int fd) { - size_t n; - ssize_t got; - int r; - - /* Figure out how much space we have left in the read buffer. */ - n = this->buffer_size - this->buffer_ptr; - - /* If we do not have too much left, */ - if (n < 128) - { - /* grow the buffer, */ - try (mds_message_extend_buffer(this)); - - /* and recalculate how much space we have left. */ - n = this->buffer_size - this->buffer_ptr; - } - - /* Then read from the socket. */ - errno = 0; - got = recv(fd, this->buffer + this->buffer_ptr, n, 0); - this->buffer_ptr += (size_t)(got < 0 ? 0 : got); - fail_if (errno); - if (got == 0) - fail_if ((errno = ECONNRESET)); - - return 0; - fail: - return -1; + size_t n; + ssize_t got; + int r; + + /* Figure out how much space we have left in the read buffer. */ + n = this->buffer_size - this->buffer_ptr; + + /* If we do not have too much left, */ + if (n < 128) { + /* grow the buffer, */ + try (mds_message_extend_buffer(this)); + + /* and recalculate how much space we have left. */ + n = this->buffer_size - this->buffer_ptr; + } + + /* Then read from the socket. */ + errno = 0; + got = recv(fd, this->buffer + this->buffer_ptr, n, 0); + this->buffer_ptr += (size_t)(got < 0 ? 0 : got); + fail_if (errno); + if (!got) + fail_if ((errno = ECONNRESET)); + + return 0; +fail: + return -1; } @@ -341,86 +343,78 @@ static int continue_read(mds_message_t* restrict this, int fd) * -2 indicates that the message is malformated, * which is a state that cannot be recovered from. */ -int mds_message_read(mds_message_t* restrict this, int fd) +int +mds_message_read(mds_message_t *restrict this, int fd) { - size_t header_commit_buffer = 0; - int r; - - /* If we are at stage 2, we are done and it is time to start over. - This is important because the function could have been interrupted. */ - if (this->stage == 2) - { - reset_message(this); - this->stage = 0; - } - - /* Read from file descriptor until we have a full message. */ - for (;;) - { - char* p; - size_t length; - - /* Stage 0: headers. */ - /* Read all headers that we have stored into the read buffer. */ - while ((this->stage == 0) && - ((p = memchr(this->buffer, '\n', this->buffer_ptr * sizeof(char))) != NULL)) - if ((length = (size_t)(p - this->buffer))) - { - /* We have found a header. */ - - /* On every eighth header found with this function call, - we prepare the header list for eight more headers so - that it does not need to be reallocated again and again. */ - if (header_commit_buffer == 0) - try (mds_message_extend_headers(this, header_commit_buffer = 8)); - - /* Create and store header. */ - try (store_header(this, length + 1)); - header_commit_buffer -= 1; - } - else - { - /* We have found an empty line, i.e. the end of the headers. */ - - /* Remove the header–payload delimiter from the buffer, - get the payload's size and allocate the payload. */ - try (initialise_payload(this)); - - /* Mark end of stage, next stage is getting the payload. */ - this->stage = 1; - } - - - /* Stage 1: payload. */ - if ((this->stage == 1) && (this->payload_size > 0)) - { - /* How much of the payload that has not yet been filled. */ - size_t need = this->payload_size - this->payload_ptr; - /* How much we have of that what is needed. */ - size_t move = min(this->buffer_ptr, need); - - /* Copy what we have, and remove it from the the read buffer. */ - memcpy(this->payload + this->payload_ptr, this->buffer, move * sizeof(char)); - unbuffer_beginning(this, move, 1); - - /* Keep track of how much we have read. */ - this->payload_ptr += move; + size_t header_commit_buffer = 0, length, need, move; + int r; + char *p; + + /* If we are at stage 2, we are done and it is time to start over. + This is important because the function could have been interrupted. */ + if (this->stage == 2) { + reset_message(this); + this->stage = 0; } - if ((this->stage == 1) && (this->payload_ptr == this->payload_size)) - { - /* If we have filled the payload (or there was no payload), - mark the end of this stage, i.e. that the message is - complete, and return with success. */ - this->stage = 2; - return 0; + + /* Read from file descriptor until we have a full message. */ + for (;;) { + /* Stage 0: headers. */ + /* Read all headers that we have stored into the read buffer. */ + while (!this->stage && ((p = memchr(this->buffer, '\n', this->buffer_ptr * sizeof(char))))) { + if ((length = (size_t)(p - this->buffer))) { + /* We have found a header. */ + + /* On every eighth header found with this function call, + we prepare the header list for eight more headers so + that it does not need to be reallocated again and again. */ + if (!header_commit_buffer) + try (mds_message_extend_headers(this, header_commit_buffer = 8)); + + /* Create and store header. */ + try (store_header(this, length + 1)); + header_commit_buffer -= 1; + } else { + /* We have found an empty line, i.e. the end of the headers. */ + + /* Remove the header–payload delimiter from the buffer, + get the payload's size and allocate the payload. */ + try (initialise_payload(this)); + + /* Mark end of stage, next stage is getting the payload. */ + this->stage = 1; + } + } + + + /* Stage 1: payload. */ + if (this->stage == 1 && this->payload_size > 0) { + /* How much of the payload that has not yet been filled. */ + need = this->payload_size - this->payload_ptr; + /* How much we have of that what is needed. */ + move = min(this->buffer_ptr, need); + + /* Copy what we have, and remove it from the the read buffer. */ + memcpy(this->payload + this->payload_ptr, this->buffer, move * sizeof(char)); + unbuffer_beginning(this, move, 1); + + /* Keep track of how much we have read. */ + this->payload_ptr += move; + } + if (this->stage == 1 && this->payload_ptr == this->payload_size) { + /* If we have filled the payload (or there was no payload), + mark the end of this stage, i.e. that the message is + complete, and return with success. */ + this->stage = 2; + return 0; + } + + + /* If stage 1 was not completed. */ + + /* Continue reading from the socket into the buffer. */ + try (continue_read(this, fd)); } - - - /* If stage 1 was not completed. */ - - /* Continue reading from the socket into the buffer. */ - try (continue_read(this, fd)); - } } @@ -431,15 +425,15 @@ int mds_message_read(mds_message_t* restrict this, int fd) * @param this The message * @return The size of the message when marshalled */ -size_t mds_message_marshal_size(const mds_message_t* restrict this) +size_t +mds_message_marshal_size(const mds_message_t *restrict this) { - size_t rc = this->header_count + this->payload_size; - size_t i; - for (i = 0; i < this->header_count; i++) - rc += strlen(this->headers[i]); - rc *= sizeof(char); - rc += 4 * sizeof(size_t) + 2 * sizeof(int); - return rc; + size_t i, rc = this->header_count + this->payload_size; + for (i = 0; i < this->header_count; i++) + rc += strlen(this->headers[i]); + rc *= sizeof(char); + rc += 4 * sizeof(size_t) + 2 * sizeof(int); + return rc; } @@ -449,29 +443,29 @@ size_t mds_message_marshal_size(const mds_message_t* restrict this) * @param this The message * @param data Output buffer for the marshalled data */ -void mds_message_marshal(const mds_message_t* restrict this, char* restrict data) +void +mds_message_marshal(const mds_message_t *restrict this, char *restrict data) { - size_t i, n; - - buf_set_next(data, int, MDS_MESSAGE_T_VERSION); - - buf_set_next(data, size_t, this->header_count); - buf_set_next(data, size_t, this->payload_size); - buf_set_next(data, size_t, this->payload_ptr); - buf_set_next(data, size_t, this->buffer_ptr); - buf_set_next(data, int, this->stage); - - for (i = 0; i < this->header_count; i++) - { - n = strlen(this->headers[i]) + 1; - memcpy(data, this->headers[i], n * sizeof(char)); - buf_next(data, char, n); - } - - memcpy(data, this->payload, this->payload_ptr * sizeof(char)); - buf_next(data, char, this->payload_ptr); - - memcpy(data, this->buffer, this->buffer_ptr * sizeof(char)); + size_t i, n; + + buf_set_next(data, int, MDS_MESSAGE_T_VERSION); + + buf_set_next(data, size_t, this->header_count); + buf_set_next(data, size_t, this->payload_size); + buf_set_next(data, size_t, this->payload_ptr); + buf_set_next(data, size_t, this->buffer_ptr); + buf_set_next(data, int, this->stage); + + for (i = 0; i < this->header_count; i++) { + n = strlen(this->headers[i]) + 1; + memcpy(data, this->headers[i], n * sizeof(char)); + buf_next(data, char, n); + } + + memcpy(data, this->payload, this->payload_ptr * sizeof(char)); + buf_next(data, char, this->payload_ptr); + + memcpy(data, this->buffer, this->buffer_ptr * sizeof(char)); } @@ -483,75 +477,74 @@ void mds_message_marshal(const mds_message_t* restrict this, char* restrict data * @return Non-zero on error, `errno` will be set accordingly. * Destroy the message on error. */ -int mds_message_unmarshal(mds_message_t* restrict this, char* restrict data) +int +mds_message_unmarshal(mds_message_t *restrict this, char *restrict data) { - size_t i, n, header_count; - - /* buf_get(data, int, 0, MDS_MESSAGE_T_VERSION); */ - buf_next(data, int, 1); - - this->header_count = 0; - buf_get_next(data, size_t, header_count); - buf_get_next(data, size_t, this->payload_size); - buf_get_next(data, size_t, this->payload_ptr); - buf_get_next(data, size_t, this->buffer_size = this->buffer_ptr); - buf_get_next(data, int, this->stage); - - /* Make sure that the pointers are NULL so that they are - not freed without being allocated when the message is - destroyed if this function fails. */ - this->headers = NULL; - this->payload = NULL; - this->buffer = NULL; - - /* To 2-power-multiple of 128 bytes. */ - this->buffer_size >>= 7; - if (this->buffer_size == 0) - this->buffer_size = 1; - else - { - this->buffer_size -= 1; - this->buffer_size |= this->buffer_size >> 1; - this->buffer_size |= this->buffer_size >> 2; - this->buffer_size |= this->buffer_size >> 4; - this->buffer_size |= this->buffer_size >> 8; - this->buffer_size |= this->buffer_size >> 16; + size_t i, n, header_count; + + /* buf_get(data, int, 0, MDS_MESSAGE_T_VERSION); */ + buf_next(data, int, 1); + + this->header_count = 0; + buf_get_next(data, size_t, header_count); + buf_get_next(data, size_t, this->payload_size); + buf_get_next(data, size_t, this->payload_ptr); + buf_get_next(data, size_t, this->buffer_size = this->buffer_ptr); + buf_get_next(data, int, this->stage); + + /* Make sure that the pointers are NULL so that they are + not freed without being allocated when the message is + destroyed if this function fails. */ + this->headers = NULL; + this->payload = NULL; + this->buffer = NULL; + + /* To 2-power-multiple of 128 bytes. */ + this->buffer_size >>= 7; + if (!this->buffer_size) { + this->buffer_size = 1; + } else { + this->buffer_size -= 1; + this->buffer_size |= this->buffer_size >> 1; + this->buffer_size |= this->buffer_size >> 2; + this->buffer_size |= this->buffer_size >> 4; + this->buffer_size |= this->buffer_size >> 8; + this->buffer_size |= this->buffer_size >> 16; #if SIZE_MAX == UINT64_MAX - this->buffer_size |= this->buffer_size >> 32; + this->buffer_size |= this->buffer_size >> 32; #endif - this->buffer_size += 1; - } - this->buffer_size <<= 7; - - /* Allocate header list, payload and read buffer. */ - - if (header_count > 0) - fail_if (xmalloc(this->headers, header_count, char*)); - - if (this->payload_size > 0) - fail_if (xmalloc(this->payload, this->payload_size, char)); - - fail_if (xmalloc(this->buffer, this->buffer_size, char)); - - /* Fill the header list, payload and read buffer. */ - - for (i = 0; i < header_count; i++) - { - n = strlen(data) + 1; - fail_if (xmemdup(this->headers[i], data, n, char)); - buf_next(data, char, n); - this->header_count++; - } - - memcpy(this->payload, data, this->payload_ptr * sizeof(char)); - buf_next(data, char, this->payload_ptr); - - memcpy(this->buffer, data, this->buffer_ptr * sizeof(char)); - - return 0; - - fail: - return -1; + this->buffer_size += 1; + } + this->buffer_size <<= 7; + + /* Allocate header list, payload and read buffer. */ + + if (header_count > 0) + fail_if (xmalloc(this->headers, header_count, char*)); + + if (this->payload_size > 0) + fail_if (xmalloc(this->payload, this->payload_size, char)); + + fail_if (xmalloc(this->buffer, this->buffer_size, char)); + + /* Fill the header list, payload and read buffer. */ + + for (i = 0; i < header_count; i++) { + n = strlen(data) + 1; + fail_if (xmemdup(this->headers[i], data, n, char)); + buf_next(data, char, n); + this->header_count++; + } + + memcpy(this->payload, data, this->payload_ptr * sizeof(char)); + buf_next(data, char, this->payload_ptr); + + memcpy(this->buffer, data, this->buffer_ptr * sizeof(char)); + + return 0; + +fail: + return -1; } @@ -562,13 +555,14 @@ int mds_message_unmarshal(mds_message_t* restrict this, char* restrict data) * @param this The message * @return The size of the message when marshalled */ -size_t mds_message_compose_size(const mds_message_t* restrict this) +size_t +mds_message_compose_size(const mds_message_t *restrict this) { - size_t rc = 1 + this->payload_size; - size_t i; - for (i = 0; i < this->header_count; i++) - rc += strlen(this->headers[i]) + 1; - return rc * sizeof(char); + size_t rc = 1 + this->payload_size; + size_t i; + for (i = 0; i < this->header_count; i++) + rc += strlen(this->headers[i]) + 1; + return rc * sizeof(char); } @@ -578,23 +572,22 @@ size_t mds_message_compose_size(const mds_message_t* restrict this) * @param this The message * @param data Output buffer for the marshalled data */ -void mds_message_compose(const mds_message_t* restrict this, char* restrict data) +void +mds_message_compose(const mds_message_t *restrict this, char *restrict data) { - size_t i, n; - - for (i = 0; i < this->header_count; i++) - { - n = strlen(this->headers[i]); - memcpy(data, this->headers[i], n * sizeof(char)); - data += n; - buf_set_next(data, char, '\n'); - } - buf_set_next(data, char, '\n'); - - if (this->payload_size > 0) - memcpy(data, this->payload, this->payload_size * sizeof(char)); + size_t i, n; + + for (i = 0; i < this->header_count; i++) { + n = strlen(this->headers[i]); + memcpy(data, this->headers[i], n * sizeof(char)); + data += n; + buf_set_next(data, char, '\n'); + } + buf_set_next(data, char, '\n'); + + if (this->payload_size > 0) + memcpy(data, this->payload, this->payload_size * sizeof(char)); } #undef try - diff --git a/src/libmdsserver/util.c b/src/libmdsserver/util.c index cac30ad..09d996a 100644 --- a/src/libmdsserver/util.c +++ b/src/libmdsserver/util.c @@ -49,20 +49,21 @@ static char self_exe[PATH_MAX] = {0}; * @param str The client ID string * @return The client ID integer */ -uint64_t parse_client_id(const char* str) +uint64_t +parse_client_id(const char *str) { - char client_words[22]; - char* client_high; - char* client_low; - uint64_t client; - - strcpy(client_high = client_words, str); - client_low = rawmemchr(client_words, ':'); - *client_low++ = '\0'; - client = atou64(client_high) << 32; - client |= atou64(client_low); - - return client; + char client_words[22]; + char *client_high; + char *client_low; + uint64_t client; + + strcpy(client_high = client_words, str); + client_low = rawmemchr(client_words, ':'); + *client_low++ = '\0'; + client = atou64(client_high) << 32; + client |= atou64(client_low); + + return client; } @@ -72,12 +73,11 @@ uint64_t parse_client_id(const char* str) * @param var The environment variable's name * @return The environment variable's value, `NULL` if empty or not defined */ -char* getenv_nonempty(const char* var) +char * +getenv_nonempty(const char *var) { - char* rc = getenv(var); - if ((rc == NULL) || (*rc == '\0')) - return NULL; - return rc; + char *rc = getenv(var); + return (rc && *rc) ? rc : NULL; } @@ -97,20 +97,21 @@ char* getenv_nonempty(const char* var) * * @return Zero on success, -1 on error */ -int prepare_reexec(void) +int +prepare_reexec(void) { - ssize_t len; - len = readlink(SELF_EXE, self_exe, (sizeof(self_exe) / sizeof(char)) - 1); - fail_if (len < 0); - /* ‘readlink() does not append a null byte to buf.’ */ - self_exe[len] = '\0'; - /* Handle possible race condition: file was removed. */ - if (access(self_exe, F_OK) < 0) - if (!strcmp(self_exe + (len - 10), " (deleted)")) - self_exe[len - 10] = '\0'; - return 0; - fail: - return -1; + ssize_t len; + len = readlink(SELF_EXE, self_exe, (sizeof(self_exe) / sizeof(char)) - 1); + fail_if (len < 0); + /* ‘readlink() does not append a null byte to buf.’ */ + self_exe[len] = '\0'; + /* Handle possible race condition: file was removed. */ + if (access(self_exe, F_OK) < 0) + if (!strcmp(self_exe + (len - 10), " (deleted)")) + self_exe[len - 10] = '\0'; + return 0; +fail: + return -1; } @@ -125,30 +126,30 @@ int prepare_reexec(void) * @param argv The command line arguments * @param reexeced Whether the server has previously been re-exec:ed */ -void reexec_server(int argc, char** argv, int reexeced) +void +reexec_server(int argc, char **argv, int reexeced) { - char** reexec_args; - char** reexec_args_; - int i; - - /* Re-exec the server. */ - reexec_args = alloca(((size_t)argc + 2) * sizeof(char*)); - reexec_args_ = reexec_args; - if (reexeced == 0) - { - *reexec_args_++ = *argv; - fail_if (xstrdup(*reexec_args_, "--re-exec")); - for (i = 1; i < argc; i++) - reexec_args_[i] = argv[i]; - } - else /* Don't let the --re-exec:s accumulate. */ - *reexec_args_ = *argv; - for (i = 1; i < argc; i++) - reexec_args_[i] = argv[i]; - reexec_args_[argc] = NULL; - execv(self_exe[0] ? self_exe : argv[0], reexec_args); - fail: - return; + char **reexec_args; + char **reexec_args_; + int i; + + /* Re-exec the server. */ + reexec_args = alloca(((size_t)argc + 2) * sizeof(char*)); + reexec_args_ = reexec_args; + if (!reexeced) { + *reexec_args_++ = *argv; + fail_if (xstrdup(*reexec_args_, "--re-exec")); + for (i = 1; i < argc; i++) + reexec_args_[i] = argv[i]; + } else { /* Don't let the --re-exec:s accumulate. */ + *reexec_args_ = *argv; + } + for (i = 1; i < argc; i++) + reexec_args_[i] = argv[i]; + reexec_args_[argc] = NULL; + execv(self_exe[0] ? self_exe : argv[0], reexec_args); +fail: + return; } @@ -164,17 +165,18 @@ void reexec_server(int argc, char** argv, int reexeced) * @param function The function to run when the signal is caught * @return Zero on success, -1 on error */ -int xsigaction(int signo, void (*function)(int signo)) +int +xsigaction(int signo, void (*function)(int signo)) { - struct sigaction action; - sigset_t sigset; - - sigemptyset(&sigset); - action.sa_handler = function; - action.sa_mask = sigset; - action.sa_flags = 0; - - return sigaction(signo, &action, NULL); + struct sigaction action; + sigset_t sigset; + + sigemptyset(&sigset); + action.sa_handler = function; + action.sa_mask = sigset; + action.sa_flags = 0; + + return sigaction(signo, &action, NULL); } @@ -186,34 +188,32 @@ int xsigaction(int signo, void (*function)(int signo)) * @param length The length of the message * @return The number of bytes that have been sent (even on error) */ -size_t send_message(int socket, const char* message, size_t length) +size_t +send_message(int socket, const char *message, size_t length) { - size_t block_size = length; - size_t sent = 0; - ssize_t just_sent; - - errno = 0; - while (length > 0) - if ((just_sent = send(socket, message + sent, min(block_size, length), MSG_NOSIGNAL)) < 0) - { - if (errno == EPIPE) - errno = ECONNRESET; - if (errno == EMSGSIZE) - { - block_size >>= 1; - if (block_size == 0) - return sent; - } - else - return sent; - } - else - { - sent += (size_t)just_sent; - length -= (size_t)just_sent; - } - - return sent; + size_t block_size = length; + size_t sent = 0; + ssize_t just_sent; + + errno = 0; + while (length > 0) { + if ((just_sent = send(socket, message + sent, min(block_size, length), MSG_NOSIGNAL)) < 0) { + if (errno == EPIPE) + errno = ECONNRESET; + if (errno == EMSGSIZE) { + block_size >>= 1; + if (!block_size) + return sent; + } else { + return sent; + } + } else { + sent += (size_t)just_sent; + length -= (size_t)just_sent; + } + } + + return sent; } @@ -226,20 +226,21 @@ size_t send_message(int socket, const char* message, size_t length) * @param max The maximum accepted value * @return Zero on success, -1 on syntax error */ -int strict_atoi(const char* str, int* value, int min, int max) +int +strict_atoi(const char *str, int *value, int min, int max) { - long long int r; - char* endptr; - - r = strtoll(str, &endptr, 10); - if ((*str == '\0') || isspace(*str) || - (endptr - str != (ssize_t)strlen(str)) || - (r < (long long int)min) || - (r > (long long int)max)) - return -1; - - *value = (int)r; - return 0; + long long int r; + char *endptr; + + r = strtoll(str, &endptr, 10); + if (!*str || isspace(*str) || + endptr - str != (ssize_t)strlen(str) || + r < (long long int)min || + r > (long long int)max) + return -1; + + *value = (int)r; + return 0; } @@ -252,51 +253,50 @@ int strict_atoi(const char* str, int* value, int min, int max) * @param max The maximum accepted value * @return Zero on success, -1 on syntax error */ -int strict_atoj(const char* str, intmax_t* value, intmax_t min, intmax_t max) +int +strict_atoj(const char *str, intmax_t *value, intmax_t min, intmax_t max) { - static char minstr[3 * sizeof(intmax_t) + 2] = { '\0' }; - intmax_t r = 0; - char c; - int neg = 0; - - if (*str == '-') - { - if (*minstr == '\0') - sprintf(minstr, "%j", INTMAX_MIN); - if (!strcmp(str, minstr)) - { - r = INTMAX_MIN; - goto done; + static char minstr[3 * sizeof(intmax_t) + 2] = { '\0' }; + intmax_t r = 0; + char c; + int neg = 0; + + if (*str == '-') { + if (!*minstr) + sprintf(minstr, "%j", INTMAX_MIN); + if (!strcmp(str, minstr)) { + r = INTMAX_MIN; + goto done; + } + neg = 1, str++; } - neg = 1, str++; - } - - if (*str == '\0') - return -1; - - while ((c = *str)) - if (('0' <= c) && (c <= '9')) - { - if (r > INTMAX_MAX / 10) - return -1; - else if (r == INTMAX_MAX / 10) - if ((c & 15) > INTMAX_MAX % 10) - return -1; - r = r * 10 + (c & 15); - } - else - return -1; - - if (neg) - r = -r; - - done: - - if ((r < min) || (r > max)) - return -1; - - *value = r; - return 0; + + if (!*str) + return -1; + + while ((c = *str)) { + if ('0' <= c && c <= '9') { + if (r > INTMAX_MAX / 10) { + return -1; + } else if (r == INTMAX_MAX / 10) { + if ((c & 15) > INTMAX_MAX % 10) + return -1; + } + r = r * 10 + (c & 15); + } else { + return -1; + } + } + + if (neg) + r = -r; + +done: + if (r < min || r > max) + return -1; + + *value = r; + return 0; } @@ -316,50 +316,53 @@ int strict_atoj(const char* str, intmax_t* value, intmax_t min, intmax_t max) * @param max The maximum accepted value * @return Zero on success, -1 on syntax error */ -int strict_atouj(const char* str, uintmax_t* value, uintmax_t min, uintmax_t max) +int +strict_atouj(const char *str, uintmax_t *value, uintmax_t min, uintmax_t max) { - uintmax_t r = 0; - char c; - - if (*str == '\0') - return -1; - - while ((c = *str)) - if (('0' <= c) && (c <= '9')) - { - if (r > INTMAX_MAX / 10) - return -1; - else if (r == INTMAX_MAX / 10) - if ((c & 15) > INTMAX_MAX % 10) - return -1; - r = r * 10 + (c & 15); - } - else - return -1; - - if ((r < min) || (r > max)) - return -1; - - *value = r; - return 0; + uintmax_t r = 0; + char c; + + if (!*str) + return -1; + + while ((c = *str)) { + if ('0' <= c && c <= '9') { + if (r > INTMAX_MAX / 10) { + return -1; + } else if (r == INTMAX_MAX / 10) { + if ((c & 15) > INTMAX_MAX % 10) + return -1; + } + r = r * 10 + (c & 15); + } else { + return -1; + } + } + + if (r < min || r > max) + return -1; + + *value = r; + return 0; } #if defined(__GNUC__) # pragma GCC diagnostic pop #endif -#define __strict_y(Y, TYPE, PARA_TYPE, HYPER_Y, HYPER_TYPE) \ - int strict_##Y(const char* str, TYPE* value, PARA_TYPE min, PARA_TYPE max) \ - { \ - HYPER_TYPE intermediate_value; \ - if (strict_##HYPER_Y(str, &intermediate_value, (HYPER_TYPE)min, (HYPER_TYPE)max) < 0) \ - return -1; \ - return *value = (TYPE)intermediate_value, 0; \ - } +#define __strict_y(Y, TYPE, PARA_TYPE, HYPER_Y, HYPER_TYPE)\ + int\ + strict_##Y(const char *str, TYPE *value, PARA_TYPE min, PARA_TYPE max)\ + {\ + HYPER_TYPE intermediate_value;\ + if (strict_##HYPER_Y(str, &intermediate_value, (HYPER_TYPE)min, (HYPER_TYPE)max) < 0)\ + return -1;\ + return *value = (TYPE)intermediate_value, 0;\ + } -#define __strict_x(X, TYPE, HYPER_X, HYPER_TYPE) \ - __strict_y(X, TYPE, TYPE, HYPER_X, HYPER_TYPE) +#define __strict_x(X, TYPE, HYPER_X, HYPER_TYPE)\ + __strict_y(X, TYPE, TYPE, HYPER_X, HYPER_TYPE) /** @@ -577,20 +580,20 @@ __strict_x(atou64, uint64_t, atouj, uintmax_t) * @param length The length of the buffer * @return Zero on success, -1 on error */ -int full_write(int fd, const char* buffer, size_t length) +int +full_write(int fd, const char *buffer, size_t length) { - ssize_t wrote; - while (length > 0) - { - errno = 0; - wrote = write(fd, buffer, length); - fail_if (errno && (errno != EINTR)); - length -= (size_t)max(wrote, 0); - buffer += (size_t)max(wrote, 0); - } - return 0; - fail: - return -1; + ssize_t wrote; + while (length > 0) { + errno = 0; + wrote = write(fd, buffer, length); + fail_if (errno && errno != EINTR); + length -= (size_t)max(wrote, 0); + buffer += (size_t)max(wrote, 0); + } + return 0; +fail: + return -1; } @@ -601,44 +604,44 @@ int full_write(int fd, const char* buffer, size_t length) * @param length Output parameter for the length of the file, may be `NULL` * @return The content of the file, you will need to free it. `NULL` on error. */ -char* full_read(int fd, size_t* length) +char * +full_read(int fd, size_t *length) { - char* old_buf = NULL; - size_t buffer_size = 8 << 10; - size_t buffer_ptr = 0; - char* buffer; - ssize_t got; - int saved_errno; - - if (length != NULL) - *length = 0; - - /* Allocate buffer for data. */ - fail_if (xmalloc(buffer, buffer_size, char)); - - /* Read the file. */ - for (;;) - { - /* Grow buffer if it is too small. */ - if (buffer_size == buffer_ptr) - fail_if (xxrealloc(old_buf, buffer, buffer_size <<= 1, char)); - - /* Read from the file into the buffer. */ - got = read(fd, buffer + buffer_ptr, buffer_size - buffer_ptr); - fail_if ((got < 0) && (errno != EINTR)); - if (got == 0) - break; - buffer_ptr += (size_t)got; - } - - if (length != NULL) - *length = buffer_ptr; - return buffer; - fail: - saved_errno = errno; - free(old_buf); - free(buffer); - return errno = saved_errno, NULL; + char *old_buf = NULL; + size_t buffer_size = 8 << 10; + size_t buffer_ptr = 0; + char *buffer; + ssize_t got; + int saved_errno; + + if (length) + *length = 0; + + /* Allocate buffer for data. */ + fail_if (xmalloc(buffer, buffer_size, char)); + + /* Read the file. */ + for (;;) { + /* Grow buffer if it is too small. */ + if (buffer_size == buffer_ptr) + fail_if (xxrealloc(old_buf, buffer, buffer_size <<= 1, char)); + + /* Read from the file into the buffer. */ + got = read(fd, buffer + buffer_ptr, buffer_size - buffer_ptr); + fail_if (got < 0 && errno != EINTR); + if (!got) + break; + buffer_ptr += (size_t)got; + } + + if (length) + *length = buffer_ptr; + return buffer; +fail: + saved_errno = errno; + free(old_buf); + free(buffer); + return errno = saved_errno, NULL; } @@ -650,20 +653,20 @@ char* full_read(int fd, size_t* length) * @param length The length of the message * @return Zero on success, -1 on error */ -int full_send(int socket, const char* message, size_t length) +int +full_send(int socket, const char *message, size_t length) { - size_t sent; + size_t sent; - while (length > 0) - { - sent = send_message(socket, message, length); - fail_if ((sent < length) && (errno != EINTR)); - message += sent; - length -= sent; - } - return 0; - fail: - return -1; + while (length > 0) { + sent = send_message(socket, message, length); + fail_if (sent < length && errno != EINTR); + message += sent; + length -= sent; + } + return 0; +fail: + return -1; } @@ -677,17 +680,18 @@ int full_send(int socket, const char* message, size_t length) * @param needle_n The length of `needle` * @return Whether the `haystack` begins with `needle` */ -int startswith_n(const char* haystack, const char* needle, size_t haystack_n, size_t needle_n) +int +startswith_n(const char *haystack, const char *needle, size_t haystack_n, size_t needle_n) { - size_t i; - if (haystack_n < needle_n) - return 0; - - for (i = 0; i < needle_n; i++) - if (haystack[i] != needle[i]) - return 0; - - return 1; + size_t i; + if (haystack_n < needle_n) + return 0; + + for (i = 0; i < needle_n; i++) + if (haystack[i] != needle[i]) + return 0; + + return 1; } @@ -700,30 +704,30 @@ int startswith_n(const char* haystack, const char* needle, size_t haystack_n, si * @param options See description of `options` in the documentation for `waitpid` * @return See the documentation for `waitpid` */ -pid_t uninterruptable_waitpid(pid_t pid, int* restrict status, int options) +pid_t +uninterruptable_waitpid(pid_t pid, int *restrict status, int options) { - struct timespec time_start; - struct timespec time_intr; - int intr_count = 0, have_time; - pid_t rc; - - have_time = (monotone(&time_start) >= 0); - - rewait: - rc = waitpid(pid, status, options); - if (rc == (pid_t)-1) - { - fail_if (errno != EINTR); - if (have_time && (monotone(&time_intr) >= 0)) - if (time_start.tv_sec != time_intr.tv_sec) - intr_count = 0; - if (intr_count++ < 100) - goto rewait; - /* Don't let the CPU catch fire! */ - errno = EINTR; - } - fail: - return rc; + struct timespec time_start; + struct timespec time_intr; + int intr_count = 0, have_time; + pid_t rc; + + have_time = (monotone(&time_start) >= 0); + +rewait: + rc = waitpid(pid, status, options); + if (rc == (pid_t)-1) { + fail_if (errno != EINTR); + if (have_time && monotone(&time_intr) >= 0) + if (time_start.tv_sec != time_intr.tv_sec) + intr_count = 0; + if (intr_count++ < 100) + goto rewait; + /* Don't let the CPU catch fire! */ + errno = EINTR; + } +fail: + return rc; } @@ -734,72 +738,71 @@ pid_t uninterruptable_waitpid(pid_t pid, int* restrict status, int options) * @param allow_modified_nul Whether Modified UTF-8 is allowed, which allows a two-byte encoding for NUL * @return Zero if good, -1 on encoding error */ -int verify_utf8(const char* string, int allow_modified_nul) +int +verify_utf8(const char *string, int allow_modified_nul) { - static long BYTES_TO_MIN_BITS[] = {0, 0, 8, 12, 17, 22, 37}; - static long BYTES_TO_MAX_BITS[] = {0, 7, 11, 16, 21, 26, 31}; - long bytes = 0, read_bytes = 0, bits = 0, c, character; - - /* min bits max bits - 0....... 0 7 - 110..... 10...... 8 11 - 1110.... 10...... 10...... 12 16 - 11110... 10...... 10...... 10...... 17 21 - 111110.. 10...... 10...... 10...... 10...... 22 26 - 1111110. 10...... 10...... 10...... 10...... 10...... 27 31 - */ - - while ((c = (long)(*string++))) - if (read_bytes == 0) - { - /* First byte of the character. */ - - if ((c & 0x80) == 0x00) - /* Single-byte character. */ - continue; - - if ((c & 0xC0) == 0x80) - /* Single-byte character marked as multibyte, or - a non-first byte in a multibyte character. */ - return -1; - - /* Multibyte character. */ - while ((c & 0x80)) - bytes++, c <<= 1; - read_bytes = 1; - character = c & 0x7F; - if (bytes > 6) - /* 31-bit characters can be encoded with 6-bytes, - and UTF-8 does not cover higher code points. */ - return -1; - } - else - { - /* Not first byte of the character. */ - - if ((c & 0xC0) != 0x80) - /* Beginning of new character before a - multibyte character has ended. */ - return -1; - - character = (character << 6) | (c & 0x7F); - - if (++read_bytes < bytes) - /* Not at last byte yet. */ - continue; - - /* Check that the character is not unnecessarily long. */ - while (character) - character >>= 1, bits++; - bits = ((bits == 0) && (bytes == 2) && allow_modified_nul) ? 8 : bits; - if ((bits < BYTES_TO_MIN_BITS[bytes]) || (BYTES_TO_MAX_BITS[bytes] < bits)) - return -1; - - read_bytes = bytes = bits = 0; - } - - /* Make sure we did not stop at the middle of a multibyte character. */ - return read_bytes == 0 ? 0 : -1; + static long BYTES_TO_MIN_BITS[] = {0, 0, 8, 12, 17, 22, 37}; + static long BYTES_TO_MAX_BITS[] = {0, 7, 11, 16, 21, 26, 31}; + long bytes = 0, read_bytes = 0, bits = 0, c, character; + + /* min bits max bits + 0....... 0 7 + 110..... 10...... 8 11 + 1110.... 10...... 10...... 12 16 + 11110... 10...... 10...... 10...... 17 21 + 111110.. 10...... 10...... 10...... 10...... 22 26 + 1111110. 10...... 10...... 10...... 10...... 10...... 27 31 + */ + + while ((c = (long)(*string++))) { + if (read_bytes == 0) { + /* First byte of the character. */ + + if (!(c & 0x80)) + /* Single-byte character. */ + continue; + + if ((c & 0xC0) == 0x80) + /* Single-byte character marked as multibyte, or + a non-first byte in a multibyte character. */ + return -1; + + /* Multibyte character. */ + while ((c & 0x80)) + bytes++, c <<= 1; + read_bytes = 1; + character = c & 0x7F; + if (bytes > 6) + /* 31-bit characters can be encoded with 6-bytes, + and UTF-8 does not cover higher code points. */ + return -1; + } else { + /* Not first byte of the character. */ + + if ((c & 0xC0) != 0x80) + /* Beginning of new character before a + multibyte character has ended. */ + return -1; + + character = (character << 6) | (c & 0x7F); + + if (++read_bytes < bytes) + /* Not at last byte yet. */ + continue; + + /* Check that the character is not unnecessarily long. */ + while (character) + character >>= 1, bits++; + bits = ((bits == 0) && (bytes == 2) && allow_modified_nul) ? 8 : bits; + if ((bits < BYTES_TO_MIN_BITS[bytes]) || (BYTES_TO_MAX_BITS[bytes] < bits)) + return -1; + + read_bytes = bytes = bits = 0; + } + } + + /* Make sure we did not stop at the middle of a multibyte character. */ + return read_bytes == 0 ? 0 : -1; } @@ -828,85 +831,85 @@ int verify_utf8(const char* string, int allow_modified_nul) * @param message_id The message ID of this message * @return The length of the message, zero on error */ -size_t construct_error_message(const char* restrict recv_client_id, const char* restrict recv_message_id, - const char* restrict recv_command, int custom, int errnum, - const char* restrict message, char** restrict send_buffer, - size_t* restrict send_buffer_size, uint32_t message_id) +size_t +construct_error_message(const char *restrict recv_client_id, const char *restrict recv_message_id, + const char *restrict recv_command, int custom, int errnum, + const char *restrict message, char **restrict send_buffer, + size_t *restrict send_buffer_size, uint32_t message_id) { - ssize_t part_length; - size_t length; - char* temp; - - /* Measure the maximum length of message, including NUL-termination.. */ - length = sizeof("Command: error\n" - "To: 4294967296:4294967296\n" - "In response to: 4294967296\n" - "Origin command: \n" - "Message ID: 4294967296\n" - "Error: custom \n" - "Length: \n" - "\n") / sizeof(char) + 3 * (sizeof(int)) + strlen(recv_command); - if (message != NULL) - length += (sizeof("Length: \n") / sizeof(char) - 1) + 3 * sizeof(char) + strlen(message) + 1; - - /* Ensure that the send buffer is large enough. */ - if (length > *send_buffer_size) - { - fail_if (yrealloc(temp, *send_buffer, length, char)); - *send_buffer_size = length; - } - - /* Reset `length` to indicate that the currently written - message has zero in length. */ - length = 0; - - /* Start writting the error message, begin with required - headers, but exclude the error number. */ - sprintf((*send_buffer) + length, - "Command: error\n" - "To: %s\n" - "In response to: %s\n" - "Origin command: %s\n" - "Message ID: %"PRIu32"\n" - "Error: %s%zn", - recv_client_id, recv_message_id, recv_command, - message_id, custom ? "custom" : "", - &part_length), - length += (size_t)part_length; - - /* If the error is custom and has a number we need - blank space before we write the error number. */ - if (custom && (errnum >= 0)) - (*send_buffer)[length++] = ' '; - - /* Add the error number of there is one. */ - if (errnum >= 0) - sprintf((*send_buffer) + length, "%i%zn", errnum, &part_length), - length += (size_t)part_length; - - /* End the `Error`-header line. */ - (*send_buffer)[length++] = '\n'; - - /* Add the `Length`-header if there is a description. */ - if (message != NULL) - sprintf((*send_buffer) + length, "Length: %zu\n%zn", - strlen(message) + 1, &part_length), - length += (size_t)part_length + strlen(message) + 1; - - /* Add an empty line to mark the end of headers. */ - (*send_buffer)[length++] = '\n'; - - /* Write the description if there is one. */ - if (message) - { - memcpy((*send_buffer) + length, message, strlen(message) * sizeof(char)); - length += strlen(message); - (*send_buffer)[length++] = '\n'; - } - - return length; - fail: - return 0; + ssize_t part_length; + size_t length; + char *temp; + + /* Measure the maximum length of message, including NUL-termination.. */ + length = sizeof("Command: error\n" + "To: 4294967296:4294967296\n" + "In response to: 4294967296\n" + "Origin command: \n" + "Message ID: 4294967296\n" + "Error: custom \n" + "Length: \n" + "\n") / sizeof(char) + 3 * (sizeof(int)) + strlen(recv_command); + if (message) + length += (sizeof("Length: \n") / sizeof(char) - 1) + 3 * sizeof(char) + strlen(message) + 1; + + /* Ensure that the send buffer is large enough. */ + if (length > *send_buffer_size) { + fail_if (yrealloc(temp, *send_buffer, length, char)); + *send_buffer_size = length; + } + + /* Reset `length` to indicate that the currently written + message has zero in length. */ + length = 0; + + /* Start writting the error message, begin with required + headers, but exclude the error number. */ + sprintf((*send_buffer) + length, + "Command: error\n" + "To: %s\n" + "In response to: %s\n" + "Origin command: %s\n" + "Message ID: %"PRIu32"\n" + "Error: %s%zn", + recv_client_id, recv_message_id, recv_command, + message_id, custom ? "custom" : "", + &part_length); + length += (size_t)part_length; + + /* If the error is custom and has a number we need + blank space before we write the error number. */ + if (custom && errnum >= 0) + (*send_buffer)[length++] = ' '; + + /* Add the error number of there is one. */ + if (errnum >= 0) + sprintf((*send_buffer) + length, "%i%zn", errnum, &part_length), + length += (size_t)part_length; + + /* End the `Error`-header line. */ + (*send_buffer)[length++] = '\n'; + + /* Add the `Length`-header if there is a description. */ + if (message) { + sprintf((*send_buffer) + length, "Length: %zu\n%zn", + strlen(message) + 1, &part_length); + length += (size_t)part_length + strlen(message) + 1; + } + + /* Add an empty line to mark the end of headers. */ + (*send_buffer)[length++] = '\n'; + + /* Write the description if there is one. */ + if (message) { + memcpy((*send_buffer) + length, message, strlen(message) * sizeof(char)); + length += strlen(message); + (*send_buffer)[length++] = '\n'; + } + + return length; +fail: + return 0; } @@ -936,17 +939,17 @@ size_t construct_error_message(const char* restrict recv_client_id, const char* * @param message_id The message ID of this message * @return Zero on success, -1 on error */ -int send_error(const char* restrict recv_client_id, const char* restrict recv_message_id, - const char* restrict recv_command, int custom, int errnum, const char* restrict message, - char** restrict send_buffer, size_t* restrict send_buffer_size, uint32_t message_id, - int socket_fd) +int +send_error(const char *restrict recv_client_id, const char *restrict recv_message_id, + const char *restrict recv_command, int custom, int errnum, const char *restrict message, + char **restrict send_buffer, size_t *restrict send_buffer_size, uint32_t message_id, + int socket_fd) { - size_t length; - fail_if ((length = construct_error_message(recv_client_id, recv_message_id, recv_command, custom, errnum, - message, send_buffer, send_buffer_size, message_id)) == 0); - fail_if (full_send(socket_fd, *send_buffer, length)); - return 0; - fail: - return -1; + size_t length; + fail_if (!(length = construct_error_message(recv_client_id, recv_message_id, recv_command, custom, errnum, + message, send_buffer, send_buffer_size, message_id))); + fail_if (full_send(socket_fd, *send_buffer, length)); + return 0; +fail: + return -1; } - diff --git a/src/mds-base.h b/src/mds-base.h index 9950117..c3bc735 100644 --- a/src/mds-base.h +++ b/src/mds-base.h @@ -23,15 +23,14 @@ #include <signal.h> -#define MDS_BASE_VARS_VERSION 0 +#define MDS_BASE_VARS_VERSION 0 /** * Characteristics of the server */ -typedef struct server_characteristics -{ +typedef struct server_characteristics { /** * Setting this to zero will cause the server to drop privileges as a security precaution */ @@ -78,7 +77,6 @@ typedef struct server_characteristics * --immortal is used. */ unsigned danger_is_deadly : 1; - } __attribute__((packed)) server_characteristics_t; diff --git a/src/mds-clipboard.h b/src/mds-clipboard.h index 26c15a4..f3672ff 100644 --- a/src/mds-clipboard.h +++ b/src/mds-clipboard.h @@ -30,30 +30,29 @@ /** * Delete entry only when needed */ -#define CLIPITEM_AUTOPURGE_NEVER 0 +#define CLIPITEM_AUTOPURGE_NEVER 0 /** * Delete entry when the client closes, or needed */ -#define CLIPITEM_AUTOPURGE_UPON_DEATH 1 +#define CLIPITEM_AUTOPURGE_UPON_DEATH 1 /** * Delete entry when a point in time has elapsed, or needed */ -#define CLIPITEM_AUTOPURGE_UPON_CLOCK 2 +#define CLIPITEM_AUTOPURGE_UPON_CLOCK 2 /** * Delete entry when the client closes or when a * point in time has elapsed, or when needed */ -#define CLIPITEM_AUTOPURGE_UPON_DEATH_OR_CLOCK 3 +#define CLIPITEM_AUTOPURGE_UPON_DEATH_OR_CLOCK 3 /** * A clipboard entry */ -typedef struct clipitem -{ +typedef struct clipitem { /** * The stored content */ @@ -78,7 +77,6 @@ typedef struct clipitem * Rule for automatic deletion */ int autopurge; - } clipitem_t; diff --git a/src/mds-colour.h b/src/mds-colour.h index 3ab718e..1332198 100644 --- a/src/mds-colour.h +++ b/src/mds-colour.h @@ -30,8 +30,7 @@ /** * Data structure for colour */ -typedef struct colour -{ +typedef struct colour { /** * The value of the red channel */ @@ -52,7 +51,6 @@ typedef struct colour * each channel is encoded */ int bytes; - } colour_t; @@ -139,4 +137,3 @@ void colour_list_entry_free(colour_list_entry_t *entry); #endif - diff --git a/src/mds-echo.c b/src/mds-echo.c index 2bb505f..72f43f8 100644 --- a/src/mds-echo.c +++ b/src/mds-echo.c @@ -30,7 +30,7 @@ -#define MDS_ECHO_VARS_VERSION 0 +#define MDS_ECHO_VARS_VERSION 0 @@ -363,4 +363,3 @@ received_info(int signo) iprintf("echo buffer size: %zu bytes", echo_buffer_size); SIGHANDLER_END; } - diff --git a/src/mds-echo.h b/src/mds-echo.h index 72aedca..5a6e87b 100644 --- a/src/mds-echo.h +++ b/src/mds-echo.h @@ -32,4 +32,3 @@ int echo_message(void); #endif - diff --git a/src/mds-kbdc/builtin-functions.c b/src/mds-kbdc/builtin-functions.c index e0594ab..72593cd 100644 --- a/src/mds-kbdc/builtin-functions.c +++ b/src/mds-kbdc/builtin-functions.c @@ -29,35 +29,35 @@ /** * Define useful data for built-in function with 2 parameters */ -#define define_2 \ - const char32_t* restrict a = *args++; \ - const char32_t* restrict b = *args++; \ - size_t an = string_length(a); \ - size_t bn = string_length(b); \ - size_t i, n = an > bn ? an : bn; \ - char32_t* restrict rc; \ - fail_if (xmalloc(rc, n + 1, char32_t)); \ - rc[n] = -1 +#define define_2\ + const char32_t *restrict a = *args++;\ + const char32_t *restrict b = *args++;\ + size_t an = string_length(a);\ + size_t bn = string_length(b);\ + size_t i, n = an > bn ? an : bn;\ + char32_t *restrict rc;\ + fail_if (xmalloc(rc, n + 1, char32_t));\ + rc[n] = -1 /** * Define useful data for built-in function with 1 parameter */ -#define define_1 \ - const char32_t* restrict a = *args++; \ - size_t i, n = string_length(a); \ - char32_t* restrict rc; \ - fail_if (xmalloc(rc, n + 1, char32_t)); \ - rc[n] = -1 +#define define_1\ + const char32_t* restrict a = *args++;\ + size_t i, n = string_length(a);\ + char32_t *restrict rc;\ + fail_if (xmalloc(rc, n + 1, char32_t));\ + rc[n] = -1 /** * Return a value, or if there was a failure somewhere, return `NULL` * * @param v:void* The value to return on success */ -#define return(v) \ - return v; \ - fail: \ - return NULL; +#define return(v)\ + return v;\ +fail:\ + return NULL; /** @@ -66,12 +66,13 @@ * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_add_2(const char32_t** restrict args) +static char32_t * +builtin_function_add_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] + b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] + b[i % bn]; + return(rc); } @@ -81,12 +82,13 @@ static char32_t* builtin_function_add_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_sub_2(const char32_t** restrict args) +static char32_t * +builtin_function_sub_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] - b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] - b[i % bn]; + return(rc); } @@ -96,12 +98,13 @@ static char32_t* builtin_function_sub_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_mul_2(const char32_t** restrict args) +static char32_t * +builtin_function_mul_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] * b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] * b[i % bn]; + return(rc); } @@ -111,12 +114,13 @@ static char32_t* builtin_function_mul_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_div_2(const char32_t** restrict args) +static char32_t * +builtin_function_div_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] / b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] / b[i % bn]; + return(rc); } @@ -126,12 +130,13 @@ static char32_t* builtin_function_div_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_mod_2(const char32_t** restrict args) +static char32_t * +builtin_function_mod_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] % b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] % b[i % bn]; + return(rc); } @@ -141,12 +146,13 @@ static char32_t* builtin_function_mod_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_rsh_2(const char32_t** restrict args) +static char32_t * +builtin_function_rsh_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] >> b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] >> b[i % bn]; + return(rc); } @@ -156,12 +162,13 @@ static char32_t* builtin_function_rsh_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_lsh_2(const char32_t** restrict args) +static char32_t * +builtin_function_lsh_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] << b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] << b[i % bn]; + return(rc); } @@ -171,12 +178,13 @@ static char32_t* builtin_function_lsh_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_or_2(const char32_t** restrict args) +static char32_t * +builtin_function_or_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] | b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] | b[i % bn]; + return(rc); } @@ -186,12 +194,13 @@ static char32_t* builtin_function_or_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_and_2(const char32_t** restrict args) +static char32_t * +builtin_function_and_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] & b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] & b[i % bn]; + return(rc); } @@ -201,12 +210,13 @@ static char32_t* builtin_function_and_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_xor_2(const char32_t** restrict args) +static char32_t * +builtin_function_xor_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] ^ b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] ^ b[i % bn]; + return(rc); } @@ -216,12 +226,13 @@ static char32_t* builtin_function_xor_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_not_1(const char32_t** restrict args) +static char32_t * +builtin_function_not_1(const char32_t **restrict args) { - define_1; - for (i = 0; i < n; i++) - rc[i] = !a[i]; - return(rc); + define_1; + for (i = 0; i < n; i++) + rc[i] = !a[i]; + return(rc); } @@ -231,12 +242,13 @@ static char32_t* builtin_function_not_1(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_equals_2(const char32_t** restrict args) +static char32_t * +builtin_function_equals_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] == b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] == b[i % bn]; + return(rc); } @@ -246,12 +258,13 @@ static char32_t* builtin_function_equals_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_greater_2(const char32_t** restrict args) +static char32_t * +builtin_function_greater_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] > b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] > b[i % bn]; + return(rc); } @@ -261,12 +274,13 @@ static char32_t* builtin_function_greater_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_less_2(const char32_t** restrict args) +static char32_t * +builtin_function_less_2(const char32_t **restrict args) { - define_2; - for (i = 0; i < n; i++) - rc[i] = a[i % an] < b[i % bn]; - return(rc); + define_2; + for (i = 0; i < n; i++) + rc[i] = a[i % an] < b[i % bn]; + return(rc); } @@ -276,17 +290,18 @@ static char32_t* builtin_function_less_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_get_2(const char32_t** restrict args) +static char32_t * +builtin_function_get_2(const char32_t **restrict args) { - const char32_t* restrict a = *args++; - const char32_t* restrict b = *args++; - char32_t* restrict rc; - size_t n = (size_t)*b; - mds_kbdc_tree_t* value = variables_get((size_t)*a)->array.elements; - while (n--) - value = value->next; - fail_if (rc = string_dup(value->compiled_string.string), rc == NULL); - return(rc); + const char32_t *restrict a = *args++; + const char32_t *restrict b = *args++; + char32_t *restrict rc; + size_t n = (size_t)*b; + mds_kbdc_tree_t *value = variables_get((size_t)*a)->array.elements; + while (n--) + value = value->next; + fail_if (rc = string_dup(value->compiled_string.string), rc == NULL); + return(rc); } @@ -296,21 +311,22 @@ static char32_t* builtin_function_get_2(const char32_t** restrict args) * @param args The arguments passed to the function * @return The return value of the function, `NULL` on error */ -static char32_t* builtin_function_set_3(const char32_t** restrict args) +static char32_t * +builtin_function_set_3(const char32_t **restrict args) { - const char32_t* restrict a = *args++; - const char32_t* restrict b = *args++; - const char32_t* restrict c = *args++; - char32_t* restrict rc; - size_t n = (size_t)*b; - mds_kbdc_tree_t* value = variables_get((size_t)*a)->array.elements; - while (n--) - value = value->next; - free(value->compiled_string.string); - value->compiled_string.string = string_dup(c); - fail_if (value->compiled_string.string == NULL); - fail_if (rc = string_dup(c), rc == NULL); - return(rc); + const char32_t *restrict a = *args++; + const char32_t *restrict b = *args++; + const char32_t *restrict c = *args++; + char32_t *restrict rc; + size_t n = (size_t)*b; + mds_kbdc_tree_t *value = variables_get((size_t)*a)->array.elements; + while (n--) + value = value->next; + free(value->compiled_string.string); + value->compiled_string.string = string_dup(c); + fail_if (!value->compiled_string.string); + fail_if (!(rc = string_dup(c))); + return(rc); } @@ -326,25 +342,26 @@ static char32_t* builtin_function_set_3(const char32_t** restrict args) * @param arg_count The number of arguments to pass to the function * @return Whether the described function is a builtin function */ -int builtin_function_defined(const char* restrict name, size_t arg_count) +int +builtin_function_defined(const char *restrict name, size_t arg_count) { - size_t i; - static const char* const BUILTIN_FUNCTIONS_2[] = - { - "add", "sub", "mul", "div", "mod", "rsh", "lsh", "or", - "and", "xor", "equals", "greater", "less", "get", NULL - }; - - if (arg_count == 3) - return !strcmp(name, "set"); - else if (arg_count == 1) - return !strcmp(name, "not"); - else if (arg_count == 2) - for (i = 0; BUILTIN_FUNCTIONS_2[i]; i++) - if (!strcmp(name, BUILTIN_FUNCTIONS_2[i])) - return 1; - - return 0; + size_t i; + static const char* const BUILTIN_FUNCTIONS_2[] = { + "add", "sub", "mul", "div", "mod", "rsh", "lsh", "or", + "and", "xor", "equals", "greater", "less", "get", NULL + }; + + if (arg_count == 1) { + return !strcmp(name, "not"); + } else if (arg_count == 2) { + for (i = 0; BUILTIN_FUNCTIONS_2[i]; i++) + if (!strcmp(name, BUILTIN_FUNCTIONS_2[i])) + return 1; + } else if (arg_count == 3) { + return !strcmp(name, "set"); + } + + return 0; } @@ -362,35 +379,35 @@ int builtin_function_defined(const char* restrict name, size_t arg_count) * @param args The arguments to pass * @return The return value of the function, `NULL` on error */ -char32_t* builtin_function_invoke(const char* restrict name, size_t arg_count, const char32_t** restrict args) +char32_t * +builtin_function_invoke(const char *restrict name, size_t arg_count, const char32_t **restrict args) { -#define t(f) do { fail_if (rc = builtin_function_##f(args), rc == NULL); return rc; } while (0) - char32_t* rc; - - if ((arg_count == 3) && !strcmp(name, "set")) t (set_3); - if ((arg_count == 1) && !strcmp(name, "not")) t (not_1); - - if (arg_count != 2) - abort(); - - if (!strcmp(name, "add")) t (add_2); - if (!strcmp(name, "sub")) t (sub_2); - if (!strcmp(name, "mul")) t (mul_2); - if (!strcmp(name, "div")) t (div_2); - if (!strcmp(name, "mod")) t (mod_2); - if (!strcmp(name, "rsh")) t (rsh_2); - if (!strcmp(name, "lsh")) t (lsh_2); - if (!strcmp(name, "or")) t (or_2); - if (!strcmp(name, "and")) t (and_2); - if (!strcmp(name, "xor")) t (xor_2); - if (!strcmp(name, "equals")) t (equals_2); - if (!strcmp(name, "greater")) t (greater_2); - if (!strcmp(name, "less")) t (less_2); - if (!strcmp(name, "get")) t (get_2); - - abort(); - fail: - return NULL; +#define t(f) do { fail_if (rc = builtin_function_##f(args), rc == NULL); return rc; } while (0) + char32_t *rc; + + if (arg_count == 3 && !strcmp(name, "set")) t (set_3); + if (arg_count == 1 && !strcmp(name, "not")) t (not_1); + + if (arg_count != 2) + abort(); + + if (!strcmp(name, "add")) t (add_2); + if (!strcmp(name, "sub")) t (sub_2); + if (!strcmp(name, "mul")) t (mul_2); + if (!strcmp(name, "div")) t (div_2); + if (!strcmp(name, "mod")) t (mod_2); + if (!strcmp(name, "rsh")) t (rsh_2); + if (!strcmp(name, "lsh")) t (lsh_2); + if (!strcmp(name, "or")) t (or_2); + if (!strcmp(name, "and")) t (and_2); + if (!strcmp(name, "xor")) t (xor_2); + if (!strcmp(name, "equals")) t (equals_2); + if (!strcmp(name, "greater")) t (greater_2); + if (!strcmp(name, "less")) t (less_2); + if (!strcmp(name, "get")) t (get_2); + + abort(); +fail: + return NULL; #undef t } - diff --git a/src/mds-kbdc/builtin-functions.h b/src/mds-kbdc/builtin-functions.h index fe94205..8d2cc2d 100644 --- a/src/mds-kbdc/builtin-functions.h +++ b/src/mds-kbdc/builtin-functions.h @@ -33,7 +33,8 @@ * @param arg_count The number of arguments to pass to the function * @return Whether the described function is a builtin function */ -int builtin_function_defined(const char* restrict name, size_t arg_count) __attribute__((pure)); +__attribute__((pure)) +int builtin_function_defined(const char *restrict name, size_t arg_count); /** * Invoke a builtin function @@ -49,9 +50,8 @@ int builtin_function_defined(const char* restrict name, size_t arg_count) __attr * @param args The arguments to pass * @return The return value of the function, `NULL` on error */ -char32_t* builtin_function_invoke(const char* restrict name, size_t arg_count, const char32_t** restrict args); +char32_t *builtin_function_invoke(const char *restrict name, size_t arg_count, const char32_t **restrict args); #endif - diff --git a/src/mds-kbdc/call-stack.c b/src/mds-kbdc/call-stack.c index 92c83a7..c864e7c 100644 --- a/src/mds-kbdc/call-stack.c +++ b/src/mds-kbdc/call-stack.c @@ -24,31 +24,29 @@ /** * An entry in the call-stack */ -typedef struct mds_kbdc_call -{ - /** - * The tree node where the call was made - */ - const mds_kbdc_tree_t* tree; - - /** - * The position of the line of the tree node - * where the call begins - */ - size_t start; - - /** - * The position of the line of the tree node - * where the call end - */ - size_t end; - - /** - * A snapshot of the include-stack as it - * looked when the call was being made - */ - mds_kbdc_include_stack_t* include_stack; - +typedef struct mds_kbdc_call { + /** + * The tree node where the call was made + */ + const mds_kbdc_tree_t *tree; + + /** + * The position of the line of the tree node + * where the call begins + */ + size_t start; + + /** + * The position of the line of the tree node + * where the call end + */ + size_t end; + + /** + * A snapshot of the include-stack as it + * looked when the call was being made + */ + mds_kbdc_include_stack_t *include_stack; } mds_kbdc_call_t; @@ -56,27 +54,27 @@ typedef struct mds_kbdc_call /** * Variable whether the latest created error is stored */ -static mds_kbdc_parse_error_t* error; +static mds_kbdc_parse_error_t *error; /** * The `result` parameter of root procedure that requires the include-stack */ -static mds_kbdc_parsed_t* result; +static mds_kbdc_parsed_t *result; /** * The original value of `result->pathname` */ -static char* original_pathname; +static char *original_pathname; /** * The original value of `result->source_code` */ -static mds_kbdc_source_code_t* original_source_code; +static mds_kbdc_source_code_t *original_source_code; /** * Stack of visited function- and macro-calls */ -static mds_kbdc_call_t* restrict calls = NULL; +static mds_kbdc_call_t *restrict calls = NULL; /** * The number elements allocated for `calls` @@ -95,57 +93,59 @@ static size_t calls_ptr = 0; * * @return Zero on success, -1 on error */ -int mds_kbdc_call_stack_dump(void) +int +mds_kbdc_call_stack_dump(void) { - char* old_pathname = result->pathname; - mds_kbdc_source_code_t* old_source_code = result->source_code; - size_t ptr = calls_ptr, iptr; - mds_kbdc_call_t* restrict call; - mds_kbdc_include_stack_t* restrict includes; - - while (ptr--) - { - call = calls + ptr; - includes = call->include_stack; - iptr = includes->ptr; - result->pathname = iptr ? includes->stack[iptr - 1]->filename : original_pathname; - result->source_code = iptr ? includes->stack[iptr - 1]->source_code : original_source_code; - NEW_ERROR_(result, NOTE, 1, call->tree->loc_line, call->start, call->end, 1, "called from here"); - DUMP_INCLUDE_STACK(iptr); - } - - result->pathname = old_pathname; - result->source_code = old_source_code; - return 0; - fail: - result->pathname = old_pathname; - result->source_code = old_source_code; - return -1; + char *old_pathname = result->pathname; + mds_kbdc_source_code_t *old_source_code = result->source_code; + size_t ptr = calls_ptr, iptr; + mds_kbdc_call_t *restrict call; + mds_kbdc_include_stack_t *restrict includes; + + while (ptr--) { + call = calls + ptr; + includes = call->include_stack; + iptr = includes->ptr; + result->pathname = iptr ? includes->stack[iptr - 1]->filename : original_pathname; + result->source_code = iptr ? includes->stack[iptr - 1]->source_code : original_source_code; + NEW_ERROR_(result, NOTE, 1, call->tree->loc_line, call->start, call->end, 1, "called from here"); + DUMP_INCLUDE_STACK(iptr); + } + + result->pathname = old_pathname; + result->source_code = old_source_code; + return 0; +fail: + result->pathname = old_pathname; + result->source_code = old_source_code; + return -1; } /** * Prepare for usage of call-stacks * -xo * @param result_ The `result` parameter of root procedure that requires the call-stack + * @param result_ The `result` parameter of root procedure that requires the call-stack */ -void mds_kbdc_call_stack_begin(mds_kbdc_parsed_t* restrict result_) +void +mds_kbdc_call_stack_begin(mds_kbdc_parsed_t *restrict result_) { - result = result_; - original_pathname = result_->pathname; - original_source_code = result_->source_code; + result = result_; + original_pathname = result_->pathname; + original_source_code = result_->source_code; } /** * Cleanup after usage of call-stacks */ -void mds_kbdc_call_stack_end(void) +void +mds_kbdc_call_stack_end(void) { - result->pathname = original_pathname; - result->source_code = original_source_code; - free(calls), calls = NULL; - calls_size = calls_ptr = 0; + result->pathname = original_pathname; + result->source_code = original_source_code; + free(calls), calls = NULL; + calls_size = calls_ptr = 0; } @@ -157,27 +157,27 @@ void mds_kbdc_call_stack_end(void) * @param end The position of the line of the tree node where the call end * @return Zero on success, -1 on error */ -int mds_kbdc_call_stack_push(const mds_kbdc_tree_t* restrict tree, size_t start, size_t end) +int +mds_kbdc_call_stack_push(const mds_kbdc_tree_t *restrict tree, size_t start, size_t end) { - mds_kbdc_call_t* tmp; - mds_kbdc_call_t* call; - - if (calls_ptr == calls_size) - { - fail_if (yrealloc(tmp, calls, calls_size + 4, mds_kbdc_call_t)); - calls_size += 4; - } - - call = calls + calls_ptr++; - call->tree = tree; - call->start = start; - call->end = end; - call->include_stack = mds_kbdc_include_stack_save(); - fail_if (call->include_stack == NULL); - - return 0; - fail: - return -1; + mds_kbdc_call_t *tmp; + mds_kbdc_call_t *call; + + if (calls_ptr == calls_size) { + fail_if (yrealloc(tmp, calls, calls_size + 4, mds_kbdc_call_t)); + calls_size += 4; + } + + call = calls + calls_ptr++; + call->tree = tree; + call->start = start; + call->end = end; + call->include_stack = mds_kbdc_include_stack_save(); + fail_if (!call->include_stack); + + return 0; +fail: + return -1; } @@ -186,10 +186,10 @@ int mds_kbdc_call_stack_push(const mds_kbdc_tree_t* restrict tree, size_t start, * * This function is guaranteed not to modify `errno` */ -void mds_kbdc_call_stack_pop(void) +void +mds_kbdc_call_stack_pop(void) { - int saved_errno = errno; - mds_kbdc_include_stack_free(calls[--calls_ptr].include_stack); - errno = saved_errno; + int saved_errno = errno; + mds_kbdc_include_stack_free(calls[--calls_ptr].include_stack); + errno = saved_errno; } - diff --git a/src/mds-kbdc/call-stack.h b/src/mds-kbdc/call-stack.h index db7a18a..94b6dc8 100644 --- a/src/mds-kbdc/call-stack.h +++ b/src/mds-kbdc/call-stack.h @@ -27,8 +27,8 @@ /** * Add “called from here”-notes */ -#define DUMP_CALL_STACK \ - fail_if (mds_kbdc_call_stack_dump()) +#define DUMP_CALL_STACK\ + fail_if (mds_kbdc_call_stack_dump()) @@ -44,7 +44,7 @@ int mds_kbdc_call_stack_dump(void); * * @param result The `result` parameter of root procedure that requires the call-stack */ -void mds_kbdc_call_stack_begin(mds_kbdc_parsed_t* restrict result); +void mds_kbdc_call_stack_begin(mds_kbdc_parsed_t *restrict result); /** * Cleanup after usage of call-stacks @@ -59,7 +59,7 @@ void mds_kbdc_call_stack_end(void); * @param end The position of the line of the tree node where the call end * @return Zero on success, -1 on error */ -int mds_kbdc_call_stack_push(const mds_kbdc_tree_t* restrict tree, size_t start, size_t end); +int mds_kbdc_call_stack_push(const mds_kbdc_tree_t *restrict tree, size_t start, size_t end); /** * Undo the lasted not-undone call to `mds_kbdc_call_stack_push` @@ -71,4 +71,3 @@ void mds_kbdc_call_stack_pop(void); #endif - diff --git a/src/mds-kbdc/callables.c b/src/mds-kbdc/callables.c index 24b1e8a..07b08b0 100644 --- a/src/mds-kbdc/callables.c +++ b/src/mds-kbdc/callables.c @@ -25,29 +25,29 @@ /** * Map, by index, from argument count, to list of callable's names */ -static char*** restrict names = NULL; +static char ***restrict names = NULL; /** * If `callable_list[callabes[i][j]]` and `callable_include_stack_list[callabes[i][j]]` * describe the callable named by `named[i][j]` with either `i` parameters, or the * number of parameters specified by the suffix in `named[i][j]` */ -static size_t** restrict callables = NULL; +static size_t **restrict callables = NULL; /** * Map the the number of elements in the, by index, corresponding element in `names` */ -static size_t* restrict bucket_sizes = NULL; +static size_t *restrict bucket_sizes = NULL; /** * List of callables */ -static mds_kbdc_tree_t** restrict callable_list = NULL; +static mds_kbdc_tree_t **restrict callable_list = NULL; /** * List of callables' include-stacks */ -static mds_kbdc_include_stack_t** restrict callable_include_stack_list = NULL; +static mds_kbdc_include_stack_t **restrict callable_include_stack_list = NULL; /** * The number of buckets in `names` and `bucket_sizes` @@ -64,26 +64,26 @@ static size_t list_ptr = 0; /** * Destroy the callable storage */ -void callables_terminate(void) +void +callables_terminate(void) { - size_t i, j, n; - char** bucket; - for (i = 0; i < buckets; i++) - { - bucket = names[i]; - for (j = 0, n = bucket_sizes[i]; j < n; j++) - free(bucket[j]); - free(bucket); - free(callables[i]); - } - for (i = 0; i < list_ptr; i++) - mds_kbdc_include_stack_free(callable_include_stack_list[i]); - free(callables), callables = NULL; - free(names), names = NULL; - free(bucket_sizes), bucket_sizes = NULL; - free(callable_list), callable_list = NULL; - free(callable_include_stack_list), callable_include_stack_list = NULL; - buckets = list_ptr = 0; + size_t i, j, n; + char **bucket; + for (i = 0; i < buckets; i++) { + bucket = names[i]; + for (j = 0, n = bucket_sizes[i]; j < n; j++) + free(bucket[j]); + free(bucket); + free(callables[i]); + } + for (i = 0; i < list_ptr; i++) + mds_kbdc_include_stack_free(callable_include_stack_list[i]); + free(callables), callables = NULL; + free(names), names = NULL; + free(bucket_sizes), bucket_sizes = NULL; + free(callable_list), callable_list = NULL; + free(callable_include_stack_list), callable_include_stack_list = NULL; + buckets = list_ptr = 0; } @@ -97,57 +97,57 @@ void callables_terminate(void) * @param callable_include_stack The include-stack for the callable * @return Zero on success, -1 on error */ -int callables_set(const char* restrict name, size_t arg_count, mds_kbdc_tree_t* restrict callable, - mds_kbdc_include_stack_t* restrict callable_include_stack) +int +callables_set(const char *restrict name, size_t arg_count, mds_kbdc_tree_t *restrict callable, + mds_kbdc_include_stack_t *restrict callable_include_stack) { -#define _yrealloc(var, elements, type) (yrealloc(tmp_##var, var, elements, type)) - - char* dupname = NULL; - char*** tmp_names = NULL; - size_t** tmp_callables = NULL; - size_t* tmp_bucket_sizes = NULL; - char** old_names = NULL; - size_t* old_callables = NULL; - mds_kbdc_tree_t** tmp_callable_list = NULL; - mds_kbdc_include_stack_t** tmp_callable_include_stack_list = NULL; - int saved_errno; - - fail_if (xstrdup(dupname, name)); - - if (arg_count >= buckets) - { - fail_if (_yrealloc(names, arg_count + 1, char**)); - fail_if (_yrealloc(callables, arg_count + 1, size_t*)); - fail_if (_yrealloc(bucket_sizes, arg_count + 1, size_t)); - memset(names + buckets, 0, (arg_count + 1 - buckets) * sizeof(char**)); - memset(callables + buckets, 0, (arg_count + 1 - buckets) * sizeof(size_t*)); - memset(bucket_sizes + buckets, 0, (arg_count + 1 - buckets) * sizeof(size_t)); - buckets = arg_count + 1; - } - - fail_if (xxrealloc(old_names, names[arg_count], bucket_sizes[arg_count] + 1, char*)); - fail_if (xxrealloc(old_callables, callables[arg_count], bucket_sizes[arg_count] + 1, size_t)); - - names[arg_count][bucket_sizes[arg_count]] = dupname, dupname = NULL; - callables[arg_count][bucket_sizes[arg_count]] = list_ptr; - bucket_sizes[arg_count]++; - - fail_if (_yrealloc(callable_list, list_ptr + 1, mds_kbdc_tree_t*)); - fail_if (_yrealloc(callable_include_stack_list, list_ptr + 1, mds_kbdc_include_stack_t*)); - - callable_list[list_ptr] = callable; - callable_include_stack_list[list_ptr] = callable_include_stack; - list_ptr++; - - return 0; - fail: - saved_errno = errno; - free(dupname); - if (old_names) - names[arg_count] = old_names; - if (old_callables) - callables[arg_count] = old_callables; - return errno = saved_errno, -1; +#define _yrealloc(var, elements, type) (yrealloc(tmp_##var, var, elements, type)) + + char *dupname = NULL; + char ***tmp_names = NULL; + size_t **tmp_callables = NULL; + size_t *tmp_bucket_sizes = NULL; + char **old_names = NULL; + size_t *old_callables = NULL; + mds_kbdc_tree_t **tmp_callable_list = NULL; + mds_kbdc_include_stack_t **tmp_callable_include_stack_list = NULL; + int saved_errno; + + fail_if (xstrdup(dupname, name)); + + if (arg_count >= buckets) { + fail_if (_yrealloc(names, arg_count + 1, char**)); + fail_if (_yrealloc(callables, arg_count + 1, size_t*)); + fail_if (_yrealloc(bucket_sizes, arg_count + 1, size_t)); + memset(names + buckets, 0, (arg_count + 1 - buckets) * sizeof(char**)); + memset(callables + buckets, 0, (arg_count + 1 - buckets) * sizeof(size_t*)); + memset(bucket_sizes + buckets, 0, (arg_count + 1 - buckets) * sizeof(size_t)); + buckets = arg_count + 1; + } + + fail_if (xxrealloc(old_names, names[arg_count], bucket_sizes[arg_count] + 1, char*)); + fail_if (xxrealloc(old_callables, callables[arg_count], bucket_sizes[arg_count] + 1, size_t)); + + names[arg_count][bucket_sizes[arg_count]] = dupname, dupname = NULL; + callables[arg_count][bucket_sizes[arg_count]] = list_ptr; + bucket_sizes[arg_count]++; + + fail_if (_yrealloc(callable_list, list_ptr + 1, mds_kbdc_tree_t*)); + fail_if (_yrealloc(callable_include_stack_list, list_ptr + 1, mds_kbdc_include_stack_t*)); + + callable_list[list_ptr] = callable; + callable_include_stack_list[list_ptr] = callable_include_stack; + list_ptr++; + + return 0; +fail: + saved_errno = errno; + free(dupname); + if (old_names) + names[arg_count] = old_names; + if (old_callables) + callables[arg_count] = old_callables; + return errno = saved_errno, -1; #undef _yrealloc } @@ -161,27 +161,26 @@ int callables_set(const char* restrict name, size_t arg_count, mds_kbdc_tree_t* * @param callable Output parameter for the callable, `NULL` if not found * @param callable_include_stack Output parameter for the include-stack for the callable */ -void callables_get(const char* restrict name, size_t arg_count, mds_kbdc_tree_t** restrict callable, - mds_kbdc_include_stack_t** restrict callable_include_stack) +void +callables_get(const char *restrict name, size_t arg_count, mds_kbdc_tree_t **restrict callable, + mds_kbdc_include_stack_t **restrict callable_include_stack) { - char** restrict names_; - size_t i, n; - - *callable = NULL; - *callable_include_stack = NULL; - - if (arg_count >= buckets) - return; - - names_ = names[arg_count]; - for (i = 0, n = bucket_sizes[arg_count]; i < n; i++) - { - if (strcmp(names_[i], name)) - continue; - i = callables[arg_count][i]; - *callable = callable_list[i]; - *callable_include_stack = callable_include_stack_list[i]; - return; - } + char **restrict names_; + size_t i, n; + + *callable = NULL; + *callable_include_stack = NULL; + + if (arg_count >= buckets) + return; + + names_ = names[arg_count]; + for (i = 0, n = bucket_sizes[arg_count]; i < n; i++) { + if (strcmp(names_[i], name)) + continue; + i = callables[arg_count][i]; + *callable = callable_list[i]; + *callable_include_stack = callable_include_stack_list[i]; + return; + } } - diff --git a/src/mds-kbdc/callables.h b/src/mds-kbdc/callables.h index bb453f1..9e0d3b3 100644 --- a/src/mds-kbdc/callables.h +++ b/src/mds-kbdc/callables.h @@ -38,8 +38,8 @@ void callables_terminate(void); * @param callable_include_stack The include-stack for the callable * @return Zero on success, -1 on error */ -int callables_set(const char* restrict name, size_t arg_count, mds_kbdc_tree_t* restrict callable, - mds_kbdc_include_stack_t* restrict callable_include_stack); +int callables_set(const char *restrict name, size_t arg_count, mds_kbdc_tree_t *restrict callable, + mds_kbdc_include_stack_t *restrict callable_include_stack); /** * Get a stored callable @@ -50,9 +50,8 @@ int callables_set(const char* restrict name, size_t arg_count, mds_kbdc_tree_t* * @param callable Output parameter for the callable * @param callable_include_stack Output parameter for the include-stack for the callable */ -void callables_get(const char* restrict name, size_t arg_count, mds_kbdc_tree_t** restrict callable, - mds_kbdc_include_stack_t** restrict callable_include_stack); +void callables_get(const char *restrict name, size_t arg_count, mds_kbdc_tree_t **restrict callable, + mds_kbdc_include_stack_t **restrict callable_include_stack); #endif - diff --git a/src/mds-kbdc/compile-layout.c b/src/mds-kbdc/compile-layout.c index 199e870..8eb832b 100644 --- a/src/mds-kbdc/compile-layout.c +++ b/src/mds-kbdc/compile-layout.c @@ -34,12 +34,12 @@ /** * This process's value for `mds_kbdc_tree_t.processed` */ -#define PROCESS_LEVEL 6 +#define PROCESS_LEVEL 6 /** * Tree type constant shortener */ -#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE +#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE /** * Add an error with “included from here”-notes and, unless @@ -50,36 +50,34 @@ * @param ...:const char*, ... Error description format string and arguments * @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored */ -#define NEW_ERROR(NODE, SEVERITY, ...) \ - do \ - { \ - NEW_ERROR_WITH_INCLUDES(NODE, includes_ptr, SEVERITY, __VA_ARGS__); \ - if (strcmp(#SEVERITY, "NOTE")) \ - DUMP_CALL_STACK; \ - } \ - while (0) +#define NEW_ERROR(NODE, SEVERITY, ...)\ + do {\ + NEW_ERROR_WITH_INCLUDES(NODE, includes_ptr, SEVERITY, __VA_ARGS__);\ + if (strcmp(#SEVERITY, "NOTE"))\ + DUMP_CALL_STACK;\ + } while (0) /** * Beginning of failure clause */ -#define FAIL_BEGIN fail: saved_errno = errno +#define FAIL_BEGIN fail: saved_errno = errno /** * End of failure clause */ -#define FAIL_END return errno = saved_errno, -1 +#define FAIL_END return errno = saved_errno, -1 /** * Variable whether the latest created error is stored */ -static mds_kbdc_parse_error_t* error; +static mds_kbdc_parse_error_t *error; /** * The parameter of `compile_layout` */ -static mds_kbdc_parsed_t* restrict result; +static mds_kbdc_parsed_t *restrict result; /** * 3: `return` is being processed @@ -101,12 +99,12 @@ static int multiple_variants = 0; * * (We will not look too hard.) */ -static mds_kbdc_tree_t* last_value_statement = NULL; +static mds_kbdc_tree_t *last_value_statement = NULL; /** * Address of the current return value */ -static char32_t** current_return_value = NULL; +static char32_t **current_return_value = NULL; /** * Whether ‘\set/3’ has been called @@ -121,7 +119,7 @@ static int have_side_effect = 0; * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_subtree(mds_kbdc_tree_t* restrict tree); +static int compile_subtree(mds_kbdc_tree_t *restrict tree); /** * Check that a function used in a part of a literal is defined @@ -133,8 +131,8 @@ static int compile_subtree(mds_kbdc_tree_t* restrict tree); * @param rc Success status output parameter: zero on success, * -1 on error, 1 if an undefined function is used */ -static void check_function_call(const mds_kbdc_tree_t* restrict tree, const char* restrict raw, - size_t lineoff, const char* restrict* restrict end, int* restrict rc); +static void check_function_call(const mds_kbdc_tree_t *restrict tree, const char *restrict raw, + size_t lineoff, const char *restrict *restrict end, int *restrict rc); /** * Parse an argument in a function call @@ -146,8 +144,8 @@ static void check_function_call(const mds_kbdc_tree_t* restrict tree, const char * @param value Output parameter for the value to which the argument evaulates * @return Zero on success, -1 on error */ -static int parse_function_argument(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff, - const char* restrict* restrict end, char32_t** restrict value); +static int parse_function_argument(mds_kbdc_tree_t *restrict tree, const char *restrict raw, size_t lineoff, + const char *restrict *restrict end, char32_t **restrict value); @@ -167,37 +165,36 @@ static int parse_function_argument(mds_kbdc_tree_t* restrict tree, const char* r * but could easily be mistaked for one that does * @return Zero on success, -1 on error */ -static int let(size_t variable, const char32_t* restrict string, const mds_kbdc_tree_t* restrict value, - mds_kbdc_tree_t* restrict statement, size_t lineoff, int possibile_shadow_attempt) +static int +let(size_t variable, const char32_t *restrict string, const mds_kbdc_tree_t *restrict value, + mds_kbdc_tree_t *restrict statement, size_t lineoff, int possibile_shadow_attempt) { - mds_kbdc_tree_t* tree = NULL; - int saved_errno; - - /* Warn if this is a possible shadow attempt. */ - if (possibile_shadow_attempt && variables_let_will_override(variable) && statement && - (variables_has_been_used_in_for(variable) == 0) && (statement->processed != PROCESS_LEVEL)) - { - statement->processed = PROCESS_LEVEL; - NEW_ERROR(statement, WARNING, "does not shadow existing definition"); - error->start = lineoff; - error->end = lineoff + (size_t)snprintf(NULL, 0, "\\%zu", variable); - } - - /* Duplicate value. */ - if (value) - fail_if (tree = mds_kbdc_tree_dup(value), tree == NULL); - if (value == NULL) - { - fail_if (tree = mds_kbdc_tree_create(C(COMPILED_STRING)), tree == NULL); - fail_if ((tree->compiled_string.string = string_dup(string)) == NULL); - } - - /* Assign variable. */ - fail_if (variables_let(variable, tree)); - return 0; - FAIL_BEGIN; - mds_kbdc_tree_free(tree); - FAIL_END; + mds_kbdc_tree_t *tree = NULL; + int saved_errno; + + /* Warn if this is a possible shadow attempt. */ + if (possibile_shadow_attempt && variables_let_will_override(variable) && statement && + !variables_has_been_used_in_for(variable) && statement->processed != PROCESS_LEVEL) { + statement->processed = PROCESS_LEVEL; + NEW_ERROR(statement, WARNING, "does not shadow existing definition"); + error->start = lineoff; + error->end = lineoff + (size_t)snprintf(NULL, 0, "\\%zu", variable); + } + + /* Duplicate value. */ + if (value) { + fail_if (!(tree = mds_kbdc_tree_dup(value))); + } else { + fail_if (!(tree = mds_kbdc_tree_create(C(COMPILED_STRING)))); + fail_if (!(tree->compiled_string.string = string_dup(string))); + } + + /* Assign variable. */ + fail_if (variables_let(variable, tree)); + return 0; + FAIL_BEGIN; + mds_kbdc_tree_free(tree); + FAIL_END; } @@ -212,48 +209,47 @@ static int let(size_t variable, const char32_t* restrict string, const mds_kbdc_ * @param end The offset on the line where the function call ends * @return Zero on success, -1 on error, 1 if the call is invalid */ -static int check_set_3_get_2_call(mds_kbdc_tree_t* restrict tree, int is_set, const char32_t* variable_arg, - const char32_t* index_arg, size_t start, size_t end) +static int +check_set_3_get_2_call(mds_kbdc_tree_t *restrict tree, int is_set, const char32_t *variable_arg, + const char32_t *index_arg, size_t start, size_t end) { -#define F (is_set ? "set/3" : "get/2") -#define FUN_ERROR(...) \ - do \ - { \ - NEW_ERROR(__VA_ARGS__); \ - error->start = start; \ - error->end = end; \ - return 1; \ - } \ - while(0); - - mds_kbdc_tree_t* variable; - mds_kbdc_tree_t* element; - size_t index, arg_count; - - if ((variable_arg[0] <= 0) || (variable_arg[1] != -1)) - FUN_ERROR(tree, ERROR, "first argument in call to function ‘%s’ must be a variable index", F); - - if ((index_arg[0] < 0) || (index_arg[1] != -1)) - FUN_ERROR(tree, ERROR, "second argument in call to function ‘%s’ must be an element index", F); - - variable = variables_get((size_t)*variable_arg); - if (variable == NULL) - FUN_ERROR(tree, ERROR, "‘\\%zu’ is not declared", (size_t)*variable_arg); - if (variable->type != C(ARRAY)) - FUN_ERROR(tree, ERROR, "‘\\%zu’ is not an array", (size_t)*variable_arg); - - arg_count = index = (size_t)*index_arg; - element = variable->array.elements; - while (element && index--) - element = element->next; - - if (element == NULL) - FUN_ERROR(tree, ERROR, "‘\\%zu’ does not hold %zu %s", - (size_t)*variable_arg, arg_count + 1, arg_count ? "elements" : "element"); - - return 0; - fail: - return -1; +#define F (is_set ? "set/3" : "get/2") +#define FUN_ERROR(...)\ + do {\ + NEW_ERROR(__VA_ARGS__);\ + error->start = start;\ + error->end = end;\ + return 1;\ + } while(0); + + mds_kbdc_tree_t *variable; + mds_kbdc_tree_t *element; + size_t index, arg_count; + + if (variable_arg[0] <= 0 || variable_arg[1] != -1) + FUN_ERROR(tree, ERROR, "first argument in call to function ‘%s’ must be a variable index", F); + + if (index_arg[0] < 0 || index_arg[1] != -1) + FUN_ERROR(tree, ERROR, "second argument in call to function ‘%s’ must be an element index", F); + + variable = variables_get((size_t)*variable_arg); + if (!variable) + FUN_ERROR(tree, ERROR, "‘\\%zu’ is not declared", (size_t)*variable_arg); + if (variable->type != C(ARRAY)) + FUN_ERROR(tree, ERROR, "‘\\%zu’ is not an array", (size_t)*variable_arg); + + arg_count = index = (size_t)*index_arg; + element = variable->array.elements; + while (element && index--) + element = element->next; + + if (!element) + FUN_ERROR(tree, ERROR, "‘\\%zu’ does not hold %zu %s", + (size_t)*variable_arg, arg_count + 1, arg_count ? "elements" : "element"); + + return 0; +fail: + return -1; #undef FUN_ERROR #undef F } @@ -274,125 +270,118 @@ static int check_set_3_get_2_call(mds_kbdc_tree_t* restrict tree, int is_set, co * as containing an error * @return Zero on success, -1 on error */ -static int call_function(mds_kbdc_tree_t* restrict tree, const char* restrict name, - const char32_t** restrict arguments, size_t start, size_t end, - char32_t** restrict return_value) +static int +call_function(mds_kbdc_tree_t *restrict tree, const char *restrict name, const char32_t **restrict arguments, + size_t start, size_t end, char32_t **restrict return_value) { -#define FUN_ERROR(...) \ - do \ - { \ - NEW_ERROR(__VA_ARGS__); \ - error->start = start; \ - error->end = end; \ - tree->processed = PROCESS_LEVEL; \ - free(*return_value), *return_value = NULL; \ - goto done; \ - } \ - while(0); - - size_t i, arg_count = 0, empty_count = 0; - char32_t** old_return_value; - mds_kbdc_tree_function_t* function = NULL; - mds_kbdc_include_stack_t* function_include_stack = NULL; - mds_kbdc_include_stack_t* our_include_stack = NULL; - int r, is_set, builtin, saved_errno; - - /* Push call-stack. */ - mds_kbdc_call_stack_push(tree, start, end); - - /* Count the number of arguments we have. */ - while (arguments[arg_count]) - arg_count++; - - /* Push return-stack. */ - *return_value = NULL; - old_return_value = current_return_value; - current_return_value = return_value; - - /* Get function definition. */ - builtin = builtin_function_defined(name, arg_count); - if (builtin == 0) - callables_get(name, arg_count, (mds_kbdc_tree_t**)&function, &function_include_stack); - if ((builtin == 0) && (function == NULL)) - FUN_ERROR(tree, ERROR, "function ‘%s/%zu’ has not been defined yet", name, arg_count); - - - /* Call non-builtin function. */ - if (builtin == 0) - { - /* Push call stack and set parameters. */ - variables_stack_push(); - for (i = 0; i < arg_count; i++) - fail_if (let(i + 1, arguments[i], NULL, NULL, 0, 0)); - - /* Switch include-stack to the function's. */ - fail_if (our_include_stack = mds_kbdc_include_stack_save(), our_include_stack == NULL); - fail_if (mds_kbdc_include_stack_restore(function_include_stack)); - - /* Call the function. */ - fail_if (compile_subtree(function->inner)); - - /* Switch back the include-stack to ours. */ - fail_if (mds_kbdc_include_stack_restore(our_include_stack)); - mds_kbdc_include_stack_free(our_include_stack), our_include_stack = NULL; - - /* Pop call stack. */ - variables_stack_pop(); - - /* Check that the function returned a value. */ - if (*return_value == NULL) - FUN_ERROR(tree, ERROR, "function ‘%s/%zu’ did not return a value", name, arg_count); - - goto done; - } - - - /* Call builtin function. */ - - /* Check argument sanity. */ - is_set = (arg_count == 3) && !strcmp(name, "set"); - if (is_set || ((arg_count == 2) && !strcmp(name, "get"))) - { - fail_if (r = check_set_3_get_2_call(tree, is_set, arguments[0], arguments[1], start, end), r < 0); - if (r) - { - tree->processed = PROCESS_LEVEL; - free(*return_value), *return_value = NULL; - goto done; +#define FUN_ERROR(...)\ + do {\ + NEW_ERROR(__VA_ARGS__);\ + error->start = start;\ + error->end = end;\ + tree->processed = PROCESS_LEVEL;\ + free(*return_value), *return_value = NULL;\ + goto done;\ + } while(0); + + size_t i, arg_count = 0, empty_count = 0; + char32_t **old_return_value; + mds_kbdc_tree_function_t *function = NULL; + mds_kbdc_include_stack_t *function_include_stack = NULL; + mds_kbdc_include_stack_t *our_include_stack = NULL; + int r, is_set, builtin, saved_errno; + + /* Push call-stack. */ + mds_kbdc_call_stack_push(tree, start, end); + + /* Count the number of arguments we have. */ + while (arguments[arg_count]) + arg_count++; + + /* Push return-stack. */ + *return_value = NULL; + old_return_value = current_return_value; + current_return_value = return_value; + + /* Get function definition. */ + builtin = builtin_function_defined(name, arg_count); + if (!builtin) + callables_get(name, arg_count, (mds_kbdc_tree_t**)&function, &function_include_stack); + if (!builtin && !function) + FUN_ERROR(tree, ERROR, "function ‘%s/%zu’ has not been defined yet", name, arg_count); + + + /* Call non-builtin function. */ + if (!builtin) { + /* Push call stack and set parameters. */ + variables_stack_push(); + for (i = 0; i < arg_count; i++) + fail_if (let(i + 1, arguments[i], NULL, NULL, 0, 0)); + + /* Switch include-stack to the function's. */ + fail_if (our_include_stack = mds_kbdc_include_stack_save(), our_include_stack == NULL); + fail_if (mds_kbdc_include_stack_restore(function_include_stack)); + + /* Call the function. */ + fail_if (compile_subtree(function->inner)); + + /* Switch back the include-stack to ours. */ + fail_if (mds_kbdc_include_stack_restore(our_include_stack)); + mds_kbdc_include_stack_free(our_include_stack), our_include_stack = NULL; + + /* Pop call stack. */ + variables_stack_pop(); + + /* Check that the function returned a value. */ + if (!*return_value) + FUN_ERROR(tree, ERROR, "function ‘%s/%zu’ did not return a value", name, arg_count); + + goto done; } - } - else - { - for (i = 0; i < arg_count; i++) - empty_count += string_length(arguments[i]) == 0; - if (empty_count && (empty_count != arg_count)) - FUN_ERROR(tree, ERROR, - "built-in function ‘%s/%zu’ requires that either none of" - " the arguments are empty strings or that all of them are", - name, arg_count); - } - - /* Call the function. */ - *return_value = builtin_function_invoke(name, arg_count, arguments); - fail_if (*return_value == NULL); - have_side_effect |= is_set; - /* XXX ideally, we want to make sure it is in a scope that actually brings side-effects. */ - - - done: - /* Pop call-stack. */ - mds_kbdc_call_stack_pop(); - - /* Pop return-stack. */ - current_return_value = old_return_value; - return 0; - - FAIL_BEGIN; - mds_kbdc_call_stack_pop(); - mds_kbdc_include_stack_free(our_include_stack); - free(*return_value), *return_value = NULL; - current_return_value = old_return_value; - FAIL_END; + + + /* Call builtin function. */ + + /* Check argument sanity. */ + is_set = arg_count == 3 && !strcmp(name, "set"); + if (is_set || (arg_count == 2 && !strcmp(name, "get"))) { + fail_if (r = check_set_3_get_2_call(tree, is_set, arguments[0], arguments[1], start, end), r < 0); + if (r) { + tree->processed = PROCESS_LEVEL; + free(*return_value), *return_value = NULL; + goto done; + } + } else { + for (i = 0; i < arg_count; i++) + empty_count += !string_length(arguments[i]); + if (empty_count && empty_count != arg_count) + FUN_ERROR(tree, ERROR, + "built-in function ‘%s/%zu’ requires that either none of" + " the arguments are empty strings or that all of them are", + name, arg_count); + } + + /* Call the function. */ + *return_value = builtin_function_invoke(name, arg_count, arguments); + fail_if (!*return_value); + have_side_effect |= is_set; + /* XXX ideally, we want to make sure it is in a scope that actually brings side-effects. */ + + +done: + /* Pop call-stack. */ + mds_kbdc_call_stack_pop(); + + /* Pop return-stack. */ + current_return_value = old_return_value; + return 0; + + FAIL_BEGIN; + mds_kbdc_call_stack_pop(); + mds_kbdc_include_stack_free(our_include_stack); + free(*return_value), *return_value = NULL; + current_return_value = old_return_value; + FAIL_END; #undef FUN_ERROR } @@ -408,102 +397,99 @@ static int call_function(mds_kbdc_tree_t* restrict tree, const char* restrict na * @param end Output parameter for the end of the escape * @return The text the escape represents, `NULL` on error */ -static char32_t* parse_function_call(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff, - int* restrict escape, const char* restrict* restrict end) +static char32_t * +parse_function_call(mds_kbdc_tree_t *restrict tree, const char *restrict raw, size_t lineoff, + int *restrict escape, const char *restrict *restrict end) { -#define R(LOWER, UPPER) (((LOWER) <= c) && (c <= (UPPER))) -#define GROW_ARGS \ - if (arguments_ptr == arguments_size) \ - fail_if (xxrealloc(old_arguments, arguments, arguments_size += 4, char32_t*)) - - const char* restrict bracket = raw + 1; - char32_t* rc = NULL; - const char32_t** restrict arguments_; - char32_t** restrict arguments = NULL; - char32_t** restrict old_arguments = NULL; - size_t arguments_ptr = 0, arguments_size = 0; - char* restrict name; - char c; - int r, saved_errno = 0; - - /* Find the opening bracket associated with the function call and validate the escape. */ - for (; c = *bracket, 1; bracket++) - if ((c == '_') || R('0', '9') || R('a', 'z') || R('A', 'Z')); - else if (c == '(') - break; - else - { - *end = bracket; - if (tree->processed != PROCESS_LEVEL) - NEW_ERROR(tree, ERROR, "invalid escape"); - goto error; - } - - /* Copy the name of the function. */ - name = alloca((size_t)(bracket - raw) * sizeof(char)); - memcpy(name, raw + 1, (size_t)(bracket - raw - 1) * sizeof(char)); - name[bracket - raw - 1] = 0; - - /* Get arguments. */ - for (*end = ++bracket;;) - { - while (**end == ' ') - (*end)++; - GROW_ARGS; - arguments[arguments_ptr] = NULL; - if (**end == ')') - { - *escape = 0; - (*end)++; - arguments_ptr++; - break; +#define R(LOWER, UPPER) ((LOWER) <= c && c <= (UPPER)) +#define GROW_ARGS\ + if (arguments_ptr == arguments_size)\ + fail_if (xxrealloc(old_arguments, arguments, arguments_size += 4, char32_t*)) + + const char *restrict bracket = raw + 1; + char32_t *rc = NULL; + const char32_t **restrict arguments_; + char32_t **restrict arguments = NULL; + char32_t **restrict old_arguments = NULL; + size_t arguments_ptr = 0, arguments_size = 0; + char *restrict name; + char c; + int r, saved_errno = 0; + + /* Find the opening bracket associated with the function call and validate the escape. */ + for (; c = *bracket, 1; bracket++) { + if (c == '_' || R('0', '9') || R('a', 'z') || R('A', 'Z')); + else if (c == '(') { + break; + } else { + *end = bracket; + if (tree->processed != PROCESS_LEVEL) + NEW_ERROR(tree, ERROR, "invalid escape"); + goto error; + } } - else if (**end == '\0') - { - if (tree->processed != PROCESS_LEVEL) - NEW_ERROR(tree, ERROR, "incomplete function call"); - goto error; + + /* Copy the name of the function. */ + name = alloca((size_t)(bracket - raw) * sizeof(char)); + memcpy(name, raw + 1, (size_t)(bracket - raw - 1) * sizeof(char)); + name[bracket - raw - 1] = 0; + + /* Get arguments. */ + for (*end = ++bracket;;) { + while (**end == ' ') + (*end)++; + GROW_ARGS; + arguments[arguments_ptr] = NULL; + if (**end == ')') { + *escape = 0; + (*end)++; + arguments_ptr++; + break; + } else if (!**end) { + if (tree->processed != PROCESS_LEVEL) + NEW_ERROR(tree, ERROR, "incomplete function call"); + goto error; + } + r = parse_function_argument(tree, *end, lineoff + (size_t)(*end - raw), end, arguments + arguments_ptr++); + fail_if (r < 0); } - r = parse_function_argument(tree, *end, lineoff + (size_t)(*end - raw), end, arguments + arguments_ptr++); - fail_if (r < 0); - } - - /* Call the function. */ - if (tree->processed == PROCESS_LEVEL) - goto stop; - arguments_ = alloca(arguments_ptr * sizeof(const char32_t*)); - memcpy(arguments_, arguments, arguments_ptr * sizeof(const char32_t*)); - fail_if (call_function(tree, name, arguments_, lineoff, lineoff + (size_t)(*end - raw), &rc)); - if (rc == NULL) - goto stop; - - goto done; - - error: - error->start = lineoff; - error->end = lineoff + (size_t)(*end - raw); - stop: - *escape = 0; - tree->processed = PROCESS_LEVEL; - fail_if (xmalloc(rc, 1, char32_t)); - *rc = -1; - goto done; - - fail: - saved_errno = errno; - free(rc); - if (old_arguments) - arguments = old_arguments; - while (arguments_ptr--) - free(arguments[arguments_ptr]); - free(arguments); - rc = NULL; - done: - while (arguments_ptr--) - free(arguments[arguments_ptr]); - free(arguments); - errno = saved_errno; - return rc; + + /* Call the function. */ + if (tree->processed == PROCESS_LEVEL) + goto stop; + arguments_ = alloca(arguments_ptr * sizeof(const char32_t*)); + memcpy(arguments_, arguments, arguments_ptr * sizeof(const char32_t*)); + fail_if (call_function(tree, name, arguments_, lineoff, lineoff + (size_t)(*end - raw), &rc)); + if (!rc) + goto stop; + + goto done; + +error: + error->start = lineoff; + error->end = lineoff + (size_t)(*end - raw); +stop: + *escape = 0; + tree->processed = PROCESS_LEVEL; + fail_if (xmalloc(rc, 1, char32_t)); + *rc = -1; + goto done; + +fail: + saved_errno = errno; + free(rc); + if (old_arguments) + arguments = old_arguments; + while (arguments_ptr--) + free(arguments[arguments_ptr]); + free(arguments); + rc = NULL; +done: + while (arguments_ptr--) + free(arguments[arguments_ptr]); + free(arguments); + errno = saved_errno; + return rc; #undef GROW_ARGS #undef R } @@ -520,41 +506,39 @@ static char32_t* parse_function_call(mds_kbdc_tree_t* restrict tree, const char* * -1 on error, 1 if an undefined function is used * @return The number of arguments the part of the literal contains */ -static size_t check_function_calls_in_literal_(const mds_kbdc_tree_t* restrict tree, - const char* restrict raw, size_t lineoff, - const char* restrict* restrict end, int* restrict rc) +static size_t +check_function_calls_in_literal_(const mds_kbdc_tree_t *restrict tree, const char *restrict raw, + size_t lineoff, const char *restrict *restrict end, int *restrict rc) { -#define R(LOWER, UPPER) (((LOWER) <= c) && (c <= (UPPER))) - const char* restrict raw_ = raw; - size_t count = 0; - int space = 1, quote = 0, escape = 0; - char c; - - while ((c = *raw++)) - { - if (space && !strchr(" )", c)) - space = 0, count++; - - if (escape) - { - escape = 0; - if (((c == '_') || R('a', 'z') || R('A', 'Z')) && (c != 'u')) - /* \u*() is disallowed because \u* is used for hexadecimal representation. */ - if (check_function_call(tree, raw - 2, lineoff + (size_t)(raw - 2 - raw_), &raw, rc), *rc < 0) - break; - } - else if (c == '\\') escape = 1; - else if (c == '"') quote ^= 1; - else if (!quote) - { - space = (c == ' '); - if (c == ')') - break; +#define R(LOWER, UPPER) ((LOWER) <= c && c <= (UPPER)) + const char *restrict raw_ = raw; + size_t count = 0; + int space = 1, quote = 0, escape = 0; + char c; + + while ((c = *raw++)) { + if (space && !strchr(" )", c)) + space = 0, count++; + + if (escape) { + escape = 0; + if ((c == '_' || R('a', 'z') || R('A', 'Z')) && c != 'u') + /* \u*() is disallowed because \u* is used for hexadecimal representation. */ + if (check_function_call(tree, raw - 2, lineoff + (size_t)(raw - 2 - raw_), &raw, rc), *rc < 0) + break; + } else if (c == '\\') { + escape = 1; + } else if (c == '"') { + quote ^= 1; + } else if (!quote) { + space = c == ' '; + if (c == ')') + break; + } } - } - - *end = raw; - return count; + + *end = raw; + return count; #undef R } @@ -569,45 +553,46 @@ static size_t check_function_calls_in_literal_(const mds_kbdc_tree_t* restrict t * @param rc Success status output parameter: zero on success, * -1 on error, 1 if an undefined function is used */ -static void check_function_call(const mds_kbdc_tree_t* restrict tree, const char* restrict raw, - size_t lineoff, const char* restrict* restrict end, int* restrict rc) +static void +check_function_call(const mds_kbdc_tree_t *restrict tree, const char *restrict raw, + size_t lineoff, const char *restrict *restrict end, int *restrict rc) { - mds_kbdc_tree_t* function = NULL; - mds_kbdc_include_stack_t* _function_include_stack; - char* restrict bracket = strchr(raw, '('); - char* restrict name; - size_t arg_count; - - /* Check that it is a function call by check that it has an opening bracket. */ - if (bracket == NULL) - { - *end = raw + strlen(raw); - return; - } - - /* Copy the name of the function. */ - name = alloca((size_t)(bracket - raw) * sizeof(char)); - memcpy(name, raw + 1, (size_t)(bracket - raw - 1) * sizeof(char)); - name[bracket++ - raw - 1] = 0; - - /* Get the number of arguments used, and check function calls there too. */ - arg_count = check_function_calls_in_literal_(tree, bracket, lineoff + (size_t)(bracket - raw), end, rc); - if (*rc < 0) return; - - /* Check that the function is defined. */ - if (builtin_function_defined(name, arg_count)) - return; - callables_get(name, arg_count, &function, &_function_include_stack); - if (function != NULL) - return; - *rc |= 1; - NEW_ERROR(tree, ERROR, "function ‘%s/%zu’ has not been defined yet", name, arg_count); - error->start = lineoff; - error->end = lineoff + (size_t)(*end - raw); - return; - - fail: - *rc |= -1; + mds_kbdc_tree_t *function = NULL; + mds_kbdc_include_stack_t *_function_include_stack; + char *restrict bracket = strchr(raw, '('); + char *restrict name; + size_t arg_count; + + /* Check that it is a function call by check that it has an opening bracket. */ + if (!bracket) { + *end = raw + strlen(raw); + return; + } + + /* Copy the name of the function. */ + name = alloca((size_t)(bracket - raw) * sizeof(char)); + memcpy(name, raw + 1, (size_t)(bracket - raw - 1) * sizeof(char)); + name[bracket++ - raw - 1] = 0; + + /* Get the number of arguments used, and check function calls there too. */ + arg_count = check_function_calls_in_literal_(tree, bracket, lineoff + (size_t)(bracket - raw), end, rc); + if (*rc < 0) + return; + + /* Check that the function is defined. */ + if (builtin_function_defined(name, arg_count)) + return; + callables_get(name, arg_count, &function, &_function_include_stack); + if (function) + return; + *rc |= 1; + NEW_ERROR(tree, ERROR, "function ‘%s/%zu’ has not been defined yet", name, arg_count); + error->start = lineoff; + error->end = lineoff + (size_t)(*end - raw); + return; + +fail: + *rc |= -1; } @@ -619,14 +604,15 @@ static void check_function_call(const mds_kbdc_tree_t* restrict tree, const char * @param lineoff The offset on the line where the literal beings * @return Zero on success, -1 on error, 1 if an undefined function is used */ -static int check_function_calls_in_literal(const mds_kbdc_tree_t* restrict tree, - const char* restrict raw, size_t lineoff) +static int +check_function_calls_in_literal(const mds_kbdc_tree_t *restrict tree, + const char *restrict raw, size_t lineoff) { - int rc = 0; - (void) check_function_calls_in_literal_(tree, raw, lineoff, &raw, &rc); - fail_if (rc < 0); - fail: - return rc; + int rc = 0; + (void) check_function_calls_in_literal_(tree, raw, lineoff, &raw, &rc); + fail_if (rc < 0); +fail: + return rc; } @@ -641,102 +627,98 @@ static int check_function_calls_in_literal(const mds_kbdc_tree_t* restrict tree, * @param end Output parameter for the end of the escape * @return The text the escape represents, `NULL` on error */ -static char32_t* parse_escape(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff, - int* restrict escape, const char* restrict* restrict end) +static char32_t * +parse_escape(mds_kbdc_tree_t *restrict tree, const char *restrict raw, size_t lineoff, + int *restrict escape, const char *restrict *restrict end) { -#define R(LOWER, UPPER) (((LOWER) <= c) && (c <= (UPPER))) -#define CR(COND, LOWER, UPPER) ((*escape == (COND)) && R(LOWER, UPPER)) -#define VARIABLE (int)(raw - raw_) - (c == '.'), raw_ -#define RETURN_ERROR(...) \ - do \ - { \ - NEW_ERROR(__VA_ARGS__); \ - error->start = lineoff; \ - error->end = lineoff + (size_t)(raw - raw_); \ - tree->processed = PROCESS_LEVEL; \ - *escape = 0; \ - if (rc) \ - goto done; \ - fail_if (xmalloc(rc, 1, char32_t)); \ - *rc = -1; \ - goto done; \ - } \ - while (0) - - const char* restrict raw_ = raw++; - char c = *raw++; - uintmax_t numbuf = 0; - char32_t* rc = NULL; - mds_kbdc_tree_t* value; - int have = 0, saved_errno; - - - /* Get escape type. */ - if (c == '0') - /* Octal representation. */ - *escape = 8, have = 1; - else if (c == 'u') - /* Hexadecimal representation. */ - *escape = 16; - else if (R('1', '9')) - /* Variable dereference. */ - *escape = 10, have = 1, numbuf = (uintmax_t)(c - '0'); - else if ((c == '_') || R('a', 'z') || R('A', 'Z')) - /* Function call. */ - *escape = 100; - else - RETURN_ERROR(tree, ERROR, "invalid escape"); - - - /* Read escape. */ - if (*escape == 100) - /* Function call. */ - { - fail_if (rc = parse_function_call(tree, raw_, lineoff, escape, end), rc == NULL); - return rc; - } - /* Octal or hexadecimal representation, or variable dereference. */ - for (; (c = *raw); have = 1, raw++) - if (CR( 8, '0', '7')) numbuf = 8 * numbuf + (c & 15); - else if (CR(16, '0', '9')) numbuf = 16 * numbuf + (c & 15); - else if (CR(16, 'a', 'f')) numbuf = 16 * numbuf + (c & 15) + 9; - else if (CR(16, 'A', 'F')) numbuf = 16 * numbuf + (c & 15) + 9; - else if (CR(10, '0', '9')) numbuf = 10 * numbuf + (c & 15); - else break; - if (c == '.') - raw++; - if (have == 0) - RETURN_ERROR(tree, ERROR, "invalid escape"); - - - /* Evaluate escape. */ - if (*escape == 10) - { - /* Variable dereference. */ - if (value = variables_get((size_t)numbuf), value == NULL) - RETURN_ERROR(tree, ERROR, "variable ‘%.*s’ is not defined", VARIABLE); - if (value->type == C(ARRAY)) - RETURN_ERROR(tree, ERROR, "variable ‘%.*s’ is an array", VARIABLE); - if (value->type != C(COMPILED_STRING)) - NEW_ERROR(tree, INTERNAL_ERROR, "variable ‘%.*s’ is of impossible type", VARIABLE); - fail_if (rc = string_dup(value->compiled_string.string), rc == NULL); - } - else - { - /* Octal or hexadecimal representation. */ - fail_if (xmalloc(rc, 2, char32_t)); - rc[0] = (char32_t)numbuf, rc[1] = -1; - } - - - done: - *escape = 0; - *end = raw; - return rc; - fail: - saved_errno = errno; - free(rc); - return errno = saved_errno, NULL; +#define R(LOWER, UPPER) ((LOWER) <= c && c <= (UPPER)) +#define CR(COND, LOWER, UPPER) (*escape == (COND) && R(LOWER, UPPER)) +#define VARIABLE (int)(raw - raw_) - (c == '.'), raw_ +#define RETURN_ERROR(...)\ + do {\ + NEW_ERROR(__VA_ARGS__);\ + error->start = lineoff;\ + error->end = lineoff + (size_t)(raw - raw_);\ + tree->processed = PROCESS_LEVEL;\ + *escape = 0;\ + if (rc)\ + goto done;\ + fail_if (xmalloc(rc, 1, char32_t));\ + *rc = -1;\ + goto done;\ + } while (0) + + const char* restrict raw_ = raw++; + char c = *raw++; + uintmax_t numbuf = 0; + char32_t* rc = NULL; + mds_kbdc_tree_t* value; + int have = 0, saved_errno; + + + /* Get escape type. */ + if (c == '0') + /* Octal representation. */ + *escape = 8, have = 1; + else if (c == 'u') + /* Hexadecimal representation. */ + *escape = 16; + else if (R('1', '9')) + /* Variable dereference. */ + *escape = 10, have = 1, numbuf = (uintmax_t)(c - '0'); + else if (c == '_' || R('a', 'z') || R('A', 'Z')) + /* Function call. */ + *escape = 100; + else + RETURN_ERROR(tree, ERROR, "invalid escape"); + + + /* Read escape. */ + if (*escape == 100) { + /* Function call. */ + fail_if (rc = parse_function_call(tree, raw_, lineoff, escape, end), rc == NULL); + return rc; + } + /* Octal or hexadecimal representation, or variable dereference. */ + for (; (c = *raw); have = 1, raw++) { + if (CR( 8, '0', '7')) numbuf = 8 * numbuf + (c & 15); + else if (CR(16, '0', '9')) numbuf = 16 * numbuf + (c & 15); + else if (CR(16, 'a', 'f')) numbuf = 16 * numbuf + (c & 15) + 9; + else if (CR(16, 'A', 'F')) numbuf = 16 * numbuf + (c & 15) + 9; + else if (CR(10, '0', '9')) numbuf = 10 * numbuf + (c & 15); + else break; + } + if (c == '.') + raw++; + if (have == 0) + RETURN_ERROR(tree, ERROR, "invalid escape"); + + + /* Evaluate escape. */ + if (*escape == 10) { + /* Variable dereference. */ + if (!(value = variables_get((size_t)numbuf))) + RETURN_ERROR(tree, ERROR, "variable ‘%.*s’ is not defined", VARIABLE); + if (value->type == C(ARRAY)) + RETURN_ERROR(tree, ERROR, "variable ‘%.*s’ is an array", VARIABLE); + if (value->type != C(COMPILED_STRING)) + NEW_ERROR(tree, INTERNAL_ERROR, "variable ‘%.*s’ is of impossible type", VARIABLE); + fail_if (!(rc = string_dup(value->compiled_string.string))); + } else { + /* Octal or hexadecimal representation. */ + fail_if (xmalloc(rc, 2, char32_t)); + rc[0] = (char32_t)numbuf, rc[1] = -1; + } + + +done: + *escape = 0; + *end = raw; + return rc; +fail: + saved_errno = errno; + free(rc); + return errno = saved_errno, NULL; #undef RETURN_ERROR #undef VARIABLE #undef CR @@ -752,127 +734,114 @@ static char32_t* parse_escape(mds_kbdc_tree_t* restrict tree, const char* restri * @param lineoff The offset on the line where the string beings * @return The string as pure text, `NULL` on error */ -static char32_t* parse_quoted_string(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff) +static char32_t * +parse_quoted_string(mds_kbdc_tree_t *restrict tree, const char *restrict raw, size_t lineoff) { -#define GROW_BUF \ - if (buf_ptr == buf_size) \ - fail_if (xxrealloc(old_buf, buf, buf_size += 16, char)) -#define COPY \ - n = string_length(subrc); \ - fail_if (xxrealloc(old_rc, rc, rc_ptr + n, char32_t)); \ - memcpy(rc + rc_ptr, subrc, n * sizeof(char32_t)), rc_ptr += n; \ - free(subrc), subrc = NULL -#define STORE \ - if (buf_ptr) \ - do \ - { \ - GROW_BUF; \ - buf[buf_ptr] = '\0', buf_ptr = 0; \ - fail_if (subrc = string_decode(buf), subrc == NULL); \ - COPY; \ - } \ - while (0) -#define CHAR_ERROR(...) \ - do \ - { \ - NEW_ERROR(__VA_ARGS__); \ - error->end = lineoff + (size_t)(raw - raw_); \ - error->start = error->end - 1; \ - } \ - while (0) - - const char* restrict raw_ = raw; - char32_t* restrict subrc = NULL; - char32_t* restrict rc = NULL; - char32_t* restrict old_rc = NULL; - char* restrict buf = NULL; - char* restrict old_buf = NULL; - size_t rc_ptr = 0, n; - size_t buf_ptr = 0, buf_size = 0; - size_t escoff = 0; - int quote = 0, escape = 0; - char c; - int saved_errno; - - /* Parse the string. */ - while ((c = *raw++)) - if (escape && quote && strchr("()[]{}<>\"\\,", c)) - { - /* Buffer UTF-8 text for convertion to UTF-32. */ - GROW_BUF; - buf[buf_ptr++] = c; - escape = 0; - } - else if (escape) - { - /* Parse escape. */ - raw -= 2, escoff = lineoff + (size_t)(raw - raw_); - subrc = parse_escape(tree, raw, escoff, &escape, &raw); - fail_if (subrc == NULL); - COPY; - } - else if (c == '"') - { - /* Close or open quote, of it got closed, convert the buffered UTF-8 text to UTF-32. */ - if (quote ^= 1) continue; - if ((quote == 1) && (raw != raw_ + 1)) - CHAR_ERROR(tree, WARNING, "strings should either be unquoted or unclosed in one large quoted"); - STORE; - } - else if (c == '\\') - { - /* Convert the buffered UTF-8 text to UTF-32, and start an escape. */ - STORE; - escape = 1; - } - else if ((quote == 0) && (tree->processed != PROCESS_LEVEL)) - { - /* Only escapes may be used without quotes, if the string contains quotes. */ - if (*raw_ == '"') - CHAR_ERROR(tree, ERROR, "only escapes may be outside quotes in quoted strings"); - else - CHAR_ERROR(tree, ERROR, "mixing numericals and escapes is not allowed"); - tree->processed = PROCESS_LEVEL; - } - else - { - /* Buffer UTF-8 text for convertion to UTF-32. */ - GROW_BUF; - buf[buf_ptr++] = c; - } - - /* Check that no escape is incomplete. */ - if (escape && (tree->processed != PROCESS_LEVEL)) - { - NEW_ERROR(tree, ERROR, "incomplete escape"); - error->start = escoff; - error->end = lineoff + strlen(raw_); - tree->processed = PROCESS_LEVEL; - } - - /* Check that the quote is complete. */ - if (quote && (tree->processed != PROCESS_LEVEL)) - { - NEW_ERROR(tree, ERROR, "quote is not closed"); - error->start = lineoff; - error->end = lineoff + strlen(raw_); - tree->processed = PROCESS_LEVEL; - } - - /* Shrink or grow to string to its minimal size, and -1-terminate it. */ - fail_if (xxrealloc(old_rc, rc, rc_ptr + 1, char32_t)); - rc[rc_ptr] = -1; - - free(buf); - return rc; - fail: - saved_errno = errno; - free(subrc); - free(old_rc); - free(old_buf); - free(rc); - free(buf); - return errno = saved_errno, NULL; +#define GROW_BUF\ + if (buf_ptr == buf_size)\ + fail_if (xxrealloc(old_buf, buf, buf_size += 16, char)) +#define COPY\ + n = string_length(subrc);\ + fail_if (xxrealloc(old_rc, rc, rc_ptr + n, char32_t));\ + memcpy(rc + rc_ptr, subrc, n * sizeof(char32_t)), rc_ptr += n;\ + free(subrc), subrc = NULL +#define STORE\ + do {\ + if (buf_ptr) {\ + GROW_BUF;\ + buf[buf_ptr] = '\0', buf_ptr = 0;\ + fail_if (!(subrc = string_decode(buf)));\ + COPY;\ + }\ + } while (0) +#define CHAR_ERROR(...)\ + do {\ + NEW_ERROR(__VA_ARGS__);\ + error->end = lineoff + (size_t)(raw - raw_);\ + error->start = error->end - 1;\ + } while (0) + + const char *restrict raw_ = raw; + char32_t *restrict subrc = NULL; + char32_t *restrict rc = NULL; + char32_t *restrict old_rc = NULL; + char *restrict buf = NULL; + char *restrict old_buf = NULL; + size_t rc_ptr = 0, n; + size_t buf_ptr = 0, buf_size = 0; + size_t escoff = 0; + int quote = 0, escape = 0; + char c; + int saved_errno; + + /* Parse the string. */ + while ((c = *raw++)) { + if (escape && quote && strchr("()[]{}<>\"\\,", c)) { + /* Buffer UTF-8 text for convertion to UTF-32. */ + GROW_BUF; + buf[buf_ptr++] = c; + escape = 0; + } else if (escape) { + /* Parse escape. */ + raw -= 2, escoff = lineoff + (size_t)(raw - raw_); + subrc = parse_escape(tree, raw, escoff, &escape, &raw); + fail_if (!subrc); + COPY; + } else if (c == '"') { + /* Close or open quote, of it got closed, convert the buffered UTF-8 text to UTF-32. */ + if ((quote ^= 1)) + continue; + if (quote == 1 && raw != raw_ + 1) + CHAR_ERROR(tree, WARNING, "strings should either be unquoted or unclosed in one large quoted"); + STORE; + } else if (c == '\\') { + /* Convert the buffered UTF-8 text to UTF-32, and start an escape. */ + STORE; + escape = 1; + } else if (!quote && tree->processed != PROCESS_LEVEL) { + /* Only escapes may be used without quotes, if the string contains quotes. */ + if (*raw_ == '"') + CHAR_ERROR(tree, ERROR, "only escapes may be outside quotes in quoted strings"); + else + CHAR_ERROR(tree, ERROR, "mixing numericals and escapes is not allowed"); + tree->processed = PROCESS_LEVEL; + } else { + /* Buffer UTF-8 text for convertion to UTF-32. */ + GROW_BUF; + buf[buf_ptr++] = c; + } + } + + /* Check that no escape is incomplete. */ + if (escape && tree->processed != PROCESS_LEVEL) { + NEW_ERROR(tree, ERROR, "incomplete escape"); + error->start = escoff; + error->end = lineoff + strlen(raw_); + tree->processed = PROCESS_LEVEL; + } + + /* Check that the quote is complete. */ + if (quote && tree->processed != PROCESS_LEVEL) { + NEW_ERROR(tree, ERROR, "quote is not closed"); + error->start = lineoff; + error->end = lineoff + strlen(raw_); + tree->processed = PROCESS_LEVEL; + } + + /* Shrink or grow to string to its minimal size, and -1-terminate it. */ + fail_if (xxrealloc(old_rc, rc, rc_ptr + 1, char32_t)); + rc[rc_ptr] = -1; + + free(buf); + return rc; +fail: + saved_errno = errno; + free(subrc); + free(old_rc); + free(old_buf); + free(rc); + free(buf); + return errno = saved_errno, NULL; #undef CHAR_ERROR #undef STORE #undef COPY @@ -888,37 +857,36 @@ static char32_t* parse_quoted_string(mds_kbdc_tree_t* restrict tree, const char* * @param lineoff The offset on the line where the string beings * @return The string as pure text, `NULL` on error */ -static char32_t* parse_unquoted_string(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff) +static char32_t * +parse_unquoted_string(mds_kbdc_tree_t *restrict tree, const char *restrict raw, size_t lineoff) { -#define R(LOWER, UPPER) (((LOWER) <= c) && (c <= (UPPER))) -#define CHAR_ERROR(...) \ - do \ - { \ - NEW_ERROR(__VA_ARGS__); \ - error->end = lineoff + (size_t)(raw - raw_); \ - error->start = error->end - 1; \ - tree->processed = PROCESS_LEVEL; \ - goto done; \ - } \ - while (0) - - const char* restrict raw_ = raw; - char32_t* rc; - char32_t buf = 0; - char c; - - while ((c = *raw++)) - if (R('0', '9')) buf = 10 * buf + (c & 15); - else if (c == '\\') CHAR_ERROR(tree, ERROR, "mixing numericals and escapes is not allowed"); - else if (c == '"') CHAR_ERROR(tree, ERROR, "mixing numericals and quotes is not allowed"); - else CHAR_ERROR(tree, ERROR, "stray ‘%c’", c); /* XXX support multibyte */ - - done: - fail_if (xmalloc(rc, 2, char32_t)); - return rc[0] = buf, rc[1] = -1, rc; +#define R(LOWER, UPPER) ((LOWER) <= c && c <= (UPPER)) +#define CHAR_ERROR(...)\ + do {\ + NEW_ERROR(__VA_ARGS__);\ + error->end = lineoff + (size_t)(raw - raw_);\ + error->start = error->end - 1;\ + tree->processed = PROCESS_LEVEL;\ + goto done;\ + } while (0) + + const char *restrict raw_ = raw; + char32_t *rc, buf = 0; + char c; + + while ((c = *raw++)) { + if (R('0', '9')) buf = 10 * buf + (c & 15); + else if (c == '\\') CHAR_ERROR(tree, ERROR, "mixing numericals and escapes is not allowed"); + else if (c == '"') CHAR_ERROR(tree, ERROR, "mixing numericals and quotes is not allowed"); + else CHAR_ERROR(tree, ERROR, "stray ‘%c’", c); /* XXX support multibyte */ + } + +done: + fail_if (xmalloc(rc, 2, char32_t)); + return rc[0] = buf, rc[1] = -1, rc; - fail: - return NULL; +fail: + return NULL; #undef CHAR_ERROR #undef R } @@ -932,15 +900,16 @@ static char32_t* parse_unquoted_string(mds_kbdc_tree_t* restrict tree, const cha * @param lineoff The offset on the line where the string beings * @return The string as pure text, `NULL` on error */ -static char32_t* parse_string(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff) +static char32_t * +parse_string(mds_kbdc_tree_t *restrict tree, const char *restrict raw, size_t lineoff) { - mds_kbdc_tree_t* old_last_value_statement = last_value_statement; - char32_t* rc = (strchr("\"\\", *raw) ? parse_quoted_string : parse_unquoted_string)(tree, raw, lineoff); - last_value_statement = old_last_value_statement; - fail_if (rc == NULL); - return rc; - fail: - return NULL; + mds_kbdc_tree_t *old_last_value_statement = last_value_statement; + char32_t *rc = (strchr("\"\\", *raw) ? parse_quoted_string : parse_unquoted_string)(tree, raw, lineoff); + last_value_statement = old_last_value_statement; + fail_if (!rc); + return rc; +fail: + return NULL; } @@ -952,120 +921,108 @@ static char32_t* parse_string(mds_kbdc_tree_t* restrict tree, const char* restri * @param lineoff The offset on the line where the string beings * @return The string as pure text, `NULL` on error */ -static char32_t* parse_keys(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff) +static char32_t * +parse_keys(mds_kbdc_tree_t *restrict tree, const char *restrict raw, size_t lineoff) { -#define GROW_BUF \ - if (buf_ptr == buf_size) \ - fail_if (xxrealloc(old_buf, buf, buf_size += 16, char)) -#define COPY \ - n = string_length(subrc); \ - fail_if (xxrealloc(old_rc, rc, rc_ptr + n, char32_t)); \ - memcpy(rc + rc_ptr, subrc, n * sizeof(char32_t)), rc_ptr += n; \ - free(subrc), subrc = NULL -#define STORE \ - if (buf_ptr) \ - do \ - { \ - GROW_BUF; \ - buf[buf_ptr] = '\0', buf_ptr = 0; \ - fail_if (subrc = string_decode(buf), subrc == NULL); \ - COPY; \ - } \ - while (0) -#define SPECIAL(VAL) \ - STORE; \ - fail_if (xxrealloc(old_rc, rc, rc_ptr + 1, char32_t)); \ - rc[rc_ptr++] = -(VAL + 1) - - mds_kbdc_tree_t* old_last_value_statement = last_value_statement; - const char* restrict raw_ = raw++; - char32_t* restrict subrc = NULL; - char32_t* restrict rc = NULL; - char32_t* restrict old_rc = NULL; - char* restrict buf = NULL; - char* restrict old_buf = NULL; - size_t rc_ptr = 0, n; - size_t buf_ptr = 0, buf_size = 0; - size_t escoff = 0; - int escape = 0, quote = 0; - char c; - int saved_errno; - - /* Parse the string. */ - while (c = *raw++, c && *raw) - if (escape && strchr("()[]{}<>\"\\,", c)) - { - /* Buffer UTF-8 text for convertion to UTF-32. */ - GROW_BUF; - buf[buf_ptr++] = c; - escape = 0; - } - else if (escape) - { - /* Parse escape. */ - raw -= 2, escoff = lineoff + (size_t)(raw - raw_); - subrc = parse_escape(tree, raw, escoff, &escape, &raw); - fail_if (subrc == NULL); - COPY; - } - else if (c == '\\') - { - /* Convert the buffered UTF-8 text to UTF-32, and start an escape. */ +#define GROW_BUF\ + if (buf_ptr == buf_size)\ + fail_if (xxrealloc(old_buf, buf, buf_size += 16, char)) +#define COPY\ + n = string_length(subrc);\ + fail_if (xxrealloc(old_rc, rc, rc_ptr + n, char32_t));\ + memcpy(rc + rc_ptr, subrc, n * sizeof(char32_t)), rc_ptr += n;\ + free(subrc), subrc = NULL +#define STORE\ + do {\ + if (buf_ptr) {\ + GROW_BUF;\ + buf[buf_ptr] = '\0', buf_ptr = 0;\ + fail_if (!(subrc = string_decode(buf)));\ + COPY;\ + }\ + } while (0) +#define SPECIAL(VAL)\ + STORE;\ + fail_if (xxrealloc(old_rc, rc, rc_ptr + 1, char32_t));\ + rc[rc_ptr++] = -(VAL + 1) + + mds_kbdc_tree_t *old_last_value_statement = last_value_statement; + const char *restrict raw_ = raw++; + char32_t *restrict subrc = NULL; + char32_t *restrict rc = NULL; + char32_t *restrict old_rc = NULL; + char *restrict buf = NULL; + char *restrict old_buf = NULL; + size_t rc_ptr = 0, n; + size_t buf_ptr = 0, buf_size = 0; + size_t escoff = 0; + int escape = 0, quote = 0; + char c; + int saved_errno; + + /* Parse the string. */ + while (c = *raw++, c && *raw) { + if (escape && strchr("()[]{}<>\"\\,", c)) { + /* Buffer UTF-8 text for convertion to UTF-32. */ + GROW_BUF; + buf[buf_ptr++] = c; + escape = 0; + } else if (escape) { + /* Parse escape. */ + raw -= 2, escoff = lineoff + (size_t)(raw - raw_); + subrc = parse_escape(tree, raw, escoff, &escape, &raw); + fail_if (!subrc); + COPY; + } else if (c == '\\') { + /* Convert the buffered UTF-8 text to UTF-32, and start an escape. */ + STORE; + escape = 1; + } else if (c == ',' && !quote) { + /* Sequence in key-combination. */ + SPECIAL(1); + } else if (c == '"') { + /* String in key-combination. */ + quote ^= 1; + SPECIAL(2); + } else { + /* Buffer UTF-8 text for convertion to UTF-32. */ + GROW_BUF; + buf[buf_ptr++] = c; + } + } STORE; - escape = 1; - } - else if ((c == ',') && !quote) - { - /* Sequence in key-combination. */ - SPECIAL(1); - } - else if (c == '"') - { - /* String in key-combination. */ - quote ^= 1; - SPECIAL(2); - } - else - { - /* Buffer UTF-8 text for convertion to UTF-32. */ - GROW_BUF; - buf[buf_ptr++] = c; - } - STORE; - - /* Check that no escape is incomplete. */ - if (escape && (tree->processed != PROCESS_LEVEL)) - { - NEW_ERROR(tree, ERROR, "incomplete escape"); - error->start = lineoff + (size_t)(strrchr(raw_, '\\') - raw_); - error->end = lineoff + strlen(raw_); - tree->processed = PROCESS_LEVEL; - } - - /* Check that key-combination is complete. */ - if ((c != '>') && (tree->processed != PROCESS_LEVEL)) - { - NEW_ERROR(tree, ERROR, "key-combination is not closed"); - error->start = lineoff; - error->end = lineoff + strlen(raw_); - tree->processed = PROCESS_LEVEL; - } - - /* Shrink or grow to string to its minimal size, and -1-terminate it. */ - fail_if (xxrealloc(old_rc, rc, rc_ptr + 1, char32_t)); - rc[rc_ptr] = -1; - - free(buf); - return last_value_statement = old_last_value_statement, rc; - fail: - saved_errno = errno; - free(subrc); - free(old_rc); - free(old_buf); - free(rc); - free(buf); - errno = saved_errno; - return last_value_statement = old_last_value_statement, NULL; + + /* Check that no escape is incomplete. */ + if (escape && tree->processed != PROCESS_LEVEL) { + NEW_ERROR(tree, ERROR, "incomplete escape"); + error->start = lineoff + (size_t)(strrchr(raw_, '\\') - raw_); + error->end = lineoff + strlen(raw_); + tree->processed = PROCESS_LEVEL; + } + + /* Check that key-combination is complete. */ + if (c != '>' && tree->processed != PROCESS_LEVEL) { + NEW_ERROR(tree, ERROR, "key-combination is not closed"); + error->start = lineoff; + error->end = lineoff + strlen(raw_); + tree->processed = PROCESS_LEVEL; + } + + /* Shrink or grow to string to its minimal size, and -1-terminate it. */ + fail_if (xxrealloc(old_rc, rc, rc_ptr + 1, char32_t)); + rc[rc_ptr] = -1; + + free(buf); + return last_value_statement = old_last_value_statement, rc; +fail: + saved_errno = errno; + free(subrc); + free(old_rc); + free(old_buf); + free(rc); + free(buf); + errno = saved_errno; + return last_value_statement = old_last_value_statement, NULL; #undef SPECIAL #undef STORE #undef COPY @@ -1081,54 +1038,55 @@ static char32_t* parse_keys(mds_kbdc_tree_t* restrict tree, const char* restrict * @param lineoff The offset on the line where the variable string begins * @return The index of the variable, zero on error */ -static size_t parse_variable(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff) +static size_t +parse_variable(mds_kbdc_tree_t *restrict tree, const char *restrict raw, size_t lineoff) { - size_t var, n; - const char* restrict raw_ = raw; - char* restrict dotless; - - /* The variable must begin with \. */ - if (*raw++ != '\\') goto bad; - /* Zero is not a valid varible, nor may there be leading zeroes or be empty. */ - if (*raw == '0') goto bad; - if (*raw == '.') goto bad; - if (*raw == '\0') goto bad; - for (; *raw; raw++) - /* Check that the variable consists only of digits. */ - if (('0' <= *raw) && (*raw <= '9')); - /* However, it may end with a dot. */ - else if ((raw[0] == '.') && (raw[1] == '\0')) - break; - else - goto bad; - - /* Parse the variable string and check that it did not overflow. */ - n = (size_t)(raw - raw_); - dotless = alloca((n + 1) * sizeof(char)); - memcpy(dotless, raw_, n * sizeof(char)), dotless[n] = '\0'; - var = atoz(dotless + 1); - if (strlen(dotless + 1) != (size_t)snprintf(NULL, 0, "%zu", var)) - fail_if ((errno = ERANGE)); - if (var == 0) - { - NEW_ERROR(tree, INTERNAL_ERROR, - "parsed a variable string to be 0, which should not be possible"); - error->start = lineoff; - error->end = lineoff + strlen(raw_); - tree->processed = PROCESS_LEVEL; - return 1; - } - return var; - fail: - return 0; - - bad: - /* Report an error but return a variable index if the variable-string is invalid. */ - NEW_ERROR(tree, ERROR, "not a variable"); - error->start = lineoff; - error->end = lineoff + strlen(raw_); - tree->processed = PROCESS_LEVEL; - return 1; + size_t var, n; + const char *restrict raw_ = raw; + char *restrict dotless; + + /* The variable must begin with \. */ + if (*raw++ != '\\') goto bad; + /* Zero is not a valid varible, nor may there be leading zeroes or be empty. */ + if (*raw == '0') goto bad; + if (*raw == '.') goto bad; + if (*raw == '\0') goto bad; + for (; *raw; raw++) { + /* Check that the variable consists only of digits. */ + if ('0' <= *raw && *raw <= '9') + /* However, it may end with a dot. */; + else if (raw[0] == '.' && raw[1] == '\0') + break; + else + goto bad; + } + + /* Parse the variable string and check that it did not overflow. */ + n = (size_t)(raw - raw_); + dotless = alloca((n + 1) * sizeof(char)); + memcpy(dotless, raw_, n * sizeof(char)), dotless[n] = '\0'; + var = atoz(dotless + 1); + if (strlen(dotless + 1) != (size_t)snprintf(NULL, 0, "%zu", var)) + fail_if ((errno = ERANGE)); + if (!var) { + NEW_ERROR(tree, INTERNAL_ERROR, + "parsed a variable string to be 0, which should not be possible"); + error->start = lineoff; + error->end = lineoff + strlen(raw_); + tree->processed = PROCESS_LEVEL; + return 1; + } + return var; +fail: + return 0; + +bad: + /* Report an error but return a variable index if the variable-string is invalid. */ + NEW_ERROR(tree, ERROR, "not a variable"); + error->start = lineoff; + error->end = lineoff + strlen(raw_); + tree->processed = PROCESS_LEVEL; + return 1; } @@ -1142,63 +1100,65 @@ static size_t parse_variable(mds_kbdc_tree_t* restrict tree, const char* restric * @param value Output parameter for the value to which the argument evaulates * @return Zero on success, -1 on error */ -static int parse_function_argument(mds_kbdc_tree_t* restrict tree, const char* restrict raw, size_t lineoff, - const char* restrict* restrict end, char32_t** restrict value) +static int +parse_function_argument(mds_kbdc_tree_t *restrict tree, const char *restrict raw, size_t lineoff, + const char *restrict *restrict end, char32_t **restrict value) { - size_t size = strlen(raw), ptr = 0, call_end = 0; - int escape = 0, quote = 0; - char* raw_argument = NULL; - int saved_errno; - - /* Find the span of the argument. */ - while (ptr < size) - { - char c = raw[ptr++]; - - /* Escapes may be longer than one character, - but only the first can affect the parsing. */ - if (escape) escape = 0; - /* Nested function and nested quotes can appear. */ - else if (ptr <= call_end) ; - /* Quotes end with the same symbols as they start with, - and quotes automatically escape brackets. */ - /* \ can either start a functon call or an escape. */ - else if (c == '\\') - { - /* It may not be an escape, but registering it - as an escape cannot harm us since we only - skip the first character, and a function call - cannot be that short. */ - escape = 1; - /* Nested quotes can appear at function calls. */ - call_end = get_end_of_call(raw, ptr, size); - } - /* " is the quote symbol. */ - else if (quote) quote = (c != '"'); - else if (c == '"') quote = 1; - /* End of argument? */ - else if (strchr(" )", c)) - { - ptr--; - break; + size_t size = strlen(raw), ptr = 0, call_end = 0; + int escape = 0, quote = 0, saved_errno; + char *raw_argument = NULL; + char c; + + /* Find the span of the argument. */ + while (ptr < size) { + c = raw[ptr++]; + + /* Escapes may be longer than one character, + but only the first can affect the parsing. */ + if (escape) + escape = 0; + /* Nested function and nested quotes can appear. */ + else if (ptr <= call_end) + ; + /* Quotes end with the same symbols as they start with, + and quotes automatically escape brackets. */ + /* \ can either start a functon call or an escape. */ + else if (c == '\\') { + /* It may not be an escape, but registering it + as an escape cannot harm us since we only + skip the first character, and a function call + cannot be that short. */ + escape = 1; + /* Nested quotes can appear at function calls. */ + call_end = get_end_of_call(raw, ptr, size); + } + /* " is the quote symbol. */ + else if (quote) + quote = (c != '"'); + else if (c == '"') + quote = 1; + /* End of argument? */ + else if (strchr(" )", c)) { + ptr--; + break; + } } - } - *end = raw + ptr; - - /* Copy the argument so that we have a NUL-terminates string. */ - fail_if (xmalloc(raw_argument, ptr + 1, char)); - memcpy(raw_argument, raw, ptr * sizeof(char)); - raw_argument[ptr] = '\0'; - - /* Evaluate argument. */ - *value = parse_string(tree, raw_argument, lineoff); - fail_if (*value == NULL); - - free(raw_argument); - return 0; - FAIL_BEGIN; - free(raw_argument); - FAIL_END; + *end = raw + ptr; + + /* Copy the argument so that we have a NUL-terminates string. */ + fail_if (xmalloc(raw_argument, ptr + 1, char)); + memcpy(raw_argument, raw, ptr * sizeof(char)); + raw_argument[ptr] = '\0'; + + /* Evaluate argument. */ + *value = parse_string(tree, raw_argument, lineoff); + fail_if (!*value); + + free(raw_argument); + return 0; + FAIL_BEGIN; + free(raw_argument); + FAIL_END; } @@ -1209,13 +1169,13 @@ static int parse_function_argument(mds_kbdc_tree_t* restrict tree, const char* r * @param macro_include_stack The include-stack for the macro * @return Zero on success, -1 on error */ -static int set_macro(mds_kbdc_tree_macro_t* restrict macro, - mds_kbdc_include_stack_t* macro_include_stack) +static int +set_macro(mds_kbdc_tree_macro_t *restrict macro, mds_kbdc_include_stack_t *macro_include_stack) { - fail_if (callables_set(macro->name, 0, (mds_kbdc_tree_t*)macro, macro_include_stack)); - return 0; - fail: - return -1; + fail_if (callables_set(macro->name, 0, (mds_kbdc_tree_t *)macro, macro_include_stack)); + return 0; +fail: + return -1; } @@ -1226,10 +1186,11 @@ static int set_macro(mds_kbdc_tree_macro_t* restrict macro, * @param macro Output parameter for the macro, `NULL` if not found * @param macro_include_stack Output parameter for the include-stack for the macro */ -static void get_macro_lax(const char* restrict macro_name, mds_kbdc_tree_macro_t** restrict macro, - mds_kbdc_include_stack_t** restrict macro_include_stack) +static void +get_macro_lax(const char *restrict macro_name, mds_kbdc_tree_macro_t **restrict macro, + mds_kbdc_include_stack_t **restrict macro_include_stack) { - callables_get(macro_name, 0, (mds_kbdc_tree_t**)macro, macro_include_stack); + callables_get(macro_name, 0, (mds_kbdc_tree_t **)macro, macro_include_stack); } @@ -1246,29 +1207,29 @@ static void get_macro_lax(const char* restrict macro_name, mds_kbdc_tree_macro_t * @param macro_include_stack Output parameter for the include-stack for the macro * @return Zero on success, -1 on error */ -static int get_macro(mds_kbdc_tree_macro_call_t* restrict macro_call, - mds_kbdc_tree_macro_t** restrict macro, - mds_kbdc_include_stack_t** restrict macro_include_stack) +static int +get_macro(mds_kbdc_tree_macro_call_t *restrict macro_call, + mds_kbdc_tree_macro_t **restrict macro, + mds_kbdc_include_stack_t **restrict macro_include_stack) { - char* code = result->source_code->lines[macro_call->loc_line]; - char* end = code + strlen(code) - 1; - - get_macro_lax(macro_call->name, macro, macro_include_stack); - if (*macro == NULL) - { - NEW_ERROR(macro_call, ERROR, "macro ‘%s’ has not been defined yet", macro_call->name); - while (*end == ' ') - end--; - error->end = (size_t)(++end - code); - macro_call->processed = PROCESS_LEVEL; - return 0; - } - if ((*macro)->processed == PROCESS_LEVEL) - *macro = NULL; - - return 0; - fail: - return -1; + char *code = result->source_code->lines[macro_call->loc_line]; + char *end = code + strlen(code) - 1; + + get_macro_lax(macro_call->name, macro, macro_include_stack); + if (!*macro) { + NEW_ERROR(macro_call, ERROR, "macro ‘%s’ has not been defined yet", macro_call->name); + while (*end == ' ') + end--; + error->end = (size_t)(++end - code); + macro_call->processed = PROCESS_LEVEL; + return 0; + } + if ((*macro)->processed == PROCESS_LEVEL) + *macro = NULL; + + return 0; +fail: + return -1; } @@ -1279,20 +1240,21 @@ static int get_macro(mds_kbdc_tree_macro_call_t* restrict macro_call, * @param function_include_stack The include-stack for the function * @return Zero on success, -1 on error */ -static int set_function(mds_kbdc_tree_function_t* restrict function, - mds_kbdc_include_stack_t* function_include_stack) +static int +set_function(mds_kbdc_tree_function_t *restrict function, + mds_kbdc_include_stack_t *function_include_stack) { - char* suffixless = function->name; - char* suffix_start = strchr(suffixless, '/'); - size_t arg_count = atoz(suffix_start + 1); - int r; - - *suffix_start = '\0'; - r = callables_set(suffixless, arg_count, (mds_kbdc_tree_t*)function, function_include_stack); - fail_if (*suffix_start = '/', r); - return 0; - fail: - return -1; + char *suffixless = function->name; + char *suffix_start = strchr(suffixless, '/'); + size_t arg_count = atoz(suffix_start + 1); + int r; + + *suffix_start = '\0'; + r = callables_set(suffixless, arg_count, (mds_kbdc_tree_t *)function, function_include_stack); + fail_if (*suffix_start = '/', r); + return 0; +fail: + return -1; } @@ -1304,11 +1266,12 @@ static int set_function(mds_kbdc_tree_function_t* restrict function, * @param function Output parameter for the function, `NULL` if not found * @param function_include_stack Output parameter for the include-stack for the function */ -static void get_function_lax(const char* restrict function_name, size_t arg_count, - mds_kbdc_tree_function_t** restrict function, - mds_kbdc_include_stack_t** restrict function_include_stack) +static void +get_function_lax(const char *restrict function_name, size_t arg_count, + mds_kbdc_tree_function_t **restrict function, + mds_kbdc_include_stack_t **restrict function_include_stack) { - callables_get(function_name, arg_count, (mds_kbdc_tree_t**)function, function_include_stack); + callables_get(function_name, arg_count, (mds_kbdc_tree_t **)function, function_include_stack); } @@ -1318,21 +1281,23 @@ static void get_function_lax(const char* restrict function_name, size_t arg_coun * @param value The value the function should return * @return Zero on success, 1 if no function is currently being called */ -static int set_return_value(char32_t* restrict value) +static int +set_return_value(char32_t *restrict value) { - if (current_return_value == NULL) - return free(value), 1; - free(*current_return_value); - *current_return_value = value; - return 0; + if (!current_return_value) + return free(value), 1; + free(*current_return_value); + *current_return_value = value; + return 0; } -static int add_mapping(mds_kbdc_tree_map_t* restrict mapping, mds_kbdc_include_stack_t* restrict include_stack) +static int +add_mapping(mds_kbdc_tree_map_t *restrict mapping, mds_kbdc_include_stack_t *restrict include_stack) { - mds_kbdc_tree_free((mds_kbdc_tree_t*)mapping); - mds_kbdc_include_stack_free(include_stack); - return 0; /* TODO */ + mds_kbdc_tree_free((mds_kbdc_tree_t *)mapping); + mds_kbdc_include_stack_free(include_stack); + return 0; /* TODO */ } @@ -1346,23 +1311,24 @@ static int add_mapping(mds_kbdc_tree_map_t* restrict mapping, mds_kbdc_include_s * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_include(mds_kbdc_tree_include_t* restrict tree) +static int +compile_include(mds_kbdc_tree_include_t *restrict tree) { - void* data; - int r; - fail_if (mds_kbdc_include_stack_push(tree, &data)); - r = compile_subtree(tree->inner); - mds_kbdc_include_stack_pop(data); - - /* For simplicity we set `last_value_statement` on includes, - * so we are sure `last_value_statement` has the same - * include-stack as its overriding statement. */ - last_value_statement = NULL; - - fail_if (r); - return 0; - fail: - return -1; + void *data; + int r; + fail_if (mds_kbdc_include_stack_push(tree, &data)); + r = compile_subtree(tree->inner); + mds_kbdc_include_stack_pop(data); + + /* For simplicity we set `last_value_statement` on includes, + * so we are sure `last_value_statement` has the same + * include-stack as its overriding statement. */ + last_value_statement = NULL; + + fail_if (r); + return 0; +fail: + return -1; } @@ -1372,39 +1338,39 @@ static int compile_include(mds_kbdc_tree_include_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_language(mds_kbdc_tree_information_language_t* restrict tree) +static int +compile_language(mds_kbdc_tree_information_language_t *restrict tree) { - size_t lineoff; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - char32_t* restrict data = NULL; - char** old = NULL; - int saved_errno; - - /* Make sure the language-list fits another entry. */ - if (result->languages_ptr == result->languages_size) - { - result->languages_size = result->languages_size ? (result->languages_size << 1) : 1; - fail_if (xxrealloc(old, result->languages, result->languages_size, char*)); - } - - /* Locate the first character in the language-string. */ - for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); - /* Evaluate function calls, variable dereferences and escapes in the language-string. */ - fail_if (data = parse_string((mds_kbdc_tree_t*)tree, tree->data, lineoff), data == NULL); - if (tree->processed == PROCESS_LEVEL) - return free(data), 0; - /* We want the string in UTF-8, not UTF-16. */ - fail_if (code = string_encode(data), code == NULL); - free(data); - - /* Add the language to the language-list. */ - result->languages[result->languages_ptr++] = code; - - return 0; - FAIL_BEGIN; - free(old); - free(data); - FAIL_END; + size_t lineoff; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + char32_t *restrict data = NULL; + char **old = NULL; + int saved_errno; + + /* Make sure the language-list fits another entry. */ + if (result->languages_ptr == result->languages_size) { + result->languages_size = result->languages_size ? (result->languages_size << 1) : 1; + fail_if (xxrealloc(old, result->languages, result->languages_size, char*)); + } + + /* Locate the first character in the language-string. */ + for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); + /* Evaluate function calls, variable dereferences and escapes in the language-string. */ + fail_if (!(data = parse_string((mds_kbdc_tree_t*)tree, tree->data, lineoff))); + if (tree->processed == PROCESS_LEVEL) + return free(data), 0; + /* We want the string in UTF-8, not UTF-16. */ + fail_if (!(code = string_encode(data))); + free(data); + + /* Add the language to the language-list. */ + result->languages[result->languages_ptr++] = code; + + return 0; + FAIL_BEGIN; + free(old); + free(data); + FAIL_END; } @@ -1414,39 +1380,39 @@ static int compile_language(mds_kbdc_tree_information_language_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_country(mds_kbdc_tree_information_country_t* restrict tree) +static int +compile_country(mds_kbdc_tree_information_country_t *restrict tree) { - size_t lineoff; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - char32_t* restrict data = NULL; - char** old = NULL; - int saved_errno; - - /* Make sure the country-list fits another entry. */ - if (result->countries_ptr == result->countries_size) - { - result->countries_size = result->countries_size ? (result->countries_size << 1) : 1; - fail_if (xxrealloc(old, result->countries, result->countries_size, char*)); - } - - /* Locate the first character in the country-string. */ - for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); - /* Evaluate function calls, variable dereferences and escapes in the country-string. */ - fail_if (data = parse_string((mds_kbdc_tree_t*)tree, tree->data, lineoff), data == NULL); - if (tree->processed == PROCESS_LEVEL) - return free(data), 0; - /* We want the string in UTF-8, not UTF-16. */ - fail_if (code = string_encode(data), code == NULL); - free(data); - - /* Add the country to the country-list. */ - result->countries[result->countries_ptr++] = code; - - return 0; - FAIL_BEGIN; - free(old); - free(data); - FAIL_END; + size_t lineoff; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + char32_t *restrict data = NULL; + char **old = NULL; + int saved_errno; + + /* Make sure the country-list fits another entry. */ + if (result->countries_ptr == result->countries_size) { + result->countries_size = result->countries_size ? (result->countries_size << 1) : 1; + fail_if (xxrealloc(old, result->countries, result->countries_size, char *)); + } + + /* Locate the first character in the country-string. */ + for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); + /* Evaluate function calls, variable dereferences and escapes in the country-string. */ + fail_if (!(data = parse_string((mds_kbdc_tree_t*)tree, tree->data, lineoff))); + if (tree->processed == PROCESS_LEVEL) + return free(data), 0; + /* We want the string in UTF-8, not UTF-16. */ + fail_if (!(code = string_encode(data))); + free(data); + + /* Add the country to the country-list. */ + result->countries[result->countries_ptr++] = code; + + return 0; + FAIL_BEGIN; + free(old); + free(data); + FAIL_END; } @@ -1456,39 +1422,39 @@ static int compile_country(mds_kbdc_tree_information_country_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_variant(mds_kbdc_tree_information_variant_t* restrict tree) +static int +compile_variant(mds_kbdc_tree_information_variant_t *restrict tree) { - size_t lineoff; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - char32_t* restrict data = NULL; - int saved_errno; - - /* Make sure the variant has not already been set. */ - if (result->variant) - { - if (multiple_variants == 0) - NEW_ERROR(tree, ERROR, "only one ‘variant’ is allowed"); - multiple_variants = 1; - return 0; - } - - /* Locate the first character in the variant-string. */ - for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); - /* Evaluate function calls, variable dereferences and escapes in the variant-string. */ - fail_if (data = parse_string((mds_kbdc_tree_t*)tree, tree->data, lineoff), data == NULL); - if (tree->processed == PROCESS_LEVEL) - return free(data), 0; - /* We want the string in UTF-8, not UTF-16. */ - fail_if (code = string_encode(data), code == NULL); - free(data); - - /* Store the variant. */ - result->variant = code; - - return 0; - FAIL_BEGIN; - free(data); - FAIL_END; + size_t lineoff; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + char32_t *restrict data = NULL; + int saved_errno; + + /* Make sure the variant has not already been set. */ + if (result->variant) { + if (!multiple_variants) + NEW_ERROR(tree, ERROR, "only one ‘variant’ is allowed"); + multiple_variants = 1; + return 0; + } + + /* Locate the first character in the variant-string. */ + for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); + /* Evaluate function calls, variable dereferences and escapes in the variant-string. */ + fail_if (!(data = parse_string((mds_kbdc_tree_t*)tree, tree->data, lineoff))); + if (tree->processed == PROCESS_LEVEL) + return free(data), 0; + /* We want the string in UTF-8, not UTF-16. */ + fail_if (!(code = string_encode(data))); + free(data); + + /* Store the variant. */ + result->variant = code; + + return 0; + FAIL_BEGIN; + free(data); + FAIL_END; } @@ -1498,54 +1464,50 @@ static int compile_variant(mds_kbdc_tree_information_variant_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_have(mds_kbdc_tree_assumption_have_t* restrict tree) +static int +compile_have(mds_kbdc_tree_assumption_have_t *restrict tree) { - mds_kbdc_tree_t* node = tree->data; - char32_t* data = NULL; - char32_t** old = NULL; - size_t new_size = 0; - int saved_errno; - - /* Make sure we can fit all assumption in the assumption list (part 1/2). */ - new_size = (node->type == C(STRING)) ? result->assumed_strings_size : result->assumed_keys_size; - new_size = new_size ? (new_size << 1) : 1; - - if (node->type == C(STRING)) - { - /* Evaluate function calls, variable dereferences and escapes in the string. */ - fail_if (data = parse_string(node, node->string.string, node->loc_start), data == NULL); - if (node->processed == PROCESS_LEVEL) - return free(data), 0; - /* Make sure we can fit all strings in the assumption list (part 2/2). */ - if (result->assumed_strings_ptr == result->assumed_strings_size) - { - fail_if (xxrealloc(old, result->assumed_strings, new_size, char32_t*)); - result->assumed_strings_size = new_size; + mds_kbdc_tree_t *node = tree->data; + char32_t *data = NULL, **old = NULL; + size_t new_size = 0; + int saved_errno; + + /* Make sure we can fit all assumption in the assumption list (part 1/2). */ + new_size = (node->type == C(STRING)) ? result->assumed_strings_size : result->assumed_keys_size; + new_size = new_size ? (new_size << 1) : 1; + + if (node->type == C(STRING)) { + /* Evaluate function calls, variable dereferences and escapes in the string. */ + fail_if (!(data = parse_string(node, node->string.string, node->loc_start))); + if (node->processed == PROCESS_LEVEL) + return free(data), 0; + /* Make sure we can fit all strings in the assumption list (part 2/2). */ + if (result->assumed_strings_ptr == result->assumed_strings_size) + { + fail_if (xxrealloc(old, result->assumed_strings, new_size, char32_t*)); + result->assumed_strings_size = new_size; + } + /* Add the assumption to the list. */ + result->assumed_strings[result->assumed_strings_ptr++] = data; + } else { + /* Evaluate function calls, variable dereferences and escapes in the key-combination. */ + fail_if (!(data = parse_keys(node, node->keys.keys, node->loc_start))); + if (node->processed == PROCESS_LEVEL) + return free(data), 0; + /* Make sure we can fit all key-combinations in the assumption list (part 2/2). */ + if (result->assumed_keys_ptr == result->assumed_keys_size) { + fail_if (xxrealloc(old, result->assumed_keys, new_size, char32_t*)); + result->assumed_keys_size = new_size; + } + /* Add the assumption to the list. */ + result->assumed_keys[result->assumed_keys_ptr++] = data; } - /* Add the assumption to the list. */ - result->assumed_strings[result->assumed_strings_ptr++] = data; - } - else - { - /* Evaluate function calls, variable dereferences and escapes in the key-combination. */ - fail_if (data = parse_keys(node, node->keys.keys, node->loc_start), data == NULL); - if (node->processed == PROCESS_LEVEL) - return free(data), 0; - /* Make sure we can fit all key-combinations in the assumption list (part 2/2). */ - if (result->assumed_keys_ptr == result->assumed_keys_size) - { - fail_if (xxrealloc(old, result->assumed_keys, new_size, char32_t*)); - result->assumed_keys_size = new_size; - } - /* Add the assumption to the list. */ - result->assumed_keys[result->assumed_keys_ptr++] = data; - } - - return 0; - FAIL_BEGIN; - free(old); - free(data); - FAIL_END; + + return 0; + FAIL_BEGIN; + free(old); + free(data); + FAIL_END; } @@ -1555,47 +1517,46 @@ static int compile_have(mds_kbdc_tree_assumption_have_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_have_chars(mds_kbdc_tree_assumption_have_chars_t* restrict tree) +static int +compile_have_chars(mds_kbdc_tree_assumption_have_chars_t *restrict tree) { - size_t lineoff; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - char32_t* restrict data = NULL; - char32_t** old = NULL; - char32_t* restrict character; - size_t n; - int saved_errno; - - /* Locate the first character in the list. */ - for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); - /* Evaluate function calls, variable dereferences - and escapes in the charcter list. */ - fail_if (data = parse_string((mds_kbdc_tree_t*)tree, tree->chars, lineoff), data == NULL); - if (tree->processed == PROCESS_LEVEL) - return free(data), 0; - - /* Make sure we can fit all characters in the assumption list. */ - for (n = 0; data[n] >= 0; n++); - if (result->assumed_strings_ptr + n > result->assumed_strings_size) - { - result->assumed_strings_size += n; - fail_if (xxrealloc(old, result->assumed_strings, result->assumed_strings_size, char32_t*)); - } - - /* Add all characters to the assumption list. */ - while (n--) - { - fail_if (xmalloc(character, 2, char32_t)); - character[0] = data[n]; - character[1] = -1; - result->assumed_strings[result->assumed_strings_ptr++] = character; - } - - free(data); - return 0; - FAIL_BEGIN; - free(data); - free(old); - FAIL_END; + size_t lineoff; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + char32_t *restrict data = NULL; + char32_t **old = NULL; + char32_t *restrict character; + size_t n; + int saved_errno; + + /* Locate the first character in the list. */ + for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); + /* Evaluate function calls, variable dereferences + and escapes in the charcter list. */ + fail_if (!(data = parse_string((mds_kbdc_tree_t*)tree, tree->chars, lineoff))); + if (tree->processed == PROCESS_LEVEL) + return free(data), 0; + + /* Make sure we can fit all characters in the assumption list. */ + for (n = 0; data[n] >= 0; n++); + if (result->assumed_strings_ptr + n > result->assumed_strings_size) { + result->assumed_strings_size += n; + fail_if (xxrealloc(old, result->assumed_strings, result->assumed_strings_size, char32_t *)); + } + + /* Add all characters to the assumption list. */ + while (n--) { + fail_if (xmalloc(character, 2, char32_t)); + character[0] = data[n]; + character[1] = -1; + result->assumed_strings[result->assumed_strings_ptr++] = character; + } + + free(data); + return 0; + FAIL_BEGIN; + free(data); + free(old); + FAIL_END; } @@ -1605,88 +1566,85 @@ static int compile_have_chars(mds_kbdc_tree_assumption_have_chars_t* restrict tr * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_have_range(mds_kbdc_tree_assumption_have_range_t* restrict tree) +static int +compile_have_range(mds_kbdc_tree_assumption_have_range_t *restrict tree) { - size_t lineoff_first; - size_t lineoff_last; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - char32_t* restrict first = NULL; - char32_t* restrict last = NULL; - char32_t** old = NULL; - char32_t* restrict character; - size_t n; - int saved_errno; - - - /* Locate the first characters of both bound strings. */ - for (lineoff_first = tree->loc_end; code[lineoff_first] == ' '; lineoff_first++); - for (lineoff_last = lineoff_first + strlen(tree->first); code[lineoff_last] == ' '; lineoff_last++); - - /* Duplicate bounds and evaluate function calls, - variable dereferences and escapes in the bounds. */ - fail_if (first = parse_string((mds_kbdc_tree_t*)tree, tree->first, lineoff_first), first == NULL); - fail_if (last = parse_string((mds_kbdc_tree_t*)tree, tree->last, lineoff_last), last == NULL); - - /* Did one of the bound not evaluate, then stop. */ - if (tree->processed == PROCESS_LEVEL) - goto done; - - - /* Check that the primary bound is single-character. */ - if ((first[0] == -1) || (first[1] != -1)) - { - NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string"); - error->start = lineoff_first, lineoff_first = 0; - error->end = error->start + strlen(tree->first); - } - /* Check that the secondary bound is single-character. */ - if ((last[0] == -1) || (last[1] != -1)) - { - NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string"); - error->start = lineoff_last, lineoff_last = 0; - error->end = error->start + strlen(tree->last); - } - - /* Was one of the bounds not single-character, then stop. */ - if ((lineoff_first == 0) || (lineoff_last == 0)) - goto done; - - - /* If the range is descending, swap the bounds so it is ascending. - (This cannot be done in for-loops as that may cause side-effects - to be created in the wrong order.) */ - if (*first > *last) - *first ^= *last, *last ^= *first, *first ^= *last; - - /* Make sure we can fit all characters in the assumption list. */ - n = (size_t)(*last - *first) + 1; - if (result->assumed_strings_ptr + n > result->assumed_strings_size) - { - result->assumed_strings_size += n; - fail_if (xxrealloc(old, result->assumed_strings, result->assumed_strings_size, char32_t*)); - } - - /* Add all characters to the assumption list. */ - for (;;) - { - fail_if (xmalloc(character, 2, char32_t)); - character[0] = *first; - character[1] = -1; - result->assumed_strings[result->assumed_strings_ptr++] = character; - /* Bounds are inclusive. */ - if ((*first)++ == *last) - break; - } - - done: - free(first); - free(last); - return 0; - FAIL_BEGIN; - free(first); - free(last); - free(old); - FAIL_END; + size_t lineoff_first; + size_t lineoff_last; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + char32_t *restrict first = NULL; + char32_t *restrict last = NULL; + char32_t **old = NULL; + char32_t *restrict character; + size_t n; + int saved_errno; + + + /* Locate the first characters of both bound strings. */ + for (lineoff_first = tree->loc_end; code[lineoff_first] == ' '; lineoff_first++); + for (lineoff_last = lineoff_first + strlen(tree->first); code[lineoff_last] == ' '; lineoff_last++); + + /* Duplicate bounds and evaluate function calls, + variable dereferences and escapes in the bounds. */ + fail_if (!(first = parse_string((mds_kbdc_tree_t*)tree, tree->first, lineoff_first))); + fail_if (!(last = parse_string((mds_kbdc_tree_t*)tree, tree->last, lineoff_last))); + + /* Did one of the bound not evaluate, then stop. */ + if (tree->processed == PROCESS_LEVEL) + goto done; + + + /* Check that the primary bound is single-character. */ + if (first[0] == -1 || first[1] != -1) { + NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string"); + error->start = lineoff_first, lineoff_first = 0; + error->end = error->start + strlen(tree->first); + } + /* Check that the secondary bound is single-character. */ + if (last[0] == -1 || last[1] != -1) { + NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string"); + error->start = lineoff_last, lineoff_last = 0; + error->end = error->start + strlen(tree->last); + } + + /* Was one of the bounds not single-character, then stop. */ + if (!lineoff_first || !lineoff_last) + goto done; + + + /* If the range is descending, swap the bounds so it is ascending. + (This cannot be done in for-loops as that may cause side-effects + to be created in the wrong order.) */ + if (*first > *last) + *first ^= *last, *last ^= *first, *first ^= *last; + + /* Make sure we can fit all characters in the assumption list. */ + n = (size_t)(*last - *first) + 1; + if (result->assumed_strings_ptr + n > result->assumed_strings_size) { + result->assumed_strings_size += n; + fail_if (xxrealloc(old, result->assumed_strings, result->assumed_strings_size, char32_t *)); + } + + /* Add all characters to the assumption list. */ + for (;;) { + fail_if (xmalloc(character, 2, char32_t)); + character[0] = *first; + character[1] = -1; + result->assumed_strings[result->assumed_strings_ptr++] = character; + /* Bounds are inclusive. */ + if ((*first)++ == *last) + break; + } + +done: + free(first); + free(last); + return 0; + FAIL_BEGIN; + free(first); + free(last); + free(old); + FAIL_END; } @@ -1696,47 +1654,48 @@ static int compile_have_range(mds_kbdc_tree_assumption_have_range_t* restrict tr * @param tree The tree to evaluate * @return Zero on success, -1 on error, 1 if an undefined macro is used */ -static int check_marco_calls(mds_kbdc_tree_t* restrict tree) +static int +check_marco_calls(mds_kbdc_tree_t *restrict tree) { -#define t(...) fail_if (rc |= r = (__VA_ARGS__), r < 0) - mds_kbdc_tree_macro_t* _macro; - mds_kbdc_include_stack_t* _macro_include_stack; - void* data; - int r, rc = 0; - again: - if (tree == NULL) - return rc; - - switch (tree->type) - { - case C(INCLUDE): - t (mds_kbdc_include_stack_push(&(tree->include), &data)); - t (r = check_marco_calls(tree->include.inner), mds_kbdc_include_stack_pop(data), r); - break; - - case C(FOR): - t (check_marco_calls(tree->for_.inner)); - break; - - case C(IF): - t (check_marco_calls(tree->if_.inner)); - t (check_marco_calls(tree->if_.otherwise)); - break; - - case C(MACRO_CALL): - t (get_macro(&(tree->macro_call), &_macro, &_macro_include_stack)); - break; - - default: - break; - } - - tree = tree->next; - goto again; - fail: - return -1; - (void) _macro; - (void) _macro_include_stack; +#define t(...) fail_if (rc |= r = (__VA_ARGS__), r < 0) + mds_kbdc_tree_macro_t *_macro; + mds_kbdc_include_stack_t *_macro_include_stack; + void *data; + int r, rc = 0; + +again: + if (!tree) + return rc; + + switch (tree->type) { + case C(INCLUDE): + t (mds_kbdc_include_stack_push(&(tree->include), &data)); + t (r = check_marco_calls(tree->include.inner), mds_kbdc_include_stack_pop(data), r); + break; + + case C(FOR): + t (check_marco_calls(tree->for_.inner)); + break; + + case C(IF): + t (check_marco_calls(tree->if_.inner)); + t (check_marco_calls(tree->if_.otherwise)); + break; + + case C(MACRO_CALL): + t (get_macro(&(tree->macro_call), &_macro, &_macro_include_stack)); + break; + + default: + break; + } + + tree = tree->next; + goto again; +fail: + return -1; + (void) _macro; + (void) _macro_include_stack; #undef t } @@ -1747,24 +1706,25 @@ static int check_marco_calls(mds_kbdc_tree_t* restrict tree) * @param tree The tree to evaluate * @return Zero on success, -1 on error, 1 if an undefined function is used */ -static int check_function_calls_in_for(const mds_kbdc_tree_for_t* restrict tree) +static int +check_function_calls_in_for(const mds_kbdc_tree_for_t *restrict tree) { -#define t(...) fail_if (rc |= r = check_function_calls_in_literal(__VA_ARGS__), r < 0) - size_t lineoff_first; - size_t lineoff_last; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - int r, rc = 0; - - for (lineoff_first = tree->loc_end; code[lineoff_first] == ' '; lineoff_first++); - for (lineoff_last = lineoff_first + strlen(tree->first); code[lineoff_last] == ' '; lineoff_last++); - for (lineoff_last += strlen("to"); code[lineoff_last] == ' '; lineoff_last++); - - t ((const mds_kbdc_tree_t*)tree, tree->first, lineoff_first); - t ((const mds_kbdc_tree_t*)tree, tree->last, lineoff_last); - - return rc; - fail: - return -1; +#define t(...) fail_if (rc |= r = check_function_calls_in_literal(__VA_ARGS__), r < 0) + size_t lineoff_first; + size_t lineoff_last; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + int r, rc = 0; + + for (lineoff_first = tree->loc_end; code[lineoff_first] == ' '; lineoff_first++); + for (lineoff_last = lineoff_first + strlen(tree->first); code[lineoff_last] == ' '; lineoff_last++); + for (lineoff_last += strlen("to"); code[lineoff_last] == ' '; lineoff_last++); + + t ((const mds_kbdc_tree_t *)tree, tree->first, lineoff_first); + t ((const mds_kbdc_tree_t *)tree, tree->last, lineoff_last); + + return rc; +fail: + return -1; #undef t } @@ -1775,17 +1735,18 @@ static int check_function_calls_in_for(const mds_kbdc_tree_for_t* restrict tree) * @param tree The tree to evaluate * @return Zero on success, -1 on error, 1 if an undefined function is used */ -static int check_function_calls_in_if(const mds_kbdc_tree_if_t* restrict tree) +static int +check_function_calls_in_if(const mds_kbdc_tree_if_t *restrict tree) { - size_t lineoff; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - int r; - - for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); - r = check_function_calls_in_literal((const mds_kbdc_tree_t*)tree, tree->condition, lineoff); - fail_if (r < 0); - fail: - return r; + size_t lineoff; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + int r; + + for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); + r = check_function_calls_in_literal((const mds_kbdc_tree_t *)tree, tree->condition, lineoff); + fail_if (r < 0); +fail: + return r; } @@ -1795,13 +1756,14 @@ static int check_function_calls_in_if(const mds_kbdc_tree_if_t* restrict tree) * @param tree The tree to evaluate * @return Zero on success, -1 on error, 1 if an undefined function is used */ -static int check_function_calls_in_keys(const mds_kbdc_tree_keys_t* restrict tree) +static int +check_function_calls_in_keys(const mds_kbdc_tree_keys_t *restrict tree) { - int r; - r = check_function_calls_in_literal((const mds_kbdc_tree_t*)tree, tree->keys, tree->loc_start); - fail_if (r < 0); - fail: - return r; + int r; + r = check_function_calls_in_literal((const mds_kbdc_tree_t *)tree, tree->keys, tree->loc_start); + fail_if (r < 0); +fail: + return r; } @@ -1811,13 +1773,14 @@ static int check_function_calls_in_keys(const mds_kbdc_tree_keys_t* restrict tre * @param tree The tree to evaluate * @return Zero on success, -1 on error, 1 if an undefined function is used */ -static int check_function_calls_in_string(const mds_kbdc_tree_string_t* restrict tree) +static int +check_function_calls_in_string(const mds_kbdc_tree_string_t *restrict tree) { - int r; - r = check_function_calls_in_literal((const mds_kbdc_tree_t*)tree, tree->string, tree->loc_start); - fail_if (r < 0); - fail: - return r; + int r; + r = check_function_calls_in_literal((const mds_kbdc_tree_t *)tree, tree->string, tree->loc_start); + fail_if (r < 0); +fail: + return r; } @@ -1827,46 +1790,47 @@ static int check_function_calls_in_string(const mds_kbdc_tree_string_t* restrict * @param tree The tree to evaluate * @return Zero on success, -1 on error, 1 if an undefined function is used */ -static int check_function_calls(const mds_kbdc_tree_t* restrict tree) +static int +check_function_calls(const mds_kbdc_tree_t *restrict tree) { -#define t(...) fail_if (rc |= r = (__VA_ARGS__), r < 0) - void* data; - int r, rc = 0; - again: - if (tree == NULL) - return rc; - - switch (tree->type) - { - case C(INCLUDE): - t (mds_kbdc_include_stack_push(&(tree->include), &data)); - t (r = check_function_calls(tree->include.inner), mds_kbdc_include_stack_pop(data), r); - break; - - case C(FOR): - t (check_function_calls_in_for(&(tree->for_))); - t (check_function_calls(tree->for_.inner)); - break; - - case C(IF): - t (check_function_calls_in_if(&(tree->if_))); - t (check_function_calls(tree->if_.inner)); - t (check_function_calls(tree->if_.otherwise)); - break; - - case C(LET): t (check_function_calls(tree->let.value)); break; - case C(ARRAY): t (check_function_calls(tree->array.elements)); break; - case C(KEYS): t (check_function_calls_in_keys(&(tree->keys))); break; - case C(STRING): t (check_function_calls_in_string(&(tree->string))); break; - case C(MAP): t (check_function_calls(tree->map.sequence)); break; - default: - break; - } - - tree = tree->next; - goto again; - fail: - return -1; +#define t(...) fail_if (rc |= r = (__VA_ARGS__), r < 0) + void *data; + int r, rc = 0; + +again: + if (!tree) + return rc; + + switch (tree->type) { + case C(INCLUDE): + t (mds_kbdc_include_stack_push(&(tree->include), &data)); + t (r = check_function_calls(tree->include.inner), mds_kbdc_include_stack_pop(data), r); + break; + + case C(FOR): + t (check_function_calls_in_for(&(tree->for_))); + t (check_function_calls(tree->for_.inner)); + break; + + case C(IF): + t (check_function_calls_in_if(&(tree->if_))); + t (check_function_calls(tree->if_.inner)); + t (check_function_calls(tree->if_.otherwise)); + break; + + case C(LET): t (check_function_calls(tree->let.value)); break; + case C(ARRAY): t (check_function_calls(tree->array.elements)); break; + case C(KEYS): t (check_function_calls_in_keys(&(tree->keys))); break; + case C(STRING): t (check_function_calls_in_string(&(tree->string))); break; + case C(MAP): t (check_function_calls(tree->map.sequence)); break; + default: + break; + } + + tree = tree->next; + goto again; +fail: + return -1; #undef t } @@ -1877,52 +1841,50 @@ static int check_function_calls(const mds_kbdc_tree_t* restrict tree) * @param tree The tree to inspect * @return Zero on sucess, -1 on error, 1 if the name-suffix in invalid */ -static int check_name_suffix(struct mds_kbdc_tree_callable* restrict tree) +static int +check_name_suffix(struct mds_kbdc_tree_callable *restrict tree) { - const char* restrict name = strchr(tree->name, '/'); - const char* restrict code = result->source_code->real_lines[tree->loc_line]; - - /* A "/" must exist in the name to tell us how many parameters there are. */ - if (name == NULL) - { - NEW_ERROR(tree, ERROR, "name-suffix is missing"); - goto name_error; - } - /* Do not let the suffix by just "/". */ - if (*++name == '\0') - { - NEW_ERROR(tree, ERROR, "empty name-suffix"); - goto name_error; - } - - /* We are all good if the suffix is simply "/0" */ - if (!strcmp(name, "0")) - return 0; - - /* The suffix may not have leading zeroes. */ - if (*name == '0') - { - NEW_ERROR(tree, ERROR, "leading zero in name-suffix"); - goto name_error; - } - /* The suffix must be a decimal, non-negative number. */ - for (; *name; name++) - if ((*name < '0') || ('9' < *name)) - { - NEW_ERROR(tree, ERROR, "name-suffix may only contain digits"); - goto name_error; - } - - return 0; - fail: - return -1; - name_error: - error->start = tree->loc_end; - while (code[error->start] == ' ') - error->start++; - error->end = error->start + strlen(tree->name); - tree->processed = PROCESS_LEVEL; - return 1; + const char *restrict name = strchr(tree->name, '/'); + const char *restrict code = result->source_code->real_lines[tree->loc_line]; + + /* A "/" must exist in the name to tell us how many parameters there are. */ + if (!name) { + NEW_ERROR(tree, ERROR, "name-suffix is missing"); + goto name_error; + } + /* Do not let the suffix by just "/". */ + if (!*++name) { + NEW_ERROR(tree, ERROR, "empty name-suffix"); + goto name_error; + } + + /* We are all good if the suffix is simply "/0" */ + if (!strcmp(name, "0")) + return 0; + + /* The suffix may not have leading zeroes. */ + if (*name == '0') { + NEW_ERROR(tree, ERROR, "leading zero in name-suffix"); + goto name_error; + } + /* The suffix must be a decimal, non-negative number. */ + for (; *name; name++) { + if (*name < '0' || '9' < *name) { + NEW_ERROR(tree, ERROR, "name-suffix may only contain digits"); + goto name_error; + } + } + + return 0; +fail: + return -1; +name_error: + error->start = tree->loc_end; + while (code[error->start] == ' ') + error->start++; + error->end = error->start + strlen(tree->name); + tree->processed = PROCESS_LEVEL; + return 1; } @@ -1932,67 +1894,67 @@ static int check_name_suffix(struct mds_kbdc_tree_callable* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_function(mds_kbdc_tree_function_t* restrict tree) +static int +compile_function(mds_kbdc_tree_function_t *restrict tree) { -#define t(expr) fail_if (r = (expr), r < 0); if (r) tree->processed = PROCESS_LEVEL - mds_kbdc_tree_function_t* function; - mds_kbdc_include_stack_t* function_include_stack; - mds_kbdc_include_stack_t* our_include_stack = NULL; - char* suffixless; - char* suffix_start = NULL; - size_t arg_count; - int r, saved_errno; - - /* Check that the suffix if properly formatted. */ - t (check_name_suffix((struct mds_kbdc_tree_callable*)tree)); - if (r) return 0; - - /* Get the function's name without suffix, and parse the suffix. */ - suffixless = tree->name; - suffix_start = strchr(suffixless, '/'); - *suffix_start++ = '\0'; - arg_count = atoz(suffix_start--); - - /* Check that the function is not already defined as a builtin function. */ - if (builtin_function_defined(suffixless, arg_count)) - { - NEW_ERROR(tree, ERROR, "function ‘%s/%zu’ is already defined as a builtin function", - tree->name, arg_count); - *suffix_start = '/'; - return 0; - } - /* Check that the function is not already defined, - the include-stack is used in the error-clause as - well as later when we list the function as defined. */ - get_function_lax(suffixless, arg_count, &function, &function_include_stack); - fail_if (our_include_stack = mds_kbdc_include_stack_save(), our_include_stack == NULL); - if (function) - { - *suffix_start = '/'; - NEW_ERROR(tree, ERROR, "function ‘%s’ is already defined", tree->name); - fail_if (mds_kbdc_include_stack_restore(function_include_stack)); - NEW_ERROR(function, NOTE, "previously defined here"); - fail_if (mds_kbdc_include_stack_restore(our_include_stack)); - mds_kbdc_include_stack_free(our_include_stack); - return 0; - } - - /* Check the the function does not call macros or functions - * before they are defined, otherwise they may get defined - * between the definition of the function and calls to it. */ - t (check_marco_calls(tree->inner)); - t (check_function_calls(tree->inner)); - - /* List the function as defined. */ - *suffix_start = '/', suffix_start = NULL; - t (set_function(tree, our_include_stack)); - - return 0; - FAIL_BEGIN; - if (suffix_start) - *suffix_start = '/'; - mds_kbdc_include_stack_free(our_include_stack); - FAIL_END; +#define t(expr) do { fail_if (r = (expr), r < 0); if (r) tree->processed = PROCESS_LEVEL; } while (0) + mds_kbdc_tree_function_t *function; + mds_kbdc_include_stack_t *function_include_stack; + mds_kbdc_include_stack_t *our_include_stack = NULL; + char *suffixless; + char *suffix_start = NULL; + size_t arg_count; + int r, saved_errno; + + /* Check that the suffix if properly formatted. */ + t (check_name_suffix((struct mds_kbdc_tree_callable*)tree)); + if (r) + return 0; + + /* Get the function's name without suffix, and parse the suffix. */ + suffixless = tree->name; + suffix_start = strchr(suffixless, '/'); + *suffix_start++ = '\0'; + arg_count = atoz(suffix_start--); + + /* Check that the function is not already defined as a builtin function. */ + if (builtin_function_defined(suffixless, arg_count)) { + NEW_ERROR(tree, ERROR, "function ‘%s/%zu’ is already defined as a builtin function", + tree->name, arg_count); + *suffix_start = '/'; + return 0; + } + /* Check that the function is not already defined, + the include-stack is used in the error-clause as + well as later when we list the function as defined. */ + get_function_lax(suffixless, arg_count, &function, &function_include_stack); + fail_if (!(our_include_stack = mds_kbdc_include_stack_save(), our_include_stack)); + if (function) { + *suffix_start = '/'; + NEW_ERROR(tree, ERROR, "function ‘%s’ is already defined", tree->name); + fail_if (mds_kbdc_include_stack_restore(function_include_stack)); + NEW_ERROR(function, NOTE, "previously defined here"); + fail_if (mds_kbdc_include_stack_restore(our_include_stack)); + mds_kbdc_include_stack_free(our_include_stack); + return 0; + } + + /* Check the the function does not call macros or functions + * before they are defined, otherwise they may get defined + * between the definition of the function and calls to it. */ + t (check_marco_calls(tree->inner)); + t (check_function_calls(tree->inner)); + + /* List the function as defined. */ + *suffix_start = '/', suffix_start = NULL; + t (set_function(tree, our_include_stack)); + + return 0; + FAIL_BEGIN; + if (suffix_start) + *suffix_start = '/'; + mds_kbdc_include_stack_free(our_include_stack); + FAIL_END; #undef t } @@ -2003,46 +1965,47 @@ static int compile_function(mds_kbdc_tree_function_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_macro(mds_kbdc_tree_macro_t* restrict tree) +static int +compile_macro(mds_kbdc_tree_macro_t *restrict tree) { -#define t(expr) fail_if (r = (expr), r < 0); if (r) tree->processed = PROCESS_LEVEL - mds_kbdc_tree_macro_t* macro; - mds_kbdc_include_stack_t* macro_include_stack; - mds_kbdc_include_stack_t* our_include_stack = NULL; - int r, saved_errno; - - /* Check that the suffix if properly formatted. */ - t (check_name_suffix((struct mds_kbdc_tree_callable*)tree)); - if (r) return 0; - - /* Check that the macro is not already defined, - the include-stack is used in the error-clause as - well as later when we list the macro as defined. */ - fail_if (our_include_stack = mds_kbdc_include_stack_save(), our_include_stack == NULL); - get_macro_lax(tree->name, ¯o, ¯o_include_stack); - if (macro) - { - NEW_ERROR(tree, ERROR, "macro ‘%s’ is already defined", tree->name); - fail_if (mds_kbdc_include_stack_restore(macro_include_stack)); - NEW_ERROR(macro, NOTE, "previously defined here"); - fail_if (mds_kbdc_include_stack_restore(our_include_stack)); - mds_kbdc_include_stack_free(our_include_stack); - return 0; - } - - /* Check the the macro does not call macros or functions - * before they are defined, otherwise they may get defined - * between the definition of the macro and calls to it. */ - t (check_marco_calls(tree->inner)); - t (check_function_calls(tree->inner)); - - /* List the macro as defined. */ - t (set_macro(tree, our_include_stack)); - - return 0; - FAIL_BEGIN; - mds_kbdc_include_stack_free(our_include_stack); - FAIL_END; +#define t(expr) do { fail_if (r = (expr), r < 0); if (r) tree->processed = PROCESS_LEVEL; } while (0) + mds_kbdc_tree_macro_t *macro; + mds_kbdc_include_stack_t *macro_include_stack; + mds_kbdc_include_stack_t *our_include_stack = NULL; + int r, saved_errno; + + /* Check that the suffix if properly formatted. */ + t (check_name_suffix((struct mds_kbdc_tree_callable*)tree)); + if (r) + return 0; + + /* Check that the macro is not already defined, + the include-stack is used in the error-clause as + well as later when we list the macro as defined. */ + fail_if (!(our_include_stack = mds_kbdc_include_stack_save())); + get_macro_lax(tree->name, ¯o, ¯o_include_stack); + if (macro) { + NEW_ERROR(tree, ERROR, "macro ‘%s’ is already defined", tree->name); + fail_if (mds_kbdc_include_stack_restore(macro_include_stack)); + NEW_ERROR(macro, NOTE, "previously defined here"); + fail_if (mds_kbdc_include_stack_restore(our_include_stack)); + mds_kbdc_include_stack_free(our_include_stack); + return 0; + } + + /* Check the the macro does not call macros or functions + * before they are defined, otherwise they may get defined + * between the definition of the macro and calls to it. */ + t (check_marco_calls(tree->inner)); + t (check_function_calls(tree->inner)); + + /* List the macro as defined. */ + t (set_macro(tree, our_include_stack)); + + return 0; + FAIL_BEGIN; + mds_kbdc_include_stack_free(our_include_stack); + FAIL_END; #undef t } @@ -2053,94 +2016,92 @@ static int compile_macro(mds_kbdc_tree_macro_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_for(mds_kbdc_tree_for_t* restrict tree) +static int +compile_for(mds_kbdc_tree_for_t *restrict tree) { - size_t lineoff_first; - size_t lineoff_last; - size_t lineoff_var; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - char32_t* restrict first = NULL; - char32_t* restrict last = NULL; - char32_t diff; - char32_t character[2]; - size_t variable; - int possible_shadow = 1, saved_errno; - - - last_value_statement = NULL; - - - /* Locate the first character of the primary bound's string. */ - for (lineoff_first = tree->loc_end; code[lineoff_first] == ' '; lineoff_first++); - /* Locate the first character of the secondary bound's string. */ - for (lineoff_last = lineoff_first + strlen(tree->first); code[lineoff_last] == ' '; lineoff_last++); - for (lineoff_last += strlen("to"); code[lineoff_last] == ' '; lineoff_last++); - /* Locate the first character of the select variable. */ - for (lineoff_var = lineoff_last + strlen(tree->last); code[lineoff_var] == ' '; lineoff_var++); - for (lineoff_var += strlen("as"); code[lineoff_var] == ' '; lineoff_var++); - - /* Duplicate bounds and evaluate function calls, - variable dereferences and escapes in the bounds. */ - fail_if (first = parse_string((mds_kbdc_tree_t*)tree, tree->first, lineoff_first), first == NULL); - fail_if (last = parse_string((mds_kbdc_tree_t*)tree, tree->last, lineoff_last), last == NULL); - /* Get the index of the selected variable. */ - fail_if (variable = parse_variable((mds_kbdc_tree_t*)tree, tree->variable, lineoff_var), variable == 0); - - /* Did one of the bound not evaluate, then stop. */ - if (tree->processed == PROCESS_LEVEL) - goto done; - - - /* Check that the primary bound is single-character. */ - if ((first[0] == -1) || (first[1] != -1)) - { - NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string"); - error->start = lineoff_first, lineoff_first = 0; - error->end = error->start + strlen(tree->first); - } - /* Check that the secondary bound is single-character. */ - if ((last[0] == -1) || (last[1] != -1)) - { - NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string"); - error->start = lineoff_last, lineoff_last = 0; - error->end = error->start + strlen(tree->last); - } - - /* Was one of the bounds not single-character, then stop. */ - if ((lineoff_first == 0) || (lineoff_last == 0)) - goto done; - - - /* Iterate over the loop for as long as a `return` or `break` has not - been encountered (without being caught elsewhere). */ - character[1] = -1; - for (diff = (*first > *last) ? -1 : +1; break_level < 2; *first += diff) - { - break_level = 0; - character[0] = *first; - fail_if (let(variable, character, NULL, (mds_kbdc_tree_t*)tree, lineoff_var, possible_shadow)); - possible_shadow = 0; - fail_if (compile_subtree(tree->inner)); - /* Bounds are inclusive. */ - if (*first == *last) - break; - } - fail_if (variables_was_used_in_for(variable)); - - /* Catch `break` and `continue`, they may not propagate further. */ - if (break_level < 3) - break_level = 0; - - - done: - last_value_statement = NULL; - free(first); - free(last); - return 0; - FAIL_BEGIN; - free(first); - free(last); - FAIL_END; + size_t lineoff_first; + size_t lineoff_last; + size_t lineoff_var; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + char32_t *restrict first = NULL; + char32_t *restrict last = NULL; + char32_t diff; + char32_t character[2]; + size_t variable; + int possible_shadow = 1, saved_errno; + + + last_value_statement = NULL; + + + /* Locate the first character of the primary bound's string. */ + for (lineoff_first = tree->loc_end; code[lineoff_first] == ' '; lineoff_first++); + /* Locate the first character of the secondary bound's string. */ + for (lineoff_last = lineoff_first + strlen(tree->first); code[lineoff_last] == ' '; lineoff_last++); + for (lineoff_last += strlen("to"); code[lineoff_last] == ' '; lineoff_last++); + /* Locate the first character of the select variable. */ + for (lineoff_var = lineoff_last + strlen(tree->last); code[lineoff_var] == ' '; lineoff_var++); + for (lineoff_var += strlen("as"); code[lineoff_var] == ' '; lineoff_var++); + + /* Duplicate bounds and evaluate function calls, + variable dereferences and escapes in the bounds. */ + fail_if (!(first = parse_string((mds_kbdc_tree_t*)tree, tree->first, lineoff_first))); + fail_if (!(last = parse_string((mds_kbdc_tree_t*)tree, tree->last, lineoff_last))); + /* Get the index of the selected variable. */ + fail_if (variable = parse_variable((mds_kbdc_tree_t*)tree, tree->variable, lineoff_var), variable == 0); + + /* Did one of the bound not evaluate, then stop. */ + if (tree->processed == PROCESS_LEVEL) + goto done; + + + /* Check that the primary bound is single-character. */ + if (first[0] == -1 || first[1] != -1) { + NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string"); + error->start = lineoff_first, lineoff_first = 0; + error->end = error->start + strlen(tree->first); + } + /* Check that the secondary bound is single-character. */ + if (last[0] == -1 || last[1] != -1) { + NEW_ERROR(tree, ERROR, "iteration boundary must be a single character string"); + error->start = lineoff_last, lineoff_last = 0; + error->end = error->start + strlen(tree->last); + } + + /* Was one of the bounds not single-character, then stop. */ + if (!lineoff_first || !lineoff_last) + goto done; + + + /* Iterate over the loop for as long as a `return` or `break` has not + been encountered (without being caught elsewhere). */ + character[1] = -1; + for (diff = (*first > *last) ? -1 : +1; break_level < 2; *first += diff) { + break_level = 0; + character[0] = *first; + fail_if (let(variable, character, NULL, (mds_kbdc_tree_t*)tree, lineoff_var, possible_shadow)); + possible_shadow = 0; + fail_if (compile_subtree(tree->inner)); + /* Bounds are inclusive. */ + if (*first == *last) + break; + } + fail_if (variables_was_used_in_for(variable)); + + /* Catch `break` and `continue`, they may not propagate further. */ + if (break_level < 3) + break_level = 0; + + +done: + last_value_statement = NULL; + free(first); + free(last); + return 0; + FAIL_BEGIN; + free(first); + free(last); + FAIL_END; } @@ -2150,36 +2111,37 @@ static int compile_for(mds_kbdc_tree_for_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_if(mds_kbdc_tree_if_t* restrict tree) +static int +compile_if(mds_kbdc_tree_if_t *restrict tree) { - size_t lineoff; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - char32_t* restrict data = NULL; - int ok, saved_errno; - size_t i; - - last_value_statement = NULL; - - /* Locate the first character in the condition. */ - for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); - /* Evaluate function calls, variable dereferences and escapes in the condition. */ - fail_if (data = parse_string((mds_kbdc_tree_t*)tree, tree->condition, lineoff), data == NULL); - if (tree->processed == PROCESS_LEVEL) - return free(data), 0; - - /* Evaluate whether the evaluted value is true. */ - for (ok = 1, i = 0; data[i] >= 0; i++) - ok &= !!(data[i]); - free(data), data = NULL;; - - /* Compile the appropriate clause. */ - ok = compile_subtree(ok ? tree->inner : tree->otherwise); - last_value_statement = NULL; - fail_if (ok < 0); - return 0; - FAIL_BEGIN; - free(data); - FAIL_END; + size_t lineoff; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + char32_t *restrict data = NULL; + int ok, saved_errno; + size_t i; + + last_value_statement = NULL; + + /* Locate the first character in the condition. */ + for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); + /* Evaluate function calls, variable dereferences and escapes in the condition. */ + fail_if (!(data = parse_string((mds_kbdc_tree_t*)tree, tree->condition, lineoff))); + if (tree->processed == PROCESS_LEVEL) + return free(data), 0; + + /* Evaluate whether the evaluted value is true. */ + for (ok = 1, i = 0; data[i] >= 0; i++) + ok &= !!(data[i]); + free(data), data = NULL;; + + /* Compile the appropriate clause. */ + ok = compile_subtree(ok ? tree->inner : tree->otherwise); + last_value_statement = NULL; + fail_if (ok < 0); + return 0; + FAIL_BEGIN; + free(data); + FAIL_END; } @@ -2189,35 +2151,36 @@ static int compile_if(mds_kbdc_tree_if_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_let(mds_kbdc_tree_let_t* restrict tree) +static int +compile_let(mds_kbdc_tree_let_t *restrict tree) { - size_t lineoff; - char* restrict code = result->source_code->real_lines[tree->loc_line]; - mds_kbdc_tree_t* value = NULL; - size_t variable; - int saved_errno; - - /* Get the index of the selected variable. */ - for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); - fail_if (variable = parse_variable((mds_kbdc_tree_t*)tree, tree->variable, lineoff), variable == 0); - if (tree->processed == PROCESS_LEVEL) - return 0; - - /* Duplicate arguments and evaluate function calls, - variable dereferences and escapes in the value. */ - fail_if (value = mds_kbdc_tree_dup(tree->value), value == NULL); - fail_if (compile_subtree(value)); - if ((tree->processed = value->processed) == PROCESS_LEVEL) - return mds_kbdc_tree_free(value), 0; - - /* Set the value of the variable. */ - fail_if (let(variable, NULL, value, NULL, 0, 0)); - - mds_kbdc_tree_free(value); - return 0; - FAIL_BEGIN; - free(value); - FAIL_END; + size_t lineoff; + char *restrict code = result->source_code->real_lines[tree->loc_line]; + mds_kbdc_tree_t* value = NULL; + size_t variable; + int saved_errno; + + /* Get the index of the selected variable. */ + for (lineoff = tree->loc_end; code[lineoff] == ' '; lineoff++); + fail_if (!(variable = parse_variable((mds_kbdc_tree_t *)tree, tree->variable, lineoff))); + if (tree->processed == PROCESS_LEVEL) + return 0; + + /* Duplicate arguments and evaluate function calls, + variable dereferences and escapes in the value. */ + fail_if (!(value = mds_kbdc_tree_dup(tree->value))); + fail_if (compile_subtree(value)); + if ((tree->processed = value->processed) == PROCESS_LEVEL) + return mds_kbdc_tree_free(value), 0; + + /* Set the value of the variable. */ + fail_if (let(variable, NULL, value, NULL, 0, 0)); + + mds_kbdc_tree_free(value); + return 0; + FAIL_BEGIN; + free(value); + FAIL_END; } @@ -2237,26 +2200,26 @@ static int compile_let(mds_kbdc_tree_let_t* restrict tree) * @param node The element to evaluate * @return Zero on success, -1 on error, 1 if the element is invalid */ -static int evaluate_element(mds_kbdc_tree_t* restrict node) +static int +evaluate_element(mds_kbdc_tree_t *restrict node) { - char32_t* restrict data = NULL; - int bad = 0; - - for (; node; node = node->next) - { - if (node->type == C(STRING)) - fail_if (data = parse_string(node, node->string.string, node->loc_start), data == NULL); - if (node->type == C(KEYS)) - fail_if (data = parse_keys(node, node->keys.keys, node->loc_start), data == NULL); - free(node->string.string); - node->type = (node->type == C(STRING)) ? C(COMPILED_STRING) : C(COMPILED_KEYS); - node->compiled_string.string = data; - bad |= (node->processed == PROCESS_LEVEL); - } - - return bad; - fail: - return -1; + char32_t *restrict data = NULL; + int bad = 0; + + for (; node; node = node->next) { + if (node->type == C(STRING)) + fail_if (!(data = parse_string(node, node->string.string, node->loc_start))); + if (node->type == C(KEYS)) + fail_if (!(data = parse_keys(node, node->keys.keys, node->loc_start))); + free(node->string.string); + node->type = (node->type == C(STRING)) ? C(COMPILED_STRING) : C(COMPILED_KEYS); + node->compiled_string.string = data; + bad |= (node->processed == PROCESS_LEVEL); + } + + return bad; +fail: + return -1; } @@ -2266,12 +2229,13 @@ static int evaluate_element(mds_kbdc_tree_t* restrict node) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_keys(mds_kbdc_tree_keys_t* restrict tree) +static int +compile_keys(mds_kbdc_tree_keys_t *restrict tree) { - fail_if (evaluate_element((mds_kbdc_tree_t*)tree) < 0); - return 0; - fail: - return -1; + fail_if (evaluate_element((mds_kbdc_tree_t *)tree) < 0); + return 0; +fail: + return -1; } @@ -2281,12 +2245,13 @@ static int compile_keys(mds_kbdc_tree_keys_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_string(mds_kbdc_tree_string_t* restrict tree) +static int +compile_string(mds_kbdc_tree_string_t *restrict tree) { - fail_if (evaluate_element((mds_kbdc_tree_t*)tree) < 0); - return 0; - fail: - return -1; + fail_if (evaluate_element((mds_kbdc_tree_t *)tree) < 0); + return 0; +fail: + return -1; } @@ -2296,15 +2261,16 @@ static int compile_string(mds_kbdc_tree_string_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_array(mds_kbdc_tree_array_t* restrict tree) +static int +compile_array(mds_kbdc_tree_array_t *restrict tree) { - int r = evaluate_element(tree->elements); - fail_if (r < 0); - if (r) - tree->processed = PROCESS_LEVEL; - return 0; - fail: - return -1; + int r = evaluate_element(tree->elements); + fail_if (r < 0); + if (r) + tree->processed = PROCESS_LEVEL; + return 0; +fail: + return -1; } @@ -2316,27 +2282,28 @@ static int compile_array(mds_kbdc_tree_array_t* restrict tree) * @return Zero on success, -1 on error, 1 if any of * the elements contain a NULL character */ -static int check_nonnul(mds_kbdc_tree_t* restrict tree) +static int +check_nonnul(mds_kbdc_tree_t *restrict tree) { - const char32_t* restrict string; - int rc = 0; - again: - if (tree == NULL) - return rc; - - for (string = tree->compiled_string.string; *string != -1; string++) - if (*string == 0) - { - NEW_ERROR(tree, ERROR, "NULL characters are not allowed in mappings"); - tree->processed = PROCESS_LEVEL; - rc = 1; - break; - } - - tree = tree->next; - goto again; - fail: - return -1; + const char32_t *restrict string; + int rc = 0; +again: + if (!tree) + return rc; + + for (string = tree->compiled_string.string; *string != -1; string++) { + if (!*string) { + NEW_ERROR(tree, ERROR, "NULL characters are not allowed in mappings"); + tree->processed = PROCESS_LEVEL; + rc = 1; + break; + } + } + + tree = tree->next; + goto again; +fail: + return -1; } @@ -2346,115 +2313,112 @@ static int check_nonnul(mds_kbdc_tree_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_map(mds_kbdc_tree_map_t* restrict tree) +static int +compile_map(mds_kbdc_tree_map_t *restrict tree) { - int bad = 0, old_have_side_effect = have_side_effect; - mds_kbdc_include_stack_t* restrict include_stack = NULL; - mds_kbdc_tree_t* seq = NULL; - mds_kbdc_tree_t* res = NULL; - mds_kbdc_tree_t* old_seq = tree->sequence; - mds_kbdc_tree_t* old_res = tree->result; - mds_kbdc_tree_map_t* dup_map = NULL; - int r, saved_errno; - mds_kbdc_tree_t* previous_last_value_statement = last_value_statement; - - have_side_effect = 0; - - /* Duplicate arguments and evaluate function calls, - variable dereferences and escapes in the mapping - input sequence. */ - fail_if (seq = mds_kbdc_tree_dup(old_seq), seq == NULL); - fail_if (bad |= evaluate_element(seq), bad < 0); - - /* Duplicate arguments and evaluate function calls, - variable dereferences and escapes in the mapping - output sequence, unless this is a value-statement. */ - if (tree->result) - { - fail_if (res = mds_kbdc_tree_dup(old_res), res == NULL); - fail_if (bad |= evaluate_element(res), bad < 0); - } - - /* Stop if any of the mapping-arguments could not be evaluated. */ - if (bad) - goto done; - - - if (tree->result) - { - /* Mapping-statement. */ - - /* Check for invalid characters in the mapping-arguments. */ - fail_if (bad |= check_nonnul(seq), bad < 0); - fail_if (bad |= check_nonnul(res), bad < 0); - if (bad) - goto done; - - /* Duplicate the mapping-statement but give it the evaluated mapping-arguments. */ - tree->sequence = NULL; - tree->result = NULL; - fail_if (dup_map = &(mds_kbdc_tree_dup((mds_kbdc_tree_t*)tree)->map), dup_map == NULL); - tree->sequence = old_seq, dup_map->sequence = seq, seq = NULL; - tree->result = old_res, dup_map->result = res, res = NULL; - - /* Enlist the mapping for assembling. */ - fail_if (include_stack = mds_kbdc_include_stack_save(), include_stack == NULL); - fail_if (add_mapping(dup_map, include_stack)); - - goto done; - } - - - /* Value-statement */ - - /* Save this statement so we can warn later if it is unnecessary, - * `set_return_value` will set it to `NULL` if there are side-effects, - * which would make this statement necessary (unless the overridding - * statement has identical side-effect, but we will not check for that). - * For simplicity, we do not store the include-stack, instead, we reset - * `last_value_statement` to `NULL` when we visit an include-statement. */ - last_value_statement = (mds_kbdc_tree_t*)tree; - - /* Add the value statement */ - r = set_return_value(seq->compiled_string.string); - seq->compiled_string.string = NULL; - - /* Check that the value-statement is inside a function call, or has - side-effects by directly or indirectly calling ‘\set/3’ on an - array that is not shadowed by an inner function- or macro-call. */ - if (r && !have_side_effect) - { - NEW_ERROR(tree, ERROR, "value-statement outside function without side-effects"); - tree->processed = PROCESS_LEVEL; - } - if (have_side_effect) - last_value_statement = NULL; - - /* Check whether we made a previous value-statement unnecessary. */ - if (previous_last_value_statement) - { - /* For simplicity we set `last_value_statement` on includes, - * so we are sure `last_value_statement` has the same include-stack. */ - - NEW_ERROR(previous_last_value_statement, WARNING, "value-statement has no effects"); - NEW_ERROR(tree, NOTE, "overridden here"); - } - - - done: - mds_kbdc_tree_free(seq); - mds_kbdc_tree_free(res); - have_side_effect |= old_have_side_effect; - return 0; - FAIL_BEGIN; - mds_kbdc_include_stack_free(include_stack); - mds_kbdc_tree_free((mds_kbdc_tree_t*)dup_map); - mds_kbdc_tree_free(seq); - mds_kbdc_tree_free(res); - tree->sequence = old_seq; - tree->result = old_res; - have_side_effect = old_have_side_effect; - FAIL_END; + int bad = 0, old_have_side_effect = have_side_effect; + mds_kbdc_include_stack_t *restrict include_stack = NULL; + mds_kbdc_tree_t *seq = NULL; + mds_kbdc_tree_t *res = NULL; + mds_kbdc_tree_t *old_seq = tree->sequence; + mds_kbdc_tree_t *old_res = tree->result; + mds_kbdc_tree_map_t *dup_map = NULL; + int r, saved_errno; + mds_kbdc_tree_t *previous_last_value_statement = last_value_statement; + + have_side_effect = 0; + + /* Duplicate arguments and evaluate function calls, + variable dereferences and escapes in the mapping + input sequence. */ + fail_if (!(seq = mds_kbdc_tree_dup(old_seq))); + fail_if ((bad |= evaluate_element(seq)) < 0); + + /* Duplicate arguments and evaluate function calls, + variable dereferences and escapes in the mapping + output sequence, unless this is a value-statement. */ + if (tree->result) { + fail_if (!(res = mds_kbdc_tree_dup(old_res))); + fail_if ((bad |= evaluate_element(res)) < 0); + } + + /* Stop if any of the mapping-arguments could not be evaluated. */ + if (bad) + goto done; + + + if (tree->result) { + /* Mapping-statement. */ + + /* Check for invalid characters in the mapping-arguments. */ + fail_if ((bad |= check_nonnul(seq)) < 0); + fail_if ((bad |= check_nonnul(res)) < 0); + if (bad) + goto done; + + /* Duplicate the mapping-statement but give it the evaluated mapping-arguments. */ + tree->sequence = NULL; + tree->result = NULL; + fail_if (!(dup_map = &mds_kbdc_tree_dup((mds_kbdc_tree_t *)tree)->map)); + tree->sequence = old_seq, dup_map->sequence = seq, seq = NULL; + tree->result = old_res, dup_map->result = res, res = NULL; + + /* Enlist the mapping for assembling. */ + fail_if (!(include_stack = mds_kbdc_include_stack_save())); + fail_if (add_mapping(dup_map, include_stack)); + + goto done; + } + + + /* Value-statement */ + + /* Save this statement so we can warn later if it is unnecessary, + * `set_return_value` will set it to `NULL` if there are side-effects, + * which would make this statement necessary (unless the overridding + * statement has identical side-effect, but we will not check for that). + * For simplicity, we do not store the include-stack, instead, we reset + * `last_value_statement` to `NULL` when we visit an include-statement. */ + last_value_statement = (mds_kbdc_tree_t *)tree; + + /* Add the value statement */ + r = set_return_value(seq->compiled_string.string); + seq->compiled_string.string = NULL; + + /* Check that the value-statement is inside a function call, or has + side-effects by directly or indirectly calling ‘\set/3’ on an + array that is not shadowed by an inner function- or macro-call. */ + if (r && !have_side_effect) { + NEW_ERROR(tree, ERROR, "value-statement outside function without side-effects"); + tree->processed = PROCESS_LEVEL; + } + if (have_side_effect) + last_value_statement = NULL; + + /* Check whether we made a previous value-statement unnecessary. */ + if (previous_last_value_statement) { + /* For simplicity we set `last_value_statement` on includes, + * so we are sure `last_value_statement` has the same include-stack. */ + + NEW_ERROR(previous_last_value_statement, WARNING, "value-statement has no effects"); + NEW_ERROR(tree, NOTE, "overridden here"); + } + + +done: + mds_kbdc_tree_free(seq); + mds_kbdc_tree_free(res); + have_side_effect |= old_have_side_effect; + return 0; + FAIL_BEGIN; + mds_kbdc_include_stack_free(include_stack); + mds_kbdc_tree_free((mds_kbdc_tree_t*)dup_map); + mds_kbdc_tree_free(seq); + mds_kbdc_tree_free(res); + tree->sequence = old_seq; + tree->result = old_res; + have_side_effect = old_have_side_effect; + FAIL_END; } @@ -2464,70 +2428,71 @@ static int compile_map(mds_kbdc_tree_map_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_macro_call(mds_kbdc_tree_macro_call_t* restrict tree) +static int +compile_macro_call(mds_kbdc_tree_macro_call_t *restrict tree) { - mds_kbdc_tree_t* arg = NULL; - mds_kbdc_tree_t* arg_; - mds_kbdc_tree_macro_t* macro; - mds_kbdc_include_stack_t* macro_include_stack; - mds_kbdc_include_stack_t* our_include_stack = NULL; - size_t variable = 0; - int bad, saved_errno; - - last_value_statement = NULL; - - /* Push call-stack. */ - mds_kbdc_call_stack_push((mds_kbdc_tree_t*)tree, tree->loc_start, tree->loc_end); - - /* Duplicate arguments and evaluate function calls, - variable dereferences and escapes in the macro - call arguments. */ - if (tree->arguments) - fail_if (arg = mds_kbdc_tree_dup(tree->arguments), arg == NULL); - fail_if (bad = evaluate_element(arg), bad < 0); - if (bad) - return mds_kbdc_tree_free(arg), 0; - - /* Get the macro's subtree and include-stack, if it has - not been defined `get_macro` will add an error message - and return `NULL`. */ - fail_if (get_macro(tree, ¯o, ¯o_include_stack)); - if (macro == NULL) - goto done; - - - /* Push variable-stack and set parameters. */ - variables_stack_push(); - for (arg_ = arg; arg_; arg_ = arg_->next) - fail_if (let(++variable, NULL, arg_, NULL, 0, 0)); - - /* Switch include-stack to the macro's. */ - fail_if (our_include_stack = mds_kbdc_include_stack_save(), our_include_stack == NULL); - fail_if (mds_kbdc_include_stack_restore(macro_include_stack)); - - /* Call the macro. */ - fail_if (compile_subtree(macro->inner)); - - /* Switch back the include-stack to ours. */ - fail_if (mds_kbdc_include_stack_restore(our_include_stack)); - mds_kbdc_include_stack_free(our_include_stack), our_include_stack = NULL; - - /* Pop variable-stack. */ - variables_stack_pop(); - - done: - /* Pop call-stack. */ - mds_kbdc_call_stack_pop(); - - last_value_statement = NULL; - break_level = 0; - mds_kbdc_tree_free(arg); - return 0; - FAIL_BEGIN; - mds_kbdc_call_stack_pop(); - mds_kbdc_tree_free(arg); - mds_kbdc_include_stack_free(our_include_stack); - FAIL_END; + mds_kbdc_tree_t *arg = NULL; + mds_kbdc_tree_t *arg_; + mds_kbdc_tree_macro_t *macro; + mds_kbdc_include_stack_t *macro_include_stack; + mds_kbdc_include_stack_t *our_include_stack = NULL; + size_t variable = 0; + int bad, saved_errno; + + last_value_statement = NULL; + + /* Push call-stack. */ + mds_kbdc_call_stack_push((mds_kbdc_tree_t *)tree, tree->loc_start, tree->loc_end); + + /* Duplicate arguments and evaluate function calls, + variable dereferences and escapes in the macro + call arguments. */ + if (tree->arguments) + fail_if (!(arg = mds_kbdc_tree_dup(tree->arguments))); + fail_if (bad = evaluate_element(arg), bad < 0); + if (bad) + return mds_kbdc_tree_free(arg), 0; + + /* Get the macro's subtree and include-stack, if it has + not been defined `get_macro` will add an error message + and return `NULL`. */ + fail_if (get_macro(tree, ¯o, ¯o_include_stack)); + if (!macro) + goto done; + + + /* Push variable-stack and set parameters. */ + variables_stack_push(); + for (arg_ = arg; arg_; arg_ = arg_->next) + fail_if (let(++variable, NULL, arg_, NULL, 0, 0)); + + /* Switch include-stack to the macro's. */ + fail_if (!(our_include_stack = mds_kbdc_include_stack_save())); + fail_if (mds_kbdc_include_stack_restore(macro_include_stack)); + + /* Call the macro. */ + fail_if (compile_subtree(macro->inner)); + + /* Switch back the include-stack to ours. */ + fail_if (mds_kbdc_include_stack_restore(our_include_stack)); + mds_kbdc_include_stack_free(our_include_stack), our_include_stack = NULL; + + /* Pop variable-stack. */ + variables_stack_pop(); + +done: + /* Pop call-stack. */ + mds_kbdc_call_stack_pop(); + + last_value_statement = NULL; + break_level = 0; + mds_kbdc_tree_free(arg); + return 0; + FAIL_BEGIN; + mds_kbdc_call_stack_pop(); + mds_kbdc_tree_free(arg); + mds_kbdc_include_stack_free(our_include_stack); + FAIL_END; } @@ -2537,64 +2502,64 @@ static int compile_macro_call(mds_kbdc_tree_macro_call_t* restrict tree) * @param tree The tree to compile * @return Zero on success, -1 on error */ -static int compile_subtree(mds_kbdc_tree_t* restrict tree) +static int +compile_subtree(mds_kbdc_tree_t *restrict tree) { -#define t(expr) fail_if ((expr) < 0) -#define c(type) t (compile_##type(&(tree->type))) -#define c_(type) t (compile_##type(&(tree->type##_))) - again: - if (tree == NULL) - return 0; - - if (tree->processed == PROCESS_LEVEL) - /* An error has occurred here before, let's skip it so - * we do not deluge the user with errors. */ - goto next; - - switch (tree->type) - { - case C(INFORMATION): - t (compile_subtree(tree->information.inner)); - break; - case C(INFORMATION_LANGUAGE): c (language); break; - case C(INFORMATION_COUNTRY): c (country); break; - case C(INFORMATION_VARIANT): c (variant); break; - case C(INCLUDE): c (include); break; - case C(FUNCTION): c (function); break; - case C(MACRO): c (macro); break; - case C(ASSUMPTION): - if (includes_ptr == 0) - fail_if (compile_subtree(tree->assumption.inner)); - break; - case C(ASSUMPTION_HAVE): c (have); break; - case C(ASSUMPTION_HAVE_CHARS): c (have_chars); break; - case C(ASSUMPTION_HAVE_RANGE): c (have_range); break; - case C(FOR): c_ (for); break; - case C(IF): c_ (if); break; - case C(LET): c (let); break; - case C(KEYS): c (keys); break; - case C(STRING): c (string); break; - case C(ARRAY): c (array); break; - case C(MAP): c (map); break; - case C(MACRO_CALL): c (macro_call); break; - case C(RETURN): break_level = 3; break; - case C(BREAK): break_level = 2; break; - case C(CONTINUE): break_level = 1; break; - default: - break; - } - +#define t(expr) fail_if ((expr) < 0) +#define c(type) t (compile_##type(&tree->type)) +#define c_(type) t (compile_##type(&tree->type##_)) +again: + if (!tree) + return 0; + + if (tree->processed == PROCESS_LEVEL) + /* An error has occurred here before, let's skip it so + * we do not deluge the user with errors. */ + goto next; + + switch (tree->type) { + case C(INFORMATION): + t (compile_subtree(tree->information.inner)); + break; + case C(INFORMATION_LANGUAGE): c (language); break; + case C(INFORMATION_COUNTRY): c (country); break; + case C(INFORMATION_VARIANT): c (variant); break; + case C(INCLUDE): c (include); break; + case C(FUNCTION): c (function); break; + case C(MACRO): c (macro); break; + case C(ASSUMPTION): + if (!includes_ptr) + fail_if (compile_subtree(tree->assumption.inner)); + break; + case C(ASSUMPTION_HAVE): c (have); break; + case C(ASSUMPTION_HAVE_CHARS): c (have_chars); break; + case C(ASSUMPTION_HAVE_RANGE): c (have_range); break; + case C(FOR): c_ (for); break; + case C(IF): c_ (if); break; + case C(LET): c (let); break; + case C(KEYS): c (keys); break; + case C(STRING): c (string); break; + case C(ARRAY): c (array); break; + case C(MAP): c (map); break; + case C(MACRO_CALL): c (macro_call); break; + case C(RETURN): break_level = 3; break; + case C(BREAK): break_level = 2; break; + case C(CONTINUE): break_level = 1; break; + default: + break; + } + next: - if (break_level) - /* If a `continue`, `break` or `return` has been encountered, - * we are done here and should return to whence we came and - * let the subcompiler of that construct deal with it. */ - return 0; - - tree = tree->next; - goto again; - fail: - return -1; + if (break_level) + /* If a `continue`, `break` or `return` has been encountered, + * we are done here and should return to whence we came and + * let the subcompiler of that construct deal with it. */ + return 0; + + tree = tree->next; + goto again; +fail: + return -1; #undef c_ #undef c #undef t @@ -2607,23 +2572,24 @@ static int compile_subtree(mds_kbdc_tree_t* restrict tree) * @param result_ `result` from `eliminate_dead_code`, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int compile_layout(mds_kbdc_parsed_t* restrict result_) +int +compile_layout(mds_kbdc_parsed_t *restrict result_) { - int r, saved_errno; - result = result_; - mds_kbdc_include_stack_begin(result_); - mds_kbdc_call_stack_begin(result_); - r = compile_subtree(result_->tree); - saved_errno = errno; - mds_kbdc_call_stack_end(); - mds_kbdc_include_stack_end(); - variables_terminate(); - callables_terminate(); - errno = saved_errno; - fail_if (r); - return 0; - fail: - return -1; + int r, saved_errno; + result = result_; + mds_kbdc_include_stack_begin(result_); + mds_kbdc_call_stack_begin(result_); + r = compile_subtree(result_->tree); + saved_errno = errno; + mds_kbdc_call_stack_end(); + mds_kbdc_include_stack_end(); + variables_terminate(); + callables_terminate(); + errno = saved_errno; + fail_if (r); + return 0; +fail: + return -1; } @@ -2633,4 +2599,3 @@ int compile_layout(mds_kbdc_parsed_t* restrict result_) #undef NEW_ERROR #undef C #undef PROCESS_LEVEL - diff --git a/src/mds-kbdc/compile-layout.h b/src/mds-kbdc/compile-layout.h index 6911a71..86604e0 100644 --- a/src/mds-kbdc/compile-layout.h +++ b/src/mds-kbdc/compile-layout.h @@ -28,8 +28,7 @@ * @param result `result` from `eliminate_dead_code`, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int compile_layout(mds_kbdc_parsed_t* restrict result); +int compile_layout(mds_kbdc_parsed_t *restrict result); #endif - diff --git a/src/mds-kbdc/eliminate-dead-code.c b/src/mds-kbdc/eliminate-dead-code.c index 039b6a8..5a8102f 100644 --- a/src/mds-kbdc/eliminate-dead-code.c +++ b/src/mds-kbdc/eliminate-dead-code.c @@ -27,7 +27,7 @@ /** * Tree type constant shortener */ -#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE +#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE /** * Add an error with “included from here”-notes to the error list @@ -38,20 +38,20 @@ * @param ...:const char*, ... Error description format string and arguments * @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored */ -#define NEW_ERROR(NODE, PTR, SEVERITY, ...) \ - NEW_ERROR_WITH_INCLUDES(NODE, PTR, SEVERITY, __VA_ARGS__) +#define NEW_ERROR(NODE, PTR, SEVERITY, ...)\ + NEW_ERROR_WITH_INCLUDES(NODE, PTR, SEVERITY, __VA_ARGS__) /** * Variable whether the latest created error is stored */ -static mds_kbdc_parse_error_t* error; +static mds_kbdc_parse_error_t *error; /** * The parameter of `eliminate_dead_code` */ -static mds_kbdc_parsed_t* restrict result; +static mds_kbdc_parsed_t *restrict result; /** * 2: Eliminating because of a return-statement @@ -68,7 +68,7 @@ static int elimination_level = 0; * @param tree The tree to reduce * @return Zero on success, -1 on error */ -static int eliminate_subtree(mds_kbdc_tree_t* restrict tree); +static int eliminate_subtree(mds_kbdc_tree_t *restrict tree); @@ -78,17 +78,18 @@ static int eliminate_subtree(mds_kbdc_tree_t* restrict tree); * @param tree The tree to reduce * @return Zero on success, -1 on error */ -static int eliminate_include(mds_kbdc_tree_include_t* restrict tree) +static int +eliminate_include(mds_kbdc_tree_include_t *restrict tree) { - void* data; - int r; - fail_if (mds_kbdc_include_stack_push(tree, &data)); - r = eliminate_subtree(tree->inner); - mds_kbdc_include_stack_pop(data); - fail_if (r); - return 0; - fail: - return -1; + void *data; + int r; + fail_if (mds_kbdc_include_stack_push(tree, &data)); + r = eliminate_subtree(tree->inner); + mds_kbdc_include_stack_pop(data); + fail_if (r); + return 0; +fail: + return -1; } @@ -98,17 +99,18 @@ static int eliminate_include(mds_kbdc_tree_include_t* restrict tree) * @param tree The tree to reduce * @return Zero on success, -1 on error */ -static int eliminate_if(mds_kbdc_tree_if_t* restrict tree) +static int +eliminate_if(mds_kbdc_tree_if_t *restrict tree) { - int elimination; - fail_if (eliminate_subtree(tree->inner)); - elimination = elimination_level, elimination_level = 0; - fail_if (eliminate_subtree(tree->otherwise)); - if (elimination > elimination_level) - elimination = elimination_level; - return 0; - fail: - return -1; + int elimination; + fail_if (eliminate_subtree(tree->inner)); + elimination = elimination_level, elimination_level = 0; + fail_if (eliminate_subtree(tree->otherwise)); + if (elimination > elimination_level) + elimination = elimination_level; + return 0; +fail: + return -1; } @@ -118,46 +120,51 @@ static int eliminate_if(mds_kbdc_tree_if_t* restrict tree) * @param tree The tree to reduce * @return Zero on success, -1 on error */ -static int eliminate_subtree(mds_kbdc_tree_t* restrict tree) +static int +eliminate_subtree(mds_kbdc_tree_t *restrict tree) { -#define e(type) fail_if (eliminate_##type(&(tree->type))) -#define E(type) fail_if (eliminate_##type(&(tree->type##_))) - again: - if (tree == NULL) - return 0; +#define e(type) fail_if (eliminate_##type(&tree->type)) +#define E(type) fail_if (eliminate_##type(&tree->type##_)) +again: + if (!tree) + return 0; - switch (tree->type) - { - case C(INCLUDE): e(include); break; - case C(IF): E(if); break; - case C(INFORMATION): - case C(FUNCTION): - case C(MACRO): - case C(ASSUMPTION): - case C(FOR): - fail_if (eliminate_subtree(tree->information.inner)); - if ((tree->type == C(FUNCTION)) || (tree->type == C(MACRO))) elimination_level = 0; - else if ((tree->type == C(FOR)) && (elimination_level == 1)) elimination_level = 0; - break; - case C(RETURN): - case C(BREAK): - case C(CONTINUE): - elimination_level = tree->type == C(RETURN) ? 2 : 1; - break; - default: - break; - } - - if (tree->next && elimination_level) - { - NEW_ERROR(tree->next, includes_ptr, WARNING, "statement is unreachable"); - mds_kbdc_tree_free(tree->next), tree->next = NULL; - } - - tree = tree->next; - goto again; - fail: - return -1; + switch (tree->type) { + case C(INCLUDE): + e(include); + break; + case C(IF): + E(if); + break; + case C(INFORMATION): + case C(FUNCTION): + case C(MACRO): + case C(ASSUMPTION): + case C(FOR): + fail_if (eliminate_subtree(tree->information.inner)); + if (tree->type == C(FUNCTION) || tree->type == C(MACRO)) + elimination_level = 0; + else if (tree->type == C(FOR) && elimination_level == 1) + elimination_level = 0; + break; + case C(RETURN): + case C(BREAK): + case C(CONTINUE): + elimination_level = tree->type == C(RETURN) ? 2 : 1; + break; + default: + break; + } + + if (tree->next && elimination_level) { + NEW_ERROR(tree->next, includes_ptr, WARNING, "statement is unreachable"); + mds_kbdc_tree_free(tree->next), tree->next = NULL; + } + + tree = tree->next; + goto again; +fail: + return -1; #undef E #undef e } @@ -169,20 +176,20 @@ static int eliminate_subtree(mds_kbdc_tree_t* restrict tree) * @param result_ `result` from `validate_tree`, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int eliminate_dead_code(mds_kbdc_parsed_t* restrict result_) +int +eliminate_dead_code(mds_kbdc_parsed_t *restrict result_) { - int r; - mds_kbdc_include_stack_begin(result = result_); - r = eliminate_subtree(result_->tree); - mds_kbdc_include_stack_end(); - fail_if (r); - return 0; - fail: - return -1; + int r; + mds_kbdc_include_stack_begin(result = result_); + r = eliminate_subtree(result_->tree); + mds_kbdc_include_stack_end(); + fail_if (r); + return 0; +fail: + return -1; } #undef NEW_ERROR #undef C - diff --git a/src/mds-kbdc/eliminate-dead-code.h b/src/mds-kbdc/eliminate-dead-code.h index cbdf731..84bc3b6 100644 --- a/src/mds-kbdc/eliminate-dead-code.h +++ b/src/mds-kbdc/eliminate-dead-code.h @@ -28,8 +28,7 @@ * @param result `result` from `validate_tree`, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int eliminate_dead_code(mds_kbdc_parsed_t* restrict result); +int eliminate_dead_code(mds_kbdc_parsed_t *restrict result); #endif - diff --git a/src/mds-kbdc/globals.c b/src/mds-kbdc/globals.c index 8e17020..01feca9 100644 --- a/src/mds-kbdc/globals.c +++ b/src/mds-kbdc/globals.c @@ -26,10 +26,9 @@ int argc; /** * The command line arguments */ -char** argv; +char **argv; /** * Whether ‘--force’ is used */ int argv_force = 0; - diff --git a/src/mds-kbdc/globals.h b/src/mds-kbdc/globals.h index b2b5cf1..1acf4bc 100644 --- a/src/mds-kbdc/globals.h +++ b/src/mds-kbdc/globals.h @@ -27,7 +27,7 @@ extern int argc; /** * The command line arguments */ -extern char** argv; +extern char **argv; /** * Whether ‘--force’ is used @@ -36,4 +36,3 @@ extern int argv_force; #endif - diff --git a/src/mds-kbdc/include-stack.c b/src/mds-kbdc/include-stack.c index 18b13d7..8ba787f 100644 --- a/src/mds-kbdc/include-stack.c +++ b/src/mds-kbdc/include-stack.c @@ -27,27 +27,27 @@ /** * Variable whether the latest created error is stored */ -static mds_kbdc_parse_error_t* error; +static mds_kbdc_parse_error_t *error; /** * The `result` parameter of root procedure that requires the include-stack */ -static mds_kbdc_parsed_t* result; +static mds_kbdc_parsed_t *result; /** * The original value of `result->pathname` */ -static char* original_pathname; +static char *original_pathname; /** * The original value of `result->source_code` */ -static mds_kbdc_source_code_t* original_source_code; +static mds_kbdc_source_code_t *original_source_code; /** * Stack of visited include-statements */ -static const mds_kbdc_tree_include_t** restrict includes = NULL; +static const mds_kbdc_tree_include_t **restrict includes = NULL; /** * The number elements allocated for `includes` @@ -62,7 +62,7 @@ size_t includes_ptr = 0; /** * The latest saved include-stack */ -static mds_kbdc_include_stack_t* latest_save = NULL; +static mds_kbdc_include_stack_t *latest_save = NULL; @@ -72,23 +72,23 @@ static mds_kbdc_include_stack_t* latest_save = NULL; * @param ptr The number of “included from here”-notes * @return Zero on success, -1 on error */ -int mds_kbdc_include_stack_dump(size_t ptr) +int +mds_kbdc_include_stack_dump(size_t ptr) { - char* old_pathname = result->pathname; - mds_kbdc_source_code_t* old_source_code = result->source_code; - while (ptr--) - { - result->pathname = ptr ? includes[ptr - 1]->filename : original_pathname; - result->source_code = ptr ? includes[ptr - 1]->source_code : original_source_code; - NEW_ERROR_WITHOUT_INCLUDES(includes[ptr], NOTE, "included from here"); - } - result->pathname = old_pathname; - result->source_code = old_source_code; - return 0; - fail: - result->pathname = old_pathname; - result->source_code = old_source_code; - return -1; + char *old_pathname = result->pathname; + mds_kbdc_source_code_t *old_source_code = result->source_code; + while (ptr--) { + result->pathname = ptr ? includes[ptr - 1]->filename : original_pathname; + result->source_code = ptr ? includes[ptr - 1]->source_code : original_source_code; + NEW_ERROR_WITHOUT_INCLUDES(includes[ptr], NOTE, "included from here"); + } + result->pathname = old_pathname; + result->source_code = old_source_code; + return 0; +fail: + result->pathname = old_pathname; + result->source_code = old_source_code; + return -1; } @@ -97,11 +97,12 @@ int mds_kbdc_include_stack_dump(size_t ptr) * * @param result_ The `result` parameter of root procedure that requires the include-stack */ -void mds_kbdc_include_stack_begin(mds_kbdc_parsed_t* restrict result_) +void +mds_kbdc_include_stack_begin(mds_kbdc_parsed_t *restrict result_) { - result = result_; - original_pathname = result_->pathname; - original_source_code = result_->source_code; + result = result_; + original_pathname = result_->pathname; + original_source_code = result_->source_code; } @@ -109,13 +110,14 @@ void mds_kbdc_include_stack_begin(mds_kbdc_parsed_t* restrict result_) * Mark the root of the tree as no longer being visited, * and release clean up after the use of this module */ -void mds_kbdc_include_stack_end(void) +void +mds_kbdc_include_stack_end(void) { - latest_save = NULL; - result->pathname = original_pathname; - result->source_code = original_source_code; - free(includes), includes = NULL; - includes_size = includes_ptr = 0; + latest_save = NULL; + result->pathname = original_pathname; + result->source_code = original_source_code; + free(includes), includes = NULL; + includes_size = includes_ptr = 0; } @@ -128,30 +130,31 @@ void mds_kbdc_include_stack_end(void) * is undefined on error * @return Zero on success, -1 on error */ -int mds_kbdc_include_stack_push(const mds_kbdc_tree_include_t* restrict tree, void** data) +int +mds_kbdc_include_stack_push(const mds_kbdc_tree_include_t *restrict tree, void **data) { - const mds_kbdc_tree_include_t** old = NULL; - int saved_errno; - - if (includes_ptr == includes_size) - fail_if (xxrealloc(old, includes, includes_size += 4, const mds_kbdc_tree_include_t*)); - - fail_if (xmalloc(*data, 3, void*)); - - ((char**)(*data))[0] = result->pathname; - ((mds_kbdc_source_code_t**)(*data))[1] = result->source_code; - ((mds_kbdc_include_stack_t**)(*data))[2] = latest_save; - - includes[includes_ptr++] = tree; - result->pathname = tree->filename; - result->source_code = tree->source_code; - latest_save = NULL; - - return 0; - fail: - saved_errno = errno; - free(old); - return errno = saved_errno, -1; + const mds_kbdc_tree_include_t **old = NULL; + int saved_errno; + + if (includes_ptr == includes_size) + fail_if (xxrealloc(old, includes, includes_size += 4, const mds_kbdc_tree_include_t*)); + + fail_if (xmalloc(*data, 3, void*)); + + ((char **)(*data))[0] = result->pathname; + ((mds_kbdc_source_code_t **)(*data))[1] = result->source_code; + ((mds_kbdc_include_stack_t **)(*data))[2] = latest_save; + + includes[includes_ptr++] = tree; + result->pathname = tree->filename; + result->source_code = tree->source_code; + latest_save = NULL; + + return 0; +fail: + saved_errno = errno; + free(old); + return errno = saved_errno, -1; } @@ -162,15 +165,16 @@ int mds_kbdc_include_stack_push(const mds_kbdc_tree_include_t* restrict tree, vo * * @param data `*data` from `mds_kbdc_include_stack_push` */ -void mds_kbdc_include_stack_pop(void* data) +void +mds_kbdc_include_stack_pop(void *data) { - int saved_errno = errno; - result->pathname = ((char**)data)[0]; - result->source_code = ((mds_kbdc_source_code_t**)data)[1]; - latest_save = ((mds_kbdc_include_stack_t**)data)[2]; - includes_ptr--; - free(data); - errno = saved_errno; + int saved_errno = errno; + result->pathname = ((char **)data)[0]; + result->source_code = ((mds_kbdc_source_code_t **)data)[1]; + latest_save = ((mds_kbdc_include_stack_t **)data)[2]; + includes_ptr--; + free(data); + errno = saved_errno; } @@ -179,34 +183,34 @@ void mds_kbdc_include_stack_pop(void* data) * * @return The include-stack, `NULL` on error */ -mds_kbdc_include_stack_t* mds_kbdc_include_stack_save(void) +mds_kbdc_include_stack_t * +mds_kbdc_include_stack_save(void) { - int saved_errno; - - if (latest_save) - { - latest_save->duplicates++; - return latest_save; - } - - fail_if (xmalloc(latest_save, 1, mds_kbdc_include_stack_t)); - - latest_save->stack = NULL; - latest_save->ptr = includes_ptr; - latest_save->duplicates = 0; - - if (latest_save->ptr == 0) - return latest_save; - - fail_if (xmemdup(latest_save->stack, includes, latest_save->ptr, const mds_kbdc_tree_include_t*)); - - return latest_save; - fail: - saved_errno = errno; - if (latest_save) - free(latest_save->stack), latest_save = NULL; - errno = saved_errno; - return NULL; + int saved_errno; + + if (latest_save) { + latest_save->duplicates++; + return latest_save; + } + + fail_if (xmalloc(latest_save, 1, mds_kbdc_include_stack_t)); + + latest_save->stack = NULL; + latest_save->ptr = includes_ptr; + latest_save->duplicates = 0; + + if (!latest_save->ptr) + return latest_save; + + fail_if (xmemdup(latest_save->stack, includes, latest_save->ptr, const mds_kbdc_tree_include_t*)); + + return latest_save; +fail: + saved_errno = errno; + if (latest_save) + free(latest_save->stack), latest_save = NULL; + errno = saved_errno; + return NULL; } @@ -216,23 +220,23 @@ mds_kbdc_include_stack_t* mds_kbdc_include_stack_save(void) * @param stack The include-stack * @return Zero on success, -1 on error */ -int mds_kbdc_include_stack_restore(mds_kbdc_include_stack_t* restrict stack) +int +mds_kbdc_include_stack_restore(mds_kbdc_include_stack_t *restrict stack) { - const mds_kbdc_tree_include_t** tmp; - - latest_save = stack; - - if (stack->ptr > includes_size) - { - fail_if (yrealloc(tmp, includes, stack->ptr, const mds_kbdc_tree_include_t*)); - includes_size = stack->ptr; - } - - memcpy(includes, stack->stack, stack->ptr * sizeof(const mds_kbdc_tree_include_t*)); - includes_ptr = stack->ptr; - return 0; - fail: - return -1; + const mds_kbdc_tree_include_t **tmp; + + latest_save = stack; + + if (stack->ptr > includes_size) { + fail_if (yrealloc(tmp, includes, stack->ptr, const mds_kbdc_tree_include_t *)); + includes_size = stack->ptr; + } + + memcpy(includes, stack->stack, stack->ptr * sizeof(const mds_kbdc_tree_include_t *)); + includes_ptr = stack->ptr; + return 0; +fail: + return -1; } @@ -241,13 +245,13 @@ int mds_kbdc_include_stack_restore(mds_kbdc_include_stack_t* restrict stack) * * @param stack The include-stack */ -void mds_kbdc_include_stack_free(mds_kbdc_include_stack_t* restrict stack) +void +mds_kbdc_include_stack_free(mds_kbdc_include_stack_t *restrict stack) { - if ((stack == NULL) || (stack->duplicates--)) - return; - free(stack->stack); - free(stack); - if (latest_save == stack) - latest_save = NULL; + if (!stack || stack->duplicates--) + return; + free(stack->stack); + free(stack); + if (latest_save == stack) + latest_save = NULL; } - diff --git a/src/mds-kbdc/include-stack.h b/src/mds-kbdc/include-stack.h index c077e2b..284bb02 100644 --- a/src/mds-kbdc/include-stack.h +++ b/src/mds-kbdc/include-stack.h @@ -31,17 +31,17 @@ * @param ...:const char*, ... Error description format string and arguments * @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored */ -#define NEW_ERROR_WITHOUT_INCLUDES(NODE, SEVERITY, ...) \ - NEW_ERROR_(result, SEVERITY, 1, (NODE)->loc_line, \ - (NODE)->loc_start, (NODE)->loc_end, 1, __VA_ARGS__) +#define NEW_ERROR_WITHOUT_INCLUDES(NODE, SEVERITY, ...)\ + NEW_ERROR_(result, SEVERITY, 1, (NODE)->loc_line,\ + (NODE)->loc_start, (NODE)->loc_end, 1, __VA_ARGS__) /** * Add “included from here”-notes * * @param PTR:size_t The number of “included from here”-notes */ -#define DUMP_INCLUDE_STACK(PTR) \ - fail_if (mds_kbdc_include_stack_dump(PTR)) +#define DUMP_INCLUDE_STACK(PTR)\ + fail_if (mds_kbdc_include_stack_dump(PTR)) /** * Add an error with “included from here”-notes to the error list @@ -52,36 +52,32 @@ * @param ...:const char*, ... Error description format string and arguments * @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored */ -#define NEW_ERROR_WITH_INCLUDES(NODE, PTR, SEVERITY, ...) \ - do \ - { \ - NEW_ERROR_WITHOUT_INCLUDES(NODE, SEVERITY, __VA_ARGS__); \ - DUMP_INCLUDE_STACK(PTR); \ - } \ - while (0) +#define NEW_ERROR_WITH_INCLUDES(NODE, PTR, SEVERITY, ...)\ + do {\ + NEW_ERROR_WITHOUT_INCLUDES(NODE, SEVERITY, __VA_ARGS__);\ + DUMP_INCLUDE_STACK(PTR);\ + } while (0) /** * A saved state of the include-stack */ -typedef struct mds_kbdc_include_stack -{ - /** - * Stack of visited include-statements - */ - const mds_kbdc_tree_include_t** stack; - - /** - * The number elements stored in `stack` (do not edit) - */ - size_t ptr; - - /** - * The number of duplicates there are of this object - */ - size_t duplicates; - +typedef struct mds_kbdc_include_stack { + /** + * Stack of visited include-statements + */ + const mds_kbdc_tree_include_t **stack; + + /** + * The number elements stored in `stack` (do not edit) + */ + size_t ptr; + + /** + * The number of duplicates there are of this object + */ + size_t duplicates; } mds_kbdc_include_stack_t; @@ -107,7 +103,7 @@ int mds_kbdc_include_stack_dump(size_t ptr); * * @param result The `result` parameter of root procedure that requires the include-stack */ -void mds_kbdc_include_stack_begin(mds_kbdc_parsed_t* restrict result); +void mds_kbdc_include_stack_begin(mds_kbdc_parsed_t *restrict result); /** * Mark the root of the tree as no longer being visited, @@ -124,7 +120,7 @@ void mds_kbdc_include_stack_end(void); * is undefined on error * @return Zero on success, -1 on error */ -int mds_kbdc_include_stack_push(const mds_kbdc_tree_include_t* restrict tree, void** data); +int mds_kbdc_include_stack_push(const mds_kbdc_tree_include_t *restrict tree, void **data); /** * Undo the lasted not-undone call to `mds_kbdc_include_stack_push` @@ -133,7 +129,7 @@ int mds_kbdc_include_stack_push(const mds_kbdc_tree_include_t* restrict tree, vo * * @param data `*data` from `mds_kbdc_include_stack_push` */ -void mds_kbdc_include_stack_pop(void* data); +void mds_kbdc_include_stack_pop(void *data); /** * Save the current include-stack @@ -148,15 +144,14 @@ mds_kbdc_include_stack_t* mds_kbdc_include_stack_save(void); * @param stack The include-stack * @return Zero on success, -1 on error */ -int mds_kbdc_include_stack_restore(mds_kbdc_include_stack_t* restrict stack); +int mds_kbdc_include_stack_restore(mds_kbdc_include_stack_t *restrict stack); /** * Destroy a previous include-stack and free its allocation * * @param stack The include-stack */ -void mds_kbdc_include_stack_free(mds_kbdc_include_stack_t* restrict stack); +void mds_kbdc_include_stack_free(mds_kbdc_include_stack_t *restrict stack); #endif - diff --git a/src/mds-kbdc/make-tree.c b/src/mds-kbdc/make-tree.c index 1b5e8a5..f5bdf55 100644 --- a/src/mds-kbdc/make-tree.c +++ b/src/mds-kbdc/make-tree.c @@ -31,7 +31,7 @@ #ifndef DEBUG # define DEBUG_PROC(statements) #else -# define DEBUG_PROC(statements) statements +# define DEBUG_PROC(statements) statements #endif @@ -40,16 +40,14 @@ * as a compiler debugging feature and should be used from * inside `DEBUG_PROC` */ -#define PRINT_STACK \ - do \ - { \ - size_t i = stack_ptr; \ - fprintf(stderr, "stack {\n"); \ - while (i--) \ - fprintf(stderr, " %s\n", keyword_stack[i]); \ - fprintf(stderr, "}\n"); \ - } \ - while (0) +#define PRINT_STACK\ + do {\ + size_t i = stack_ptr;\ + fprintf(stderr, "stack {\n");\ + while (i--)\ + fprintf(stderr, " %s\n", keyword_stack[i]);\ + fprintf(stderr, "}\n");\ + } while (0) /** @@ -60,8 +58,8 @@ * @param UPPER:¿T? The upper bound, inclusive * @return :int 1 if `LOWER` ≤ `VALUE` ≤ `UPPER`, otherwise 0 */ -#define in_range(LOWER, VALUE, UPPER) \ - (((LOWER) <= (VALUE)) && ((VALUE) <= (UPPER))) +#define in_range(LOWER, VALUE, UPPER)\ + ((LOWER) <= (VALUE) && (VALUE) <= (UPPER)) /** @@ -70,23 +68,23 @@ * @param C:char The character * @return :int Zero if `C` is a valid callable name character or a forward slash, otherwise 0 */ -#define is_name_char(C) \ - (in_range('a', C, 'z') || in_range('A', C, 'Z') || strchr("0123456789_/", C)) +#define is_name_char(C)\ + (in_range('a', C, 'z') || in_range('A', C, 'Z') || strchr("0123456789_/", C)) /** * Pointer to the beginning of the current line */ -#define LINE \ - (result->source_code->lines[line_i]) +#define LINE\ + (result->source_code->lines[line_i]) /** * Update the tip of the stack to point to the address * of the current stack's tip's `next`-member */ -#define NEXT \ - tree_stack[stack_ptr] = &(tree_stack[stack_ptr][0]->next) +#define NEXT\ + tree_stack[stack_ptr] = &(tree_stack[stack_ptr][0]->next) /** @@ -97,9 +95,9 @@ * @param ...:const char*, ... Error description format string and arguments * @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored */ -#define NEW_ERROR(ERROR_IS_IN_FILE, SEVERITY, ...) \ - NEW_ERROR_(result, SEVERITY, ERROR_IS_IN_FILE, line_i, \ - (size_t)(line - LINE), (size_t)(end - LINE), 1, __VA_ARGS__) +#define NEW_ERROR(ERROR_IS_IN_FILE, SEVERITY, ...)\ + NEW_ERROR_(result, SEVERITY, ERROR_IS_IN_FILE, line_i,\ + (size_t)(line - LINE), (size_t)(end - LINE), 1, __VA_ARGS__) /** @@ -108,13 +106,13 @@ * @param LOWERCASE:identifier The keyword, for the node type, in lower case * @param UPPERCASE:identifier The keyword, for the node type, in upper case */ -#define NEW_NODE(LOWERCASE, UPPERCASE) \ - mds_kbdc_tree_##LOWERCASE##_t* node; \ - fail_if (xcalloc(node, 1, mds_kbdc_tree_##LOWERCASE##_t)); \ - node->type = MDS_KBDC_TREE_TYPE_##UPPERCASE; \ - node->loc_line = line_i; \ - node->loc_start = (size_t)(line - LINE); \ - node->loc_end = (size_t)(end - LINE) +#define NEW_NODE(LOWERCASE, UPPERCASE)\ + mds_kbdc_tree_##LOWERCASE##_t *node;\ + fail_if (xcalloc(node, 1, mds_kbdc_tree_##LOWERCASE##_t));\ + node->type = MDS_KBDC_TREE_TYPE_##UPPERCASE;\ + node->loc_line = line_i;\ + node->loc_start = (size_t)(line - LINE);\ + node->loc_end = (size_t)(end - LINE) /** @@ -123,13 +121,13 @@ * @param LOWERCASE:identifier The keyword, for the node type, in lower case * @param UPPERCASE:identifier The keyword, for the node type, in upper case */ -#define NEW_SUBNODE(LOWERCASE, UPPERCASE) \ - mds_kbdc_tree_##LOWERCASE##_t* subnode; \ - fail_if (xcalloc(subnode, 1, mds_kbdc_tree_##LOWERCASE##_t)); \ - subnode->type = MDS_KBDC_TREE_TYPE_##UPPERCASE; \ - subnode->loc_line = line_i; \ - subnode->loc_start = (size_t)(line - LINE); \ - subnode->loc_end = (size_t)(end - LINE) +#define NEW_SUBNODE(LOWERCASE, UPPERCASE)\ + mds_kbdc_tree_##LOWERCASE##_t *subnode;\ + fail_if (xcalloc(subnode, 1, mds_kbdc_tree_##LOWERCASE##_t));\ + subnode->type = MDS_KBDC_TREE_TYPE_##UPPERCASE;\ + subnode->loc_line = line_i;\ + subnode->loc_start = (size_t)(line - LINE);\ + subnode->loc_end = (size_t)(end - LINE) /** @@ -142,10 +140,10 @@ * * @param KEYWORD:const char* The keyword for the current node's type */ -#define BRANCH(KEYWORD) \ - (*(tree_stack[stack_ptr]) = (mds_kbdc_tree_t*)node, \ - tree_stack[stack_ptr + 1] = &(node->inner), \ - keyword_stack[stack_ptr++] = KEYWORD) +#define BRANCH(KEYWORD)\ + (*(tree_stack[stack_ptr]) = (mds_kbdc_tree_t *)node,\ + tree_stack[stack_ptr + 1] = &(node->inner),\ + keyword_stack[stack_ptr++] = KEYWORD) /** @@ -156,9 +154,9 @@ * This is what should be done when a leaf node has been * created and should be added to the result tree */ -#define LEAF \ - (*(tree_stack[stack_ptr]) = (mds_kbdc_tree_t*)node, \ - NEXT) +#define LEAF\ + (*(tree_stack[stack_ptr]) = (mds_kbdc_tree_t*)node,\ + NEXT) /** @@ -166,9 +164,9 @@ * * @param var:const char* The variable */ -#define SKIP_SPACES(var) \ - while (*var && (*var == ' ')) \ - var++ +#define SKIP_SPACES(var)\ + while (*var && *var == ' ')\ + var++ /** @@ -176,8 +174,8 @@ * * @param KEYWORD:const char* The keyword */ -#define NO_PARAMETERS(KEYWORD) \ - fail_if (no_parameters(KEYWORD)) +#define NO_PARAMETERS(KEYWORD)\ + fail_if (no_parameters(KEYWORD)) /** @@ -187,18 +185,18 @@ * @param var:identifier The name of the member variable, for the current * node, where the parameter should be stored */ -#define NAMES_1(var) \ - fail_if (names_1(&(node->var))) +#define NAMES_1(var)\ + fail_if (names_1(&node->var)) /** * Suppress the next `line = STREND(line)` */ -#define NO_JUMP \ - (*end = prev_end_char, \ - end = line, \ - prev_end_char = *end, \ - *end = '\0') +#define NO_JUMP\ + (*end = prev_end_char,\ + end = line,\ + prev_end_char = *end,\ + *end = '\0') /** @@ -206,8 +204,8 @@ * * @param c:char The character */ -#define IS_END(c) \ - strchr(" >}])", c) +#define IS_END(c)\ + strchr(" >}])", c) /** @@ -217,31 +215,28 @@ * @param var:identifier The name of the member variable, for the current * node, where the parameter should be stored */ -#define CHARS(var) \ - fail_if (chars(&(node->var))) +#define CHARS(var)\ + fail_if (chars(&node->var)) /** * Test that there are no more parameters */ -#define END \ - do \ - { \ - SKIP_SPACES(line); \ - if (*line) \ - { \ - NEW_ERROR(1, ERROR, "too many parameters"); \ - error->end = strlen(LINE); \ - } \ - } \ - while (0) +#define END\ + do {\ + SKIP_SPACES(line);\ + if (*line) {\ + NEW_ERROR(1, ERROR, "too many parameters");\ + error->end = strlen(LINE);\ + }\ + } while (0) /** * Test that the next parameter is in quotes */ -#define QUOTES \ - fail_if (quotes()) +#define QUOTES\ + fail_if (quotes()) /** @@ -251,14 +246,12 @@ * @param var:identifier The name of the member variable, for the current * node, where the parameter should be stored */ -#define QUOTES_1(var) \ - do \ - { \ - QUOTES; \ - CHARS(var); \ - END; \ - } \ - while (0) +#define QUOTES_1(var)\ + do {\ + QUOTES;\ + CHARS(var);\ + END;\ + } while (0) /** @@ -266,8 +259,8 @@ * * @param KEYWORD:const char* The keyword */ -#define TEST_FOR_KEYWORD(KEYWORD) \ - fail_if (test_for_keyword(KEYWORD)) +#define TEST_FOR_KEYWORD(KEYWORD)\ + fail_if (test_for_keyword(KEYWORD)) /** @@ -277,8 +270,8 @@ * @param var:identifier The name of the member variable, for the current * node, where the parameter should be stored */ -#define KEYS(var) \ - fail_if (keys(&(node->var))) +#define KEYS(var)\ + fail_if (keys(&node->var)) /** @@ -288,8 +281,8 @@ * @param var:identifier The name of the member variable, for the current * node, where the parameter should be stored */ -#define PURE_KEYS(var) \ - fail_if (pure_keys(&(node->var))) +#define PURE_KEYS(var)\ + fail_if (pure_keys(&node->var)) @@ -299,23 +292,21 @@ * @param mapseq:int Whether this is a mapping sequence, otherwise * it is treated as macro call arguments */ -#define SEQUENCE(mapseq) \ - do /* for(;;) */ \ - { \ - *end = prev_end_char; \ - SKIP_SPACES(line); \ - if ((*line == '\0') || (*line == (mapseq ? ':' : ')'))) \ - break; \ - fail_if (sequence(mapseq, stack_orig)); \ - } \ - while (1) +#define SEQUENCE(mapseq)\ + do /* for(;;) */ {\ + *end = prev_end_char;\ + SKIP_SPACES(line);\ + if (!*line || *line == (mapseq ? ':' : ')'))\ + break;\ + fail_if (sequence(mapseq, stack_orig));\ + } while (1) /** * Check that the scopes created in `SEQUENCE` has all been popped */ -#define SEQUENCE_FULLY_POPPED \ - fail_if (sequence_fully_popped(stack_orig)) +#define SEQUENCE_FULLY_POPPED\ + fail_if (sequence_fully_popped(stack_orig)) /** @@ -325,14 +316,12 @@ * @param UPPERCASE:identifier The keyword, for the node type, in upper case * @param PARSE:expression Statement, without final semicolon, to retrieve members */ -#define MAKE_LEAF(LOWERCASE, UPPERCASE, PARSE) \ - do \ - { \ - NEW_NODE(LOWERCASE, UPPERCASE); \ - PARSE; \ - LEAF; \ - } \ - while (0) +#define MAKE_LEAF(LOWERCASE, UPPERCASE, PARSE)\ + do {\ + NEW_NODE(LOWERCASE, UPPERCASE);\ + PARSE;\ + LEAF;\ + } while (0) /** @@ -342,26 +331,24 @@ * @param UPPERCASE:identifier The keyword, for the node type, in upper case * @param PARSE:expression Statement, without final semicolon, to retrieve members */ -#define MAKE_BRANCH(LOWERCASE, UPPERCASE, PARSE) \ - do \ - { \ - NEW_NODE(LOWERCASE, UPPERCASE); \ - PARSE; \ - BRANCH(#LOWERCASE); \ - } \ - while (0) +#define MAKE_BRANCH(LOWERCASE, UPPERCASE, PARSE)\ + do {\ + NEW_NODE(LOWERCASE, UPPERCASE);\ + PARSE;\ + BRANCH(#LOWERCASE);\ + } while (0) /** * Variable whether the latest created error is stored */ -static mds_kbdc_parse_error_t* error; +static mds_kbdc_parse_error_t *error; /** * Output parameter for the parsing result */ -static mds_kbdc_parsed_t* restrict result; +static mds_kbdc_parsed_t *restrict result; /** * The head of the parsing-stack @@ -371,12 +358,12 @@ static size_t stack_ptr; /** * The keyword portion of the parsing-stack */ -static const char** restrict keyword_stack; +static const char **restrict keyword_stack; /** * The tree portion of the parsing-stack */ -static mds_kbdc_tree_t*** restrict tree_stack; +static mds_kbdc_tree_t ***restrict tree_stack; /** * The index of the currently parsed line @@ -392,12 +379,12 @@ static int in_array; * The beginning of what has not get been parsed * on the current line */ -static char* line = NULL; +static char *line = NULL; /** * The end of what has been parsed on the current line */ -static char* end = NULL; +static char *end = NULL; /** * The previous value of `*end` @@ -408,7 +395,7 @@ static char prev_end_char; * Pointer to the first non-whitespace character * on the current line */ -static char* original; +static char *original; /** * Whether it has been identified that the @@ -427,40 +414,39 @@ static int too_few; * @param filename The filename of the parsed file * @return The value the caller should return, or 1 if the caller should not return, -1 on error */ -static int get_pathname(const char* restrict filename) +static int +get_pathname(const char *restrict filename) { - char* cwd = NULL; - int saved_errno; - - /* Get a non-relative pathname for the file, relative filenames - * can be misleading as the program can have changed working - * directory to be able to resolve filenames. */ - result->pathname = abspath(filename); - if (result->pathname == NULL) - { - fail_if (errno != ENOENT); - saved_errno = errno; - fail_if (cwd = curpath(), cwd == NULL); - fail_if (xstrdup(result->pathname, filename)); - NEW_ERROR_(result, ERROR, 0, 0, 0, 0, 1, "no such file or directory in ‘%s’", cwd); - free(cwd); - return 0; - } - - /* Check that the file exists and can be read. */ - if (access(result->pathname, R_OK) < 0) - { - saved_errno = errno; - NEW_ERROR_(result, ERROR, 0, 0, 0, 0, 0, NULL); - fail_if (xstrdup(error->description, strerror(saved_errno))); - return 0; - } - - return 1; - fail: - saved_errno = errno; - free(cwd); - return errno = saved_errno, -1; + char *cwd = NULL; + int saved_errno; + + /* Get a non-relative pathname for the file, relative filenames + * can be misleading as the program can have changed working + * directory to be able to resolve filenames. */ + result->pathname = abspath(filename); + if (!result->pathname) { + fail_if (errno != ENOENT); + saved_errno = errno; + fail_if (!(cwd = curpath())); + fail_if (xstrdup(result->pathname, filename)); + NEW_ERROR_(result, ERROR, 0, 0, 0, 0, 1, "no such file or directory in ‘%s’", cwd); + free(cwd); + return 0; + } + + /* Check that the file exists and can be read. */ + if (access(result->pathname, R_OK) < 0) { + saved_errno = errno; + NEW_ERROR_(result, ERROR, 0, 0, 0, 0, 0, NULL); + fail_if (xstrdup(error->description, strerror(saved_errno))); + return 0; + } + + return 1; +fail: + saved_errno = errno; + free(cwd); + return errno = saved_errno, -1; } @@ -469,25 +455,25 @@ static int get_pathname(const char* restrict filename) * * @return Zero on success, -1 on error */ -static int allocate_stacks(void) +static int +allocate_stacks(void) { - size_t max_line_length = 0, cur_line_length, line_n; - - /* The maximum line-length is needed because lines can have there own stacking, - * like sequence mapping lines, additionally, let statements can have one array. */ - for (line_i = 0, line_n = result->source_code->line_count; line_i < line_n; line_i++) - { - cur_line_length = strlen(LINE); - if (max_line_length < cur_line_length) - max_line_length = cur_line_length; - } - - fail_if (xmalloc(keyword_stack, line_n + max_line_length, const char*)); - fail_if (xmalloc(tree_stack, line_n + max_line_length + 1, mds_kbdc_tree_t**)); - - return 0; - fail: - return -1; + size_t max_line_length = 0, cur_line_length, line_n; + + /* The maximum line-length is needed because lines can have there own stacking, + * like sequence mapping lines, additionally, let statements can have one array. */ + for (line_i = 0, line_n = result->source_code->line_count; line_i < line_n; line_i++) { + cur_line_length = strlen(LINE); + if (max_line_length < cur_line_length) + max_line_length = cur_line_length; + } + + fail_if (xmalloc(keyword_stack, line_n + max_line_length, const char*)); + fail_if (xmalloc(tree_stack, line_n + max_line_length + 1, mds_kbdc_tree_t**)); + + return 0; +fail: + return -1; } @@ -496,14 +482,15 @@ static int allocate_stacks(void) * * @return Zero on success, -1 on error */ -static int read_source_code(void) +static int +read_source_code(void) { - /* Read the file and simplify it a bit. */ - fail_if (read_source_lines(result->pathname, result->source_code) < 0); - - return 0; - fail: - return -1; + /* Read the file and simplify it a bit. */ + fail_if (read_source_lines(result->pathname, result->source_code) < 0); + + return 0; +fail: + return -1; } @@ -517,34 +504,32 @@ static int read_source_code(void) * * @return Zero on success, -1 on error */ -static int check_for_premature_end_of_file(void) +static int +check_for_premature_end_of_file(void) { - /* Check that all scopes have been popped. */ - if (stack_ptr) - { - while (stack_ptr && keyword_stack[stack_ptr - 1] == NULL) - stack_ptr--; - if (stack_ptr) - { - NEW_ERROR(0, ERROR, "premature end of file"); - while (stack_ptr--) - { - if (keyword_stack[stack_ptr] == NULL) - continue; - line_i = tree_stack[stack_ptr][0]->loc_line; - line = LINE + tree_stack[stack_ptr][0]->loc_start; - end = LINE + tree_stack[stack_ptr][0]->loc_end; - if (!strcmp(keyword_stack[stack_ptr], "}")) - NEW_ERROR(1, NOTE, "missing associated ‘%s’", keyword_stack[stack_ptr]); - else - NEW_ERROR(1, NOTE, "missing associated ‘end %s’", keyword_stack[stack_ptr]); - } + /* Check that all scopes have been popped. */ + if (stack_ptr) { + while (stack_ptr && !keyword_stack[stack_ptr - 1]) + stack_ptr--; + if (stack_ptr) { + NEW_ERROR(0, ERROR, "premature end of file"); + while (stack_ptr--) { + if (!keyword_stack[stack_ptr]) + continue; + line_i = tree_stack[stack_ptr][0]->loc_line; + line = LINE + tree_stack[stack_ptr][0]->loc_start; + end = LINE + tree_stack[stack_ptr][0]->loc_end; + if (!strcmp(keyword_stack[stack_ptr], "}")) + NEW_ERROR(1, NOTE, "missing associated ‘%s’", keyword_stack[stack_ptr]); + else + NEW_ERROR(1, NOTE, "missing associated ‘end %s’", keyword_stack[stack_ptr]); + } + } } - } - - return 0; - fail: - return -1; + + return 0; +fail: + return -1; } @@ -555,16 +540,16 @@ static int check_for_premature_end_of_file(void) * * @return Zero on success, -1 on error */ -static int check_whether_file_is_empty(void) +static int +check_whether_file_is_empty(void) { - /* Warn about empty files. */ - if (result->tree == NULL) - if (result->errors_ptr == 0) - NEW_ERROR(0, WARNING, "file is empty"); - - return 0; - fail: - return -1; + /* Warn about empty files. */ + if (!result->tree && !result->errors_ptr) + NEW_ERROR(0, WARNING, "file is empty"); + + return 0; +fail: + return -1; } @@ -578,20 +563,20 @@ static int check_whether_file_is_empty(void) * @param keyword The keyword * @return Zero on success, -1 on error */ -static int no_parameters(const char* restrict keyword) +static int +no_parameters(const char *restrict keyword) { - line = STREND(line); - *end = prev_end_char, prev_end_char = '\0'; - SKIP_SPACES(line); - if (*line) - { - end = STREND(line); - NEW_ERROR(1, ERROR, "extra token after ‘%s’", keyword); - } - - return 0; - fail: - return -1; + line = STREND(line); + *end = prev_end_char, prev_end_char = '\0'; + SKIP_SPACES(line); + if (*line) { + end = STREND(line); + NEW_ERROR(1, ERROR, "extra token after ‘%s’", keyword); + } + + return 0; +fail: + return -1; } @@ -604,55 +589,51 @@ static int no_parameters(const char* restrict keyword) * node, where the parameter should be stored * @return Zero on success, -1 on error */ -static int names_1(char** restrict var) +static int +names_1(char **restrict var) { - char* name_end; - char* test; - int stray_char = 0; - char* end_end; - - line = STREND(line); - *end = prev_end_char, prev_end_char = '\0'; - SKIP_SPACES(line); - if (*line == '\0') - { - line = original, end = STREND(line); - NEW_ERROR(1, ERROR, "a name is expected"); - } - else - { - name_end = line; - while (*name_end && is_name_char(*name_end)) - name_end++; - if (*name_end && (*name_end != ' ')) - { - end_end = name_end + 1; - while ((*end_end & 0xC0) == 0x80) - end_end++; - prev_end_char = *end_end, *end_end = '\0'; - NEW_ERROR(1, ERROR, "stray ‘%s’ character", name_end); - error->start = (size_t)(name_end - LINE); - error->end = (size_t)(end_end - LINE); - *end_end = prev_end_char; - stray_char = 1; + char *name_end; + char *test; + int stray_char = 0; + char *end_end; + + line = STREND(line); + *end = prev_end_char, prev_end_char = '\0'; + SKIP_SPACES(line); + if (!*line) { + line = original, end = STREND(line); + NEW_ERROR(1, ERROR, "a name is expected"); + } else { + name_end = line; + while (*name_end && is_name_char(*name_end)) + name_end++; + if (*name_end && (*name_end != ' ')) { + end_end = name_end + 1; + while ((*end_end & 0xC0) == 0x80) + end_end++; + prev_end_char = *end_end, *end_end = '\0'; + NEW_ERROR(1, ERROR, "stray ‘%s’ character", name_end); + error->start = (size_t)(name_end - LINE); + error->end = (size_t)(end_end - LINE); + *end_end = prev_end_char; + stray_char = 1; + } + test = name_end; + SKIP_SPACES(test); + if (*test && !stray_char) { + NEW_ERROR(1, ERROR, "too many parameters"); + error->start = (size_t)(test - LINE); + error->end = strlen(LINE); + } + end = name_end; + prev_end_char = *end; + *end = '\0'; + fail_if (xstrdup(*var, line)); } - test = name_end; - SKIP_SPACES(test); - if (*test && !stray_char) - { - NEW_ERROR(1, ERROR, "too many parameters"); - error->start = (size_t)(test - LINE); - error->end = strlen(LINE); - } - end = name_end; - prev_end_char = *end; - *end = '\0'; - fail_if (xstrdup(*var, line)); - } - - return 0; - fail: - return -1; + + return 0; +fail: + return -1; } @@ -664,46 +645,49 @@ static int names_1(char** restrict var) * node, where the parameter should be stored * @return Zero on success, -1 on error */ -static int chars(char** restrict var) +static int +chars(char **restrict var) { - if (too_few) - return 0; - line = STREND(line); - *end = prev_end_char, prev_end_char = '\0'; - SKIP_SPACES(line); - if (*line == '\0') - { - line = original, end = STREND(line); - NEW_ERROR(1, ERROR, "too few parameters"); - line = end, too_few = 1; - } - else - { - char* arg_end = line; - char* call_end = arg_end; - int escape = 0, quote = 0; - while (*arg_end) - { - char c = *arg_end++; - if (escape) escape = 0; - else if (arg_end <= call_end) ; - else if (c == '\\') - { - escape = 1; - call_end = arg_end + get_end_of_call(arg_end, 0, strlen(arg_end)); - } - else if (quote) quote = (c != '"'); - else if (IS_END(c)) { arg_end--; break; } - else quote = (c == '"'); + char *arg_end, *call_end, c; + int escape, quote; + if (too_few) + return 0; + line = STREND(line); + *end = prev_end_char, prev_end_char = '\0'; + SKIP_SPACES(line); + if (!*line) { + line = original, end = STREND(line); + NEW_ERROR(1, ERROR, "too few parameters"); + line = end, too_few = 1; + } else { + arg_end = line; + call_end = arg_end; + escape = quote = 0; + while (*arg_end) { + c = *arg_end++; + if (escape) { + escape = 0; + } else if (arg_end <= call_end) { ; + } else if (c == '\\') { + escape = 1; + call_end = arg_end + get_end_of_call(arg_end, 0, strlen(arg_end)); + } else if (quote) { + quote = c != '"'; + } else if (IS_END(c)) { + arg_end--; + break; + } else { + quote = c == '"'; + } + } + prev_end_char = *arg_end, *arg_end = '\0', end = arg_end; + fail_if (xstrdup(*var, line)); + line = end; } - prev_end_char = *arg_end, *arg_end = '\0', end = arg_end; - fail_if (xstrdup(*var, line)); - line = end; - } - - return 0; - fail: - return -1; + + return 0; +fail: + return -1; } @@ -712,25 +696,25 @@ static int chars(char** restrict var) * * @return Zero on success, -1 on error */ -static int quotes(void) +static int +quotes(void) { - char* line_ = line; - line = STREND(line); - *end = prev_end_char; - SKIP_SPACES(line); - if (*line && (*line != '"')) - { - char* arg_end = line; - SKIP_SPACES(arg_end); - NEW_ERROR(1, ERROR, "parameter must be in quotes"); - error->end = (size_t)(arg_end - LINE); - } - *end = '\0'; - line = line_; - - return 0; - fail: - return -1; + char *line_ = line, *arg_end; + line = STREND(line); + *end = prev_end_char; + SKIP_SPACES(line); + if (*line && *line != '"') { + arg_end = line; + SKIP_SPACES(arg_end); + NEW_ERROR(1, ERROR, "parameter must be in quotes"); + error->end = (size_t)(arg_end - LINE); + } + *end = '\0'; + line = line_; + + return 0; +fail: + return -1; } @@ -739,23 +723,23 @@ static int quotes(void) * * @return Whether the currently line has unparsed parameters, -1 on error */ -static int have_more_parameters(void) +static int +have_more_parameters(void) { - if (too_few) - return 0; - line = STREND(line); - *end = prev_end_char, prev_end_char = '\0'; - SKIP_SPACES(line); - if (*line == '\0') - { - line = original, end = STREND(line); - NEW_ERROR(1, ERROR, "too few parameters"); - line = end, too_few = 1; - return 0; - } - return 1; - fail: - return -1; + if (too_few) + return 0; + line = STREND(line); + *end = prev_end_char, prev_end_char = '\0'; + SKIP_SPACES(line); + if (!*line) { + line = original, end = STREND(line); + NEW_ERROR(1, ERROR, "too few parameters"); + line = end, too_few = 1; + return 0; + } + return 1; +fail: + return -1; } @@ -765,32 +749,33 @@ static int have_more_parameters(void) * @param keyword The keyword * @return Zero on success, -1 on error */ -static int test_for_keyword(const char* restrict keyword) +static int +test_for_keyword(const char *restrict keyword) { - int ok, r = have_more_parameters(); - fail_if (r < 0); - if (r == 0) - return 0; - - ok = (strstr(line, keyword) == line); - line += strlen(keyword); - ok = ok && ((*line == '\0') || (*line == ' ')); - if (ok) - { - end = line; - prev_end_char = *end, *end = '\0'; - return 0; - } - line -= strlen(keyword); - end = line; - SKIP_SPACES(end); - prev_end_char = *end, *end = '\0'; - NEW_ERROR(1, ERROR, "expecting keyword ‘%s’", keyword); - error->end = error->start + 1; - - return 0; - fail: - return -1; + int ok, r = have_more_parameters(); + fail_if (r < 0); + if (!r) + return 0; + + ok = (strstr(line, keyword) == line); + line += strlen(keyword); + ok = ok && (!*line || *line == ' '); + if (ok) { + end = line; + prev_end_char = *end; + *end = '\0'; + return 0; + } + line -= strlen(keyword); + end = line; + SKIP_SPACES(end); + prev_end_char = *end, *end = '\0'; + NEW_ERROR(1, ERROR, "expecting keyword ‘%s’", keyword); + error->end = error->start + 1; + + return 0; +fail: + return -1; } @@ -802,52 +787,53 @@ static int test_for_keyword(const char* restrict keyword) * node, where the parameter should be stored * @return Zero on success, -1 on error */ -static int keys(mds_kbdc_tree_t** restrict var) +static int +keys(mds_kbdc_tree_t **restrict var) { - char* arg_end; - char* call_end; - int r, escape = 0, quote = 0, triangle; - r = have_more_parameters(); - fail_if (r < 0); - if (r == 0) - return 0; - - arg_end = line; - call_end = arg_end; - triangle = (*arg_end == '<'); - while (*arg_end) - { - char c = *arg_end++ ; - if (escape) escape = 0; - else if (arg_end <= call_end) ; - else if (c == '\\') - { - escape = 1; - call_end = arg_end + get_end_of_call(arg_end, 0, strlen(arg_end)); + char *arg_end, *call_end, c; + int r, escape = 0, quote = 0, triangle; + r = have_more_parameters(); + fail_if (r < 0); + if (!r) + return 0; + + arg_end = line; + call_end = arg_end; + triangle = *arg_end == '<'; + while (*arg_end) { + c = *arg_end++; + if (escape) { + escape = 0; + } else if (arg_end <= call_end) { ; + } else if (c == '\\') { + escape = 1; + call_end = arg_end + get_end_of_call(arg_end, 0, strlen(arg_end)); + } else if (quote) { + quote = c != '"'; + } else if (c == '\"') { + quote = 1; + } else if (c == '>') { + triangle = 0; + } else if (IS_END(c) && !triangle) { + arg_end--; + break; + } } - else if (quote) quote = (c != '"'); - else if (c == '\"') quote = 1; - else if (c == '>') triangle = 0; - else if (IS_END(c) && !triangle) { arg_end--; break; } - } - prev_end_char = *arg_end, *arg_end = '\0', end = arg_end; - if (*line == '<') - { - NEW_SUBNODE(keys, KEYS); - *var = (mds_kbdc_tree_t*)subnode; - fail_if (xstrdup(subnode->keys, line)); - } - else - { - NEW_SUBNODE(string, STRING); - *var = (mds_kbdc_tree_t*)subnode; - fail_if (xstrdup(subnode->string, line)); - } - line = end; - - return 0; - fail: - return -1; + prev_end_char = *arg_end, *arg_end = '\0', end = arg_end; + if (*line == '<') { + NEW_SUBNODE(keys, KEYS); + *var = (mds_kbdc_tree_t *)subnode; + fail_if (xstrdup(subnode->keys, line)); + } else { + NEW_SUBNODE(string, STRING); + *var = (mds_kbdc_tree_t *)subnode; + fail_if (xstrdup(subnode->string, line)); + } + line = end; + + return 0; +fail: + return -1; } @@ -860,41 +846,45 @@ static int keys(mds_kbdc_tree_t** restrict var) * node, where the parameter should be stored * @return Zero on success, -1 on error */ -static int pure_keys(char** restrict var) +static int +pure_keys(char **restrict var) { - char* arg_end; - char* call_end; - int r, escape = 0, quote = 0, triangle; - r = have_more_parameters(); - fail_if (r < 0); - if (r == 0) - return 0; - - arg_end = line; - call_end = arg_end; - triangle = (*arg_end == '<'); - while (*arg_end) - { - char c = *arg_end++ ; - if (escape) escape = 0; - else if (arg_end <= call_end) ; - else if (c == '\\') - { - escape = 1; - call_end = arg_end + get_end_of_call(arg_end, 0, strlen(arg_end)); + char *arg_end, *call_end, c; + int r, escape = 0, quote = 0, triangle; + r = have_more_parameters(); + fail_if (r < 0); + if (!r) + return 0; + + arg_end = line; + call_end = arg_end; + triangle = *arg_end == '<'; + while (*arg_end) { + c = *arg_end++; + if (escape) { + escape = 0; + } else if (arg_end <= call_end) { ; + } else if (c == '\\') { + escape = 1; + call_end = arg_end + get_end_of_call(arg_end, 0, strlen(arg_end)); + } else if (quote) { + quote = c != '"'; + } else if (c == '\"') { + quote = 1; + } else if (c == '>') { + triangle = 0; + } else if (IS_END(c) && !triangle) { + arg_end--; + break; + } } - else if (quote) quote = (c != '"'); - else if (c == '\"') quote = 1; - else if (c == '>') triangle = 0; - else if (IS_END(c) && !triangle) { arg_end--; break; } - } - prev_end_char = *arg_end, *arg_end = '\0'; - fail_if (xstrdup(*var, line)); - end = arg_end, line = end; - - return 0; - fail: - return -1; + prev_end_char = *arg_end, *arg_end = '\0'; + fail_if (xstrdup(*var, line)); + end = arg_end, line = end; + + return 0; +fail: + return -1; } @@ -906,65 +896,54 @@ static int pure_keys(char** restrict var) * @param stack_orig The size of the stack when `SEQUENCE` was called * @return Zero on success, -1 on error */ -static int sequence(int mapseq, size_t stack_orig) +static int +sequence(int mapseq, size_t stack_orig) { - if (mapseq && (*line == '(')) - { - NEW_NODE(unordered, UNORDERED); - node->loc_end = node->loc_start + 1; - BRANCH(")"); - line++; - } - else if (*line == '[') - { - NEW_NODE(alternation, ALTERNATION); - node->loc_end = node->loc_start + 1; - BRANCH("]"); - line++; - } - else if (*line == '.') - { - NEW_NODE(nothing, NOTHING); - node->loc_end = node->loc_start + 1; - LEAF; - line++; - } - else if (strchr("])", *line)) - { - end = line + 1; - prev_end_char = *end, *end = '\0'; - if (stack_ptr == stack_orig) - NEW_ERROR(1, ERROR, "runaway ‘%s’", line); - else - { - stack_ptr--; - if (strcmp(line, keyword_stack[stack_ptr])) - NEW_ERROR(1, ERROR, "expected ‘%s’ but got ‘%s’", keyword_stack[stack_ptr], line); - NEXT; + if (mapseq && *line == '(') { + NEW_NODE(unordered, UNORDERED); + node->loc_end = node->loc_start + 1; + BRANCH(")"); + line++; + } else if (*line == '[') { + NEW_NODE(alternation, ALTERNATION); + node->loc_end = node->loc_start + 1; + BRANCH("]"); + line++; + } else if (*line == '.') { + NEW_NODE(nothing, NOTHING); + node->loc_end = node->loc_start + 1; + LEAF; + line++; + } else if (strchr("])", *line)) { + end = line + 1; + prev_end_char = *end, *end = '\0'; + if (stack_ptr == stack_orig) { + NEW_ERROR(1, ERROR, "runaway ‘%s’", line); + } else { + stack_ptr--; + if (strcmp(line, keyword_stack[stack_ptr])) + NEW_ERROR(1, ERROR, "expected ‘%s’ but got ‘%s’", keyword_stack[stack_ptr], line); + NEXT; + } + *end = prev_end_char; + line++; + } else if (*line == '<') { + NEW_NODE(keys, KEYS); + NO_JUMP; + PURE_KEYS(keys); + LEAF; + node->loc_end = (size_t)(line - LINE); + } else { + NEW_NODE(string, STRING); + NO_JUMP; + CHARS(string); + LEAF; + node->loc_end = (size_t)(line - LINE); } - *end = prev_end_char; - line++; - } - else if (*line == '<') - { - NEW_NODE(keys, KEYS); - NO_JUMP; - PURE_KEYS(keys); - LEAF; - node->loc_end = (size_t)(line - LINE); - } - else - { - NEW_NODE(string, STRING); - NO_JUMP; - CHARS(string); - LEAF; - node->loc_end = (size_t)(line - LINE); - } - - return 0; + + return 0; fail: - return -1; + return -1; } @@ -973,23 +952,23 @@ static int sequence(int mapseq, size_t stack_orig) * * @param stack_orig The size of the stack when `SEQUENCE` was called */ -static int sequence_fully_popped(size_t stack_orig) +static int +sequence_fully_popped(size_t stack_orig) { - if (stack_ptr == stack_orig) - return 0; - end = line + 1; - NEW_ERROR(1, ERROR, "premature end of sequence"); - while (stack_ptr > stack_orig) - { - stack_ptr--; - NEW_ERROR(1, NOTE, "missing associated ‘%s’", keyword_stack[stack_ptr]); - error->start = tree_stack[stack_ptr][0]->loc_start; - error->end = tree_stack[stack_ptr][0]->loc_end; - } - - return 0; - fail: - return -1; + if (stack_ptr == stack_orig) + return 0; + end = line + 1; + NEW_ERROR(1, ERROR, "premature end of sequence"); + while (stack_ptr > stack_orig) { + stack_ptr--; + NEW_ERROR(1, NOTE, "missing associated ‘%s’", keyword_stack[stack_ptr]); + error->start = tree_stack[stack_ptr][0]->loc_start; + error->end = tree_stack[stack_ptr][0]->loc_end; + } + + return 0; +fail: + return -1; } @@ -1002,62 +981,54 @@ static int sequence_fully_popped(size_t stack_orig) * * @return Zero on success, -1 on error, 1 if the caller should go to `redo` */ -static int parse_else(void) +static int +parse_else(void) { - size_t i; - if (stack_ptr == 0) - { - NEW_ERROR(1, ERROR, "runaway ‘else’ statement"); - return 0; - } - line = STREND(line); - *end = prev_end_char, prev_end_char = '\0'; - end = STREND(line); - SKIP_SPACES(line); - i = stack_ptr - 1; - while (keyword_stack[i] == NULL) - i--; - if (strcmp(keyword_stack[i], "if")) - { - stack_ptr--; - line = original, end = STREND(line); - NEW_ERROR(1, ERROR, "runaway ‘else’ statement"); - } - else if (*line == '\0') - { - /* else */ - mds_kbdc_tree_if_t* supernode = &(tree_stack[stack_ptr - 1][0]->if_); - if (supernode->otherwise) - { - line = strstr(LINE, "else"); - end = line + 4, prev_end_char = *end; - NEW_ERROR(1, ERROR, "multiple ‘else’ statements"); - mds_kbdc_tree_free(supernode->otherwise); - supernode->otherwise = NULL; + size_t i; + if (!stack_ptr) { + NEW_ERROR(1, ERROR, "runaway ‘else’ statement"); + return 0; } - tree_stack[stack_ptr] = &(supernode->otherwise); - } - else if ((strstr(line, "if") == line) && ((line[2] == ' ') || (line[2] == '\0'))) - { - /* else if */ - mds_kbdc_tree_if_t* supernode = &(tree_stack[stack_ptr - 1][0]->if_); - NEW_NODE(if, IF); - node->loc_end = node->loc_start + 2; - end = line += 2, prev_end_char = *end, *end = '\0'; - CHARS(condition); - END; - tree_stack[stack_ptr] = &(supernode->otherwise); - BRANCH(NULL); - } - else - { - NEW_ERROR(1, ERROR, "expecting nothing or ‘if’"); - stack_ptr--; - } - - return 0; - fail: - return -1; + line = STREND(line); + *end = prev_end_char, prev_end_char = '\0'; + end = STREND(line); + SKIP_SPACES(line); + i = stack_ptr - 1; + while (!keyword_stack[i]) + i--; + if (strcmp(keyword_stack[i], "if")) { + stack_ptr--; + line = original, end = STREND(line); + NEW_ERROR(1, ERROR, "runaway ‘else’ statement"); + } else if (!*line) { + /* else */ + mds_kbdc_tree_if_t *supernode = &tree_stack[stack_ptr - 1][0]->if_; + if (supernode->otherwise) { + line = strstr(LINE, "else"); + end = line + 4, prev_end_char = *end; + NEW_ERROR(1, ERROR, "multiple ‘else’ statements"); + mds_kbdc_tree_free(supernode->otherwise); + supernode->otherwise = NULL; + } + tree_stack[stack_ptr] = &supernode->otherwise; + } else if (strstr(line, "if") == line && (line[2] == ' ' || !line[2])) { + /* else if */ + mds_kbdc_tree_if_t *supernode = &tree_stack[stack_ptr - 1][0]->if_; + NEW_NODE(if, IF); + node->loc_end = node->loc_start + 2; + end = line += 2, prev_end_char = *end, *end = '\0'; + CHARS(condition); + END; + tree_stack[stack_ptr] = &(supernode->otherwise); + BRANCH(NULL); + } else { + NEW_ERROR(1, ERROR, "expecting nothing or ‘if’"); + stack_ptr--; + } + + return 0; +fail: + return -1; } @@ -1066,20 +1037,21 @@ static int parse_else(void) * * @return Zero on success, -1 on error, 1 if the caller should go to `redo` */ -static int parse_for(void) +static int +parse_for(void) { - NEW_NODE(for, FOR); - CHARS(first); - TEST_FOR_KEYWORD("to"); - CHARS(last); - TEST_FOR_KEYWORD("as"); - CHARS(variable); - END; - BRANCH("for"); - - return 0; - fail: - return -1; + NEW_NODE(for, FOR); + CHARS(first); + TEST_FOR_KEYWORD("to"); + CHARS(last); + TEST_FOR_KEYWORD("as"); + CHARS(variable); + END; + BRANCH("for"); + + return 0; +fail: + return -1; } @@ -1088,52 +1060,48 @@ static int parse_for(void) * * @return Zero on success, -1 on error, 1 if the caller should go to `redo` */ -static int parse_let(void) +static int +parse_let(void) { - NEW_NODE(let, LET); - CHARS(variable); - TEST_FOR_KEYWORD(":"); - *end = prev_end_char; - SKIP_SPACES(line); - if (*line == '{') + NEW_NODE(let, LET); + CHARS(variable); + TEST_FOR_KEYWORD(":"); + *end = prev_end_char; + SKIP_SPACES(line); + if (*line == '{') #define inner value - BRANCH(NULL); + BRANCH(NULL); #undef inner - else - LEAF; - if (*line == '\0') - { - line = original, end = STREND(line), prev_end_char = '\0'; - NEW_ERROR(1, ERROR, "too few parameters"); - } - else if (*line != '{') - { + else + LEAF; + if (!*line) { + line = original, end = STREND(line), prev_end_char = '\0'; + NEW_ERROR(1, ERROR, "too few parameters"); + } else if (*line != '{') { #define node subnode - NEW_NODE(string, STRING); - NO_JUMP; - CHARS(string); - node->loc_end = (size_t)(end - LINE); + NEW_NODE(string, STRING); + NO_JUMP; + CHARS(string); + node->loc_end = (size_t)(end - LINE); #undef node - node->value = (mds_kbdc_tree_t*)subnode; - END; - } - else - { + node->value = (mds_kbdc_tree_t*)subnode; + END; + } else { #define node subnode #define inner elements - NEW_NODE(array, ARRAY); - BRANCH("}"); - node->loc_end = node->loc_start + 1; + NEW_NODE(array, ARRAY); + BRANCH("}"); + node->loc_end = node->loc_start + 1; #undef inner #undef node - in_array = 1; - line++; - return 1; - } - - return 0; - fail: - return -1; + in_array = 1; + line++; + return 1; + } + + return 0; +fail: + return -1; } @@ -1142,29 +1110,28 @@ static int parse_let(void) * * @return Zero on success, -1 on error, 1 if the caller should go to `redo` */ -static int parse_end(void) +static int +parse_end(void) { - if (stack_ptr == 0) - { - NEW_ERROR(1, ERROR, "runaway ‘end’ statement"); - return 0; - } - line = STREND(line); - *end = prev_end_char, prev_end_char = '\0'; - SKIP_SPACES(line); - while (keyword_stack[--stack_ptr] == NULL); - if (*line == '\0') - { - line = original, end = STREND(line); - NEW_ERROR(1, ERROR, "expecting a keyword after ‘end’"); - } - else if (strcmp(line, keyword_stack[stack_ptr])) - NEW_ERROR(1, ERROR, "expected ‘%s’ but got ‘%s’", keyword_stack[stack_ptr], line); - NEXT; - - return 0; - fail: - return -1; + if (!stack_ptr) { + NEW_ERROR(1, ERROR, "runaway ‘end’ statement"); + return 0; + } + line = STREND(line); + *end = prev_end_char, prev_end_char = '\0'; + SKIP_SPACES(line); + while (!keyword_stack[--stack_ptr]); + if (!*line) { + line = original, end = STREND(line); + NEW_ERROR(1, ERROR, "expecting a keyword after ‘end’"); + } else if (strcmp(line, keyword_stack[stack_ptr])) { + NEW_ERROR(1, ERROR, "expected ‘%s’ but got ‘%s’", keyword_stack[stack_ptr], line); + } + NEXT; + + return 0; +fail: + return -1; } @@ -1173,57 +1140,56 @@ static int parse_end(void) * * @return Zero on success, -1 on error, 1 if the caller should go to `redo` */ -static int parse_map(void) +static int +parse_map(void) { - size_t stack_orig = stack_ptr + 1; - char* colon; + size_t stack_orig = stack_ptr + 1; + char *colon; #define node supernode #define inner sequence - NEW_NODE(map, MAP); - node->loc_end = node->loc_start; - BRANCH(":"); + NEW_NODE(map, MAP); + node->loc_end = node->loc_start; + BRANCH(":"); #undef inner #undef node - SEQUENCE(1); - SEQUENCE_FULLY_POPPED; + SEQUENCE(1); + SEQUENCE_FULLY_POPPED; #define node supernode #define inner result - stack_ptr--; - *end = prev_end_char; - supernode->loc_end = (size_t)(end - LINE); - SKIP_SPACES(line); - if (colon = line, *line++ != ':') - { - LEAF; - prev_end_char = *end; - return 0; /* Not an error in functions, or if \set is access, even indirectly. */ - } - BRANCH(":"); + stack_ptr--; + *end = prev_end_char; + supernode->loc_end = (size_t)(end - LINE); + SKIP_SPACES(line); + if (colon = line, *line++ != ':') { + LEAF; + prev_end_char = *end; + return 0; /* Not an error in functions, or if \set is access, even indirectly. */ + } + BRANCH(":"); #undef inner #undef node - SEQUENCE(1); - SEQUENCE_FULLY_POPPED; - stack_ptr--; - *end = prev_end_char; - supernode->loc_end = (size_t)(end - LINE); - SKIP_SPACES(line); + SEQUENCE(1); + SEQUENCE_FULLY_POPPED; + stack_ptr--; + *end = prev_end_char; + supernode->loc_end = (size_t)(end - LINE); + SKIP_SPACES(line); #define node supernode - LEAF; + LEAF; #undef node - if (supernode->result == NULL) - { - NEW_ERROR(1, ERROR, "output missing"); - error->start = (size_t)(colon - LINE); - error->end = error->start + 1; - } - if (*line == '\0') - return prev_end_char = *end, 0; - end = STREND(line), prev_end_char = *end; - NEW_ERROR(1, ERROR, "too many parameters"); - - return 0; - fail: - return -1; + if (!supernode->result) { + NEW_ERROR(1, ERROR, "output missing"); + error->start = (size_t)(colon - LINE); + error->end = error->start + 1; + } + if (!*line) + return prev_end_char = *end, 0; + end = STREND(line), prev_end_char = *end; + NEW_ERROR(1, ERROR, "too many parameters"); + + return 0; +fail: + return -1; } @@ -1232,63 +1198,59 @@ static int parse_map(void) * * @return Zero on success, -1 on error, 1 if the caller should go to `redo` */ -static int parse_macro_call(void) +static int +parse_macro_call(void) { - char* old_end = end; - char old_prev_end_char = prev_end_char; - size_t stack_orig = stack_ptr + 1; - *end = prev_end_char; - end = strchrnul(line, '('); - prev_end_char = *end, *end = '\0'; - if (prev_end_char) - { + char *old_end = end; + char old_prev_end_char = prev_end_char; + size_t stack_orig = stack_ptr + 1; + *end = prev_end_char; + end = strchrnul(line, '('); + prev_end_char = *end, *end = '\0'; + if (prev_end_char) { #define node supernode #define inner arguments - NEW_NODE(macro_call, MACRO_CALL); - old_end = end, old_prev_end_char = prev_end_char; - NO_JUMP; - *old_end = '\0'; - CHARS(name); - BRANCH(NULL); - end = old_end, prev_end_char = old_prev_end_char; - line++; + NEW_NODE(macro_call, MACRO_CALL); + old_end = end, old_prev_end_char = prev_end_char; + NO_JUMP; + *old_end = '\0'; + CHARS(name); + BRANCH(NULL); + end = old_end, prev_end_char = old_prev_end_char; + line++; #undef inner #undef node - SEQUENCE(0); - SEQUENCE_FULLY_POPPED; + SEQUENCE(0); + SEQUENCE_FULLY_POPPED; #define node supernode - if (*line == ')') - { - line++; - SKIP_SPACES(line); - if (*line) - { - NEW_ERROR(1, ERROR, "extra token after macro call"); - error->end = strlen(LINE); - } - } - else - { - NEW_ERROR(1, ERROR, "missing ‘)’"); - error->start = (size_t)(strchr(LINE, '(') - LINE); - error->end = error->start + 1; - } - stack_ptr--; - NEXT; - return 0; + if (*line == ')') { + line++; + SKIP_SPACES(line); + if (*line) { + NEW_ERROR(1, ERROR, "extra token after macro call"); + error->end = strlen(LINE); + } + } else { + NEW_ERROR(1, ERROR, "missing ‘)’"); + error->start = (size_t)(strchr(LINE, '(') - LINE); + error->end = error->start + 1; + } + stack_ptr--; + NEXT; + return 0; #undef node - } - *old_end = '\0'; - end = old_end; - prev_end_char = old_prev_end_char; - if (strchr("}", *line)) - NEW_ERROR(1, ERROR, "runaway ‘%c’", *line); - else - NEW_ERROR(1, ERROR, "invalid syntax ‘%s’", line); - - return 0; - fail: - return -1; + } + *old_end = '\0'; + end = old_end; + prev_end_char = old_prev_end_char; + if (strchr("}", *line)) + NEW_ERROR(1, ERROR, "runaway ‘%c’", *line); + else + NEW_ERROR(1, ERROR, "invalid syntax ‘%s’", line); + + return 0; +fail: + return -1; } @@ -1297,48 +1259,44 @@ static int parse_macro_call(void) * * @return Zero on success, -1 on error, 1 if the caller should go to `redo` */ -static int parse_array_elements(void) +static int +parse_array_elements(void) { - for (;;) - { - SKIP_SPACES(line); - if (*line == '\0') - return 0; - else if (*line == '}') - { - line++; - end = STREND(line); - END; - line = end, prev_end_char = '\0'; - goto done; + for (;;) { + SKIP_SPACES(line); + if (!*line) { + return 0; + } else if (*line == '}') { + line++; + end = STREND(line); + END; + line = end, prev_end_char = '\0'; + goto done; + } else { + NEW_NODE(string, STRING); + if (strchr("[]()<>{}", *line)) { + mds_kbdc_tree_free((mds_kbdc_tree_t*)node); + NEW_ERROR(1, ERROR, "x-stray ‘%c’", *line); + error->end = error->start + 1; + goto done; + } + NO_JUMP; + CHARS(string); + LEAF; + node->loc_end = (size_t)(end - LINE); + *end = prev_end_char; + line = end; + } } - else - { - NEW_NODE(string, STRING); - if (strchr("[]()<>{}", *line)) - { - mds_kbdc_tree_free((mds_kbdc_tree_t*)node); - NEW_ERROR(1, ERROR, "x-stray ‘%c’", *line); - error->end = error->start + 1; - goto done; - } - NO_JUMP; - CHARS(string); - LEAF; - node->loc_end = (size_t)(end - LINE); - *end = prev_end_char; - line = end; - } - } - - fail: - return -1; - - done: - in_array = 0; - stack_ptr -= 2; - NEXT; - return 0; + +fail: + return -1; + +done: + in_array = 0; + stack_ptr -= 2; + NEXT; + return 0; } @@ -1347,50 +1305,47 @@ static int parse_array_elements(void) * * @return Zero on success, -1 on error */ -static int parse_line(void) +static int +parse_line(void) { -#define p(function) \ - do \ - { \ - fail_if (r = function(), r < 0); \ - if (r > 0) \ - goto redo; \ - } \ - while (0) - - int r; - - redo: - if (in_array) p (parse_array_elements); - else if (!strcmp(line, "have_chars")) - MAKE_LEAF(assumption_have_chars, ASSUMPTION_HAVE_CHARS, QUOTES_1(chars)); - else if (!strcmp(line, "have_range")) - MAKE_LEAF(assumption_have_range, ASSUMPTION_HAVE_RANGE, CHARS(first); CHARS(last); END); - else if (!strcmp(line, "have")) MAKE_LEAF(assumption_have, ASSUMPTION_HAVE, KEYS(data); END); - else if (!strcmp(line, "information")) MAKE_BRANCH(information, INFORMATION, NO_PARAMETERS("information")); - else if (!strcmp(line, "assumption")) MAKE_BRANCH(assumption, ASSUMPTION, NO_PARAMETERS("assumption")); - else if (!strcmp(line, "return")) MAKE_LEAF(return, RETURN, NO_PARAMETERS("return")); - else if (!strcmp(line, "continue")) MAKE_LEAF(continue, CONTINUE, NO_PARAMETERS("continue")); - else if (!strcmp(line, "break")) MAKE_LEAF(break, BREAK, NO_PARAMETERS("break")); - else if (!strcmp(line, "language")) MAKE_LEAF(information_language, INFORMATION_LANGUAGE, QUOTES_1(data)); - else if (!strcmp(line, "country")) MAKE_LEAF(information_country, INFORMATION_COUNTRY, QUOTES_1(data)); - else if (!strcmp(line, "variant")) MAKE_LEAF(information_variant, INFORMATION_VARIANT, QUOTES_1(data)); - else if (!strcmp(line, "include")) MAKE_LEAF(include, INCLUDE, QUOTES_1(filename)); - else if (!strcmp(line, "function")) MAKE_BRANCH(function, FUNCTION, NAMES_1(name)); - else if (!strcmp(line, "macro")) MAKE_BRANCH(macro, MACRO, NAMES_1(name)); - else if (!strcmp(line, "if")) MAKE_BRANCH(if, IF, CHARS(condition); END); - else if (!strcmp(line, "else")) p (parse_else); - else if (!strcmp(line, "for")) p (parse_for); - else if (!strcmp(line, "let")) p (parse_let); - else if (!strcmp(line, "end")) p (parse_end); - else if (strchr("\\\"<([0123456789", *line)) p (parse_map); - else p (parse_macro_call); - - *end = prev_end_char; - - return 0; - fail: - return -1; +#define p(function)\ + do {\ + fail_if ((r = function()) < 0);\ + if (r > 0)\ + goto redo;\ + } while (0) + + int r; + +redo: + if (in_array) p (parse_array_elements); + else if (!strcmp(line, "have_chars")) MAKE_LEAF(assumption_have_chars, ASSUMPTION_HAVE_CHARS, QUOTES_1(chars)); + else if (!strcmp(line, "have_range")) MAKE_LEAF(assumption_have_range, ASSUMPTION_HAVE_RANGE, CHARS(first); CHARS(last); END); + else if (!strcmp(line, "have")) MAKE_LEAF(assumption_have, ASSUMPTION_HAVE, KEYS(data); END); + else if (!strcmp(line, "information")) MAKE_BRANCH(information, INFORMATION, NO_PARAMETERS("information")); + else if (!strcmp(line, "assumption")) MAKE_BRANCH(assumption, ASSUMPTION, NO_PARAMETERS("assumption")); + else if (!strcmp(line, "return")) MAKE_LEAF(return, RETURN, NO_PARAMETERS("return")); + else if (!strcmp(line, "continue")) MAKE_LEAF(continue, CONTINUE, NO_PARAMETERS("continue")); + else if (!strcmp(line, "break")) MAKE_LEAF(break, BREAK, NO_PARAMETERS("break")); + else if (!strcmp(line, "language")) MAKE_LEAF(information_language, INFORMATION_LANGUAGE, QUOTES_1(data)); + else if (!strcmp(line, "country")) MAKE_LEAF(information_country, INFORMATION_COUNTRY, QUOTES_1(data)); + else if (!strcmp(line, "variant")) MAKE_LEAF(information_variant, INFORMATION_VARIANT, QUOTES_1(data)); + else if (!strcmp(line, "include")) MAKE_LEAF(include, INCLUDE, QUOTES_1(filename)); + else if (!strcmp(line, "function")) MAKE_BRANCH(function, FUNCTION, NAMES_1(name)); + else if (!strcmp(line, "macro")) MAKE_BRANCH(macro, MACRO, NAMES_1(name)); + else if (!strcmp(line, "if")) MAKE_BRANCH(if, IF, CHARS(condition); END); + else if (!strcmp(line, "else")) p (parse_else); + else if (!strcmp(line, "for")) p (parse_for); + else if (!strcmp(line, "let")) p (parse_let); + else if (!strcmp(line, "end")) p (parse_end); + else if (strchr("\\\"<([0123456789", *line)) p (parse_map); + else p (parse_macro_call); + + *end = prev_end_char; + + return 0; +fail: + return -1; #undef p } @@ -1406,63 +1361,62 @@ static int parse_line(void) * @param result_ Output parameter for the parsing result * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int parse_to_tree(const char* restrict filename, mds_kbdc_parsed_t* restrict result_) +int +parse_to_tree(const char *restrict filename, mds_kbdc_parsed_t *restrict result_) { - size_t line_n; - int r, saved_errno; - - - /* Prepare parsing. */ - result = result_; - stack_ptr = 0; - keyword_stack = NULL; - tree_stack = NULL; - in_array = 0; - - fail_if (xmalloc(result->source_code, 1, mds_kbdc_source_code_t)); - mds_kbdc_source_code_initialise(result->source_code); - - r = get_pathname(filename); - fail_if (r < 0); - if (r == 0) - return 0; - - fail_if (read_source_code()); - fail_if (allocate_stacks()); - - - /* Create a node-slot for the tree root. */ - *tree_stack = &(result->tree); - - /* Parse the file. */ - for (line_i = 0, line_n = result->source_code->line_count; line_i < line_n; line_i++) - { - line = LINE; - SKIP_SPACES(line); - if (end = strchrnul(line, ' '), end == line) - continue; - prev_end_char = *end, *end = '\0'; - original = line; - too_few = 0; - - parse_line(); - } - - - /* Check parsing state. */ - fail_if (check_for_premature_end_of_file()); - fail_if (check_whether_file_is_empty()); - - /* Clean up. */ - free(keyword_stack); - free(tree_stack); - return 0; - - fail: - saved_errno = errno; - free(keyword_stack); - free(tree_stack); - return errno = saved_errno, -1; + size_t line_n; + int r, saved_errno; + + + /* Prepare parsing. */ + result = result_; + stack_ptr = 0; + keyword_stack = NULL; + tree_stack = NULL; + in_array = 0; + + fail_if (xmalloc(result->source_code, 1, mds_kbdc_source_code_t)); + mds_kbdc_source_code_initialise(result->source_code); + + fail_if ((r = get_pathname(filename)) < 0); + if (!r) + return 0; + + fail_if (read_source_code()); + fail_if (allocate_stacks()); + + + /* Create a node-slot for the tree root. */ + *tree_stack = &(result->tree); + + /* Parse the file. */ + for (line_i = 0, line_n = result->source_code->line_count; line_i < line_n; line_i++) { + line = LINE; + SKIP_SPACES(line); + if ((end = strchrnul(line, ' ')) == line) + continue; + prev_end_char = *end, *end = '\0'; + original = line; + too_few = 0; + + parse_line(); + } + + + /* Check parsing state. */ + fail_if (check_for_premature_end_of_file()); + fail_if (check_whether_file_is_empty()); + + /* Clean up. */ + free(keyword_stack); + free(tree_stack); + return 0; + +fail: + saved_errno = errno; + free(keyword_stack); + free(tree_stack); + return errno = saved_errno, -1; } @@ -1493,4 +1447,3 @@ int parse_to_tree(const char* restrict filename, mds_kbdc_parsed_t* restrict res #undef in_range #undef PRINT_STACK #undef DEBUG_PROC - diff --git a/src/mds-kbdc/make-tree.h b/src/mds-kbdc/make-tree.h index c645d94..0878414 100644 --- a/src/mds-kbdc/make-tree.h +++ b/src/mds-kbdc/make-tree.h @@ -29,8 +29,7 @@ * @param result Output parameter for the parsing result * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int parse_to_tree(const char* restrict filename, mds_kbdc_parsed_t* restrict result); +int parse_to_tree(const char *restrict filename, mds_kbdc_parsed_t *restrict result); #endif - diff --git a/src/mds-kbdc/mds-kbdc.c b/src/mds-kbdc/mds-kbdc.c index 1c5a6e8..0f668e4 100644 --- a/src/mds-kbdc/mds-kbdc.c +++ b/src/mds-kbdc/mds-kbdc.c @@ -37,15 +37,13 @@ /** * Parse command line arguments */ -static void parse_cmdline(void) +static void +parse_cmdline(void) { - int i; - for (i = 0; i < argc; i++) - { - char* arg = argv[i]; - if (strequals(arg, "--force")) - argv_force = 1; - } + int i; + for (i = 0; i < argc; i++) + if (strequals(argv[i], "--force")) + argv_force = 1; } @@ -56,39 +54,39 @@ static void parse_cmdline(void) * @param argv_ The command line arguments * @return Zero on and only one success */ -int main(int argc_, char** argv_) +int +main(int argc_, char **argv_) { -#define process(expr) \ - fail_if ((expr) < 0); \ - if (fatal = mds_kbdc_parsed_is_fatal(&result), fatal) \ - goto stop; - - mds_kbdc_parsed_t result; - int fatal; - - argc = argc_; - argv = argv_; - - parse_cmdline(); - - mds_kbdc_parsed_initialise(&result); - process (parse_to_tree(argv[1], &result)); - process (simplify_tree(&result)); - process (process_includes(&result)); - process (validate_tree(&result)); - process (eliminate_dead_code(&result)); - process (compile_layout(&result)); - /* TODO process (assemble_layout(&result)); */ - stop: - /* mds_kbdc_tree_print(result.tree, stderr); // for testing passes parse_to_tree–eliminate_dead_code */ - mds_kbdc_parsed_print_errors(&result, stderr); - mds_kbdc_parsed_destroy(&result); - return fatal; - - fail: - xperror(*argv); - mds_kbdc_parsed_destroy(&result); - return 1; +#define process(expr)\ + fail_if ((expr) < 0);\ + if ((fatal = mds_kbdc_parsed_is_fatal(&result)))\ + goto stop; + + mds_kbdc_parsed_t result; + int fatal; + + argc = argc_; + argv = argv_; + + parse_cmdline(); + + mds_kbdc_parsed_initialise(&result); + process (parse_to_tree(argv[1], &result)); + process (simplify_tree(&result)); + process (process_includes(&result)); + process (validate_tree(&result)); + process (eliminate_dead_code(&result)); + process (compile_layout(&result)); + /* TODO process (assemble_layout(&result)); */ +stop: + /* mds_kbdc_tree_print(result.tree, stderr); // for testing passes parse_to_tree–eliminate_dead_code */ + mds_kbdc_parsed_print_errors(&result, stderr); + mds_kbdc_parsed_destroy(&result); + return fatal; + +fail: + xperror(*argv); + mds_kbdc_parsed_destroy(&result); + return 1; #undef process } - diff --git a/src/mds-kbdc/mds-kbdc.h b/src/mds-kbdc/mds-kbdc.h index a0f0d0f..8cf6204 100644 --- a/src/mds-kbdc/mds-kbdc.h +++ b/src/mds-kbdc/mds-kbdc.h @@ -23,4 +23,3 @@ #endif - diff --git a/src/mds-kbdc/parse-error.c b/src/mds-kbdc/parse-error.c index 242b730..6a31424 100644 --- a/src/mds-kbdc/parse-error.c +++ b/src/mds-kbdc/parse-error.c @@ -32,46 +32,45 @@ * @param output The output file * @param desc The description of the error */ -static void print(const mds_kbdc_parse_error_t* restrict this, FILE* restrict output, const char* restrict desc) +static void +print(const mds_kbdc_parse_error_t *restrict this, FILE *restrict output, const char *restrict desc) { - size_t i, n, start = 0, end = 0; - const char* restrict code = this->code; - char* restrict path = relpath(this->pathname, NULL); - - /* Convert bytes count to character count for the code position. */ - for (i = 0, n = this->start; i < n; i++) - if ((code[i] & 0xC0) != 0x80) - start++; - for (n = this->end; i < n; i++) - if ((code[i] & 0xC0) != 0x80) - end++; - end += start; - - /* Print error information. */ - fprintf(output, "\033[01m%s\033[21m:", path ? path : this->pathname); - free(path); - if (this->error_is_in_file) - fprintf(output, "%zu:%zu–%zu:", this->line + 1, start, end); - switch (this->severity) - { - case MDS_KBDC_PARSE_ERROR_NOTE: fprintf(output, " \033[01;36mnote:\033[00m "); break; - case MDS_KBDC_PARSE_ERROR_WARNING: fprintf(output, " \033[01;35mwarning:\033[00m "); break; - case MDS_KBDC_PARSE_ERROR_ERROR: fprintf(output, " \033[01;31merror:\033[00m "); break; - case MDS_KBDC_PARSE_ERROR_INTERNAL_ERROR: fprintf(output, " \033[01;31minternal error:\033[00m "); break; - default: - abort(); - break; - } - if (this->error_is_in_file) - { - fprintf(output, "%s\n %s\n \033[01;32m", desc, code); - i = 0; - for (n = start; i < n; i++) fputc(' ', output); - for (n = end; i < n; i++) fputc('^', output); - } - else - fprintf(output, "%s\n", desc); - fprintf(output, "\033[00m\n"); + size_t i, n, start = 0, end = 0; + const char *restrict code = this->code; + char *restrict path = relpath(this->pathname, NULL); + + /* Convert bytes count to character count for the code position. */ + for (i = 0, n = this->start; i < n; i++) + if ((code[i] & 0xC0) != 0x80) + start++; + for (n = this->end; i < n; i++) + if ((code[i] & 0xC0) != 0x80) + end++; + end += start; + + /* Print error information. */ + fprintf(output, "\033[01m%s\033[21m:", path ? path : this->pathname); + free(path); + if (this->error_is_in_file) + fprintf(output, "%zu:%zu–%zu:", this->line + 1, start, end); + switch (this->severity) { + case MDS_KBDC_PARSE_ERROR_NOTE: fprintf(output, " \033[01;36mnote:\033[00m "); break; + case MDS_KBDC_PARSE_ERROR_WARNING: fprintf(output, " \033[01;35mwarning:\033[00m "); break; + case MDS_KBDC_PARSE_ERROR_ERROR: fprintf(output, " \033[01;31merror:\033[00m "); break; + case MDS_KBDC_PARSE_ERROR_INTERNAL_ERROR: fprintf(output, " \033[01;31minternal error:\033[00m "); break; + default: + abort(); + break; + } + if (this->error_is_in_file) { + fprintf(output, "%s\n %s\n \033[01;32m", desc, code); + i = 0; + for (n = start; i < n; i++) fputc(' ', output); + for (n = end; i < n; i++) fputc('^', output); + } else { + fprintf(output, "%s\n", desc); + } + fprintf(output, "\033[00m\n"); } @@ -81,49 +80,57 @@ static void print(const mds_kbdc_parse_error_t* restrict this, FILE* restrict ou * @param this The error structure * @param output The output file */ -void mds_kbdc_parse_error_print(const mds_kbdc_parse_error_t* restrict this, FILE* restrict output) +void +mds_kbdc_parse_error_print(const mds_kbdc_parse_error_t *restrict this, FILE *restrict output) { - ssize_t m; - size_t n; - char* desc; - char* dend = this->description + strlen(this->description); - char* dstart; - char* dptr; - char* p; - char* q; - - /* Count the number points in the description we should modify to format it. */ - for (p = this->description, n = 0;;) - { - if (q = strstr(p, "‘"), q == NULL) q = dend; - if (p = strstr(p, "’"), p == NULL) p = dend; - if (q < p) p = q; - if (*p++) n++; - else break; - } - - /* Allocate string for the formatted description. */ - n = 1 + strlen(this->description) + strlen("\033[xxm’") * n; - dptr = desc = alloca(n * sizeof(char)); - - /* Format description. */ - for (p = this->description;;) - { - dstart = p; - if (q = strstr(p, "‘"), q == NULL) q = dend; - if (p = strstr(p, "’"), p == NULL) p = dend; - if (q < p) p = q; - if ((n = (size_t)(p - dstart))) - memcpy(dptr, dstart, n), dptr += n; - if (p == dend) - break; - if (strstr(p, "‘") == p) sprintf(dptr, "\033[01m‘%zn", &m), dptr += (size_t)m, p += strlen("‘"); - else sprintf(dptr, "’\033[21m%zn", &m), dptr += (size_t)m, p += strlen("’"); - } - *dptr = '\0'; - - /* Print the error. */ - print(this, output, desc); + size_t n; + char *desc; + char *dend = this->description + strlen(this->description); + char *dstart; + char *dptr; + char *p; + char *q; + + /* Count the number points in the description we should modify to format it. */ + for (p = this->description, n = 0;;) { + if (!(q = strstr(p, "‘"))) + q = dend; + if (!(p = strstr(p, "’"))) + p = dend; + if (q < p) + p = q; + if (*p++) + n++; + else + break; + } + + /* Allocate string for the formatted description. */ + n = 1 + strlen(this->description) + strlen("\033[xxm’") * n; + dptr = desc = alloca(n * sizeof(char)); + + /* Format description. */ + for (p = this->description;;) { + dstart = p; + if (!(q = strstr(p, "‘"))) + q = dend; + if (!(p = strstr(p, "’"))) + p = dend; + if (q < p) + p = q; + if ((n = (size_t)(p - dstart))) + memcpy(dptr, dstart, n), dptr += n; + if (p == dend) + break; + if (strstr(p, "‘") == p) + dptr += sprintf(dptr, "\033[01m‘"), p += strlen("‘"); + else + dptr += sprintf(dptr, "’\033[21m"), p += strlen("’"); + } + *dptr = '\0'; + + /* Print the error. */ + print(this, output, desc); } @@ -133,13 +140,14 @@ void mds_kbdc_parse_error_print(const mds_kbdc_parse_error_t* restrict this, FIL * * @param this The error structure */ -void mds_kbdc_parse_error_destroy(mds_kbdc_parse_error_t* restrict this) +void +mds_kbdc_parse_error_destroy(mds_kbdc_parse_error_t *restrict this) { - if (this == NULL) - return; - free(this->pathname), this->pathname = NULL; - free(this->code), this->code = NULL; - free(this->description), this->description = NULL; + if (!this) + return; + free(this->pathname), this->pathname = NULL; + free(this->code), this->code = NULL; + free(this->description), this->description = NULL; } @@ -149,10 +157,11 @@ void mds_kbdc_parse_error_destroy(mds_kbdc_parse_error_t* restrict this) * * @param this The error structure */ -void mds_kbdc_parse_error_free(mds_kbdc_parse_error_t* restrict this) +void +mds_kbdc_parse_error_free(mds_kbdc_parse_error_t *restrict this) { - mds_kbdc_parse_error_destroy(this); - free(this); + mds_kbdc_parse_error_destroy(this); + free(this); } @@ -162,13 +171,14 @@ void mds_kbdc_parse_error_free(mds_kbdc_parse_error_t* restrict this) * * @param this The group of error structures */ -void mds_kbdc_parse_error_destroy_all(mds_kbdc_parse_error_t** restrict these) +void +mds_kbdc_parse_error_destroy_all(mds_kbdc_parse_error_t **restrict these) { - mds_kbdc_parse_error_t* restrict that; - if (these == NULL) - return; - while (that = *these, that != NULL) - mds_kbdc_parse_error_free(that), *these++ = NULL; + mds_kbdc_parse_error_t *restrict that; + if (!these) + return; + while ((that = *these)) + mds_kbdc_parse_error_free(that), *these++ = NULL; } @@ -178,9 +188,9 @@ void mds_kbdc_parse_error_destroy_all(mds_kbdc_parse_error_t** restrict these) * * @param this The group of error structures */ -void mds_kbdc_parse_error_free_all(mds_kbdc_parse_error_t** restrict these) +void +mds_kbdc_parse_error_free_all(mds_kbdc_parse_error_t**restrict these) { - mds_kbdc_parse_error_destroy_all(these); - free(these); + mds_kbdc_parse_error_destroy_all(these); + free(these); } - diff --git a/src/mds-kbdc/parse-error.h b/src/mds-kbdc/parse-error.h index b7e879c..9668f8f 100644 --- a/src/mds-kbdc/parse-error.h +++ b/src/mds-kbdc/parse-error.h @@ -27,74 +27,72 @@ /** * Not an error, simply a note about the previous error or warning */ -#define MDS_KBDC_PARSE_ERROR_NOTE 1 +#define MDS_KBDC_PARSE_ERROR_NOTE 1 /** * A warning, must likely an error that is not fatal to the compilation */ -#define MDS_KBDC_PARSE_ERROR_WARNING 2 +#define MDS_KBDC_PARSE_ERROR_WARNING 2 /** * An error, the compilation will halt */ -#define MDS_KBDC_PARSE_ERROR_ERROR 3 +#define MDS_KBDC_PARSE_ERROR_ERROR 3 /** * Internal compiler error or system error, compilation halts */ -#define MDS_KBDC_PARSE_ERROR_INTERNAL_ERROR 4 +#define MDS_KBDC_PARSE_ERROR_INTERNAL_ERROR 4 /** * Description of an parsing error */ -typedef struct mds_kbdc_parse_error -{ - /** - * Either of: - * - `MDS_KBDC_PARSE_ERROR_NOTE` - * - `MDS_KBDC_PARSE_ERROR_WARNING` - * - `MDS_KBDC_PARSE_ERROR_ERROR` - * - `MDS_KBDC_PARSE_ERROR_INTERNAL_ERROR` - */ - int severity; - - /** - * If zero, disregard `.line`, `.start`, `.end` and `.code` - */ - int error_is_in_file; - - /** - * The pathname of the file with the error - */ - char* pathname; - - /** - * The line where the error occurred, zero-based - */ - size_t line; - - /** - * The byte where the error started, inclusive, zero-based - */ - size_t start; - - /** - * The byte where the error ended, exclusive, zero-based - */ - size_t end; - - /** - * The code on the line where the error occurred - */ - char* code; - - /** - * Description of the error - */ - char* description; - +typedef struct mds_kbdc_parse_error { + /** + * Either of: + * - `MDS_KBDC_PARSE_ERROR_NOTE` + * - `MDS_KBDC_PARSE_ERROR_WARNING` + * - `MDS_KBDC_PARSE_ERROR_ERROR` + * - `MDS_KBDC_PARSE_ERROR_INTERNAL_ERROR` + */ + int severity; + + /** + * If zero, disregard `.line`, `.start`, `.end` and `.code` + */ + int error_is_in_file; + + /** + * The pathname of the file with the error + */ + char *pathname; + + /** + * The line where the error occurred, zero-based + */ + size_t line; + + /** + * The byte where the error started, inclusive, zero-based + */ + size_t start; + + /** + * The byte where the error ended, exclusive, zero-based + */ + size_t end; + + /** + * The code on the line where the error occurred + */ + char *code; + + /** + * Description of the error + */ + char *description; } mds_kbdc_parse_error_t; @@ -105,7 +103,7 @@ typedef struct mds_kbdc_parse_error * @param this The error structure * @param output The output file */ -void mds_kbdc_parse_error_print(const mds_kbdc_parse_error_t* restrict this, FILE* restrict output); +void mds_kbdc_parse_error_print(const mds_kbdc_parse_error_t *restrict this, FILE *restrict output); /** @@ -113,7 +111,7 @@ void mds_kbdc_parse_error_print(const mds_kbdc_parse_error_t* restrict this, FIL * * @param this The error structure */ -void mds_kbdc_parse_error_destroy(mds_kbdc_parse_error_t* restrict this); +void mds_kbdc_parse_error_destroy(mds_kbdc_parse_error_t *restrict this); /** * Release all resources allocated in a `mds_kbdc_parse_error_t*` @@ -121,7 +119,7 @@ void mds_kbdc_parse_error_destroy(mds_kbdc_parse_error_t* restrict this); * * @param this The error structure */ -void mds_kbdc_parse_error_free(mds_kbdc_parse_error_t* restrict this); +void mds_kbdc_parse_error_free(mds_kbdc_parse_error_t *restrict this); /** * Release all resources allocated in a `NULL`-terminated group @@ -129,7 +127,7 @@ void mds_kbdc_parse_error_free(mds_kbdc_parse_error_t* restrict this); * * @param this The group of error structures */ -void mds_kbdc_parse_error_destroy_all(mds_kbdc_parse_error_t** restrict these); +void mds_kbdc_parse_error_destroy_all(mds_kbdc_parse_error_t **restrict these); /** * Release all resources allocated in a `NULL`-terminated group of @@ -137,9 +135,8 @@ void mds_kbdc_parse_error_destroy_all(mds_kbdc_parse_error_t** restrict these); * * @param this The group of error structures */ -void mds_kbdc_parse_error_free_all(mds_kbdc_parse_error_t** restrict these); +void mds_kbdc_parse_error_free_all(mds_kbdc_parse_error_t **restrict these); #endif - diff --git a/src/mds-kbdc/parsed.c b/src/mds-kbdc/parsed.c index d9c8f23..e4c23dc 100644 --- a/src/mds-kbdc/parsed.c +++ b/src/mds-kbdc/parsed.c @@ -28,9 +28,10 @@ * * @param this The `mds_kbdc_parsed_t*` */ -void mds_kbdc_parsed_initialise(mds_kbdc_parsed_t* restrict this) +void +mds_kbdc_parsed_initialise(mds_kbdc_parsed_t *restrict this) { - memset(this, 0, sizeof(mds_kbdc_parsed_t)); + memset(this, 0, sizeof(mds_kbdc_parsed_t)); } @@ -39,27 +40,28 @@ void mds_kbdc_parsed_initialise(mds_kbdc_parsed_t* restrict this) * * @param this The `mds_kbdc_parsed_t*` */ -void mds_kbdc_parsed_destroy(mds_kbdc_parsed_t* restrict this) +void +mds_kbdc_parsed_destroy(mds_kbdc_parsed_t *restrict this) { - mds_kbdc_tree_free(this->tree); - mds_kbdc_source_code_destroy(this->source_code); - free(this->source_code); - free(this->pathname); - mds_kbdc_parse_error_free_all(this->errors); - while (this->languages_ptr--) - free(this->languages[this->languages_ptr]); - free(this->languages); - while (this->countries_ptr--) - free(this->countries[this->countries_ptr]); - free(this->countries); - free(this->variant); - while (this->assumed_strings_ptr--) - free(this->assumed_strings[this->assumed_strings_ptr]); - free(this->assumed_strings); - while (this->assumed_keys_ptr--) - free(this->assumed_keys[this->assumed_keys_ptr]); - free(this->assumed_keys); - memset(this, 0, sizeof(mds_kbdc_parsed_t)); + mds_kbdc_tree_free(this->tree); + mds_kbdc_source_code_destroy(this->source_code); + free(this->source_code); + free(this->pathname); + mds_kbdc_parse_error_free_all(this->errors); + while (this->languages_ptr--) + free(this->languages[this->languages_ptr]); + free(this->languages); + while (this->countries_ptr--) + free(this->countries[this->countries_ptr]); + free(this->countries); + free(this->variant); + while (this->assumed_strings_ptr--) + free(this->assumed_strings[this->assumed_strings_ptr]); + free(this->assumed_strings); + while (this->assumed_keys_ptr--) + free(this->assumed_keys[this->assumed_keys_ptr]); + free(this->assumed_keys); + memset(this, 0, sizeof(mds_kbdc_parsed_t)); } @@ -69,9 +71,10 @@ void mds_kbdc_parsed_destroy(mds_kbdc_parsed_t* restrict this) * @param this The parsing result * @return Whether a fatal errors has occurred */ -int mds_kbdc_parsed_is_fatal(mds_kbdc_parsed_t* restrict this) +int +mds_kbdc_parsed_is_fatal(mds_kbdc_parsed_t *restrict this) { - return this->severest_error_level >= MDS_KBDC_PARSE_ERROR_ERROR; + return this->severest_error_level >= MDS_KBDC_PARSE_ERROR_ERROR; } @@ -81,23 +84,22 @@ int mds_kbdc_parsed_is_fatal(mds_kbdc_parsed_t* restrict this) * @param this The parsing result * @param output The output file */ -void mds_kbdc_parsed_print_errors(mds_kbdc_parsed_t* restrict this, FILE* output) +void +mds_kbdc_parsed_print_errors(mds_kbdc_parsed_t *restrict this, FILE *output) { - mds_kbdc_parse_error_t** errors = this->errors; - char* env = getenv("MDS_KBDC_ERRORS_ORDER"); - if (errors == NULL) - return; - if (env && (strcasecmp(env, "reversed") || strcasecmp(env, "reverse"))) - { - while (*errors) - errors++; - while (errors-- != this->errors) - mds_kbdc_parse_error_print(*errors, output); - } - else - while (*errors) - mds_kbdc_parse_error_print(*errors++, output); - + mds_kbdc_parse_error_t **errors = this->errors; + char *env = getenv("MDS_KBDC_ERRORS_ORDER"); + if (!errors) { + return; + } else if (env && (strcasecmp(env, "reversed") || strcasecmp(env, "reverse"))) { + while (*errors) + errors++; + while (errors-- != this->errors) + mds_kbdc_parse_error_print(*errors, output); + } else { + while (*errors) + mds_kbdc_parse_error_print(*errors++, output); + } } @@ -112,49 +114,47 @@ void mds_kbdc_parsed_print_errors(mds_kbdc_parsed_t* restrict this, FILE* output * @param end The byte where the error ended, on the line, exclusive, zero-based * @return The new error on success, `NULL` on error */ -mds_kbdc_parse_error_t* mds_kbdc_parsed_new_error(mds_kbdc_parsed_t* restrict this, int severity, - int error_is_in_file, size_t line, size_t start, size_t end) +mds_kbdc_parse_error_t * +mds_kbdc_parsed_new_error(mds_kbdc_parsed_t *restrict this, int severity, + int error_is_in_file, size_t line, size_t start, size_t end) { - mds_kbdc_parse_error_t* error = NULL; - size_t old_errors_ptr = this->errors_ptr; - int saved_errno; - - if (this->errors_ptr + 1 >= this->errors_size) - { - size_t new_errors_size = this->errors_size ? (this->errors_size << 1) : 2; - mds_kbdc_parse_error_t** new_errors = this->errors; - - fail_if (xrealloc(new_errors, new_errors_size, mds_kbdc_parse_error_t*)); - this->errors = new_errors; - this->errors_size = new_errors_size; - } - - fail_if (xcalloc(error, 1, mds_kbdc_parse_error_t)); - this->errors[this->errors_ptr + 0] = error; - this->errors[this->errors_ptr + 1] = NULL; - this->errors_ptr++; - - error->severity = severity; - if (this->severest_error_level < severity) - this->severest_error_level = severity; - - fail_if (xstrdup(error->pathname, this->pathname)); - - if ((error->error_is_in_file = error_is_in_file)) - { - error->line = line; - error->start = start; - error->end = end; - fail_if (xstrdup(error->code, this->source_code->real_lines[line])); - } - - return error; - fail: - saved_errno = errno; - free(error); - this->errors_ptr = old_errors_ptr; - this->errors[this->errors_ptr] = NULL; - errno = saved_errno; - return NULL; -} + mds_kbdc_parse_error_t *error = NULL, **new_errors; + size_t old_errors_ptr = this->errors_ptr, new_errors_size; + int saved_errno; + + if (this->errors_ptr + 1 >= this->errors_size) { + new_errors_size = this->errors_size ? (this->errors_size << 1) : 2; + new_errors = this->errors; + + fail_if (xrealloc(new_errors, new_errors_size, mds_kbdc_parse_error_t*)); + this->errors = new_errors; + this->errors_size = new_errors_size; + } + + fail_if (xcalloc(error, 1, mds_kbdc_parse_error_t)); + this->errors[this->errors_ptr + 0] = error; + this->errors[this->errors_ptr + 1] = NULL; + this->errors_ptr++; + error->severity = severity; + if (this->severest_error_level < severity) + this->severest_error_level = severity; + + fail_if (xstrdup(error->pathname, this->pathname)); + + if ((error->error_is_in_file = error_is_in_file)) { + error->line = line; + error->start = start; + error->end = end; + fail_if (xstrdup(error->code, this->source_code->real_lines[line])); + } + + return error; +fail: + saved_errno = errno; + free(error); + this->errors_ptr = old_errors_ptr; + this->errors[this->errors_ptr] = NULL; + errno = saved_errno; + return NULL; +} diff --git a/src/mds-kbdc/parsed.h b/src/mds-kbdc/parsed.h index 7d01695..58ad6fa 100644 --- a/src/mds-kbdc/parsed.h +++ b/src/mds-kbdc/parsed.h @@ -42,15 +42,13 @@ * @param ...:const char*, ... Error description format string and arguments * @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored */ -#define NEW_ERROR_(RESULT, SEVERITY, ERROR_IS_IN_FILE, LINE, START, END, WITH_DESCRIPTION, ...) \ - do \ - { \ - error = mds_kbdc_parsed_new_error(RESULT, MDS_KBDC_PARSE_ERROR_##SEVERITY, \ - ERROR_IS_IN_FILE, LINE, START, END); \ - fail_if (error == NULL); \ - fail_if (WITH_DESCRIPTION && xasprintf(error->description, __VA_ARGS__)); \ - } \ - while (0) +#define NEW_ERROR_(RESULT, SEVERITY, ERROR_IS_IN_FILE, LINE, START, END, WITH_DESCRIPTION, ...)\ + do {\ + error = mds_kbdc_parsed_new_error(RESULT, MDS_KBDC_PARSE_ERROR_##SEVERITY,\ + ERROR_IS_IN_FILE, LINE, START, END);\ + fail_if (!error);\ + fail_if (WITH_DESCRIPTION && xasprintf(error->description, __VA_ARGS__));\ + } while (0) @@ -58,115 +56,113 @@ * Structure with parsed tree, error list * source code and the file's pathname */ -typedef struct mds_kbdc_parsed -{ - /** - * The parsed tree - */ - mds_kbdc_tree_t* tree; - - /** - * The source code of the parsed file - */ - mds_kbdc_source_code_t* source_code; - - /** - * A non-relative pathname to the parsed file. - * Relative filenames can be misleading as the - * program can have changed working directory - * to be able to resolve filenames. - */ - char* pathname; - - /** - * `NULL`-terminated list of found errors - * `NULL` if no errors that could be listed - * were found - */ - mds_kbdc_parse_error_t** errors; - - /** - * The number of elements allocated to `errors` - */ - size_t errors_size; - - /** - * The number of elements stored in `errors` - */ - size_t errors_ptr; - - /** - * The level of the severest countered error, - * 0 if none has been encountered. - */ - int severest_error_level; - - /** - * List of languages for which the layout is designed - */ - char** languages; - - /** - * The number of elements allocated to `languages` - */ - size_t languages_size; - - /** - * The number of elements stored in `languages` - */ - size_t languages_ptr; - - /** - * List of countries for which the layout is designed - */ - char** countries; - - /** - * The number of elements allocated to `countries` - */ - size_t countries_size; - - /** - * The number of elements stored in `countries` - */ - size_t countries_ptr; - - /** - * The variant of the keyboard for the languages/countries, - * `NULL` if not specified - */ - char* variant; - - /** - * List of strings the assembler should assume are provided - */ - char32_t** assumed_strings; - - /** - * The number of elements allocated to `assumed_strings` - */ - size_t assumed_strings_size; - - /** - * The number of elements stored in `assumed_strings` - */ - size_t assumed_strings_ptr; - - /** - * List of keys the assembler should assume are provided - */ - char32_t** assumed_keys; - - /** - * The number of elements allocated to `assumed_keys` - */ - size_t assumed_keys_size; - - /** - * The number of elements stored in `assumed_keys` - */ - size_t assumed_keys_ptr; - +typedef struct mds_kbdc_parsed { + /** + * The parsed tree + */ + mds_kbdc_tree_t *tree; + + /** + * The source code of the parsed file + */ + mds_kbdc_source_code_t *source_code; + + /** + * A non-relative pathname to the parsed file. + * Relative filenames can be misleading as the + * program can have changed working directory + * to be able to resolve filenames. + */ + char *pathname; + + /** + * `NULL`-terminated list of found errors + * `NULL` if no errors that could be listed + * were found + */ + mds_kbdc_parse_error_t **errors; + + /** + * The number of elements allocated to `errors` + */ + size_t errors_size; + + /** + * The number of elements stored in `errors` + */ + size_t errors_ptr; + + /** + * The level of the severest countered error, + * 0 if none has been encountered. + */ + int severest_error_level; + + /** + * List of languages for which the layout is designed + */ + char **languages; + + /** + * The number of elements allocated to `languages` + */ + size_t languages_size; + + /** + * The number of elements stored in `languages` + */ + size_t languages_ptr; + + /** + * List of countries for which the layout is designed + */ + char **countries; + + /** + * The number of elements allocated to `countries` + */ + size_t countries_size; + + /** + * The number of elements stored in `countries` + */ + size_t countries_ptr; + + /** + * The variant of the keyboard for the languages/countries, + * `NULL` if not specified + */ + char *variant; + + /** + * List of strings the assembler should assume are provided + */ + char32_t **assumed_strings; + + /** + * The number of elements allocated to `assumed_strings` + */ + size_t assumed_strings_size; + + /** + * The number of elements stored in `assumed_strings` + */ + size_t assumed_strings_ptr; + + /** + * List of keys the assembler should assume are provided + */ + char32_t **assumed_keys; + + /** + * The number of elements allocated to `assumed_keys` + */ + size_t assumed_keys_size; + + /** + * The number of elements stored in `assumed_keys` + */ + size_t assumed_keys_ptr; } mds_kbdc_parsed_t; @@ -176,14 +172,14 @@ typedef struct mds_kbdc_parsed * * @param this The `mds_kbdc_parsed_t*` */ -void mds_kbdc_parsed_initialise(mds_kbdc_parsed_t* restrict this); +void mds_kbdc_parsed_initialise(mds_kbdc_parsed_t *restrict this); /** * Release all resources allocated in a `mds_kbdc_parsed_t*` * * @param this The `mds_kbdc_parsed_t*` */ -void mds_kbdc_parsed_destroy(mds_kbdc_parsed_t* restrict this); +void mds_kbdc_parsed_destroy(mds_kbdc_parsed_t *restrict this); /** * Check whether a fatal errors has occurred @@ -191,7 +187,8 @@ void mds_kbdc_parsed_destroy(mds_kbdc_parsed_t* restrict this); * @param this The parsing result * @return Whether a fatal errors has occurred */ -int mds_kbdc_parsed_is_fatal(mds_kbdc_parsed_t* restrict this) __attribute__((pure)); +__attribute__((pure)) +int mds_kbdc_parsed_is_fatal(mds_kbdc_parsed_t *restrict this); /** * Print all encountered errors @@ -199,7 +196,7 @@ int mds_kbdc_parsed_is_fatal(mds_kbdc_parsed_t* restrict this) __attribute__((pu * @param this The parsing result * @param output The output file */ -void mds_kbdc_parsed_print_errors(mds_kbdc_parsed_t* restrict this, FILE* output); +void mds_kbdc_parsed_print_errors(mds_kbdc_parsed_t *restrict this, FILE *output); /** * Add a new error to the list @@ -212,9 +209,8 @@ void mds_kbdc_parsed_print_errors(mds_kbdc_parsed_t* restrict this, FILE* output * @param end The byte where the error ended, on the line, exclusive, zero-based * @return The new error on success, `NULL` on error */ -mds_kbdc_parse_error_t* mds_kbdc_parsed_new_error(mds_kbdc_parsed_t* restrict this, int severity, - int error_is_in_file, size_t line, size_t start, size_t end); +mds_kbdc_parse_error_t *mds_kbdc_parsed_new_error(mds_kbdc_parsed_t *restrict this, int severity, + int error_is_in_file, size_t line, size_t start, size_t end); #endif - diff --git a/src/mds-kbdc/paths.c b/src/mds-kbdc/paths.c index 53ae6fa..70bddf1 100644 --- a/src/mds-kbdc/paths.c +++ b/src/mds-kbdc/paths.c @@ -31,32 +31,32 @@ * * @return The current working directory */ -char* curpath(void) +char * +curpath(void) { - static size_t cwd_size = 4096; - char* cwd = NULL; - char* old = NULL; - int saved_errno; - - /* glibc offers ways to do this in just one function call, - * but we will not assume that glibc is used here. */ - for (;;) - { - fail_if (xxrealloc(old, cwd, cwd_size + 1, char)); - if (getcwd(cwd, cwd_size)) - break; - else - fail_if (errno != ERANGE); - cwd_size <<= 1; - } - - return cwd; - fail: - saved_errno = errno; - free(old); - free(cwd); - errno = saved_errno; - return NULL; + static size_t cwd_size = 4096; + char *cwd = NULL; + char *old = NULL; + int saved_errno; + + /* glibc offers ways to do this in just one function call, + * but we will not assume that glibc is used here. */ + for (;;) { + fail_if (xxrealloc(old, cwd, cwd_size + 1, char)); + if (getcwd(cwd, cwd_size)) + break; + else + fail_if (errno != ERANGE); + cwd_size <<= 1; + } + + return cwd; +fail: + saved_errno = errno; + free(old); + free(cwd); + errno = saved_errno; + return NULL; } @@ -66,53 +66,51 @@ char* curpath(void) * @param path The filename of the file * @return The file's absolute path, `NULL` on error */ -char* abspath(const char* path) +char * +abspath(const char *path) { - char* cwd = NULL; - char* buf = NULL; - int saved_errno, slash = 1; - size_t size, p; - - if (*path == '/') - { - fail_if (xstrdup(buf, path)); - return buf; - } - - fail_if (cwd = curpath(), cwd == NULL); - size = (p = strlen(cwd)) + strlen(path) + 2; - fail_if (xmalloc(buf, size + 1, char)); - memcpy(buf, cwd, (p + 1) * sizeof(char)); - if (buf[p - 1] != '/') - buf[p++] = '/'; - - while (*path) - if (slash && (path[0] == '/')) - path += 1; - else if (slash && (path[0] == '.') && (path[1] == '/')) - path += 2; - else if (slash && (path[0] == '.') && (path[1] == '.') && (path[2] == '/')) - { - path += 3; - p--; - while (p && (buf[--p] != '/')); - p++; - } - else - { - buf[p++] = *path; - slash = (*path++ == '/'); - } - - buf[p] = '\0'; - - free(cwd); - return buf; - fail: - saved_errno = errno; - free(cwd); - errno = saved_errno; - return NULL; + char *cwd = NULL; + char *buf = NULL; + int saved_errno, slash = 1; + size_t size, p; + + if (*path == '/') { + fail_if (xstrdup(buf, path)); + return buf; + } + + fail_if (!(cwd = curpath())); + size = (p = strlen(cwd)) + strlen(path) + 2; + fail_if (xmalloc(buf, size + 1, char)); + memcpy(buf, cwd, (p + 1) * sizeof(char)); + if (buf[p - 1] != '/') + buf[p++] = '/'; + + while (*path) { + if (slash && path[0] == '/') { + path += 1; + } else if (slash && path[0] == '.' && path[1] == '/') { + path += 2; + } else if (slash && path[0] == '.' && path[1] == '.' && path[2] == '/') { + path += 3; + p--; + while (p && buf[--p] != '/'); + p++; + } else { + buf[p++] = *path; + slash = *path++ == '/'; + } + } + + buf[p] = '\0'; + + free(cwd); + return buf; +fail: + saved_errno = errno; + free(cwd); + errno = saved_errno; + return NULL; } @@ -124,46 +122,46 @@ char* abspath(const char* path) * `NULL` for the current working directroy * @return The file's relative path, `NULL` on error */ -char* relpath(const char* path, const char* base) +char * +relpath(const char *path, const char *base) { - char* abs = abspath(path); - char* absbase = NULL; - char* buf = NULL; - char* old = NULL; - int saved_errno; - size_t p, slash = 1, back = 0; - - fail_if (abs == NULL); - absbase = base ? abspath(base) : curpath(); - fail_if (absbase == NULL); - - if (absbase[strlen(absbase) - 1] != '/') - /* Both `abspath` and `curpath` (and `relpath`) allocates one extra slot. */ - absbase[strlen(absbase) + 1] = '\0', absbase[strlen(absbase)] = '/'; - - for (p = 1; abs[p] && absbase[p] && (abs[p] == absbase[p]); p++) - if (abs[p] == '/') - slash = p + 1; - - for (p = slash; absbase[p]; p++) - if (absbase[p] == '/') - back++; - - fail_if (xmalloc(buf, back * 3 + strlen(abs + slash) + 2, char)); - - for (p = 0; back--;) - buf[p++] = '.', buf[p++] = '.', buf[p++] = '/'; - memcpy(buf + p, abs + slash, (strlen(abs + slash) + 1) * sizeof(char)); - - free(abs); - free(absbase); - return buf; - fail: - saved_errno = errno; - free(abs); - free(absbase); - free(old); - errno = saved_errno; - return NULL; -} + char *abs = abspath(path); + char *absbase = NULL; + char *buf = NULL; + char *old = NULL; + int saved_errno; + size_t p, slash = 1, back = 0; + fail_if (!abs); + absbase = base ? abspath(base) : curpath(); + fail_if (!absbase); + + if (absbase[strlen(absbase) - 1] != '/') + /* Both `abspath` and `curpath` (and `relpath`) allocates one extra slot. */ + absbase[strlen(absbase) + 1] = '\0', absbase[strlen(absbase)] = '/'; + + for (p = 1; abs[p] && absbase[p] && abs[p] == absbase[p]; p++) + if (abs[p] == '/') + slash = p + 1; + + for (p = slash; absbase[p]; p++) + if (absbase[p] == '/') + back++; + + fail_if (xmalloc(buf, back * 3 + strlen(abs + slash) + 2, char)); + + for (p = 0; back--;) + buf[p++] = '.', buf[p++] = '.', buf[p++] = '/'; + memcpy(buf + p, abs + slash, (strlen(abs + slash) + 1) * sizeof(char)); + + free(abs); + free(absbase); + return buf; +fail: + saved_errno = errno; + free(abs); + free(absbase); + free(old); + errno = saved_errno; + return NULL; +} diff --git a/src/mds-kbdc/paths.h b/src/mds-kbdc/paths.h index 6c24042..6dbe007 100644 --- a/src/mds-kbdc/paths.h +++ b/src/mds-kbdc/paths.h @@ -24,7 +24,7 @@ * * @return The current working directory */ -char* curpath(void); +char *curpath(void); /** * Get the absolute path of a file @@ -32,7 +32,7 @@ char* curpath(void); * @param path The filename of the file * @return The file's absolute path, `NULL` on error */ -char* abspath(const char* path); +char *abspath(const char *path); /** * Get a relative path of a file @@ -42,8 +42,7 @@ char* abspath(const char* path); * `NULL` for the current working directroy * @return The file's relative path, `NULL` on error */ -char* relpath(const char* path, const char* base); +char *relpath(const char* path, const char *base); #endif - diff --git a/src/mds-kbdc/process-includes.c b/src/mds-kbdc/process-includes.c index 69b9c73..a46533c 100644 --- a/src/mds-kbdc/process-includes.c +++ b/src/mds-kbdc/process-includes.c @@ -32,7 +32,7 @@ /** * Tree type constant shortener */ -#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE +#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE /** * Add an error to the error list @@ -42,26 +42,26 @@ * @param ...:const char*, ... Error description format string and arguments * @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored */ -#define NEW_ERROR(NODE, SEVERITY, ...) \ - NEW_ERROR_(result, SEVERITY, 1, (NODE)->loc_line, \ - (NODE)->loc_start, (NODE)->loc_end, 1, __VA_ARGS__) +#define NEW_ERROR(NODE, SEVERITY, ...)\ + NEW_ERROR_(result, SEVERITY, 1, (NODE)->loc_line,\ + (NODE)->loc_start, (NODE)->loc_end, 1, __VA_ARGS__) /** * Variable whether the latest created error is stored */ -static mds_kbdc_parse_error_t* error; +static mds_kbdc_parse_error_t *error; /** * The parameter of `process_includes` */ -static mds_kbdc_parsed_t* restrict result; +static mds_kbdc_parsed_t *restrict result; /** * Stack of attributes of already included files */ -static struct stat* restrict included; +static struct stat *restrict included; /** * The number elements allocated for `included` @@ -81,66 +81,62 @@ static size_t included_ptr = 0; * @param subresult The results of the processed include * @param tree The include statement */ -static int transfer_errors(mds_kbdc_parsed_t* restrict subresult, mds_kbdc_tree_include_t* restrict tree) +static int +transfer_errors(mds_kbdc_parsed_t *restrict subresult, mds_kbdc_tree_include_t *restrict tree) { - mds_kbdc_parse_error_t** errors = NULL; - mds_kbdc_parse_error_t* suberror; - size_t errors_ptr = 0; - int saved_errno, annotated = 0; - - /* Allocate temporary list for errors. */ - if (subresult->errors_ptr == 0) - return 0; - fail_if (xmalloc(errors, subresult->errors_ptr * 2, mds_kbdc_parse_error_t*)); - - /* List errors backwards, so that we can easily handle errors and add “included from here”-note. */ - while (subresult->errors_ptr--) - { - suberror = subresult->errors[subresult->errors_ptr]; - - /* If it is more severe than a note, we want to say there it was included. */ - if (annotated == 0) - { - NEW_ERROR(tree, NOTE, "included from here"); - errors[errors_ptr++] = error; - result->errors[--(result->errors_ptr)] = NULL; - annotated = 1; + mds_kbdc_parse_error_t **errors = NULL, *suberror, **new_errors; + size_t errors_ptr = 0, new_errors_size; + int saved_errno, annotated = 0; + + /* Allocate temporary list for errors. */ + if (!subresult->errors_ptr) + return 0; + fail_if (xmalloc(errors, subresult->errors_ptr * 2, mds_kbdc_parse_error_t*)); + + /* List errors backwards, so that we can easily handle errors and add “included from here”-note. */ + while (subresult->errors_ptr--) { + suberror = subresult->errors[subresult->errors_ptr]; + + /* If it is more severe than a note, we want to say there it was included. */ + if (!annotated) { + NEW_ERROR(tree, NOTE, "included from here"); + errors[errors_ptr++] = error; + result->errors[--(result->errors_ptr)] = NULL; + annotated = 1; + } + + /* Include error. */ + errors[errors_ptr++] = suberror; + subresult->errors[subresult->errors_ptr] = NULL; + + /* Make sure when there are nested inclusions that the outermost inclusion * is annotated last. */ + if (suberror->severity > MDS_KBDC_PARSE_ERROR_NOTE) + annotated = 0; } - - /* Include error. */ - errors[errors_ptr++] = suberror; - subresult->errors[subresult->errors_ptr] = NULL; - - /* Make sure when there are nested inclusions that the outermost inclusion * is annotated last. */ - if (suberror->severity > MDS_KBDC_PARSE_ERROR_NOTE) - annotated = 0; - } - - /* Append errors. */ - for (; errors_ptr--; errors[errors_ptr] = NULL) - { - if (result->errors_ptr + 1 >= result->errors_size) - { - size_t new_errors_size = result->errors_size ? (result->errors_size << 1) : 2; - mds_kbdc_parse_error_t** new_errors = result->errors; - - fail_if (xrealloc(new_errors, new_errors_size, mds_kbdc_parse_error_t*)); - result->errors = new_errors; - result->errors_size = new_errors_size; + + /* Append errors. */ + for (; errors_ptr--; errors[errors_ptr] = NULL) { + if (result->errors_ptr + 1 >= result->errors_size) { + new_errors_size = result->errors_size ? (result->errors_size << 1) : 2; + new_errors = result->errors; + + fail_if (xrealloc(new_errors, new_errors_size, mds_kbdc_parse_error_t*)); + result->errors = new_errors; + result->errors_size = new_errors_size; + } + + result->errors[result->errors_ptr++] = errors[errors_ptr]; + result->errors[result->errors_ptr] = NULL; } - - result->errors[result->errors_ptr++] = errors[errors_ptr]; - result->errors[result->errors_ptr] = NULL; - } - - free(errors); - return 0; - fail: - saved_errno = errno; - while (errors_ptr--) - mds_kbdc_parse_error_free(errors[errors_ptr]); - free(errors); - return errno = saved_errno, -1; + + free(errors); + return 0; +fail: + saved_errno = errno; + while (errors_ptr--) + mds_kbdc_parse_error_free(errors[errors_ptr]); + free(errors); + return errno = saved_errno, -1; } @@ -150,86 +146,83 @@ static int transfer_errors(mds_kbdc_parsed_t* restrict subresult, mds_kbdc_tree_ * @param tree The include-statement * @return Zero on success, -1 on error */ -static int process_include(mds_kbdc_tree_include_t* restrict tree) +static int +process_include(mds_kbdc_tree_include_t *restrict tree) { -#define process(expr) \ - fail_if ((expr) < 0); \ - if (mds_kbdc_parsed_is_fatal(&subresult)) \ - goto stop; - - mds_kbdc_parsed_t subresult; - mds_kbdc_parsed_t* our_result; - char* dirname = NULL; - char* cwd = NULL; - char* old = NULL; - size_t cwd_size = 4096 >> 1; - int saved_errno; - - /* Initialise result structure for the included file. */ - mds_kbdc_parsed_initialise(&subresult); - - /* Get dirname of current file. */ - fail_if (xstrdup(dirname, result->pathname)); - *(strrchr(dirname, '/')) = '\0'; - - /* Get the current working directory. */ - /* glibc offers ways to do this in just one function call, - * but we will not assume that glibc is used here. */ - for (;;) - { - fail_if (xxrealloc(old, cwd, cwd_size <<= 1, char)); - if (getcwd(cwd, cwd_size)) - break; - else - fail_if (errno != ERANGE); - } - - /* Switch working directory. */ - fail_if (chdir(dirname)); - free(dirname), dirname = NULL; - - /* Store `result` as it will be switched by the inner `process_includes`. */ - our_result = result; - - /* Process include. */ - old = tree->filename, tree->filename = NULL; - tree->filename = parse_raw_string(old); - fail_if (tree->filename == NULL); - free(old), old = NULL; - process (parse_to_tree(tree->filename, &subresult)); - process (simplify_tree(&subresult)); - process (process_includes(&subresult)); - stop: - - /* Switch back `result`. */ - result = our_result; - - /* Switch back to the old working directory. */ - fail_if (chdir(cwd)); - free(cwd), cwd = NULL; - - /* Move over data to our result. */ - free(tree->filename); - tree->filename = subresult.pathname, subresult.pathname = NULL; - tree->source_code = subresult.source_code, subresult.source_code = NULL; - tree->inner = subresult.tree, subresult.tree = NULL; - if (result->severest_error_level < subresult.severest_error_level) - result->severest_error_level = subresult.severest_error_level; - - /* Move over errors. */ - fail_if (transfer_errors(&subresult, tree)); - - /* Release resources. */ - mds_kbdc_parsed_destroy(&subresult); - - return 0; - fail: - saved_errno = errno; - free(dirname); - free(cwd); - free(old); - mds_kbdc_parsed_destroy(&subresult); - return errno = saved_errno, -1; +#define process(expr)\ + fail_if ((expr) < 0);\ + if (mds_kbdc_parsed_is_fatal(&subresult))\ + goto stop; + + mds_kbdc_parsed_t subresult, *our_result; + char *dirname = NULL, *cwd = NULL, *old = NULL; + size_t cwd_size = 4096 >> 1; + int saved_errno; + + /* Initialise result structure for the included file. */ + mds_kbdc_parsed_initialise(&subresult); + + /* Get dirname of current file. */ + fail_if (xstrdup(dirname, result->pathname)); + *(strrchr(dirname, '/')) = '\0'; + + /* Get the current working directory. */ + /* glibc offers ways to do this in just one function call, + * but we will not assume that glibc is used here. */ + for (;;) { + fail_if (xxrealloc(old, cwd, cwd_size <<= 1, char)); + if (getcwd(cwd, cwd_size)) + break; + else + fail_if (errno != ERANGE); + } + + /* Switch working directory. */ + fail_if (chdir(dirname)); + free(dirname), dirname = NULL; + + /* Store `result` as it will be switched by the inner `process_includes`. */ + our_result = result; + + /* Process include. */ + old = tree->filename, tree->filename = NULL; + tree->filename = parse_raw_string(old); + fail_if (tree->filename == NULL); + free(old), old = NULL; + process (parse_to_tree(tree->filename, &subresult)); + process (simplify_tree(&subresult)); + process (process_includes(&subresult)); +stop: + + /* Switch back `result`. */ + result = our_result; + + /* Switch back to the old working directory. */ + fail_if (chdir(cwd)); + free(cwd), cwd = NULL; + + /* Move over data to our result. */ + free(tree->filename); + tree->filename = subresult.pathname, subresult.pathname = NULL; + tree->source_code = subresult.source_code, subresult.source_code = NULL; + tree->inner = subresult.tree, subresult.tree = NULL; + if (result->severest_error_level < subresult.severest_error_level) + result->severest_error_level = subresult.severest_error_level; + + /* Move over errors. */ + fail_if (transfer_errors(&subresult, tree)); + + /* Release resources. */ + mds_kbdc_parsed_destroy(&subresult); + + return 0; +fail: + saved_errno = errno; + free(dirname); + free(cwd); + free(old); + mds_kbdc_parsed_destroy(&subresult); + return errno = saved_errno, -1; #undef process } @@ -240,32 +233,32 @@ static int process_include(mds_kbdc_tree_include_t* restrict tree) * @param tree The tree * @return Zero on success, -1 on error */ -static int process_includes_in_tree(mds_kbdc_tree_t* restrict tree) +static int +process_includes_in_tree(mds_kbdc_tree_t *restrict tree) { -#define p(expr) fail_if (process_includes_in_tree(tree->expr)) - again: - if (tree == NULL) - return 0; - - switch (tree->type) - { - case C(INFORMATION): p (information.inner); break; - case C(FUNCTION): p (function.inner); break; - case C(MACRO): p (macro.inner); break; - case C(ASSUMPTION): p (assumption.inner); break; - case C(FOR): p (for_.inner); break; - case C(IF): p (if_.inner); p (if_.otherwise); break; - case C(INCLUDE): - fail_if (process_include(&(tree->include))); - break; - default: - break; - } - - tree = tree->next; - goto again; - fail: - return -1; +#define p(expr) fail_if (process_includes_in_tree(tree->expr)) +again: + if (!tree) + return 0; + + switch (tree->type) { + case C(INFORMATION): p (information.inner); break; + case C(FUNCTION): p (function.inner); break; + case C(MACRO): p (macro.inner); break; + case C(ASSUMPTION): p (assumption.inner); break; + case C(FOR): p (for_.inner); break; + case C(IF): p (if_.inner); p (if_.otherwise); break; + case C(INCLUDE): + fail_if (process_include(&(tree->include))); + break; + default: + break; + } + + tree = tree->next; + goto again; +fail: + return -1; #undef p } @@ -276,45 +269,43 @@ static int process_includes_in_tree(mds_kbdc_tree_t* restrict tree) * @param result_ `result` from `simplify_tree`, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int process_includes(mds_kbdc_parsed_t* restrict result_) +int +process_includes(mds_kbdc_parsed_t *restrict result_) { - int r, saved_errno; - struct stat attr; - size_t i; - - result = result_; - - fail_if (stat(result->pathname, &attr)); - - if (included_ptr == included_size) - { - struct stat* old; - if (xxrealloc(old, included, included_size += 4, struct stat)) - fail_if (included = old, 1); - } - - for (i = 0; i < included_ptr; i++) - if ((included[i].st_dev == attr.st_dev) && (included[i].st_ino == attr.st_ino)) - { - NEW_ERROR_(result, ERROR, 0, 0, 0, 0, 1, "resursive inclusion"); - return 0; - } - - included[included_ptr++] = attr; - - r = process_includes_in_tree(result_->tree); - saved_errno = errno; - - if (--included_ptr == 0) - free(included), included_size = 0; - - return errno = saved_errno, r; - fail: - return -1; + int r, saved_errno; + struct stat attr, *old; + size_t i; + + result = result_; + + fail_if (stat(result->pathname, &attr)); + + if (included_ptr == included_size) { + if (xxrealloc(old, included, included_size += 4, struct stat)) + fail_if (included = old, 1); + } + + for (i = 0; i < included_ptr; i++) { + if ((included[i].st_dev == attr.st_dev) && (included[i].st_ino == attr.st_ino)) { + NEW_ERROR_(result, ERROR, 0, 0, 0, 0, 1, "resursive inclusion"); + return 0; + } + } + + included[included_ptr++] = attr; + + r = process_includes_in_tree(result_->tree); + saved_errno = errno; + + if (!--included_ptr) + free(included), included_size = 0; + + return errno = saved_errno, r; +fail: + return -1; } #undef NEW_ERROR #undef C - diff --git a/src/mds-kbdc/process-includes.h b/src/mds-kbdc/process-includes.h index 5644dd9..6146600 100644 --- a/src/mds-kbdc/process-includes.h +++ b/src/mds-kbdc/process-includes.h @@ -28,8 +28,7 @@ * @param result `result` from `simplify_tree`, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int process_includes(mds_kbdc_parsed_t* restrict result); +int process_includes(mds_kbdc_parsed_t *restrict result); #endif - diff --git a/src/mds-kbdc/raw-data.c b/src/mds-kbdc/raw-data.c index e40be68..2b89840 100644 --- a/src/mds-kbdc/raw-data.c +++ b/src/mds-kbdc/raw-data.c @@ -39,14 +39,15 @@ * * @param this The `mds_kbdc_source_code_t*` */ -void mds_kbdc_source_code_initialise(mds_kbdc_source_code_t* restrict this) +void +mds_kbdc_source_code_initialise(mds_kbdc_source_code_t *restrict this) { - this->lines = NULL; - this->real_lines = NULL; - this->content = NULL; - this->real_content = NULL; - this->line_count = 0; - this->duplicates = 0; + this->lines = NULL; + this->real_lines = NULL; + this->content = NULL; + this->real_content = NULL; + this->line_count = 0; + this->duplicates = 0; } @@ -55,16 +56,17 @@ void mds_kbdc_source_code_initialise(mds_kbdc_source_code_t* restrict this) * * @param this The `mds_kbdc_source_code_t*` */ -void mds_kbdc_source_code_destroy(mds_kbdc_source_code_t* restrict this) +void +mds_kbdc_source_code_destroy(mds_kbdc_source_code_t *restrict this) { - if (this == NULL) - return; - if (this->duplicates--) - return; - free(this->lines), this->lines = NULL; - free(this->real_lines), this->real_lines = NULL; - free(this->content), this->content = NULL; - free(this->real_content), this->real_content = NULL; + if (!this) + return; + if (this->duplicates--) + return; + free(this->lines), this->lines = NULL; + free(this->real_lines), this->real_lines = NULL; + free(this->content), this->content = NULL; + free(this->real_content), this->real_content = NULL; } @@ -73,17 +75,18 @@ void mds_kbdc_source_code_destroy(mds_kbdc_source_code_t* restrict this) * * @param this The `mds_kbdc_source_code_t*` */ -void mds_kbdc_source_code_free(mds_kbdc_source_code_t* restrict this) +void +mds_kbdc_source_code_free(mds_kbdc_source_code_t *restrict this) { - if (this == NULL) - return; - if (this->duplicates--) - return; - free(this->lines); - free(this->real_lines); - free(this->content); - free(this->real_content); - free(this); + if (!this) + return; + if (this->duplicates--) + return; + free(this->lines); + free(this->real_lines); + free(this->content); + free(this->real_content); + free(this); } /** @@ -92,10 +95,11 @@ void mds_kbdc_source_code_free(mds_kbdc_source_code_t* restrict this) * @param this The `mds_kbdc_source_code_t*` * @return `this` is returned */ -mds_kbdc_source_code_t* mds_kbdc_source_code_dup(mds_kbdc_source_code_t* restrict this) +mds_kbdc_source_code_t * +mds_kbdc_source_code_dup(mds_kbdc_source_code_t *restrict this) { - this->duplicates++; - return this; + this->duplicates++; + return this; } @@ -107,51 +111,51 @@ mds_kbdc_source_code_t* mds_kbdc_source_code_dup(mds_kbdc_source_code_t* restric * @param size Output parameter for the size of the read content, in char:s * @return The read content, `NULL` on error */ -static char* read_file(const char* restrict pathname, size_t* restrict size) +static char * +read_file(const char *restrict pathname, size_t *restrict size) { - size_t buf_size = 8096; - size_t buf_ptr = 0; - char* restrict content = NULL; - char* restrict old = NULL; - int fd = -1; - ssize_t got; - - /* Allocate buffer for the file's content. */ - fail_if (xmalloc(content, buf_size, char)); - /* Open the file to compile. */ - fail_if ((fd = open(pathname, O_RDONLY)) < 0); - - /* Read the file to compile. */ - for (;;) - { - /* Make sure the buffer is not small. */ - if (buf_size - buf_ptr < 2048) - fail_if (xxrealloc(old, content, buf_size <<= 1, char)); - /* Read a chunk of the file. */ - got = read(fd, content + buf_ptr, (buf_size - buf_ptr) * sizeof(char)); - if ((got < 0) && (errno == EINTR)) continue; - if (got == 0) break; - fail_if (got < 0); - buf_ptr += (size_t)got; - } - - /* Shrink the buffer so it is not excessively large. */ - if (buf_ptr) /* Simplest way to handle empty files: let the have the initial allocation size. */ - fail_if (xxrealloc(old, content, buf_ptr, char)); - - /* Close file decriptor for the file. */ - xclose(fd); - - *size = buf_ptr; - return content; - - fail: - xperror(*argv); - free(old); - free(content); - if (fd >= 0) - xclose(fd); - return NULL; + size_t buf_size = 8096; + size_t buf_ptr = 0; + char *restrict content = NULL; + char *restrict old = NULL; + int fd = -1; + ssize_t got; + + /* Allocate buffer for the file's content. */ + fail_if (xmalloc(content, buf_size, char)); + /* Open the file to compile. */ + fail_if ((fd = open(pathname, O_RDONLY)) < 0); + + /* Read the file to compile. */ + for (;;) { + /* Make sure the buffer is not small. */ + if (buf_size - buf_ptr < 2048) + fail_if (xxrealloc(old, content, buf_size <<= 1, char)); + /* Read a chunk of the file. */ + got = read(fd, content + buf_ptr, (buf_size - buf_ptr) * sizeof(char)); + if (got < 0 && errno == EINTR) continue; + if (got == 0) break; + fail_if (got < 0); + buf_ptr += (size_t)got; + } + + /* Shrink the buffer so it is not excessively large. */ + if (buf_ptr) /* Simplest way to handle empty files: let the have the initial allocation size. */ + fail_if (xxrealloc(old, content, buf_ptr, char)); + + /* Close file decriptor for the file. */ + xclose(fd); + + *size = buf_ptr; + return content; + +fail: + xperror(*argv); + free(old); + free(content); + if (fd >= 0) + xclose(fd); + return NULL; } @@ -167,54 +171,59 @@ static char* read_file(const char* restrict pathname, size_t* restrict size) * or `size` if the call do not end (that is, the code ends * prematurely), or zero if there is no function call at `offset` */ -size_t get_end_of_call(const char* restrict content, size_t offset, size_t size) +size_t +get_end_of_call(const char *restrict content, size_t offset, size_t size) { -#define C content[ptr] -#define r(lower, upper) (((lower) <= C) && (C <= (upper))) - - size_t ptr = offset, call_end = 0; - int escape = 0, quote = 0; - - /* Skip to end of function name. */ - while ((ptr < size) && (r('a', 'z') || r('A', 'Z') || r('0', '9') || (C == '_'))) - ptr++; - - /* Check that it is a function call. */ - if ((ptr == size) || (ptr == offset) || (C != '(')) - return 0; - - /* Find the end of the function call. */ - while (ptr < size) - { - char c = content[ptr++]; - - /* Escapes may be longer than one character, - but only the first can affect the parsing. */ - if (escape) escape = 0; - /* Nested function and nested quotes can appear. */ - else if (ptr <= call_end) ; - /* Quotes end with the same symbols as they start with, - and quotes automatically escape brackets. */ - /* \ can either start a functon call or an escape. */ - else if (c == '\\') - { - /* It may not be an escape, but registering it - as an escape cannot harm us since we only - skip the first character, and a function call - cannot be that short. */ - escape = 1; - /* Nested quotes can appear at function calls. */ - call_end = get_end_of_call(content, ptr, size); +#define C content[ptr] +#define r(lower, upper) ((lower) <= C && C <= (upper)) + + size_t ptr = offset, call_end = 0; + int escape = 0, quote = 0; + char c; + + /* Skip to end of function name. */ + while (ptr < size && (r('a', 'z') || r('A', 'Z') || r('0', '9') || (C == '_'))) + ptr++; + + /* Check that it is a function call. */ + if (ptr == size || ptr == offset || C != '(') + return 0; + + /* Find the end of the function call. */ + while (ptr < size) { + c = content[ptr++]; + + if (escape) { + /* Escapes may be longer than one character, + but only the first can affect the parsing. */ + escape = 0; + } else if (ptr <= call_end) { + /* Nested function and nested quotes can appear. */; + } else if (c == '\\') { + /* Quotes end with the same symbols as they start with, + and quotes automatically escape brackets. */ + /* \ can either start a functon call or an escape. */ + + /* It may not be an escape, but registering it + as an escape cannot harm us since we only + skip the first character, and a function call + cannot be that short. */ + escape = 1; + /* Nested quotes can appear at function calls. */ + call_end = get_end_of_call(content, ptr, size); + } else if (quote) { + quote = (c != '"'); + } else if (c == ')') { + /* End of function call, end of fun. */ + break; + } else if (c == '"') { + /* " is the quote symbol. */ + quote = 1; + } } - else if (quote) quote = (c != '"'); - /* End of function call, end of fun. */ - else if (c == ')') break; - /* " is the quote symbol. */ - else if (c == '"') quote = 1; - } - - return ptr; - + + return ptr; + #undef r #undef C } @@ -227,55 +236,58 @@ size_t get_end_of_call(const char* restrict content, size_t offset, size_t size) * @param size The size of `content`, in char:s * @return The new size of `content`, in char:s; this function cannot fail */ -static size_t remove_comments(char* restrict content, size_t size) +static size_t +remove_comments(char *restrict content, size_t size) { -#define t content[n_ptr++] = c - - size_t n_ptr = 0, o_ptr = 0, call_end = 0; - int comment = 0, quote = 0, escape = 0; - - while (o_ptr < size) - { - char c = content[o_ptr++]; - /* Remove comment. */ - if (comment) - { - if (c == '\n') t, comment = 0; - } - /* Escapes may be longer than one character, - but only the first can affect the parsing. */ - else if (escape) t, escape = 0; - /* Nested quotes can appear at function calls. */ - else if (o_ptr <= call_end) t; - /* \ can either start a functon call or an escape. */ - else if (c == '\\') - { - t; - /* It may not be an escape, but registering it - as an escape cannot harm us since we only - skip the first character, and a function call - cannot be that short. */ - escape = 1; - /* Nested quotes can appear at function calls. */ - call_end = get_end_of_call(content, o_ptr, size); - } - /* Quotes end with the same symbols as they start with, - and quotes automatically escape comments. */ - else if (quote) - { - t; - if (strchr("\"\n", c)) quote = 0; +#define t content[n_ptr++] = c + + size_t n_ptr = 0, o_ptr = 0, call_end = 0; + int comment = 0, quote = 0, escape = 0; + char c; + + while (o_ptr < size) { + c = content[o_ptr++]; + if (comment) { + /* Remove comment. */ + if (c == '\n') + t, comment = 0; + } else if (escape) { + /* Escapes may be longer than one character, + but only the first can affect the parsing. */ + t, escape = 0; + } else if (o_ptr <= call_end) { + /* Nested quotes can appear at function calls. */ + t; + } else if (c == '\\') { + /* \ can either start a functon call or an escape. */ + t; + /* It may not be an escape, but registering it + as an escape cannot harm us since we only + skip the first character, and a function call + cannot be that short. */ + escape = 1; + /* Nested quotes can appear at function calls. */ + call_end = get_end_of_call(content, o_ptr, size); + } else if (quote) { + /* Quotes end with the same symbols as they start with, + and quotes automatically escape comments. */ + t; + if (strchr("\"\n", c)) + quote = 0; + } else if (c == '#') { + /* # is the comment symbol. */ + comment = 1; + } else if (c == '"') { + /* " is the quote symbol. */ + t, quote = 1; + } else { + /* Code and whitespace. */ + t; + } } - /* # is the comment symbol. */ - else if (c == '#') comment = 1; - /* " is the quote symbol. */ - else if (c == '"') t, quote = 1; - /* Code and whitespace. */ - else t; - } - - return n_ptr; - + + return n_ptr; + #undef t } @@ -298,36 +310,35 @@ static size_t remove_comments(char* restrict content, size_t size) * `NULL` is returned, and `content` will not * have been modified. */ -static char** line_split(char* content, size_t length) +static char ** +line_split(char *content, size_t length) { - char** restrict lines = NULL; - size_t count = 0; - size_t i, j; - int new_line = 1; - - for (i = 0; i < length; i++) - if (content[i] == '\n') - count++; - - fail_if (xmalloc(lines, count + 1, char*)); - lines[count] = NULL; - - for (i = j = 0; i < length; i++) - { - if (new_line) - new_line = 0, lines[j++] = content + i; - if (content[i] == '\n') - { - new_line = 1; - content[i] = '\0'; + char **restrict lines = NULL; + size_t count = 0; + size_t i, j; + int new_line = 1; + + for (i = 0; i < length; i++) + if (content[i] == '\n') + count++; + + fail_if (xmalloc(lines, count + 1, char*)); + lines[count] = NULL; + + for (i = j = 0; i < length; i++) { + if (new_line) + new_line = 0, lines[j++] = content + i; + if (content[i] == '\n') { + new_line = 1; + content[i] = '\0'; + } } - } - - return lines; - - fail: - xperror(*argv); - return NULL; + + return lines; + +fail: + xperror(*argv); + return NULL; } @@ -338,40 +349,44 @@ static char** line_split(char* content, size_t length) * @param content_size Input and output parameter for the size of the file's content * @return Zero on success, -1 on error */ -static int expand(char** restrict content, size_t* restrict content_size) +static int +expand(char **restrict content, size_t *restrict content_size) { - size_t extra = 0, added = 0, ptr, col, n = *content_size; - char* restrict data = *content; - - /* Calculate the new size of the file. */ - for (ptr = col = 0; ptr < n; ptr++) - if (data[ptr] == '\n') - col = 0; - else if (data[ptr] == '\t') - extra += 8 - (col % 8) - 1; - - /* Extend the allocation. */ - if (extra == 0) - return 0; - *content_size += extra; - fail_if (xrealloc(data, *content_size, char)); - *content = data; - - /* Expand tab spaces. */ - memmove(data + extra, data, n); - for (ptr = 0; ptr < n; ptr++, added--) - if (data[ptr + extra] == '\n') - data[ptr + added++] = data[ptr + extra], col = 0; - else if (data[ptr + extra] != '\t') - data[ptr + added++] = data[ptr + extra], col++; - else - do - data[ptr + added++] = ' '; - while (++col % 8); - - return 0; - fail: - return -1; + size_t extra = 0, added = 0, ptr, col, n = *content_size; + char *restrict data = *content; + + /* Calculate the new size of the file. */ + for (ptr = col = 0; ptr < n; ptr++) { + if (data[ptr] == '\n') + col = 0; + else if (data[ptr] == '\t') + extra += 8 - (col % 8) - 1; + } + + /* Extend the allocation. */ + if (!extra) + return 0; + *content_size += extra; + fail_if (xrealloc(data, *content_size, char)); + *content = data; + + /* Expand tab spaces. */ + memmove(data + extra, data, n); + for (ptr = 0; ptr < n; ptr++, added--) { + if (data[ptr + extra] == '\n') { + data[ptr + added++] = data[ptr + extra], col = 0; + } else if (data[ptr + extra] != '\t') { + data[ptr + added++] = data[ptr + extra], col++; + } else { + do + data[ptr + added++] = ' '; + while (++col % 8); + } + } + + return 0; +fail: + return -1; } @@ -382,60 +397,60 @@ static int expand(char** restrict content, size_t* restrict content_size) * @param source_code Output parameter for read data * @return Zero on success, -1 on error */ -int read_source_lines(const char* restrict pathname, mds_kbdc_source_code_t* restrict source_code) +int +read_source_lines(const char *restrict pathname, mds_kbdc_source_code_t *restrict source_code) { - char* content = NULL; - char* real_content = NULL; - char* old = NULL; - size_t content_size; - size_t real_content_size; - char** lines = NULL; - char** real_lines = NULL; - size_t line_count = 0; - - /* Read the file. */ - content = read_file(pathname, &content_size); - fail_if (content == NULL); - - /* Expand tab spaces. */ - fail_if (expand(&content, &content_size)); - - /* Make sure the content ends with a new line. */ - if (!content_size || (content[content_size - 1] != '\n')) - { - fail_if (xxrealloc(old, content, content_size + 1, char)); - content[content_size++] = '\n'; - } - - /* Simplify file. */ - fail_if (xmemdup(real_content, content, content_size, char)); - real_content_size = content_size; - content_size = remove_comments(content, content_size); - fail_if (xxrealloc(old, content, content_size, char)); - - /* Split by line. */ - fail_if ((lines = line_split(content, content_size)) == NULL); - fail_if ((real_lines = line_split(real_content, real_content_size)) == NULL); - - /* Count the number of lines. */ - while (lines[line_count] != NULL) - line_count++; - - source_code->lines = lines; - source_code->real_lines = real_lines; - source_code->content = content; - source_code->real_content = real_content; - source_code->line_count = line_count; - return 0; - - fail: - xperror(*argv); - free(old); - free(content); - free(real_content); - free(lines); - free(real_lines); - return -1; + char *content = NULL; + char *real_content = NULL; + char *old = NULL; + size_t content_size; + size_t real_content_size; + char **lines = NULL; + char **real_lines = NULL; + size_t line_count = 0; + + /* Read the file. */ + content = read_file(pathname, &content_size); + fail_if (!content); + + /* Expand tab spaces. */ + fail_if (expand(&content, &content_size)); + + /* Make sure the content ends with a new line. */ + if (!content_size || content[content_size - 1] != '\n') { + fail_if (xxrealloc(old, content, content_size + 1, char)); + content[content_size++] = '\n'; + } + + /* Simplify file. */ + fail_if (xmemdup(real_content, content, content_size, char)); + real_content_size = content_size; + content_size = remove_comments(content, content_size); + fail_if (xxrealloc(old, content, content_size, char)); + + /* Split by line. */ + fail_if (!(lines = line_split(content, content_size))); + fail_if (!(real_lines = line_split(real_content, real_content_size))); + + /* Count the number of lines. */ + while (lines[line_count]) + line_count++; + + source_code->lines = lines; + source_code->real_lines = real_lines; + source_code->content = content; + source_code->real_content = real_content; + source_code->line_count = line_count; + return 0; + +fail: + xperror(*argv); + free(old); + free(content); + free(real_content); + free(lines); + free(real_lines); + return -1; } @@ -446,24 +461,25 @@ int read_source_lines(const char* restrict pathname, mds_kbdc_source_code_t* res * @param character The character * @return The of the character in `buffer`, `NULL` on error */ -static char* encode_utf8(char* buffer, char32_t character) +static char * +encode_utf8(char *buffer, char32_t character) { - char32_t text[2]; - char* restrict str; - char* restrict str_; - - text[0] = character; - text[1] = -1; - - fail_if (str_ = str = string_encode(text), str == NULL); - - while (*str) - *buffer++ = *str++; - - free(str_); - return buffer; - fail: - return NULL; + char32_t text[2]; + char *restrict str; + char *restrict str_; + + text[0] = character; + text[1] = -1; + + fail_if (!(str_ = str = string_encode(text))); + + while (*str) + *buffer++ = *str++; + + free(str_); + return buffer; +fail: + return NULL; } @@ -473,53 +489,57 @@ static char* encode_utf8(char* buffer, char32_t character) * @param string The string * @return The string in machine-readable format, `NULL` on error */ -char* parse_raw_string(const char* restrict string) +char * +parse_raw_string(const char *restrict string) { -#define r(cond, lower, upper) ((cond) && ((lower) <= c) && (c <= (upper))) - char* rc; - char* p; - int escape = 0; - char32_t buf = 0; - char c; - - /* We know that the output string can only be shorter because - * it is surrounded by 2 quotes and escape can only be longer - * then what they escape, for example \uA0, is four characters, - * but when parsed it generateds 2 bytes in UTF-8, and their - * is not code point whose UTF-8 encoding is longer than its - * hexadecimal representation. */ - fail_if (xmalloc(p = rc, strlen(string), char)); - - while ((c = *string++)) - if (r(escape == 8, '0', '7')) buf = (buf << 3) | (c & 15); - else if (r(escape == 16, '0', '9')) buf = (buf << 4) | (c & 15); - else if (r(escape == 16, 'a', 'f')) buf = (buf << 4) | ((c & 15) + 9); - else if (r(escape == 16, 'A', 'F')) buf = (buf << 4) | ((c & 15) + 9); - else if (escape > 1) - { - escape = 0; - fail_if ((p = encode_utf8(p, buf), p == NULL)); - if (c != '.') - *p++ = c; - } - else if (escape == 1) - { - escape = 0, buf = 0; - switch (c) - { - case '0': escape = 8; break; - case 'u': escape = 16; break; - default: *p++ = c; break; - } - } - else if (c == '\\') escape = 1; - else if (c != '\"') *p++ = c; - - *p = '\0'; - return rc; - fail: - free(rc); - return NULL; +#define r(cond, lower, upper) ((cond) && ((lower) <= c) && (c <= (upper))) + char *rc, *p; + int escape = 0; + char32_t buf = 0; + char c; + + /* We know that the output string can only be shorter because + * it is surrounded by 2 quotes and escape can only be longer + * then what they escape, for example \uA0, is four characters, + * but when parsed it generateds 2 bytes in UTF-8, and their + * is not code point whose UTF-8 encoding is longer than its + * hexadecimal representation. */ + fail_if (xmalloc(p = rc, strlen(string), char)); + + while ((c = *string++)) { + if (r(escape == 8, '0', '7')) { + buf = (buf << 3) | (c & 15); + } else if (r(escape == 16, '0', '9')) { + buf = (buf << 4) | (c & 15); + } else if (r(escape == 16, 'a', 'f')) { + buf = (buf << 4) | ((c & 15) + 9); + } else if (r(escape == 16, 'A', 'F')) { + buf = (buf << 4) | ((c & 15) + 9); + } else if (escape > 1) { + escape = 0; + fail_if (!(p = encode_utf8(p, buf))); + if (c != '.') + *p++ = c; + } else if (escape == 1) { + escape = 0; + buf = 0; + if (c == '0') + escape = 8; + else if (c == 'u') + escape = 16; + else + *p++ = c; + } else if (c == '\\') { + escape = 1; + } else if (c != '\"') { + *p++ = c; + } + } + + *p = '\0'; + return rc; +fail: + free(rc); + return NULL; #undef r } - diff --git a/src/mds-kbdc/raw-data.h b/src/mds-kbdc/raw-data.h index 3638042..bdc1078 100644 --- a/src/mds-kbdc/raw-data.h +++ b/src/mds-kbdc/raw-data.h @@ -25,42 +25,40 @@ /** * Source code by lines, with and without comments */ -typedef struct mds_kbdc_source_code -{ - /** - * Source code by lines without comments, - * `NULL`-terminated. - */ - char** restrict lines; - - /** - * Source code by lines with comments, - * `NULL`-terminated. - */ - char** restrict real_lines; - - /** - * Data for `lines` (internal data) - */ - char* content; - - /** - * Data for `real_lines` (internal data) - */ - char* real_content; - - /** - * The number of lines, that is, the number of - * elements in `lines` and `real_lines`. - */ - size_t line_count; - - /** - * The number of duplicates there are of this - * structure that shared the memory - */ - size_t duplicates; - +typedef struct mds_kbdc_source_code { + /** + * Source code by lines without comments, + * `NULL`-terminated. + */ + char **restrict lines; + + /** + * Source code by lines with comments, + * `NULL`-terminated. + */ + char **restrict real_lines; + + /** + * Data for `lines` (internal data) + */ + char *content; + + /** + * Data for `real_lines` (internal data) + */ + char *real_content; + + /** + * The number of lines, that is, the number of + * elements in `lines` and `real_lines`. + */ + size_t line_count; + + /** + * The number of duplicates there are of this + * structure that shared the memory + */ + size_t duplicates; } mds_kbdc_source_code_t; @@ -69,21 +67,21 @@ typedef struct mds_kbdc_source_code * * @param this The `mds_kbdc_source_code_t*` */ -void mds_kbdc_source_code_initialise(mds_kbdc_source_code_t* restrict this); +void mds_kbdc_source_code_initialise(mds_kbdc_source_code_t *restrict this); /** * Release all data in a `mds_kbdc_source_code_t*` * * @param this The `mds_kbdc_source_code_t*` */ -void mds_kbdc_source_code_destroy(mds_kbdc_source_code_t* restrict this); +void mds_kbdc_source_code_destroy(mds_kbdc_source_code_t *restrict this); /** * Release all data in a `mds_kbdc_source_code_t*`, and free it * * @param this The `mds_kbdc_source_code_t*` */ -void mds_kbdc_source_code_free(mds_kbdc_source_code_t* restrict this); +void mds_kbdc_source_code_free(mds_kbdc_source_code_t *restrict this); /** * Create a duplicate of a `mds_kbdc_source_code_t*` @@ -91,7 +89,7 @@ void mds_kbdc_source_code_free(mds_kbdc_source_code_t* restrict this); * @param this The `mds_kbdc_source_code_t*` * @return `this` is returned */ -mds_kbdc_source_code_t* mds_kbdc_source_code_dup(mds_kbdc_source_code_t* restrict this); +mds_kbdc_source_code_t *mds_kbdc_source_code_dup(mds_kbdc_source_code_t *restrict this); /** @@ -106,7 +104,8 @@ mds_kbdc_source_code_t* mds_kbdc_source_code_dup(mds_kbdc_source_code_t* restric * or `size` if the call do not end (that is, the code ends * prematurely), or zero if there is no function call at `offset` */ -size_t get_end_of_call(const char* restrict content, size_t offset, size_t size) __attribute__((pure)); +__attribute__((pure)) +size_t get_end_of_call(const char *restrict content, size_t offset, size_t size); /** * Read lines of a source file @@ -115,7 +114,7 @@ size_t get_end_of_call(const char* restrict content, size_t offset, size_t size) * @param source_code Output parameter for read data * @return Zero on success, -1 on error */ -int read_source_lines(const char* restrict pathname, mds_kbdc_source_code_t* restrict source_code); +int read_source_lines(const char *restrict pathname, mds_kbdc_source_code_t *restrict source_code); /** @@ -124,8 +123,7 @@ int read_source_lines(const char* restrict pathname, mds_kbdc_source_code_t* res * @param string The string * @return The string in machine-readable format, `NULL` on error */ -char* parse_raw_string(const char* restrict string); +char *parse_raw_string(const char *restrict string); #endif - diff --git a/src/mds-kbdc/simplify-tree.c b/src/mds-kbdc/simplify-tree.c index d559e2e..b3f588c 100644 --- a/src/mds-kbdc/simplify-tree.c +++ b/src/mds-kbdc/simplify-tree.c @@ -27,13 +27,13 @@ /** * This process's value for `mds_kbdc_tree_t.processed` */ -#define PROCESS_LEVEL 2 +#define PROCESS_LEVEL 2 /** * Tree type constant shortener */ -#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE +#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE /** @@ -44,9 +44,9 @@ * @param ...:const char*, ... Error description format string and arguments * @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored */ -#define NEW_ERROR(NODE, SEVERITY, ...) \ - NEW_ERROR_(result, SEVERITY, 1, (NODE)->loc_line, \ - (NODE)->loc_start, (NODE)->loc_end, 1, __VA_ARGS__) +#define NEW_ERROR(NODE, SEVERITY, ...)\ + NEW_ERROR_(result, SEVERITY, 1, (NODE)->loc_line,\ + (NODE)->loc_start, (NODE)->loc_end, 1, __VA_ARGS__) @@ -58,25 +58,25 @@ * @scope here:mds_kbdc_tree_t** Help variable that must be available for use * @scope argument:mds_kbdc_tree_t* Help variable that must be available for use */ -#define REMOVE_NOTHING(START) \ - do \ - { \ - long processed = tree->processed; \ - tree->processed = PROCESS_LEVEL; \ - for (here = &(tree->START); *here;) \ - if ((*here)->type != C(NOTHING)) \ - here = &((*here)->next); \ - else \ - while (*here && (*here)->type == C(NOTHING)) \ - { \ - argument = (*here)->next, (*here)->next = NULL; \ - if ((processed != PROCESS_LEVEL) && ((*here)->processed != PROCESS_LEVEL)) \ - NEW_ERROR(*here, WARNING, "‘.’ outside alternation has no effect"); \ - mds_kbdc_tree_free(*here); \ - *here = argument; \ - } \ - } \ - while (0) +#define REMOVE_NOTHING(START)\ + do {\ + long int processed = tree->processed;\ + tree->processed = PROCESS_LEVEL;\ + for (here = &(tree->START); *here;) {\ + if ((*here)->type != C(NOTHING)) {\ + here = &((*here)->next);\ + } else {\ + while (*here && (*here)->type == C(NOTHING)) {\ + argument = (*here)->next;\ + (*here)->next = NULL;\ + if (processed != PROCESS_LEVEL && (*here)->processed != PROCESS_LEVEL)\ + NEW_ERROR(*here, WARNING, "‘.’ outside alternation has no effect");\ + mds_kbdc_tree_free(*here);\ + *here = argument;\ + }\ + }\ + }\ + } while (0) @@ -89,38 +89,36 @@ * @scope here:mds_kbdc_tree_t** Pointer to the space where the argument was found * @scope temp:mds_kbdc_tree_t* Help variable that must be available for use */ -#define FLATTEN(argument) \ - do \ - { \ - /* Remember the alternation/subsequence and the argument that follows it. */ \ - mds_kbdc_tree_t* eliminated_argument = argument; \ - temp = argument->next; \ - /* Find the last alternative/element. */ \ - for (argument->next = argument->ordered.inner; argument->next;) \ - argument = argument->next; \ - /* Attach the argument that was after the alternation/subsequence to the */ \ - /* end of the alternation/subsequence, that is, flatten the right side. */ \ - argument->next = temp; \ - /* Flatten the left side. */ \ - *here = eliminated_argument->next; \ - /* Free the memory of the alternation/subsequence. */ \ - eliminated_argument->ordered.inner = NULL; \ - eliminated_argument->next = NULL; \ - mds_kbdc_tree_free(eliminated_argument); \ - } \ - while (0) +#define FLATTEN(argument)\ + do {\ + /* Remember the alternation/subsequence and the argument that follows it. */\ + mds_kbdc_tree_t *eliminated_argument = argument;\ + temp = argument->next;\ + /* Find the last alternative/element. */\ + for (argument->next = argument->ordered.inner; argument->next;)\ + argument = argument->next;\ + /* Attach the argument that was after the alternation/subsequence to the */\ + /* end of the alternation/subsequence, that is, flatten the right side. */\ + argument->next = temp;\ + /* Flatten the left side. */\ + *here = eliminated_argument->next;\ + /* Free the memory of the alternation/subsequence. */\ + eliminated_argument->ordered.inner = NULL;\ + eliminated_argument->next = NULL;\ + mds_kbdc_tree_free(eliminated_argument);\ + } while (0) /** * Variable whether the latest created error is stored */ -static mds_kbdc_parse_error_t* error; +static mds_kbdc_parse_error_t *error; /** * The parameter of `simplify_tree` */ -static mds_kbdc_parsed_t* restrict result; +static mds_kbdc_parsed_t *restrict result; @@ -130,7 +128,7 @@ static mds_kbdc_parsed_t* restrict result; * @param tree The tree * @return Zero on success, -1 on error */ -static int simplify(mds_kbdc_tree_t* restrict tree); +static int simplify(mds_kbdc_tree_t *restrict tree); /** * Simplify an unordered subsequence-subtree @@ -138,7 +136,7 @@ static int simplify(mds_kbdc_tree_t* restrict tree); * @param tree The unordered subsequence-subtree * @return Zero on success, -1 on error */ -static int simplify_unordered(mds_kbdc_tree_unordered_t* restrict tree); +static int simplify_unordered(mds_kbdc_tree_unordered_t *restrict tree); @@ -150,60 +148,61 @@ static int simplify_unordered(mds_kbdc_tree_unordered_t* restrict tree); * @param argument_index The index of the argument to eliminate * @return Zero on sucess, -1 on error */ -static int eliminate_alternation(mds_kbdc_tree_t* tree, mds_kbdc_tree_t* argument, size_t argument_index) +static int +eliminate_alternation(mds_kbdc_tree_t *tree, mds_kbdc_tree_t *argument, size_t argument_index) { - mds_kbdc_tree_t** here; - mds_kbdc_tree_t* first; - mds_kbdc_tree_t* last; - mds_kbdc_tree_t* new_tree; - mds_kbdc_tree_t* alternative; - mds_kbdc_tree_t* next_statement; - mds_kbdc_tree_t* next_alternative; - mds_kbdc_tree_t* new_argument; - size_t i; - int saved_errno; - - /* Detach next statement, we do not want to duplicate all following statements. */ - next_statement = tree->next, tree->next = NULL; - /* Detach alternation, we replace it in all duplcates, - no need to duplicate all alternatives. */ - alternative = argument->alternation.inner, argument->alternation.inner = NULL; - /* Eliminate. */ - for (first = last = NULL; alternative; alternative = next_alternative) - { - /* Duplicate statement. */ - fail_if (new_tree = mds_kbdc_tree_dup(tree), new_tree == NULL); - /* Join trees. */ - if (last) - last->next = new_tree; - last = new_tree; - first = first ? first : new_tree; - /* Jump to the alternation. */ - here = &(new_tree->macro_call.arguments); /* `new_tree->macro_call.arguments` and - * `new_tree->map.sequence` as the same address. */ - for (new_argument = *here, i = 0; i < argument_index; i++, here = &((*here)->next)) - new_argument = new_argument->next; - /* Detach alternative. */ - next_alternative = alternative->next; - /* Right-join alternative. */ - alternative->next = new_argument->next, new_argument->next = NULL; - mds_kbdc_tree_free(new_argument); - /* Left-join alternative. */ - *here = alternative; - } - /* Replace the statement with the first generated statement without the alternation. */ - mds_kbdc_tree_destroy((mds_kbdc_tree_t*)tree); - memcpy(tree, first, sizeof(mds_kbdc_tree_t)); - if (first == last) last = (mds_kbdc_tree_t*)tree; - free(first); - /* Reattach the statement that followed to the last generated statement. */ - last->next = next_statement; - return 0; - fail: - saved_errno = errno; - argument->alternation.inner = alternative; - tree->next = next_statement; - return errno = saved_errno, -1; + mds_kbdc_tree_t **here; + mds_kbdc_tree_t *first; + mds_kbdc_tree_t *last; + mds_kbdc_tree_t *new_tree; + mds_kbdc_tree_t *alternative; + mds_kbdc_tree_t *next_statement; + mds_kbdc_tree_t *next_alternative; + mds_kbdc_tree_t *new_argument; + size_t i; + int saved_errno; + + /* Detach next statement, we do not want to duplicate all following statements. */ + next_statement = tree->next, tree->next = NULL; + /* Detach alternation, we replace it in all duplcates, + no need to duplicate all alternatives. */ + alternative = argument->alternation.inner, argument->alternation.inner = NULL; + /* Eliminate. */ + for (first = last = NULL; alternative; alternative = next_alternative) { + /* Duplicate statement. */ + fail_if (!(new_tree = mds_kbdc_tree_dup(tree))); + /* Join trees. */ + if (last) + last->next = new_tree; + last = new_tree; + first = first ? first : new_tree; + /* Jump to the alternation. */ + here = &(new_tree->macro_call.arguments); /* `new_tree->macro_call.arguments` and + * `new_tree->map.sequence` as the same address. */ + for (new_argument = *here, i = 0; i < argument_index; i++, here = &((*here)->next)) + new_argument = new_argument->next; + /* Detach alternative. */ + next_alternative = alternative->next; + /* Right-join alternative. */ + alternative->next = new_argument->next, new_argument->next = NULL; + mds_kbdc_tree_free(new_argument); + /* Left-join alternative. */ + *here = alternative; + } + /* Replace the statement with the first generated statement without the alternation. */ + mds_kbdc_tree_destroy((mds_kbdc_tree_t*)tree); + memcpy(tree, first, sizeof(mds_kbdc_tree_t)); + if (first == last) + last = (mds_kbdc_tree_t*)tree; + free(first); + /* Reattach the statement that followed to the last generated statement. */ + last->next = next_statement; + return 0; +fail: + saved_errno = errno; + argument->alternation.inner = alternative; + tree->next = next_statement; + return errno = saved_errno, -1; } @@ -213,118 +212,119 @@ static int eliminate_alternation(mds_kbdc_tree_t* tree, mds_kbdc_tree_t* argumen * @param tree The macro call-subtree * @return Zero on success, -1 on error */ -static int simplify_macro_call(mds_kbdc_tree_macro_call_t* restrict tree) +static int +simplify_macro_call(mds_kbdc_tree_macro_call_t *restrict tree) { - mds_kbdc_tree_t* argument; - mds_kbdc_tree_t* dup_arguments = NULL; - mds_kbdc_tree_t** here; - char* full_macro_name; - size_t argument_index = 0; - int saved_errno; - - /* Simplify arguments. */ - for (argument = tree->arguments; argument; argument = argument->next) - fail_if (simplify(argument)); - - /* Remove ‘.’:s. */ - REMOVE_NOTHING(arguments); - - /* Copy arguments. */ - if (tree->arguments == NULL) - goto no_args; - fail_if (dup_arguments = mds_kbdc_tree_dup(tree->arguments), dup_arguments == NULL); - - /* Eliminate alterations. */ - for (argument = dup_arguments; argument; argument = argument->next, argument_index++) - if (argument->type == C(ALTERNATION)) - fail_if (eliminate_alternation((mds_kbdc_tree_t*)tree, argument, argument_index)); - mds_kbdc_tree_free(dup_arguments), dup_arguments = NULL; - - /* Add argument count suffix. */ - no_args: - for (argument_index = 0, argument = tree->arguments; argument; argument = argument->next) - argument_index++; - fail_if (xasprintf(full_macro_name, "%s/%zu", tree->name, argument_index)); - free(tree->name), tree->name = full_macro_name; - - /* Example of what will happend: - * - * my_macro([1 2] [1 2] [1 2]) ## call 1 - * - * simplify_macro_call on call 1 - * after processing argument 1 - * my_macro(1 [1 2] [1 2]) ## call 1 - * my_macro(2 [1 2] [1 2]) ## call 5 - * after processing argument 2 - * my_macro(1 1 [1 2]) ## call 1 - * my_macro(1 2 [1 2]) ## call 3 - * my_macro(2 [1 2] [1 2]) ## call 5 - * after processing argument 3 - * my_macro(1 1 1) ## call 1 - * my_macro(1 1 2) ## call 2 - * my_macro(1 2 [1 2]) ## call 3 - * my_macro(2 [1 2] [1 2]) ## call 5 - * - * no difference after simplify_macro_call on call 2 - * - * simplify_macro_call on call 3 - * no difference after processing argument 1 - * no difference after processing argument 2 - * after processing argument 3 - * my_macro(1 1 1) ## (call 1) - * my_macro(1 1 2) ## (call 2) - * my_macro(1 2 1) ## call 3 - * my_macro(1 2 1) ## call 4 - * my_macro(2 [1 2] [1 2]) ## call 5 - * - * no difference after simplify_macro_call on call 4 - * - * simplify_macro_call on call 5 - * no difference after processing argument 1 - * after processing argument 2 - * my_macro(1 1 1) ## (call 1) - * my_macro(1 1 2) ## (call 2) - * my_macro(1 2 1) ## (call 3) - * my_macro(1 2 2) ## (call 4) - * my_macro(2 1 [1 2]) ## call 5 - * my_macro(2 2 [1 2]) ## call 7 - * after processing argument 3 - * my_macro(1 1 1) ## (call 1) - * my_macro(1 1 2) ## (call 2) - * my_macro(1 2 1) ## (call 3) - * my_macro(1 2 2) ## (call 4) - * my_macro(2 1 1) ## call 5 - * my_macro(2 1 2) ## call 6 - * my_macro(2 2 [1 2]) ## call 7 - * - * no difference after simplify_macro_call on call 6 - * - * simplify_macro_call on call 7 - * no difference after processing argument 1 - * no difference after processing argument 2 - * after processing argument 3 - * my_macro(1 1 1) ## (call 1) - * my_macro(1 1 2) ## (call 2) - * my_macro(1 2 1) ## (call 3) - * my_macro(1 2 2) ## (call 4) - * my_macro(2 1 1) ## (call 5) - * my_macro(2 1 2) ## (call 6) - * my_macro(2 2 1) ## call 7 - * my_macro(2 2 2) ## call 8 - * - * no difference after simplify_macro_call on call 8 - * - * Nothings (‘.’) are removed before processing the alternations. - * - * It should also be noticed that all macro names are update to - * with the argument count suffix. - */ - - return 0; - fail: - saved_errno = errno; - mds_kbdc_tree_free(dup_arguments); - return errno = saved_errno, -1; + mds_kbdc_tree_t *argument; + mds_kbdc_tree_t *dup_arguments = NULL; + mds_kbdc_tree_t **here; + char *full_macro_name; + size_t argument_index = 0; + int saved_errno; + + /* Simplify arguments. */ + for (argument = tree->arguments; argument; argument = argument->next) + fail_if (simplify(argument)); + + /* Remove ‘.’:s. */ + REMOVE_NOTHING(arguments); + + /* Copy arguments. */ + if (!tree->arguments) + goto no_args; + fail_if (!(dup_arguments = mds_kbdc_tree_dup(tree->arguments))); + + /* Eliminate alterations. */ + for (argument = dup_arguments; argument; argument = argument->next, argument_index++) + if (argument->type == C(ALTERNATION)) + fail_if (eliminate_alternation((mds_kbdc_tree_t*)tree, argument, argument_index)); + mds_kbdc_tree_free(dup_arguments), dup_arguments = NULL; + + /* Add argument count suffix. */ +no_args: + for (argument_index = 0, argument = tree->arguments; argument; argument = argument->next) + argument_index++; + fail_if (xasprintf(full_macro_name, "%s/%zu", tree->name, argument_index)); + free(tree->name), tree->name = full_macro_name; + + /* Example of what will happend: + * + * my_macro([1 2] [1 2] [1 2]) ## call 1 + * + * simplify_macro_call on call 1 + * after processing argument 1 + * my_macro(1 [1 2] [1 2]) ## call 1 + * my_macro(2 [1 2] [1 2]) ## call 5 + * after processing argument 2 + * my_macro(1 1 [1 2]) ## call 1 + * my_macro(1 2 [1 2]) ## call 3 + * my_macro(2 [1 2] [1 2]) ## call 5 + * after processing argument 3 + * my_macro(1 1 1) ## call 1 + * my_macro(1 1 2) ## call 2 + * my_macro(1 2 [1 2]) ## call 3 + * my_macro(2 [1 2] [1 2]) ## call 5 + * + * no difference after simplify_macro_call on call 2 + * + * simplify_macro_call on call 3 + * no difference after processing argument 1 + * no difference after processing argument 2 + * after processing argument 3 + * my_macro(1 1 1) ## (call 1) + * my_macro(1 1 2) ## (call 2) + * my_macro(1 2 1) ## call 3 + * my_macro(1 2 1) ## call 4 + * my_macro(2 [1 2] [1 2]) ## call 5 + * + * no difference after simplify_macro_call on call 4 + * + * simplify_macro_call on call 5 + * no difference after processing argument 1 + * after processing argument 2 + * my_macro(1 1 1) ## (call 1) + * my_macro(1 1 2) ## (call 2) + * my_macro(1 2 1) ## (call 3) + * my_macro(1 2 2) ## (call 4) + * my_macro(2 1 [1 2]) ## call 5 + * my_macro(2 2 [1 2]) ## call 7 + * after processing argument 3 + * my_macro(1 1 1) ## (call 1) + * my_macro(1 1 2) ## (call 2) + * my_macro(1 2 1) ## (call 3) + * my_macro(1 2 2) ## (call 4) + * my_macro(2 1 1) ## call 5 + * my_macro(2 1 2) ## call 6 + * my_macro(2 2 [1 2]) ## call 7 + * + * no difference after simplify_macro_call on call 6 + * + * simplify_macro_call on call 7 + * no difference after processing argument 1 + * no difference after processing argument 2 + * after processing argument 3 + * my_macro(1 1 1) ## (call 1) + * my_macro(1 1 2) ## (call 2) + * my_macro(1 2 1) ## (call 3) + * my_macro(1 2 2) ## (call 4) + * my_macro(2 1 1) ## (call 5) + * my_macro(2 1 2) ## (call 6) + * my_macro(2 2 1) ## call 7 + * my_macro(2 2 2) ## call 8 + * + * no difference after simplify_macro_call on call 8 + * + * Nothings (‘.’) are removed before processing the alternations. + * + * It should also be noticed that all macro names are update to + * with the argument count suffix. + */ + + return 0; +fail: + saved_errno = errno; + mds_kbdc_tree_free(dup_arguments); + return errno = saved_errno, -1; } @@ -334,26 +334,27 @@ static int simplify_macro_call(mds_kbdc_tree_macro_call_t* restrict tree) * @param tree The value statement-tree * @return Zero on success, -1 on error */ -static int check_value_statement_before_simplification(mds_kbdc_tree_map_t* restrict tree) +static int +check_value_statement_before_simplification(mds_kbdc_tree_map_t *restrict tree) { - again: - /* Check for alternation. */ - if ((tree->sequence->type == C(ALTERNATION)) && (tree->processed != PROCESS_LEVEL)) - NEW_ERROR(tree->sequence, WARNING, - "alternated value statement is undefined unless the alternatives are identical"); - - /* Check for unordered. */ - if (tree->sequence->type != C(UNORDERED)) - return 0; - if (tree->processed != PROCESS_LEVEL) - NEW_ERROR(tree->sequence, WARNING, "use of sequence in value statement is discouraged"); - - /* Simplify argument and start over. */ - fail_if (simplify(tree->sequence)); - goto again; - - fail: - return -1; +again: + /* Check for alternation. */ + if (tree->sequence->type == C(ALTERNATION) && tree->processed != PROCESS_LEVEL) + NEW_ERROR(tree->sequence, WARNING, + "alternated value statement is undefined unless the alternatives are identical"); + + /* Check for unordered. */ + if (tree->sequence->type != C(UNORDERED)) + return 0; + if (tree->processed != PROCESS_LEVEL) + NEW_ERROR(tree->sequence, WARNING, "use of sequence in value statement is discouraged"); + + /* Simplify argument and start over. */ + fail_if (simplify(tree->sequence)); + goto again; + +fail: + return -1; } @@ -363,19 +364,20 @@ static int check_value_statement_before_simplification(mds_kbdc_tree_map_t* rest * @param tree The value statement-tree * @return Zero on success, -1 on error */ -static int check_value_statement_after_simplification(mds_kbdc_tree_map_t* restrict tree) +static int +check_value_statement_after_simplification(mds_kbdc_tree_map_t *restrict tree) { - /* Check that there is only one value. */ - if (tree->sequence->next) - NEW_ERROR(tree->sequence->next, ERROR, "more the one value in value statement"); - - /* Check the type of the value */ - if (tree->sequence->type != C(STRING)) - NEW_ERROR(tree->sequence, ERROR, "bad value type"); - - return 0; - fail: - return -1; + /* Check that there is only one value. */ + if (tree->sequence->next) + NEW_ERROR(tree->sequence->next, ERROR, "more the one value in value statement"); + + /* Check the type of the value */ + if (tree->sequence->type != C(STRING)) + NEW_ERROR(tree->sequence, ERROR, "bad value type"); + + return 0; +fail: + return -1; } @@ -385,155 +387,154 @@ static int check_value_statement_after_simplification(mds_kbdc_tree_map_t* restr * @param tree The mapping-subtree * @return Zero on success, -1 on error */ -static int simplify_map(mds_kbdc_tree_map_t* restrict tree) +static int +simplify_map(mds_kbdc_tree_map_t *restrict tree) { - mds_kbdc_tree_t* argument; - mds_kbdc_tree_t** here; - mds_kbdc_tree_t* dup_sequence = NULL; - mds_kbdc_tree_t* temp; - size_t argument_index; - int redo = 0, need_reelimination, saved_errno; - - /* Check for bad things in the result. */ - for (argument = tree->result; argument; argument = argument->next) - if ((argument->type != C(KEYS)) && (argument->type != C(STRING))) - NEW_ERROR(argument, ERROR, "not allowed in mapping output"); - - /* Valid value properties. */ - if (tree->result == NULL) - fail_if (check_value_statement_before_simplification(tree)); - - /* Simplify sequence. */ - for (argument = tree->sequence; argument; argument = argument->next) - fail_if (simplify(argument)); - - /* Test predicted emptyness. */ - for (argument = tree->sequence; argument; argument = argument->next) - if (argument->type != C(NOTHING)) - goto will_not_be_empty; - if (tree->sequence->processed != PROCESS_LEVEL) - { - if (tree->result) - NEW_ERROR(tree->sequence, ERROR, "mapping of null sequence"); - else - NEW_ERROR(tree->sequence, ERROR, "nothing in value statement"); - } - /* The tree parsing process will not allow a mapping statement - * to start with a ‘.’. Thus if we select to highlight it we - * know that it is either an empty alternation, an empty - * unordered subsequence or a nothing inside an alternation. - * If it is already been processed by the simplifier, it is an - * error because it is an empty alternation or empty unordered - * subsequence, and there is not reason to print an additional - * error. If however it is a nothing inside an alternation we - * know that it is the cause of the error, however possibily - * in conjunction with additional such constructs, but those - * are harder to locate. */ - return 0; - will_not_be_empty: - - /* Remove ‘.’:s. */ - REMOVE_NOTHING(sequence); - - /* Because unordered are simplified to alternations of ordered subsequences, which - in turn can contain alternations, possibiled from simplification of nested - unordered sequenceses, we need to reeliminated until there are not alternations. */ - for (need_reelimination = 1; need_reelimination ? (need_reelimination = 0, 1) : 0; redo = 0) - { - /* Copy sequence. */ - fail_if (dup_sequence = mds_kbdc_tree_dup(tree->sequence), dup_sequence == NULL); - - /* Eliminate alterations, remember, unordered subsequences have - been simplified to alternations of ordered subsequences. */ - for (argument_index = 0, argument = dup_sequence; argument; argument = argument->next, argument_index++) - if (argument->type == C(ALTERNATION)) - fail_if (eliminate_alternation((mds_kbdc_tree_t*)tree, argument, argument_index)); - - mds_kbdc_tree_free(dup_sequence), dup_sequence = NULL; - - /* Eliminated ordered subsequences. */ - for (here = &(tree->sequence); (argument = *here); redo ? (redo = 0) : (here = &(argument->next), 0)) - if (argument->type == C(ORDERED)) - { - FLATTEN(argument); - redo = 1; - } - else if (argument->type == C(ALTERNATION)) - need_reelimination = 1; - } - - /* Valid value properties. */ - if (tree->result == NULL) - fail_if (check_value_statement_after_simplification(tree)); - - /* Mapping statements are simplified in a manner similar - * to how macro calls are simplified. However mapping - * statements can also contain unordered subsequences, - * there are translated into alternations of ordered - * subsequences. Thus after the elimination of alternations, - * ordered subsequences are eliminated too. - * - * Example of what will happen, ‘{ }’ represents an - * ordered subsequence: - * - * (1 2) (3 4) : 0 ## mapping 1 - * - * simplify_map on mapping 1 - * after simplification - * [{1 2} {2 1}] [{3 4} {4 3}] ## mapping 1 - * after alternation elimination on argument 1 - * {1 2} [{3 4} {4 3}] ## mapping 1 - * {2 1} [{3 4} {4 3}] ## mapping 3 - * after alternation elimination on argument 2 - * {1 2} {3 4} ## mapping 1 - * {1 2} {4 3} ## mapping 2 - * {2 1} [{3 4} {4 3}] ## mapping 3 - * after ordered subsequence elimination - * 1 2 3 4 ## mapping 1 - * {1 2} {4 3} ## mapping 2 - * {2 1} [{3 4} {4 3}] ## mapping 3 - * - * simplify_map on mapping 2 - * no difference after simplification - * no difference after alternation elimination on argument 1 - * no difference after alternation elimination on argument 2 - * after ordered subsequence elimination - * 1 2 3 4 ## (mapping 1) - * 1 2 4 3 ## mapping 2 - * {2 1} [{3 4} {4 3}] ## mapping 3 - * - * simplify_map on mapping 3 - * no difference after simplification - * no difference after alternation elimination on argument 1 - * after alternation elimination on argument 2 - * 1 2 3 4 ## (mapping 1) - * 1 2 4 3 ## (mapping 2) - * {2 1} {3 4} ## mapping 3 - * {2 1} {4 3} ## mapping 4 - * after ordered subsequence elimination - * 1 2 3 4 ## (mapping 1) - * 1 2 4 3 ## (mapping 2) - * 2 1 3 4 ## mapping 3 - * {2 1} {4 3} ## mapping 4 - * - * simplify_map on mapping 4 - * no difference after simplification - * no difference after alternation elimination on argument 1 - * no difference after alternation elimination on argument 2 - * after ordered subsequence elimination - * 1 2 3 4 ## (mapping 1) - * 1 2 4 3 ## (mapping 2) - * 2 1 3 4 ## (mapping 3) - * 2 1 4 3 ## mapping 4 - * - * Nothings (‘.’) are removed before processing the alternations. - */ - - return 0; - fail: - saved_errno = errno; - mds_kbdc_tree_free(dup_sequence); - return errno = saved_errno, -1; + mds_kbdc_tree_t *argument; + mds_kbdc_tree_t **here; + mds_kbdc_tree_t *dup_sequence = NULL; + mds_kbdc_tree_t *temp; + size_t argument_index; + int redo = 0, need_reelimination, saved_errno; + + /* Check for bad things in the result. */ + for (argument = tree->result; argument; argument = argument->next) + if (argument->type != C(KEYS) && argument->type != C(STRING)) + NEW_ERROR(argument, ERROR, "not allowed in mapping output"); + + /* Valid value properties. */ + if (!tree->result) + fail_if (check_value_statement_before_simplification(tree)); + + /* Simplify sequence. */ + for (argument = tree->sequence; argument; argument = argument->next) + fail_if (simplify(argument)); + + /* Test predicted emptyness. */ + for (argument = tree->sequence; argument; argument = argument->next) + if (argument->type != C(NOTHING)) + goto will_not_be_empty; + if (tree->sequence->processed != PROCESS_LEVEL) { + if (tree->result) + NEW_ERROR(tree->sequence, ERROR, "mapping of null sequence"); + else + NEW_ERROR(tree->sequence, ERROR, "nothing in value statement"); + } + /* The tree parsing process will not allow a mapping statement + * to start with a ‘.’. Thus if we select to highlight it we + * know that it is either an empty alternation, an empty + * unordered subsequence or a nothing inside an alternation. + * If it is already been processed by the simplifier, it is an + * error because it is an empty alternation or empty unordered + * subsequence, and there is not reason to print an additional + * error. If however it is a nothing inside an alternation we + * know that it is the cause of the error, however possibily + * in conjunction with additional such constructs, but those + * are harder to locate. */ + return 0; +will_not_be_empty: + + /* Remove ‘.’:s. */ + REMOVE_NOTHING(sequence); + + /* Because unordered are simplified to alternations of ordered subsequences, which + in turn can contain alternations, possibiled from simplification of nested + unordered sequenceses, we need to reeliminated until there are not alternations. */ + for (need_reelimination = 1; need_reelimination ? (need_reelimination = 0, 1) : 0; redo = 0) { + /* Copy sequence. */ + fail_if (!(dup_sequence = mds_kbdc_tree_dup(tree->sequence))); + + /* Eliminate alterations, remember, unordered subsequences have + been simplified to alternations of ordered subsequences. */ + for (argument_index = 0, argument = dup_sequence; argument; argument = argument->next, argument_index++) + if (argument->type == C(ALTERNATION)) + fail_if (eliminate_alternation((mds_kbdc_tree_t*)tree, argument, argument_index)); + + mds_kbdc_tree_free(dup_sequence), dup_sequence = NULL; + + /* Eliminated ordered subsequences. */ + for (here = &(tree->sequence); (argument = *here); redo ? (redo = 0) : (here = &(argument->next), 0)) { + if (argument->type == C(ORDERED)) { + FLATTEN(argument); + redo = 1; + } else if (argument->type == C(ALTERNATION)) { + need_reelimination = 1; + } + } + } + + /* Valid value properties. */ + if (!tree->result) + fail_if (check_value_statement_after_simplification(tree)); + + /* Mapping statements are simplified in a manner similar + * to how macro calls are simplified. However mapping + * statements can also contain unordered subsequences, + * there are translated into alternations of ordered + * subsequences. Thus after the elimination of alternations, + * ordered subsequences are eliminated too. + * + * Example of what will happen, ‘{ }’ represents an + * ordered subsequence: + * + * (1 2) (3 4) : 0 ## mapping 1 + * + * simplify_map on mapping 1 + * after simplification + * [{1 2} {2 1}] [{3 4} {4 3}] ## mapping 1 + * after alternation elimination on argument 1 + * {1 2} [{3 4} {4 3}] ## mapping 1 + * {2 1} [{3 4} {4 3}] ## mapping 3 + * after alternation elimination on argument 2 + * {1 2} {3 4} ## mapping 1 + * {1 2} {4 3} ## mapping 2 + * {2 1} [{3 4} {4 3}] ## mapping 3 + * after ordered subsequence elimination + * 1 2 3 4 ## mapping 1 + * {1 2} {4 3} ## mapping 2 + * {2 1} [{3 4} {4 3}] ## mapping 3 + * + * simplify_map on mapping 2 + * no difference after simplification + * no difference after alternation elimination on argument 1 + * no difference after alternation elimination on argument 2 + * after ordered subsequence elimination + * 1 2 3 4 ## (mapping 1) + * 1 2 4 3 ## mapping 2 + * {2 1} [{3 4} {4 3}] ## mapping 3 + * + * simplify_map on mapping 3 + * no difference after simplification + * no difference after alternation elimination on argument 1 + * after alternation elimination on argument 2 + * 1 2 3 4 ## (mapping 1) + * 1 2 4 3 ## (mapping 2) + * {2 1} {3 4} ## mapping 3 + * {2 1} {4 3} ## mapping 4 + * after ordered subsequence elimination + * 1 2 3 4 ## (mapping 1) + * 1 2 4 3 ## (mapping 2) + * 2 1 3 4 ## mapping 3 + * {2 1} {4 3} ## mapping 4 + * + * simplify_map on mapping 4 + * no difference after simplification + * no difference after alternation elimination on argument 1 + * no difference after alternation elimination on argument 2 + * after ordered subsequence elimination + * 1 2 3 4 ## (mapping 1) + * 1 2 4 3 ## (mapping 2) + * 2 1 3 4 ## (mapping 3) + * 2 1 4 3 ## mapping 4 + * + * Nothings (‘.’) are removed before processing the alternations. + */ + + return 0; +fail: + saved_errno = errno; + mds_kbdc_tree_free(dup_sequence); + return errno = saved_errno, -1; } @@ -543,69 +544,63 @@ static int simplify_map(mds_kbdc_tree_map_t* restrict tree) * @param tree The alternation-subtree * @return Zero on success, -1 on error */ -static int simplify_alternation(mds_kbdc_tree_alternation_t* restrict tree) +static int +simplify_alternation(mds_kbdc_tree_alternation_t *restrict tree) { - mds_kbdc_tree_t* argument; - mds_kbdc_tree_t* first_nothing = NULL; - mds_kbdc_tree_t* temp; - mds_kbdc_tree_t** here; - int redo = 0; - - /* Test emptyness. */ - if (tree->inner == NULL) - { - NEW_ERROR(tree, ERROR, "empty alternation"); - tree->type = C(NOTHING); - tree->processed = PROCESS_LEVEL; - return 0; - } - - /* Test singletonness. */ - if (tree->inner->next == NULL) - { - temp = tree->inner; - NEW_ERROR(tree, WARNING, "singleton alternation"); - memcpy(tree, temp, sizeof(mds_kbdc_tree_t)); - free(temp); - fail_if (simplify((mds_kbdc_tree_t*)tree)); - return 0; - } - - /* Simplify. */ - for (here = &(tree->inner); (argument = *here); redo ? (redo = 0) : (here = &(argument->next), 0)) - if ((argument->type == C(NOTHING)) && (argument->processed != PROCESS_LEVEL)) - { - /* Test multiple nothings. */ - if (first_nothing == NULL) - first_nothing = argument; - else - { - NEW_ERROR(argument, WARNING, "multiple ‘.’ inside an alternation"); - NEW_ERROR(first_nothing, NOTE, "first ‘.’ was here"); - } - } - else if (argument->type == C(ALTERNATION)) - { - /* Alternation nesting. */ - if (argument->processed != PROCESS_LEVEL) - NEW_ERROR(argument, WARNING, "alternation inside alternation is unnessary"); - fail_if (simplify_alternation(&(argument->alternation))); - if (argument->type == C(ALTERNATION)) - FLATTEN(argument); - redo = 1; - } - else if (argument->type == C(UNORDERED)) - { - /* Nesting unordered subsequence, - simplifies to alternation of ordered subsequence, or simpler. */ - NEW_ERROR(argument, WARNING, "unordered subsequence inside alternation is discouraged"); - fail_if (simplify_unordered(&(argument->unordered))); - redo = 1; - } - - return 0; - fail: - return -1; + mds_kbdc_tree_t *argument; + mds_kbdc_tree_t *first_nothing = NULL; + mds_kbdc_tree_t *temp; + mds_kbdc_tree_t **here; + int redo = 0; + + /* Test emptyness. */ + if (!tree->inner) { + NEW_ERROR(tree, ERROR, "empty alternation"); + tree->type = C(NOTHING); + tree->processed = PROCESS_LEVEL; + return 0; + } + + /* Test singletonness. */ + if (!tree->inner->next) { + temp = tree->inner; + NEW_ERROR(tree, WARNING, "singleton alternation"); + memcpy(tree, temp, sizeof(mds_kbdc_tree_t)); + free(temp); + fail_if (simplify((mds_kbdc_tree_t*)tree)); + return 0; + } + + /* Simplify. */ + for (here = &(tree->inner); (argument = *here); redo ? (redo = 0) : (here = &(argument->next), 0)) { + if (argument->type == C(NOTHING) && argument->processed != PROCESS_LEVEL) { + /* Test multiple nothings. */ + if (!first_nothing) { + first_nothing = argument; + } else{ + NEW_ERROR(argument, WARNING, "multiple ‘.’ inside an alternation"); + NEW_ERROR(first_nothing, NOTE, "first ‘.’ was here"); + } + } else if (argument->type == C(ALTERNATION)) { + /* Alternation nesting. */ + if (argument->processed != PROCESS_LEVEL) + NEW_ERROR(argument, WARNING, "alternation inside alternation is unnessary"); + fail_if (simplify_alternation(&(argument->alternation))); + if (argument->type == C(ALTERNATION)) + FLATTEN(argument); + redo = 1; + } else if (argument->type == C(UNORDERED)) { + /* Nesting unordered subsequence, + simplifies to alternation of ordered subsequence, or simpler. */ + NEW_ERROR(argument, WARNING, "unordered subsequence inside alternation is discouraged"); + fail_if (simplify_unordered(&(argument->unordered))); + redo = 1; + } + } + + return 0; +fail: + return -1; } @@ -616,77 +611,75 @@ static int simplify_alternation(mds_kbdc_tree_alternation_t* restrict tree) * @param elements The subtrees, chained * @return Chain of ordered subsequence, `NULL` on error */ -static mds_kbdc_tree_t* create_permutations(mds_kbdc_tree_t* elements) +static mds_kbdc_tree_t * +create_permutations(mds_kbdc_tree_t *elements) { - mds_kbdc_tree_t* first = NULL; - mds_kbdc_tree_t** here = &first; - mds_kbdc_tree_t** previous_next = &elements; - mds_kbdc_tree_t* argument; - mds_kbdc_tree_t* temp; - mds_kbdc_tree_t* subperms = NULL; - mds_kbdc_tree_t* perm; - mds_kbdc_tree_t ordered; - int saved_errno, no_perms, stage = 0; - - /* Error case. */ - fail_if (elements == NULL); - - /* Base case. */ - if (elements->next == NULL) - { - fail_if ((first = mds_kbdc_tree_create(C(ORDERED))) == NULL); - fail_if ((first->ordered.inner = mds_kbdc_tree_dup(elements)) == NULL); - return first; - } - - stage++; - for (previous_next = &elements; (argument = *previous_next); previous_next = &((*previous_next)->next)) - { - /* Created ordered alternative for a permutation prototype. */ - mds_kbdc_tree_initialise(&ordered, C(ORDERED)); - /* Select the first element. */ - temp = argument->next, argument->next = NULL; - ordered.ordered.inner = mds_kbdc_tree_dup(argument); - argument->next = temp; - fail_if (ordered.ordered.inner == NULL); - /* Create subpermutations. */ - *previous_next = argument->next; - argument->next = NULL; - no_perms = (elements == NULL); - subperms = create_permutations(elements); - argument->next = *previous_next; - *previous_next = argument; - fail_if (no_perms ? 0 : (subperms == NULL)); - /* Join first element with subpermutations. */ - while (subperms) - { - /* Join. */ - fail_if (perm = mds_kbdc_tree_dup(&ordered), perm == NULL); - perm->ordered.inner->next = subperms->ordered.inner; - subperms->ordered.inner = NULL; - /* Add the permutation to the chain. */ - *here = perm; - here = &(perm->next); - /* Select next permutation. */ - temp = subperms; - subperms = subperms->next; - temp->next = NULL; - mds_kbdc_tree_free(temp); + mds_kbdc_tree_t *first = NULL; + mds_kbdc_tree_t **here = &first; + mds_kbdc_tree_t **previous_next = &elements; + mds_kbdc_tree_t *argument; + mds_kbdc_tree_t *temp; + mds_kbdc_tree_t *subperms = NULL; + mds_kbdc_tree_t *perm; + mds_kbdc_tree_t ordered; + int saved_errno, no_perms, stage = 0; + + /* Error case. */ + fail_if (!elements); + + /* Base case. */ + if (!elements->next) { + fail_if (!(first = mds_kbdc_tree_create(C(ORDERED)))); + fail_if (!(first->ordered.inner = mds_kbdc_tree_dup(elements))); + return first; } - /* Destroy prototype. */ - mds_kbdc_tree_destroy(&ordered); - } - - return first; - - fail: - saved_errno = errno; - mds_kbdc_tree_free(first); - mds_kbdc_tree_free(subperms); - if (stage > 0) - mds_kbdc_tree_destroy(&ordered); - errno = saved_errno; - return NULL; + + stage++; + for (previous_next = &elements; (argument = *previous_next); previous_next = &(*previous_next)->next) { + /* Created ordered alternative for a permutation prototype. */ + mds_kbdc_tree_initialise(&ordered, C(ORDERED)); + /* Select the first element. */ + temp = argument->next, argument->next = NULL; + ordered.ordered.inner = mds_kbdc_tree_dup(argument); + argument->next = temp; + fail_if (!ordered.ordered.inner); + /* Create subpermutations. */ + *previous_next = argument->next; + argument->next = NULL; + no_perms = !elements; + subperms = create_permutations(elements); + argument->next = *previous_next; + *previous_next = argument; + fail_if (no_perms && !subperms); + /* Join first element with subpermutations. */ + while (subperms) { + /* Join. */ + fail_if (!(perm = mds_kbdc_tree_dup(&ordered))); + perm->ordered.inner->next = subperms->ordered.inner; + subperms->ordered.inner = NULL; + /* Add the permutation to the chain. */ + *here = perm; + here = &perm->next; + /* Select next permutation. */ + temp = subperms; + subperms = subperms->next; + temp->next = NULL; + mds_kbdc_tree_free(temp); + } + /* Destroy prototype. */ + mds_kbdc_tree_destroy(&ordered); + } + + return first; + +fail: + saved_errno = errno; + mds_kbdc_tree_free(first); + mds_kbdc_tree_free(subperms); + if (stage > 0) + mds_kbdc_tree_destroy(&ordered); + errno = saved_errno; + return NULL; } @@ -696,105 +689,97 @@ static mds_kbdc_tree_t* create_permutations(mds_kbdc_tree_t* elements) * @param tree The unordered subsequence-subtree * @return Zero on success, -1 on error */ -static int simplify_unordered(mds_kbdc_tree_unordered_t* restrict tree) +static int +simplify_unordered(mds_kbdc_tree_unordered_t *restrict tree) { - mds_kbdc_tree_t* arguments; - mds_kbdc_tree_t* argument; - mds_kbdc_tree_t* temp; - mds_kbdc_tree_t** here; - int allow_long = 0; - size_t argument_count; - - /* Test for ‘(( ))’. */ - if (tree->inner && (tree->inner->next == NULL) && (tree->inner->type == C(UNORDERED))) - { - tree->loc_end = tree->inner->loc_end; - temp = tree->inner; - tree->inner = tree->inner->unordered.inner; - temp->unordered.inner = NULL; - mds_kbdc_tree_free(temp); - allow_long = 1; - } - - /* Test emptyness. */ - if (tree->inner == NULL) - { - NEW_ERROR(tree, ERROR, "empty unordered subsequence"); - tree->type = C(NOTHING); - tree->processed = PROCESS_LEVEL; - return 0; - } - - /* Test singletonness. */ - if (tree->inner->next == NULL) - { - temp = tree->inner; - NEW_ERROR(tree, WARNING, "singleton unordered subsequence"); - memcpy(tree, temp, sizeof(mds_kbdc_tree_t)); - free(temp); - fail_if (simplify((mds_kbdc_tree_t*)tree)); - return -1; - } - - /* Remove ‘.’:s. */ - REMOVE_NOTHING(inner); - - /* Check that the sequnced contained anything else. */ - if (tree->inner == NULL) - { - NEW_ERROR(tree, ERROR, "unordered subsequence contained nothing else than ‘.’"); - tree->type = C(NOTHING); - tree->processed = PROCESS_LEVEL; - return 0; - } - - /* Simplify. */ - for (argument = tree->inner, argument_count = 0; argument; argument = argument->next, argument_count++) - if (argument->type == C(ALTERNATION)) - { - fail_if (simplify_alternation(&(argument->alternation))); - argument->processed = PROCESS_LEVEL; - } - else if (argument->type == C(UNORDERED)) - { - NEW_ERROR(argument, WARNING, "unordered subsequence inside unordered subsequence is discouraged"); - fail_if (simplify_unordered(&(argument->unordered))); - argument->processed = PROCESS_LEVEL; - } - - /* Check the size of the subsequence. */ - if ((argument_count > 5) && (allow_long * argv_force == 0)) - { - if (allow_long == 0) - NEW_ERROR(tree->inner, ERROR, - "unordered subsequence longer than 5 elements need double brackets"); - else if (argv_force == 0) - NEW_ERROR(tree->inner, ERROR, - "unordered subsequence of size %zu found, requires ‘--force’ to compile", argument_count); - return 0; - } - - /* Generate permutations. */ - tree->type = C(ALTERNATION); - tree->processed = PROCESS_LEVEL; - arguments = tree->inner; - if (tree->inner = create_permutations(arguments), tree->inner == NULL) - { - if (errno == 0) - { - /* `create_permutations` can return `NULL` without setting `errno` - * if it does not list any permutations. */ - NEW_ERROR_(result, INTERNAL_ERROR, 0, 0, 0, 0, 1, - "Fail to create permutations of an unordered sequence"); - return 0; + mds_kbdc_tree_t *arguments; + mds_kbdc_tree_t *argument; + mds_kbdc_tree_t *temp; + mds_kbdc_tree_t **here; + int allow_long = 0; + size_t argument_count; + + /* Test for ‘(( ))’. */ + if (tree->inner && !tree->inner->next && tree->inner->type == C(UNORDERED)) { + tree->loc_end = tree->inner->loc_end; + temp = tree->inner; + tree->inner = tree->inner->unordered.inner; + temp->unordered.inner = NULL; + mds_kbdc_tree_free(temp); + allow_long = 1; } - fail_if (tree->inner = arguments, 1); - } - mds_kbdc_tree_free(arguments); - - return 0; - fail: - return -1; + + /* Test emptyness. */ + if (!tree->inner) { + NEW_ERROR(tree, ERROR, "empty unordered subsequence"); + tree->type = C(NOTHING); + tree->processed = PROCESS_LEVEL; + return 0; + } + + /* Test singletonness. */ + if (!tree->inner->next) { + temp = tree->inner; + NEW_ERROR(tree, WARNING, "singleton unordered subsequence"); + memcpy(tree, temp, sizeof(mds_kbdc_tree_t)); + free(temp); + fail_if (simplify((mds_kbdc_tree_t*)tree)); + return -1; + } + + /* Remove ‘.’:s. */ + REMOVE_NOTHING(inner); + + /* Check that the sequnced contained anything else. */ + if (!tree->inner) { + NEW_ERROR(tree, ERROR, "unordered subsequence contained nothing else than ‘.’"); + tree->type = C(NOTHING); + tree->processed = PROCESS_LEVEL; + return 0; + } + + /* Simplify. */ + for (argument = tree->inner, argument_count = 0; argument; argument = argument->next, argument_count++) { + if (argument->type == C(ALTERNATION)) { + fail_if (simplify_alternation(&(argument->alternation))); + argument->processed = PROCESS_LEVEL; + } else if (argument->type == C(UNORDERED)) { + NEW_ERROR(argument, WARNING, "unordered subsequence inside unordered subsequence is discouraged"); + fail_if (simplify_unordered(&(argument->unordered))); + argument->processed = PROCESS_LEVEL; + } + } + + /* Check the size of the subsequence. */ + if (argument_count > 5 && (!allow_long || !argv_force)) { + if (!allow_long) + NEW_ERROR(tree->inner, ERROR, + "unordered subsequence longer than 5 elements need double brackets"); + else if (!argv_force) + NEW_ERROR(tree->inner, ERROR, + "unordered subsequence of size %zu found, requires ‘--force’ to compile", argument_count); + return 0; + } + + /* Generate permutations. */ + tree->type = C(ALTERNATION); + tree->processed = PROCESS_LEVEL; + arguments = tree->inner; + if (!(tree->inner = create_permutations(arguments))) { + if (!errno) { + /* `create_permutations` can return `NULL` without setting `errno` + * if it does not list any permutations. */ + NEW_ERROR_(result, INTERNAL_ERROR, 0, 0, 0, 0, 1, + "Fail to create permutations of an unordered sequence"); + return 0; + } + fail_if (tree->inner = arguments, 1); + } + mds_kbdc_tree_free(arguments); + + return 0; +fail: + return -1; } @@ -804,34 +789,34 @@ static int simplify_unordered(mds_kbdc_tree_unordered_t* restrict tree) * @param tree The tree * @return Zero on success, -1 on error */ -static int simplify(mds_kbdc_tree_t* restrict tree) +static int +simplify(mds_kbdc_tree_t *restrict tree) { -#define s(expr) fail_if (simplify(tree->expr)) -#define S(type) fail_if (simplify_##type(&(tree->type))) - again: - if (tree == NULL) - return 0; - - switch (tree->type) - { - case C(INFORMATION): s (information.inner); break; - case C(FUNCTION): s (function.inner); break; - case C(MACRO): s (macro.inner); break; - case C(ASSUMPTION): s (assumption.inner); break; - case C(FOR): s (for_.inner); break; - case C(IF): s (if_.inner); s (if_.otherwise); break; - case C(MAP): S (map); break; - case C(ALTERNATION): S (alternation); break; - case C(UNORDERED): S (unordered); break; - case C(MACRO_CALL): S (macro_call); break; - default: - break; - } - - tree = tree->next; - goto again; +#define s(expr) fail_if (simplify(tree->expr)) +#define S(type) fail_if (simplify_##type(&(tree->type))) +again: + if (!tree) + return 0; + + switch (tree->type) { + case C(INFORMATION): s (information.inner); break; + case C(FUNCTION): s (function.inner); break; + case C(MACRO): s (macro.inner); break; + case C(ASSUMPTION): s (assumption.inner); break; + case C(FOR): s (for_.inner); break; + case C(IF): s (if_.inner); s (if_.otherwise); break; + case C(MAP): S (map); break; + case C(ALTERNATION): S (alternation); break; + case C(UNORDERED): S (unordered); break; + case C(MACRO_CALL): S (macro_call); break; + default: + break; + } + + tree = tree->next; + goto again; fail: - return -1; + return -1; #undef s #undef S } @@ -843,10 +828,11 @@ static int simplify(mds_kbdc_tree_t* restrict tree) * @param result_ `result` from `parse_to_tree`, same sematics, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int simplify_tree(mds_kbdc_parsed_t* restrict result_) +int +simplify_tree(mds_kbdc_parsed_t *restrict result_) { - result = result_; - return simplify(result_->tree); + result = result_; + return simplify(result_->tree); } @@ -856,4 +842,3 @@ int simplify_tree(mds_kbdc_parsed_t* restrict result_) #undef NEW_ERROR #undef C #undef PROCESS_LEVEL - diff --git a/src/mds-kbdc/simplify-tree.h b/src/mds-kbdc/simplify-tree.h index b5e5ce2..e648a46 100644 --- a/src/mds-kbdc/simplify-tree.h +++ b/src/mds-kbdc/simplify-tree.h @@ -28,8 +28,7 @@ * @param result `result` from `parse_to_tree`, same sematics, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int simplify_tree(mds_kbdc_parsed_t* restrict result); +int simplify_tree(mds_kbdc_parsed_t *restrict result); #endif - diff --git a/src/mds-kbdc/string.c b/src/mds-kbdc/string.c index a334611..c0e9852 100644 --- a/src/mds-kbdc/string.c +++ b/src/mds-kbdc/string.c @@ -30,12 +30,13 @@ * @param string The string * @return The length of the string */ -size_t string_length(const char32_t* restrict string) +size_t +string_length(const char32_t *restrict string) { - size_t i = 0; - while (string[i] != -1) - i++; - return i; + size_t i = 0; + while (string[i] != -1) + i++; + return i; } @@ -45,43 +46,41 @@ size_t string_length(const char32_t* restrict string) * @param string The UTF-8 string * @return The string in UTF-32, `NULL` on error */ -char32_t* string_decode(const char* restrict string) +char32_t * +string_decode(const char *restrict string) { - size_t i, j, n, length = 0; - char32_t* rc; - - /* Get the length of the UTF-32 string, excluding termination. */ - for (i = 0; string[i]; i++) - if ((string[i] & 0xC0) != 0x80) - length++; - - /* Allocated UTF-32 string. */ - fail_if (xmalloc(rc, length + 1, char32_t)); - - /* Convert to UTF-32. */ - for (i = j = n = 0; string[i]; i++) - { - char c = string[i]; - if (n) - { - rc[j] <<= 6, rc[j] |= c & 0x3F; - if (--n == 0) - j++; - } - else if ((c & 0xC0) == 0xC0) - { - while (c & 0x80) - n++, c = (char)(c << 1); - rc[j] = c >> n--; + size_t i, j, n, length = 0; + char32_t *rc; + char c; + + /* Get the length of the UTF-32 string, excluding termination. */ + for (i = 0; string[i]; i++) + if ((string[i] & 0xC0) != 0x80) + length++; + + /* Allocated UTF-32 string. */ + fail_if (xmalloc(rc, length + 1, char32_t)); + + /* Convert to UTF-32. */ + for (i = j = n = 0; string[i]; i++) { + c = string[i]; + if (n) { + rc[j] <<= 6, rc[j] |= c & 0x3F; + if (!--n) + j++; + } else if ((c & 0xC0) == 0xC0) { + while (c & 0x80) + n++, c = (char)(c << 1); + rc[j] = c >> n--; + } else { + rc[j++] = c & 255; + } } - else - rc[j++] = c & 255; - } - /* -1-terminate and return. */ - return rc[length] = -1, rc; - fail: - return NULL; + /* -1-terminate and return. */ + return rc[length] = -1, rc; +fail: + return NULL; } @@ -93,42 +92,43 @@ char32_t* string_decode(const char* restrict string) * @param string The UTF-32 string * @return The string in UTF-8, `NULL` on error */ -char* string_encode(const char32_t* restrict string) +char * +string_encode(const char32_t *restrict string) { - size_t i, j, n = string_length(string); - char* restrict rc; - - /* Allocated Modified UTF-8 string. */ - fail_if (xmalloc(rc, 7 * n + 1, char)); - - /* Convert to Modified UTF-8. */ - for (i = j = 0; i < n; i++) - { -#define _c(s) rc[j++] = (char)(((c >> (s)) & 0x3F) | 0x80) -#define _t(s) (0 < c) && ((uint32_t)c < (uint32_t)(1ULL << s)) - char32_t c = string[i]; - if (c == 0) rc[j++] = (char)0xC0, rc[j++] = (char)0x80; - else if (_t( 7)) rc[j++] = (char)c; - else if (_t(11)) rc[j++] = (char)((c >> 6) | 0xC0), _c( 0); - else if (_t(16)) rc[j++] = (char)((c >> 12) | 0xE0), _c( 6), _c( 0); - else if (_t(21)) rc[j++] = (char)((c >> 18) | 0xF0), _c(12), _c( 6), _c( 0); - /* UTF-8 actually ends here, fits 32 planes. */ - else if (_t(26)) rc[j++] = (char)((c >> 24) | 0xF8), _c(18), _c(12), _c( 6), _c(0); - else if (_t(31)) rc[j++] = (char)((c >> 30) | 0xFC), _c(24), _c(18), _c(12), _c(6), _c(0); - /* The orginal UTF-8 specification ended here, fits 31 bits. - * However, we added another byte so we can fit 32 bits - * (actually we ca now fit 36 bits.) - * However, we only needed this in `string_decode` which would - * not require any changed, but we added it here for symmetry. */ - else rc[j++] = (char)0xFE, _c(30), _c(24), _c(18), _c(12), _c(6), _c(0); + size_t i, j, n = string_length(string); + char *restrict rc; + char32_t c; + + /* Allocated Modified UTF-8 string. */ + fail_if (xmalloc(rc, 7 * n + 1, char)); + + /* Convert to Modified UTF-8. */ + for (i = j = 0; i < n; i++) { +#define _c(s) rc[j++] = (char)(((c >> (s)) & 0x3F) | 0x80) +#define _t(s) (0 < c) && ((uint32_t)c < (uint32_t)(1ULL << (s))) + c = string[i]; + if (!c) rc[j++] = (char)0xC0, rc[j++] = (char)0x80; + else if (_t( 7)) rc[j++] = (char)c; + else if (_t(11)) rc[j++] = (char)((c >> 6) | 0xC0), _c( 0); + else if (_t(16)) rc[j++] = (char)((c >> 12) | 0xE0), _c( 6), _c( 0); + else if (_t(21)) rc[j++] = (char)((c >> 18) | 0xF0), _c(12), _c( 6), _c( 0); + /* UTF-8 actually ends here, fits 32 planes. */ + else if (_t(26)) rc[j++] = (char)((c >> 24) | 0xF8), _c(18), _c(12), _c( 6), _c(0); + else if (_t(31)) rc[j++] = (char)((c >> 30) | 0xFC), _c(24), _c(18), _c(12), _c(6), _c(0); + /* The orginal UTF-8 specification ended here, fits 31 bits. + * However, we added another byte so we can fit 32 bits + * (actually we ca now fit 36 bits.) + * However, we only needed this in `string_decode` which would + * not require any changed, but we added it here for symmetry. */ + else rc[j++] = (char)0xFE, _c(30), _c(24), _c(18), _c(12), _c(6), _c(0); #undef _t #undef _c - } - - /* NUL-terminate and return. */ - return rc[j] = '\0', rc; - fail: - return NULL; + } + + /* NUL-terminate and return. */ + return rc[j] = '\0', rc; +fail: + return NULL; } @@ -138,16 +138,16 @@ char* string_encode(const char32_t* restrict string) * @param string The string * @return A duplicate of the string, `NULL` on error or if `string` is `NULL` */ -char32_t* string_dup(const char32_t* restrict string) +char32_t * +string_dup(const char32_t *restrict string) { - size_t n; - char32_t* rc; - if (string == NULL) - return NULL; - n = string_length(string) + 1; - fail_if (xmemdup(rc, string, n, char32_t)); - return rc; - fail: - return NULL; + size_t n; + char32_t *rc; + if (!string) + return NULL; + n = string_length(string) + 1; + fail_if (xmemdup(rc, string, n, char32_t)); + return rc; +fail: + return NULL; } - diff --git a/src/mds-kbdc/string.h b/src/mds-kbdc/string.h index a58eb91..81155ed 100644 --- a/src/mds-kbdc/string.h +++ b/src/mds-kbdc/string.h @@ -35,7 +35,8 @@ typedef int32_t char32_t; * @param string The string * @return The length of the string */ -size_t string_length(const char32_t* restrict string) __attribute__((pure, nonnull)); +__attribute__((pure, nonnull)) +size_t string_length(const char32_t *restrict string); /** * Convert a NUL-terminated UTF-8 string to a -1-terminated UTF-32 string @@ -43,7 +44,8 @@ size_t string_length(const char32_t* restrict string) __attribute__((pure, nonnu * @param string The UTF-8 string * @return The string in UTF-32, `NULL` on error */ -char32_t* string_decode(const char* restrict string) __attribute__((nonnull)); +__attribute__((nonnull)) +char32_t *string_decode(const char *restrict string); /** * Convert a -1-terminated UTF-32 string to a NUL-terminated Modified UTF-8 string @@ -51,7 +53,8 @@ char32_t* string_decode(const char* restrict string) __attribute__((nonnull)); * @param string The UTF-32 string * @return The string in UTF-8, `NULL` on error */ -char* string_encode(const char32_t* restrict string) __attribute__((nonnull)); +__attribute__((nonnull)) +char *string_encode(const char32_t *restrict string); /** * Create duplicate of a string @@ -59,9 +62,8 @@ char* string_encode(const char32_t* restrict string) __attribute__((nonnull)); * @param string The string * @return A duplicate of the string, `NULL` on error or if `string` is `NULL` */ -char32_t* string_dup(const char32_t* restrict string); +char32_t *string_dup(const char32_t *restrict string); #endif - diff --git a/src/mds-kbdc/tree.c b/src/mds-kbdc/tree.c index 289ccac..33db89e 100644 --- a/src/mds-kbdc/tree.c +++ b/src/mds-kbdc/tree.c @@ -36,7 +36,7 @@ typedef struct mds_kbdc_tree_information_data mds_kbdc_tree_information_data_t; /** * Tree type constant shortener */ -#define C(t) MDS_KBDC_TREE_TYPE_##t +#define C(t) MDS_KBDC_TREE_TYPE_##t /** @@ -45,10 +45,11 @@ typedef struct mds_kbdc_tree_information_data mds_kbdc_tree_information_data_t; * @param this The memory slot for the tree node * @param type The type of the node */ -void mds_kbdc_tree_initialise(mds_kbdc_tree_t* restrict this, int type) +void +mds_kbdc_tree_initialise(mds_kbdc_tree_t *restrict this, int type) { - memset(this, 0, sizeof(mds_kbdc_tree_t)); - this->type = type; + memset(this, 0, sizeof(mds_kbdc_tree_t)); + this->type = type; } @@ -58,14 +59,15 @@ void mds_kbdc_tree_initialise(mds_kbdc_tree_t* restrict this, int type) * @param type The type of the node * @return The tree node, `NULL` on error */ -mds_kbdc_tree_t* mds_kbdc_tree_create(int type) +mds_kbdc_tree_t * +mds_kbdc_tree_create(int type) { - mds_kbdc_tree_t* this; - fail_if (xmalloc(this, 1, mds_kbdc_tree_t)); - mds_kbdc_tree_initialise(this, type); - return this; - fail: - return NULL; + mds_kbdc_tree_t *this; + fail_if (xmalloc(this, 1, mds_kbdc_tree_t)); + mds_kbdc_tree_initialise(this, type); + return this; +fail: + return NULL; } @@ -75,110 +77,109 @@ mds_kbdc_tree_t* mds_kbdc_tree_create(int type) * @param this The tree node * @param recursive Whether subtree should be destroyed and freed */ -static void mds_kbdc_tree_destroy_(mds_kbdc_tree_t* restrict this, int recursive) +static void mds_kbdc_tree_destroy_(mds_kbdc_tree_t *restrict this, int recursive) { -#define V(type, var) (((type)this)->var) -#define xfree(t, v) (free(V(t, v)), V(t, v) = NULL) -#define xdestroy(t, v) (recursive ? (mds_kbdc_tree_destroy_(V(t, v), 1), xfree(t, v)) : (V(t, v) = NULL)) - - mds_kbdc_tree_t* prev = NULL; - mds_kbdc_tree_t* first = this; - - again: - if (this == NULL) - return; - - switch (this->type) - { - case C(INFORMATION): - case C(ASSUMPTION): - case C(ALTERNATION): - case C(UNORDERED): - case C(ORDERED): - xdestroy(mds_kbdc_tree_nesting_t*, inner); - break; - - case C(INFORMATION_LANGUAGE): - case C(INFORMATION_COUNTRY): - case C(INFORMATION_VARIANT): - xfree(mds_kbdc_tree_information_data_t*, data); - break; - - case C(FUNCTION): - case C(MACRO): - xfree(mds_kbdc_tree_callable_t*, name); - xdestroy(mds_kbdc_tree_callable_t*, inner); - break; - - case C(INCLUDE): - xfree(mds_kbdc_tree_include_t*, filename); - xdestroy(mds_kbdc_tree_include_t*, inner); - mds_kbdc_source_code_free(this->include.source_code); - break; - - case C(ASSUMPTION_HAVE): - xdestroy(mds_kbdc_tree_assumption_have_t*, data); - break; - - case C(ASSUMPTION_HAVE_CHARS): - xfree(mds_kbdc_tree_assumption_have_chars_t*, chars); - break; - - case C(ASSUMPTION_HAVE_RANGE): - xfree(mds_kbdc_tree_assumption_have_range_t*, first); - xfree(mds_kbdc_tree_assumption_have_range_t*, last); - break; - - case C(FOR): - xfree(mds_kbdc_tree_for_t*, first); - xfree(mds_kbdc_tree_for_t*, last); - xfree(mds_kbdc_tree_for_t*, variable); - xdestroy(mds_kbdc_tree_for_t*, inner); - break; - - case C(IF): - xfree(mds_kbdc_tree_if_t*, condition); - xdestroy(mds_kbdc_tree_if_t*, inner); - xdestroy(mds_kbdc_tree_if_t*, otherwise); - break; - - case C(LET): - xfree(mds_kbdc_tree_let_t*, variable); - xdestroy(mds_kbdc_tree_let_t*, value); - break; - - case C(MAP): - xdestroy(mds_kbdc_tree_map_t*, sequence); - xdestroy(mds_kbdc_tree_map_t*, result); - break; - - case C(ARRAY): - xdestroy(mds_kbdc_tree_array_t*, elements); - break; - - case C(KEYS): - case C(STRING): - case C(COMPILED_KEYS): - case C(COMPILED_STRING): - xfree(mds_kbdc_tree_keys_t*, keys); - /* We are abusing the similaries of the structures. */ - break; - - case C(MACRO_CALL): - xfree(mds_kbdc_tree_macro_call_t*, name); - xdestroy(mds_kbdc_tree_macro_call_t*, arguments); - break; - - default: - break; - } - - prev = this; - this = this->next; - if (prev != first) - free(prev); - goto again; - +#define V(type, var) (((type)this)->var) +#define xfree(t, v) (free(V(t, v)), V(t, v) = NULL) +#define xdestroy(t, v) (recursive ? (mds_kbdc_tree_destroy_(V(t, v), 1), xfree(t, v)) : (V(t, v) = NULL)) + + mds_kbdc_tree_t *prev = NULL; + mds_kbdc_tree_t *first = this; + +again: + if (!this) + return; + + switch (this->type) { + case C(INFORMATION): + case C(ASSUMPTION): + case C(ALTERNATION): + case C(UNORDERED): + case C(ORDERED): + xdestroy(mds_kbdc_tree_nesting_t *, inner); + break; + + case C(INFORMATION_LANGUAGE): + case C(INFORMATION_COUNTRY): + case C(INFORMATION_VARIANT): + xfree(mds_kbdc_tree_information_data_t *, data); + break; + + case C(FUNCTION): + case C(MACRO): + xfree(mds_kbdc_tree_callable_t *, name); + xdestroy(mds_kbdc_tree_callable_t *, inner); + break; + + case C(INCLUDE): + xfree(mds_kbdc_tree_include_t *, filename); + xdestroy(mds_kbdc_tree_include_t *, inner); + mds_kbdc_source_code_free(this->include.source_code); + break; + + case C(ASSUMPTION_HAVE): + xdestroy(mds_kbdc_tree_assumption_have_t *, data); + break; + + case C(ASSUMPTION_HAVE_CHARS): + xfree(mds_kbdc_tree_assumption_have_chars_t *, chars); + break; + + case C(ASSUMPTION_HAVE_RANGE): + xfree(mds_kbdc_tree_assumption_have_range_t *, first); + xfree(mds_kbdc_tree_assumption_have_range_t *, last); + break; + + case C(FOR): + xfree(mds_kbdc_tree_for_t *, first); + xfree(mds_kbdc_tree_for_t *, last); + xfree(mds_kbdc_tree_for_t *, variable); + xdestroy(mds_kbdc_tree_for_t *, inner); + break; + + case C(IF): + xfree(mds_kbdc_tree_if_t *, condition); + xdestroy(mds_kbdc_tree_if_t *, inner); + xdestroy(mds_kbdc_tree_if_t *, otherwise); + break; + + case C(LET): + xfree(mds_kbdc_tree_let_t *, variable); + xdestroy(mds_kbdc_tree_let_t *, value); + break; + + case C(MAP): + xdestroy(mds_kbdc_tree_map_t *, sequence); + xdestroy(mds_kbdc_tree_map_t *, result); + break; + + case C(ARRAY): + xdestroy(mds_kbdc_tree_array_t *, elements); + break; + + case C(KEYS): + case C(STRING): + case C(COMPILED_KEYS): + case C(COMPILED_STRING): + xfree(mds_kbdc_tree_keys_t *, keys); + /* We are abusing the similaries of the structures. */ + break; + + case C(MACRO_CALL): + xfree(mds_kbdc_tree_macro_call_t *, name); + xdestroy(mds_kbdc_tree_macro_call_t *, arguments); + break; + + default: + break; + } + + prev = this; + this = this->next; + if (prev != first) + free(prev); + goto again; + #undef xdestroy #undef xfree #undef V @@ -192,9 +193,10 @@ static void mds_kbdc_tree_destroy_(mds_kbdc_tree_t* restrict this, int recursive * * @param this The tree node */ -void mds_kbdc_tree_destroy_nonrecursive(mds_kbdc_tree_t* restrict this) +void +mds_kbdc_tree_destroy_nonrecursive(mds_kbdc_tree_t *restrict this) { - mds_kbdc_tree_destroy_(this, 0); + mds_kbdc_tree_destroy_(this, 0); } @@ -206,10 +208,11 @@ void mds_kbdc_tree_destroy_nonrecursive(mds_kbdc_tree_t* restrict this) * * @param this The tree node */ -void mds_kbdc_tree_free_nonrecursive(mds_kbdc_tree_t* restrict this) +void +mds_kbdc_tree_free_nonrecursive(mds_kbdc_tree_t *restrict this) { - mds_kbdc_tree_destroy_nonrecursive(this); - free(this); + mds_kbdc_tree_destroy_nonrecursive(this); + free(this); } @@ -220,9 +223,10 @@ void mds_kbdc_tree_free_nonrecursive(mds_kbdc_tree_t* restrict this) * * @param this The tree node */ -void mds_kbdc_tree_destroy(mds_kbdc_tree_t* restrict this) +void +mds_kbdc_tree_destroy(mds_kbdc_tree_t *restrict this) { - mds_kbdc_tree_destroy_(this, 1); + mds_kbdc_tree_destroy_(this, 1); } @@ -233,10 +237,11 @@ void mds_kbdc_tree_destroy(mds_kbdc_tree_t* restrict this) * * @param this The tree node */ -void mds_kbdc_tree_free(mds_kbdc_tree_t* restrict this) +void +mds_kbdc_tree_free(mds_kbdc_tree_t *restrict this) { - mds_kbdc_tree_destroy(this); - free(this); + mds_kbdc_tree_destroy(this); + free(this); } @@ -246,7 +251,7 @@ void mds_kbdc_tree_free(mds_kbdc_tree_t* restrict this) * * @param member:identifer The member in the tree to duplicate */ -#define T(member) fail_if (t->member && (n->member = mds_kbdc_tree_dup(t->member), n->member == NULL)) +#define T(member) fail_if (t->member && !(n->member = mds_kbdc_tree_dup(t->member))) /** @@ -254,7 +259,7 @@ void mds_kbdc_tree_free(mds_kbdc_tree_t* restrict this) * * @param member:identifer The member in the tree to duplicate */ -#define S(member) fail_if (t->member && xstrdup(n->member, t->member)) +#define S(member) fail_if (t->member && xstrdup(n->member, t->member)) /** @@ -262,7 +267,7 @@ void mds_kbdc_tree_free(mds_kbdc_tree_t* restrict this) * * @param member:identifer The member in the tree to duplicate */ -#define Z(member) fail_if (t->member && (n->member = string_dup(t->member), n->member == NULL)) +#define Z(member) fail_if (t->member && !(n->member = string_dup(t->member))) /** @@ -270,7 +275,7 @@ void mds_kbdc_tree_free(mds_kbdc_tree_t* restrict this) * * @param member:identifer The member in the tree to copied */ -#define R(member) fail_if (t->member && (n->member = mds_kbdc_source_code_dup(t->member), n->member == NULL)) +#define R(member) fail_if (t->member && !(n->member = mds_kbdc_source_code_dup(t->member))) @@ -280,62 +285,109 @@ void mds_kbdc_tree_free(mds_kbdc_tree_t* restrict this) * @param this The tree node * @return A duplicate of `this`, `NULL` on error */ -mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) +mds_kbdc_tree_t * +mds_kbdc_tree_dup(const mds_kbdc_tree_t *restrict this) { -#define t this -#define n (*node) - mds_kbdc_tree_t* rc = NULL; - mds_kbdc_tree_t** node = &rc; - int saved_errno; - - again: - if (t == NULL) return rc; - fail_if (xcalloc(n, 1, mds_kbdc_tree_t)); +#define t this +#define n (*node) + mds_kbdc_tree_t *rc = NULL; + mds_kbdc_tree_t **node = &rc; + int saved_errno; + +again: + if (!t) + return rc; + fail_if (xcalloc(n, 1, mds_kbdc_tree_t)); + + n->type = t->type; + n->loc_line = t->loc_line; + n->loc_start = t->loc_start; + n->loc_end = t->loc_end; + n->processed = t->processed; + + switch (this->type) { + case C(INFORMATION): + case C(ASSUMPTION): + case C(ALTERNATION): + case C(UNORDERED): + case C(ORDERED): + T(ordered.inner); + break; + case C(FUNCTION): + case C(MACRO): + S(macro.name); + T(macro.inner); + break; + case C(ASSUMPTION_HAVE): + T(have.data); + break; + case C(ARRAY): + T(array.elements); + break; + case C(LET): + S(let.variable); + T(let.value); + break; + case C(MACRO_CALL): + S(macro_call.name); + T(macro_call.arguments); + break; + case C(INFORMATION_LANGUAGE): + case C(INFORMATION_COUNTRY): + case C(INFORMATION_VARIANT): + S(variant.data); + break; + case C(INCLUDE): + S(include.filename); + T(include.inner); + R(include.source_code); + break; + case C(ASSUMPTION_HAVE_CHARS): + S(have_chars.chars); + break; + case C(KEYS): + S(keys.keys); + break; + case C(STRING): + S(string.string); + break; + case C(COMPILED_KEYS): + Z(compiled_keys.keys); + break; + case C(COMPILED_STRING): + Z(compiled_string.string); + break; + case C(ASSUMPTION_HAVE_RANGE): + S(have_range.first); + S(have_range.last); + break; + case C(FOR): + S(for_.first); + S(for_.last); + S(for_.variable); + T(for_.inner); + break; + case C(IF): + S(if_.condition); + T(if_.inner); + T(if_.otherwise); + break; + case C(MAP): + T(map.sequence); + T(map.result); + break; + default: + break; + } + + t = t->next; + node = &(n->next); + goto again; - n->type = t->type; - n->loc_line = t->loc_line; - n->loc_start = t->loc_start; - n->loc_end = t->loc_end; - n->processed = t->processed; - - switch (this->type) - { - case C(INFORMATION): - case C(ASSUMPTION): - case C(ALTERNATION): - case C(UNORDERED): - case C(ORDERED): T(ordered.inner); break; - case C(FUNCTION): - case C(MACRO): S(macro.name); T(macro.inner); break; - case C(ASSUMPTION_HAVE): T(have.data); break; - case C(ARRAY): T(array.elements); break; - case C(LET): S(let.variable); T(let.value); break; - case C(MACRO_CALL): S(macro_call.name); T(macro_call.arguments); break; - case C(INFORMATION_LANGUAGE): - case C(INFORMATION_COUNTRY): - case C(INFORMATION_VARIANT): S(variant.data); break; - case C(INCLUDE): S(include.filename); T(include.inner); R(include.source_code); break; - case C(ASSUMPTION_HAVE_CHARS): S(have_chars.chars); break; - case C(KEYS): S(keys.keys); break; - case C(STRING): S(string.string); break; - case C(COMPILED_KEYS): Z(compiled_keys.keys); break; - case C(COMPILED_STRING): Z(compiled_string.string); break; - case C(ASSUMPTION_HAVE_RANGE): S(have_range.first); S(have_range.last); break; - case C(FOR): S(for_.first); S(for_.last); S(for_.variable); T(for_.inner); break; - case C(IF): S(if_.condition); T(if_.inner); T(if_.otherwise); break; - case C(MAP): T(map.sequence); T(map.result); break; - default: - break; - } - - t = t->next; - node = &(n->next); - goto again; - - fail: - saved_errno = errno; - mds_kbdc_tree_free(rc); - return errno = saved_errno, NULL; +fail: + saved_errno = errno; + mds_kbdc_tree_free(rc); + return errno = saved_errno, NULL; #undef n #undef t } @@ -355,12 +407,12 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * @param LOWERCASE:identifer The name of subtype * @param NOTATION:const char* The notation for the subtype */ -#define NODE(LOWERCASE, NOTATION) \ - const mds_kbdc_tree_##LOWERCASE##_t* node; \ - node = (const mds_kbdc_tree_##LOWERCASE##_t*)this; \ - fprintf(output, "%*.s(\033[01m%s\033[00m", indent, "", NOTATION); \ - fprintf(output, " \033[36m(@ %zu %zu-%zu)\033[00m", \ - node->loc_line + 1, node->loc_start, node->loc_end) +#define NODE(LOWERCASE, NOTATION)\ + const mds_kbdc_tree_##LOWERCASE##_t *node;\ + node = (const mds_kbdc_tree_##LOWERCASE##_t *)this;\ + fprintf(output, "%*.s(\033[01m%s\033[00m", indent, "", NOTATION);\ + fprintf(output, " \033[36m(@ %zu %zu-%zu)\033[00m",\ + node->loc_line + 1, node->loc_start, node->loc_end) /** @@ -368,22 +420,23 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * * @param MEMBER:identifier The tree structure's member */ -#define BRANCH(MEMBER) \ - if (node->MEMBER) \ - { \ - fprintf(output, "\n%*.s(.%s\n", indent + 2, "", #MEMBER); \ - mds_kbdc_tree_print_indented(node->MEMBER, output, indent + 4); \ - fprintf(output, "%*.s)", indent + 2, ""); \ - } \ - else \ - fprintf(output, "\n%*.s(.%s \033[35mnil\033[00m)", indent + 2, "", #MEMBER) +#define BRANCH(MEMBER)\ + do {\ + if (node->MEMBER) {\ + fprintf(output, "\n%*.s(.%s\n", indent + 2, "", #MEMBER);\ + mds_kbdc_tree_print_indented(node->MEMBER, output, indent + 4);\ + fprintf(output, "%*.s)", indent + 2, "");\ + } else {\ + fprintf(output, "\n%*.s(.%s \033[35mnil\033[00m)", indent + 2, "", #MEMBER);\ + }\ + } while (0) /** * End a tree which has at least one member that is a subtree */ -#define COMPLEX \ - fprintf(output, "\n%*.s)\n", indent, "") +#define COMPLEX\ + fprintf(output, "\n%*.s)\n", indent, "") /** @@ -391,11 +444,13 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * * @param MEMBER:identifier The tree structure's member */ -#define STRING(MEMBER) \ - if (node->MEMBER) \ - fprintf(output, " ‘\033[32m%s\033[00m’", node->MEMBER); \ - else \ - fprintf(output, " \033[35mnil\033[00m") +#define STRING(MEMBER)\ + do {\ + if (node->MEMBER)\ + fprintf(output, " ‘\033[32m%s\033[00m’", node->MEMBER);\ + else\ + fprintf(output, " \033[35mnil\033[00m");\ + } while (0) /** @@ -404,9 +459,11 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * * @param MEMBER:identifier The tree structure's member */ -#define SIMPLE(MEMBER) \ - STRING(MEMBER); \ - fprintf(output, ")\n") +#define SIMPLE(MEMBER)\ + do {\ + STRING(MEMBER);\ + fprintf(output, ")\n");\ + } while (0) /** @@ -417,12 +474,12 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * @param NOTATION:const char* See `NODE` * @param MEMBER:identifier See `STRING` */ -#define SIMPLEX(LOWERCASE, NOTATION, MEMBER) \ - { \ - NODE(LOWERCASE, NOTATION); \ - SIMPLE(MEMBER); \ - } \ - break +#define SIMPLEX(LOWERCASE, NOTATION, MEMBER)\ + {\ + NODE(LOWERCASE, NOTATION);\ + SIMPLE(MEMBER);\ + }\ + break /** @@ -434,13 +491,13 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * @param FIRST:identifier See `STRING`, the first member * @param LAST:identifier See `STRING`, the second member */ -#define DUPLEX(LOWERCASE, NOTATION, FIRST, LAST) \ - { \ - NODE(LOWERCASE, NOTATION); \ - STRING(FIRST); \ - SIMPLE(LAST); \ - } \ - break +#define DUPLEX(LOWERCASE, NOTATION, FIRST, LAST)\ + {\ + NODE(LOWERCASE, NOTATION);\ + STRING(FIRST);\ + SIMPLE(LAST);\ + }\ + break /** @@ -451,13 +508,13 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * @param NOTATION:const char* See `NODE` * @param MEMBER:identifier See `BRANCH` */ -#define NESTING(LOWERCASE, NOTATION, MEMBER) \ - { \ - NODE(LOWERCASE, NOTATION); \ - BRANCH(MEMBER); \ - COMPLEX; \ - } \ - break +#define NESTING(LOWERCASE, NOTATION, MEMBER)\ + {\ + NODE(LOWERCASE, NOTATION);\ + BRANCH(MEMBER);\ + COMPLEX;\ + }\ + break /** @@ -470,14 +527,14 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * @param NAMER:identifier See `STRING` * @param MEMBER:identifier See `BRANCH` */ -#define NAMED_NESTING(LOWERCASE, NOTATION, NAMER, MEMBER) \ - { \ - NODE(LOWERCASE, NOTATION); \ - STRING(NAMER); \ - BRANCH(MEMBER); \ - COMPLEX; \ - } \ - break +#define NAMED_NESTING(LOWERCASE, NOTATION, NAMER, MEMBER)\ + {\ + NODE(LOWERCASE, NOTATION);\ + STRING(NAMER);\ + BRANCH(MEMBER);\ + COMPLEX;\ + }\ + break /** @@ -485,12 +542,12 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * * @param NOTATION:const char* See `NODE` */ -#define NOTHING(NOTATION) \ - fprintf(output, "%*.s(\033[01m%s\033[00m", indent, "", NOTATION); \ - fprintf(output, " \033[36m(@ %zu %zu-%zu)\033[00m", \ - this->loc_line + 1, this->loc_start, this->loc_end); \ - fprintf(output, ")\n"); \ - break +#define NOTHING(NOTATION)\ + fprintf(output, "%*.s(\033[01m%s\033[00m", indent, "", NOTATION);\ + fprintf(output, " \033[36m(@ %zu %zu-%zu)\033[00m",\ + this->loc_line + 1, this->loc_start, this->loc_end);\ + fprintf(output, ")\n");\ + break @@ -501,100 +558,100 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this) * @param output The output file * @param indent The indent */ -static void mds_kbdc_tree_print_indented(const mds_kbdc_tree_t* restrict this, FILE* output, int indent) +static void +mds_kbdc_tree_print_indented(const mds_kbdc_tree_t *restrict this, FILE *output, int indent) { - again: - if (this == NULL) - return; - - switch (this->type) - { - /* These have their break built into their macro. */ - case C(INFORMATION): NESTING(information, "information", inner); - case C(INFORMATION_LANGUAGE): SIMPLEX(information_language, "language", data); - case C(INFORMATION_COUNTRY): SIMPLEX(information_country, "country", data); - case C(INFORMATION_VARIANT): SIMPLEX(information_variant, "variant", data); - case C(INCLUDE): NAMED_NESTING(include, "include", filename, inner); - case C(FUNCTION): NAMED_NESTING(function, "function", name, inner); - case C(MACRO): NAMED_NESTING(macro, "macro", name, inner); - case C(ASSUMPTION): NESTING(assumption, "assumption", inner); - case C(ASSUMPTION_HAVE): NESTING(assumption_have, "have", data); - case C(ASSUMPTION_HAVE_CHARS): SIMPLEX(assumption_have_chars, "have_chars", chars); - case C(ASSUMPTION_HAVE_RANGE): DUPLEX(assumption_have_range, "have_range", first, last); - case C(LET): NAMED_NESTING(let, "let", variable, value); - case C(ARRAY): NESTING(array, "array", elements); - case C(KEYS): SIMPLEX(keys, "keys", keys); - case C(STRING): SIMPLEX(string, "string", string); - case C(NOTHING): NOTHING("nothing"); - case C(ALTERNATION): NESTING(alternation, "alternation", inner); - case C(UNORDERED): NESTING(unordered, "unordered", inner); - case C(ORDERED): NESTING(ordered, "ordered", inner); - case C(MACRO_CALL): NAMED_NESTING(macro_call, "macro_call", name, arguments); - case C(RETURN): NOTHING("return"); - case C(BREAK): NOTHING("break"); - case C(CONTINUE): NOTHING("continue"); - - case C(COMPILED_KEYS): - { - NODE(compiled_keys, "compiled_keys"); - if (node->keys) - fprintf(output, " ‘\033[32m%s\033[00m’", string_encode(node->keys)); - else - fprintf(output, " \033[35mnil\033[00m"); - fprintf(output, ")\n"); - } - break; - - case C(COMPILED_STRING): - { - NODE(compiled_string, "compiled_string"); - if (node->string) - fprintf(output, " ‘\033[32m%s\033[00m’", string_encode(node->string)); - else - fprintf(output, " \033[35mnil\033[00m"); - fprintf(output, ")\n"); - } - break; - - case C(FOR): - { - NODE(for, "for"); - STRING(first); - STRING(last); - fprintf(output, " (.variable"); - STRING(variable); - fprintf(output, ")"); - BRANCH(inner); - COMPLEX; - } - break; - - case C(IF): - { - NODE(if, "if"); - STRING(condition); - BRANCH(inner); - BRANCH(otherwise); - COMPLEX; - } - break; - - case C(MAP): - { - NODE(map, "map"); - BRANCH(sequence); - BRANCH(result); - COMPLEX; - } - break; - - default: - abort(); - break; - } - - this = this->next; - goto again; +again: + if (!this) + return; + + switch (this->type) { + /* These have their break built into their macro. */ + case C(INFORMATION): NESTING(information, "information", inner); + case C(INFORMATION_LANGUAGE): SIMPLEX(information_language, "language", data); + case C(INFORMATION_COUNTRY): SIMPLEX(information_country, "country", data); + case C(INFORMATION_VARIANT): SIMPLEX(information_variant, "variant", data); + case C(INCLUDE): NAMED_NESTING(include, "include", filename, inner); + case C(FUNCTION): NAMED_NESTING(function, "function", name, inner); + case C(MACRO): NAMED_NESTING(macro, "macro", name, inner); + case C(ASSUMPTION): NESTING(assumption, "assumption", inner); + case C(ASSUMPTION_HAVE): NESTING(assumption_have, "have", data); + case C(ASSUMPTION_HAVE_CHARS): SIMPLEX(assumption_have_chars, "have_chars", chars); + case C(ASSUMPTION_HAVE_RANGE): DUPLEX(assumption_have_range, "have_range", first, last); + case C(LET): NAMED_NESTING(let, "let", variable, value); + case C(ARRAY): NESTING(array, "array", elements); + case C(KEYS): SIMPLEX(keys, "keys", keys); + case C(STRING): SIMPLEX(string, "string", string); + case C(NOTHING): NOTHING("nothing"); + case C(ALTERNATION): NESTING(alternation, "alternation", inner); + case C(UNORDERED): NESTING(unordered, "unordered", inner); + case C(ORDERED): NESTING(ordered, "ordered", inner); + case C(MACRO_CALL): NAMED_NESTING(macro_call, "macro_call", name, arguments); + case C(RETURN): NOTHING("return"); + case C(BREAK): NOTHING("break"); + case C(CONTINUE): NOTHING("continue"); + + case C(COMPILED_KEYS): + { + NODE(compiled_keys, "compiled_keys"); + if (node->keys) + fprintf(output, " ‘\033[32m%s\033[00m’", string_encode(node->keys)); + else + fprintf(output, " \033[35mnil\033[00m"); + fprintf(output, ")\n"); + } + break; + + case C(COMPILED_STRING): + { + NODE(compiled_string, "compiled_string"); + if (node->string) + fprintf(output, " ‘\033[32m%s\033[00m’", string_encode(node->string)); + else + fprintf(output, " \033[35mnil\033[00m"); + fprintf(output, ")\n"); + } + break; + + case C(FOR): + { + NODE(for, "for"); + STRING(first); + STRING(last); + fprintf(output, " (.variable"); + STRING(variable); + fprintf(output, ")"); + BRANCH(inner); + COMPLEX; + } + break; + + case C(IF): + { + NODE(if, "if"); + STRING(condition); + BRANCH(inner); + BRANCH(otherwise); + COMPLEX; + } + break; + + case C(MAP): + { + NODE(map, "map"); + BRANCH(sequence); + BRANCH(result); + COMPLEX; + } + break; + + default: + abort(); + break; + } + + this = this->next; + goto again; } @@ -604,9 +661,10 @@ static void mds_kbdc_tree_print_indented(const mds_kbdc_tree_t* restrict this, F * @param this The tree node * @param output The output file */ -void mds_kbdc_tree_print(const mds_kbdc_tree_t* restrict this, FILE* output) +void +mds_kbdc_tree_print(const mds_kbdc_tree_t *restrict this, FILE *output) { - mds_kbdc_tree_print_indented(this, output, 0); + mds_kbdc_tree_print_indented(this, output, 0); } @@ -622,4 +680,3 @@ void mds_kbdc_tree_print(const mds_kbdc_tree_t* restrict this, FILE* output) #undef NODE #undef C - diff --git a/src/mds-kbdc/tree.h b/src/mds-kbdc/tree.h index e9d28f4..392c85b 100644 --- a/src/mds-kbdc/tree.h +++ b/src/mds-kbdc/tree.h @@ -32,142 +32,142 @@ /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_information_t` */ -#define MDS_KBDC_TREE_TYPE_INFORMATION 0 +#define MDS_KBDC_TREE_TYPE_INFORMATION 0 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_information_language_t` */ -#define MDS_KBDC_TREE_TYPE_INFORMATION_LANGUAGE 1 +#define MDS_KBDC_TREE_TYPE_INFORMATION_LANGUAGE 1 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_information_country_t` */ -#define MDS_KBDC_TREE_TYPE_INFORMATION_COUNTRY 2 +#define MDS_KBDC_TREE_TYPE_INFORMATION_COUNTRY 2 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_information_variant_t` */ -#define MDS_KBDC_TREE_TYPE_INFORMATION_VARIANT 3 +#define MDS_KBDC_TREE_TYPE_INFORMATION_VARIANT 3 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_include_t` */ -#define MDS_KBDC_TREE_TYPE_INCLUDE 4 +#define MDS_KBDC_TREE_TYPE_INCLUDE 4 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_function_t` */ -#define MDS_KBDC_TREE_TYPE_FUNCTION 5 +#define MDS_KBDC_TREE_TYPE_FUNCTION 5 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_macro_t` */ -#define MDS_KBDC_TREE_TYPE_MACRO 6 +#define MDS_KBDC_TREE_TYPE_MACRO 6 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_assumption` */ -#define MDS_KBDC_TREE_TYPE_ASSUMPTION 7 +#define MDS_KBDC_TREE_TYPE_ASSUMPTION 7 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_assumption_have_t` */ -#define MDS_KBDC_TREE_TYPE_ASSUMPTION_HAVE 8 +#define MDS_KBDC_TREE_TYPE_ASSUMPTION_HAVE 8 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_assumption_have_chars_t` */ -#define MDS_KBDC_TREE_TYPE_ASSUMPTION_HAVE_CHARS 9 +#define MDS_KBDC_TREE_TYPE_ASSUMPTION_HAVE_CHARS 9 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_assumption_have_range_t` */ -#define MDS_KBDC_TREE_TYPE_ASSUMPTION_HAVE_RANGE 10 +#define MDS_KBDC_TREE_TYPE_ASSUMPTION_HAVE_RANGE 10 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_for_t` */ -#define MDS_KBDC_TREE_TYPE_FOR 11 +#define MDS_KBDC_TREE_TYPE_FOR 11 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_if_t` */ -#define MDS_KBDC_TREE_TYPE_IF 12 +#define MDS_KBDC_TREE_TYPE_IF 12 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_let_t` */ -#define MDS_KBDC_TREE_TYPE_LET 13 +#define MDS_KBDC_TREE_TYPE_LET 13 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_map_t` */ -#define MDS_KBDC_TREE_TYPE_MAP 14 +#define MDS_KBDC_TREE_TYPE_MAP 14 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_array_t` */ -#define MDS_KBDC_TREE_TYPE_ARRAY 15 +#define MDS_KBDC_TREE_TYPE_ARRAY 15 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_keys_t` */ -#define MDS_KBDC_TREE_TYPE_KEYS 16 +#define MDS_KBDC_TREE_TYPE_KEYS 16 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_string_t` */ -#define MDS_KBDC_TREE_TYPE_STRING 17 +#define MDS_KBDC_TREE_TYPE_STRING 17 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_compiled_keys_t` */ -#define MDS_KBDC_TREE_TYPE_COMPILED_KEYS 18 +#define MDS_KBDC_TREE_TYPE_COMPILED_KEYS 18 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_compiled_string_t` */ -#define MDS_KBDC_TREE_TYPE_COMPILED_STRING 19 +#define MDS_KBDC_TREE_TYPE_COMPILED_STRING 19 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_nothing_t` */ -#define MDS_KBDC_TREE_TYPE_NOTHING 20 +#define MDS_KBDC_TREE_TYPE_NOTHING 20 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_alternation_t` */ -#define MDS_KBDC_TREE_TYPE_ALTERNATION 21 +#define MDS_KBDC_TREE_TYPE_ALTERNATION 21 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_unordered_t` */ -#define MDS_KBDC_TREE_TYPE_UNORDERED 22 +#define MDS_KBDC_TREE_TYPE_UNORDERED 22 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_ordered_t` */ -#define MDS_KBDC_TREE_TYPE_ORDERED 23 +#define MDS_KBDC_TREE_TYPE_ORDERED 23 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_macro_call_t` */ -#define MDS_KBDC_TREE_TYPE_MACRO_CALL 24 +#define MDS_KBDC_TREE_TYPE_MACRO_CALL 24 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_return_t` */ -#define MDS_KBDC_TREE_TYPE_RETURN 25 +#define MDS_KBDC_TREE_TYPE_RETURN 25 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_break_t` */ -#define MDS_KBDC_TREE_TYPE_BREAK 26 +#define MDS_KBDC_TREE_TYPE_BREAK 26 /** * Value of `mds_kbdc_tree_t.type` for `mds_kbdc_tree_continue_t` */ -#define MDS_KBDC_TREE_TYPE_CONTINUE 27 +#define MDS_KBDC_TREE_TYPE_CONTINUE 27 @@ -196,13 +196,13 @@ typedef union mds_kbdc_tree mds_kbdc_tree_t; * - size_t loc_end; -- The last byte in the source code where this is found, exclusive * - long processed; -- The lasted step where the statement has already been processed once */ -#define MDS_KBDC_TREE_COMMON \ - int type; \ - mds_kbdc_tree_t* next; \ - size_t loc_line; \ - size_t loc_start; \ - size_t loc_end; \ - long processed +#define MDS_KBDC_TREE_COMMON\ + int type;\ + mds_kbdc_tree_t *next;\ + size_t loc_line;\ + size_t loc_start;\ + size_t loc_end;\ + long processed /** * This macro is used in this header file, and is then @@ -211,7 +211,7 @@ typedef union mds_kbdc_tree mds_kbdc_tree_t; * @param S:size_t The size of the data structure excluding this padding and * the members defined by the macro `MDS_KBDC_TREE_COMMON` */ -#define MDS_KBDC_TREE_PADDING_(S) char _padding[(5 * sizeof(void*) - (S)) / sizeof(char)] +#define MDS_KBDC_TREE_PADDING_(S) char _padding[(5 * sizeof(void*) - (S)) / sizeof(char)] /** * This macro is used in this header file, and is then @@ -221,7 +221,7 @@ typedef union mds_kbdc_tree mds_kbdc_tree_t; * structure excluding this padding and the members defined * by the macro `MDS_KBDC_TREE_COMMON` */ -#define MDS_KBDC_TREE_PADDING(N) MDS_KBDC_TREE_PADDING_((N) * sizeof(void*)) +#define MDS_KBDC_TREE_PADDING(N) MDS_KBDC_TREE_PADDING_((N) * sizeof(void*)) @@ -232,17 +232,16 @@ typedef union mds_kbdc_tree mds_kbdc_tree_t; * the common members, a pointer to the first * node on next level in the tree */ -struct mds_kbdc_tree_nesting -{ - MDS_KBDC_TREE_COMMON; - - /** - * The first child node, `.inner.next` - * is used to access the second child node. - */ - mds_kbdc_tree_t* inner; - - MDS_KBDC_TREE_PADDING(1); +struct mds_kbdc_tree_nesting { + MDS_KBDC_TREE_COMMON; + + /** + * The first child node, `.inner.next` + * is used to access the second child node. + */ + mds_kbdc_tree_t *inner; + + MDS_KBDC_TREE_PADDING(1); }; @@ -258,16 +257,15 @@ typedef struct mds_kbdc_tree_nesting mds_kbdc_tree_information_t; * for the tree structurs for the information * entries: the children of `mds_kbdc_tree_information_t` */ -struct mds_kbdc_tree_information_data -{ - MDS_KBDC_TREE_COMMON; - - /** - * The value of the information entry - */ - char* data; - - MDS_KBDC_TREE_PADDING(1); +struct mds_kbdc_tree_information_data { + MDS_KBDC_TREE_COMMON; + + /** + * The value of the information entry + */ + char *data; + + MDS_KBDC_TREE_PADDING(1); }; @@ -290,27 +288,25 @@ typedef struct mds_kbdc_tree_information_data mds_kbdc_tree_information_variant_ /** * Leaf structure for inclusion of a file */ -typedef struct mds_kbdc_tree_include -{ - MDS_KBDC_TREE_COMMON; - - /** - * The included layout code tree - */ - mds_kbdc_tree_t* inner; - - /** - * The filename of the file to include - */ - char* filename; - - /** - * The source code of the file included by this statement - */ - mds_kbdc_source_code_t* source_code; - - MDS_KBDC_TREE_PADDING(3); - +typedef struct mds_kbdc_tree_include { + MDS_KBDC_TREE_COMMON; + + /** + * The included layout code tree + */ + mds_kbdc_tree_t *inner; + + /** + * The filename of the file to include + */ + char *filename; + + /** + * The source code of the file included by this statement + */ + mds_kbdc_source_code_t* source_code; + + MDS_KBDC_TREE_PADDING(3); } mds_kbdc_tree_include_t; @@ -320,28 +316,27 @@ typedef struct mds_kbdc_tree_include * for tree structurs that define a callable * element */ -struct mds_kbdc_tree_callable -{ - MDS_KBDC_TREE_COMMON; - - /** - * The first child node, `.inner.next` - * is used to access the second child node - */ - mds_kbdc_tree_t* inner; - - /* It is important that `.inner` is first because - * it is first in `struct mds_kbdc_tree_nesting` - * too which means that `.inner` has to same - * offset everyever (except in `mds_kbdc_tree_if_t`). - */ - - /** - * The name of the callable - */ - char* name; - - MDS_KBDC_TREE_PADDING(2); +struct mds_kbdc_tree_callable { + MDS_KBDC_TREE_COMMON; + + /** + * The first child node, `.inner.next` + * is used to access the second child node + */ + mds_kbdc_tree_t *inner; + + /* It is important that `.inner` is first because + * it is first in `struct mds_kbdc_tree_nesting` + * too which means that `.inner` has to same + * offset everyever (except in `mds_kbdc_tree_if_t`). + */ + + /** + * The name of the callable + */ + char *name; + + MDS_KBDC_TREE_PADDING(2); }; @@ -366,17 +361,15 @@ typedef struct mds_kbdc_tree_nesting mds_kbdc_tree_assumption_t; * Tree structure for making the assumption * that there is a mapping to a key or string */ -typedef struct mds_kbdc_tree_assumption_have -{ - MDS_KBDC_TREE_COMMON; - - /** - * The key or string - */ - mds_kbdc_tree_t* data; - - MDS_KBDC_TREE_PADDING(1); - +typedef struct mds_kbdc_tree_assumption_have { + MDS_KBDC_TREE_COMMON; + + /** + * The key or string + */ + mds_kbdc_tree_t *data; + + MDS_KBDC_TREE_PADDING(1); } mds_kbdc_tree_assumption_have_t; @@ -384,17 +377,15 @@ typedef struct mds_kbdc_tree_assumption_have * Leaf structure for making the assumption * that there are mappings to a set of characters */ -typedef struct mds_kbdc_tree_assumption_have_chars -{ - MDS_KBDC_TREE_COMMON; - - /** - * The characters - */ - char* chars; - - MDS_KBDC_TREE_PADDING(1); - +typedef struct mds_kbdc_tree_assumption_have_chars { + MDS_KBDC_TREE_COMMON; + + /** + * The characters + */ + char *chars; + + MDS_KBDC_TREE_PADDING(1); } mds_kbdc_tree_assumption_have_chars_t; @@ -402,91 +393,85 @@ typedef struct mds_kbdc_tree_assumption_have_chars * Leaf structure for making the assumption * that there are mappings to a range of characters */ -typedef struct mds_kbdc_tree_assumption_have_range -{ - MDS_KBDC_TREE_COMMON; - - /** - * The first character, inclusive - */ - char* first; - - /** - * The last character, inclusive - */ - char* last; - - MDS_KBDC_TREE_PADDING(2); - +typedef struct mds_kbdc_tree_assumption_have_range { + MDS_KBDC_TREE_COMMON; + + /** + * The first character, inclusive + */ + char *first; + + /** + * The last character, inclusive + */ + char *last; + + MDS_KBDC_TREE_PADDING(2); } mds_kbdc_tree_assumption_have_range_t; /** * Tree structure for a "for"-loop */ -typedef struct mds_kbdc_tree_for -{ - MDS_KBDC_TREE_COMMON; - - /** - * The first child node, `.inner.next` is - * used to access the second child node. - * This is what should be done inside the loop. - */ - mds_kbdc_tree_t* inner; - - /* It is important that `.inner` is first because - * it is first in `struct mds_kbdc_tree_nesting` - * too which means that `.inner` has to same - * offset everyever (except in `mds_kbdc_tree_if_t`). - */ - - /** - * The first value to variable should take, inclusive - */ - char* first; - - /** - * The last value the variable should take, inclusive - */ - char* last; - - /** - * The variable - */ - char* variable; - - MDS_KBDC_TREE_PADDING(4); - +typedef struct mds_kbdc_tree_for { + MDS_KBDC_TREE_COMMON; + + /** + * The first child node, `.inner.next` is + * used to access the second child node. + * This is what should be done inside the loop. + */ + mds_kbdc_tree_t *inner; + + /* It is important that `.inner` is first because + * it is first in `struct mds_kbdc_tree_nesting` + * too which means that `.inner` has to same + * offset everyever (except in `mds_kbdc_tree_if_t`). + */ + + /** + * The first value to variable should take, inclusive + */ + char *first; + + /** + * The last value the variable should take, inclusive + */ + char *last; + + /** + * The variable + */ + char *variable; + + MDS_KBDC_TREE_PADDING(4); } mds_kbdc_tree_for_t; /** * Tree structure for a "if"-statement */ -typedef struct mds_kbdc_tree_if -{ - MDS_KBDC_TREE_COMMON; - - /** - * The condition - */ - char* condition; - - /** - * This is what should be done inside - * if the condition is satisfied - */ - mds_kbdc_tree_t* inner; - - /** - * This is what should be done inside - * if the condition is not satisfied - */ - mds_kbdc_tree_t* otherwise; - - MDS_KBDC_TREE_PADDING(3); - +typedef struct mds_kbdc_tree_if { + MDS_KBDC_TREE_COMMON; + + /** + * The condition + */ + char *condition; + + /** + * This is what should be done inside + * if the condition is satisfied + */ + mds_kbdc_tree_t *inner; + + /** + * This is what should be done inside + * if the condition is not satisfied + */ + mds_kbdc_tree_t *otherwise; + + MDS_KBDC_TREE_PADDING(3); } mds_kbdc_tree_if_t; @@ -494,22 +479,20 @@ typedef struct mds_kbdc_tree_if * Tree structure for assigning a value to a variable, * possibly declaring the variable in the process */ -typedef struct mds_kbdc_tree_let -{ - MDS_KBDC_TREE_COMMON; - - /** - * The variable - */ - char* variable; - - /** - * The value to assign to the variable - */ - mds_kbdc_tree_t* value; - - MDS_KBDC_TREE_PADDING(2); - +typedef struct mds_kbdc_tree_let { + MDS_KBDC_TREE_COMMON; + + /** + * The variable + */ + char *variable; + + /** + * The value to assign to the variable + */ + mds_kbdc_tree_t *value; + + MDS_KBDC_TREE_PADDING(2); } mds_kbdc_tree_let_t; @@ -522,127 +505,115 @@ typedef struct mds_kbdc_tree_let * in such case `sequence` should not be `NULL` but * `sequence.next` and `result` should be `NULL` */ -typedef struct mds_kbdc_tree_map -{ - MDS_KBDC_TREE_COMMON; - - /** - * The input sequence - */ - mds_kbdc_tree_t* sequence; - - /** - * The output sequence - */ - mds_kbdc_tree_t* result; - - /* - * These are ordered so that `mds_kbdc_tree_t.macro_call.arguments` - * and `mds_kbdc_tree_t.map.sequence` have the same address. - */ - - MDS_KBDC_TREE_PADDING(2); - +typedef struct mds_kbdc_tree_map { + MDS_KBDC_TREE_COMMON; + + /** + * The input sequence + */ + mds_kbdc_tree_t *sequence; + + /** + * The output sequence + */ + mds_kbdc_tree_t *result; + + /* + * These are ordered so that `mds_kbdc_tree_t.macro_call.arguments` + * and `mds_kbdc_tree_t.map.sequence` have the same address. + */ + + MDS_KBDC_TREE_PADDING(2); } mds_kbdc_tree_map_t; /** * Tree structure for an array of values */ -typedef struct mds_kbdc_tree_array -{ - MDS_KBDC_TREE_COMMON; - - /** - * The first value, `.elements.next` - * is used to access the second value. - */ - mds_kbdc_tree_t* elements; - - MDS_KBDC_TREE_PADDING(1); - +typedef struct mds_kbdc_tree_array { + MDS_KBDC_TREE_COMMON; + + /** + * The first value, `.elements.next` + * is used to access the second value. + */ + mds_kbdc_tree_t *elements; + + MDS_KBDC_TREE_PADDING(1); } mds_kbdc_tree_array_t; /** * Leaf structure for a key-combination */ -typedef struct mds_kbdc_tree_keys -{ - MDS_KBDC_TREE_COMMON; - - /** - * The key-combination - */ - char* keys; - - MDS_KBDC_TREE_PADDING(1); - +typedef struct mds_kbdc_tree_keys { + MDS_KBDC_TREE_COMMON; + + /** + * The key-combination + */ + char *keys; + + MDS_KBDC_TREE_PADDING(1); } mds_kbdc_tree_keys_t; /** * Leaf structure for a string */ -typedef struct mds_kbdc_tree_string -{ - MDS_KBDC_TREE_COMMON; - - /** - * The string - */ - char* string; - - /* - * `evaluate_element` in "compile-layout.c" utilises - * that `mds_kbdc_tree_string.string` has the same - * offset as `mds_kbdc_tree_keys.keys`. - */ - - MDS_KBDC_TREE_PADDING(1); - +typedef struct mds_kbdc_tree_string { + MDS_KBDC_TREE_COMMON; + + /** + * The string + */ + char *string; + + /* + * `evaluate_element` in "compile-layout.c" utilises + * that `mds_kbdc_tree_string.string` has the same + * offset as `mds_kbdc_tree_keys.keys`. + */ + + MDS_KBDC_TREE_PADDING(1); } mds_kbdc_tree_string_t; /** * Leaf structure for a compiled key-combination */ -typedef struct mds_kbdc_tree_compiled_keys -{ - MDS_KBDC_TREE_COMMON; - - /** - * The key-combination - * - * Strictly terminated by -1 - */ - char32_t* keys; - - MDS_KBDC_TREE_PADDING(1); - +typedef struct mds_kbdc_tree_compiled_keys { + MDS_KBDC_TREE_COMMON; + + /** + * The key-combination + * + * Strictly terminated by -1 + */ + char32_t *keys; + + MDS_KBDC_TREE_PADDING(1); } mds_kbdc_tree_compiled_keys_t; /** * Leaf structure for a compiled string */ -typedef struct mds_kbdc_tree_compiled_string -{ - MDS_KBDC_TREE_COMMON; - - /** - * The string - */ - char32_t* string; - - /* - * `evaluate_element` in "compile-layout.c" utilises - * that `mds_kbdc_tree_string.compiled_string` has the - * same offset as `mds_kbdc_tree_keys.compiled_keys`. - */ - - MDS_KBDC_TREE_PADDING(1); - +typedef struct mds_kbdc_tree_compiled_string { + MDS_KBDC_TREE_COMMON; + + /** + * The string + */ + char32_t *string; + + /* + * `evaluate_element` in "compile-layout.c" utilises + * that `mds_kbdc_tree_string.compiled_string` has the + * same offset as `mds_kbdc_tree_keys.compiled_keys`. + */ + + MDS_KBDC_TREE_PADDING(1); } mds_kbdc_tree_compiled_string_t; @@ -652,11 +623,9 @@ typedef struct mds_kbdc_tree_compiled_string * Other leaf structures without any content may `typedef` * this structure */ -typedef struct mds_kbdc_tree_nothing -{ - MDS_KBDC_TREE_COMMON; - MDS_KBDC_TREE_PADDING(0); - +typedef struct mds_kbdc_tree_nothing { + MDS_KBDC_TREE_COMMON; + MDS_KBDC_TREE_PADDING(0); } mds_kbdc_tree_nothing_t; @@ -682,29 +651,27 @@ typedef struct mds_kbdc_tree_nesting mds_kbdc_tree_ordered_t; /** * Tree structure for a macro call */ -typedef struct mds_kbdc_tree_macro_call -{ - MDS_KBDC_TREE_COMMON; - - /** - * The first input argument for the - * macro call, the second is accessed - * using `.arguments.next` - */ - mds_kbdc_tree_t* arguments; - - /** - * The name of the macro - */ - char* name; - - /* - * These are ordered so that `mds_kbdc_tree_t.macro_call.arguments` - * and `mds_kbdc_tree_t.map.sequence` have the same address. - */ - - MDS_KBDC_TREE_PADDING(2); - +typedef struct mds_kbdc_tree_macro_call { + MDS_KBDC_TREE_COMMON; + + /** + * The first input argument for the + * macro call, the second is accessed + * using `.arguments.next` + */ + mds_kbdc_tree_t *arguments; + + /** + * The name of the macro + */ + char *name; + + /* + * These are ordered so that `mds_kbdc_tree_t.macro_call.arguments` + * and `mds_kbdc_tree_t.map.sequence` have the same address. + */ + + MDS_KBDC_TREE_PADDING(2); } mds_kbdc_tree_macro_call_t; @@ -728,45 +695,47 @@ typedef struct mds_kbdc_tree_nothing mds_kbdc_tree_continue_t; /** * Keyboard layout syntax tree */ -union mds_kbdc_tree -{ +union mds_kbdc_tree { +#if defined(__GNUC__) # pragma GCC diagnostic push # pragma GCC diagnostic ignored "-Wpedantic" /* unnamed struct */ - struct - { - MDS_KBDC_TREE_COMMON; - MDS_KBDC_TREE_PADDING(0); - }; +#endif + struct { + MDS_KBDC_TREE_COMMON; + MDS_KBDC_TREE_PADDING(0); + }; +#if defined(__GNUC__) # pragma GCC diagnostic pop - - mds_kbdc_tree_information_t information; - mds_kbdc_tree_information_language_t language; - mds_kbdc_tree_information_country_t country; - mds_kbdc_tree_information_variant_t variant; - mds_kbdc_tree_include_t include; - mds_kbdc_tree_function_t function; - mds_kbdc_tree_macro_t macro; - mds_kbdc_tree_assumption_t assumption; - mds_kbdc_tree_assumption_have_t have; - mds_kbdc_tree_assumption_have_chars_t have_chars; - mds_kbdc_tree_assumption_have_range_t have_range; - mds_kbdc_tree_for_t for_; - mds_kbdc_tree_if_t if_; - mds_kbdc_tree_let_t let; - mds_kbdc_tree_map_t map; - mds_kbdc_tree_array_t array; - mds_kbdc_tree_keys_t keys; - mds_kbdc_tree_string_t string; - mds_kbdc_tree_compiled_keys_t compiled_keys; - mds_kbdc_tree_compiled_string_t compiled_string; - mds_kbdc_tree_nothing_t nothing; - mds_kbdc_tree_alternation_t alternation; - mds_kbdc_tree_unordered_t unordered; - mds_kbdc_tree_ordered_t ordered; - mds_kbdc_tree_macro_call_t macro_call; - mds_kbdc_tree_return_t return_; - mds_kbdc_tree_break_t break_; - mds_kbdc_tree_continue_t continue_; +#endif + + mds_kbdc_tree_information_t information; + mds_kbdc_tree_information_language_t language; + mds_kbdc_tree_information_country_t country; + mds_kbdc_tree_information_variant_t variant; + mds_kbdc_tree_include_t include; + mds_kbdc_tree_function_t function; + mds_kbdc_tree_macro_t macro; + mds_kbdc_tree_assumption_t assumption; + mds_kbdc_tree_assumption_have_t have; + mds_kbdc_tree_assumption_have_chars_t have_chars; + mds_kbdc_tree_assumption_have_range_t have_range; + mds_kbdc_tree_for_t for_; + mds_kbdc_tree_if_t if_; + mds_kbdc_tree_let_t let; + mds_kbdc_tree_map_t map; + mds_kbdc_tree_array_t array; + mds_kbdc_tree_keys_t keys; + mds_kbdc_tree_string_t string; + mds_kbdc_tree_compiled_keys_t compiled_keys; + mds_kbdc_tree_compiled_string_t compiled_string; + mds_kbdc_tree_nothing_t nothing; + mds_kbdc_tree_alternation_t alternation; + mds_kbdc_tree_unordered_t unordered; + mds_kbdc_tree_ordered_t ordered; + mds_kbdc_tree_macro_call_t macro_call; + mds_kbdc_tree_return_t return_; + mds_kbdc_tree_break_t break_; + mds_kbdc_tree_continue_t continue_; }; @@ -777,7 +746,7 @@ union mds_kbdc_tree * @param this The memory slot for the tree node * @param type The type of the node */ -void mds_kbdc_tree_initialise(mds_kbdc_tree_t* restrict this, int type); +void mds_kbdc_tree_initialise(mds_kbdc_tree_t *restrict this, int type); /** * Create a tree node @@ -785,7 +754,7 @@ void mds_kbdc_tree_initialise(mds_kbdc_tree_t* restrict this, int type); * @param type The type of the node * @return The tree node, `NULL` on error */ -mds_kbdc_tree_t* mds_kbdc_tree_create(int type); +mds_kbdc_tree_t *mds_kbdc_tree_create(int type); /** * Release all resources stored in a tree node, @@ -794,7 +763,7 @@ mds_kbdc_tree_t* mds_kbdc_tree_create(int type); * * @param this The tree node */ -void mds_kbdc_tree_destroy_nonrecursive(mds_kbdc_tree_t* restrict this); +void mds_kbdc_tree_destroy_nonrecursive(mds_kbdc_tree_t *restrict this); /** * Release all resources stored in a tree node, @@ -804,7 +773,7 @@ void mds_kbdc_tree_destroy_nonrecursive(mds_kbdc_tree_t* restrict this); * * @param this The tree node */ -void mds_kbdc_tree_free_nonrecursive(mds_kbdc_tree_t* restrict this); +void mds_kbdc_tree_free_nonrecursive(mds_kbdc_tree_t *restrict this); /** * Release all resources stored in a tree node @@ -813,7 +782,7 @@ void mds_kbdc_tree_free_nonrecursive(mds_kbdc_tree_t* restrict this); * * @param this The tree node */ -void mds_kbdc_tree_destroy(mds_kbdc_tree_t* restrict this); +void mds_kbdc_tree_destroy(mds_kbdc_tree_t *restrict this); /** * Release all resources stored in a tree node @@ -822,7 +791,7 @@ void mds_kbdc_tree_destroy(mds_kbdc_tree_t* restrict this); * * @param this The tree node */ -void mds_kbdc_tree_free(mds_kbdc_tree_t* restrict this); +void mds_kbdc_tree_free(mds_kbdc_tree_t *restrict this); /** @@ -832,7 +801,7 @@ void mds_kbdc_tree_free(mds_kbdc_tree_t* restrict this); * @param this The tree node * @return A duplicate of `this`, `NULL` on error */ -mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this); +mds_kbdc_tree_t *mds_kbdc_tree_dup(const mds_kbdc_tree_t *restrict this); /** @@ -841,7 +810,7 @@ mds_kbdc_tree_t* mds_kbdc_tree_dup(const mds_kbdc_tree_t* restrict this); * @param this The tree node * @param output The output file */ -void mds_kbdc_tree_print(const mds_kbdc_tree_t* restrict this, FILE* output); +void mds_kbdc_tree_print(const mds_kbdc_tree_t *restrict this, FILE *output); @@ -850,4 +819,3 @@ void mds_kbdc_tree_print(const mds_kbdc_tree_t* restrict this, FILE* output); #undef MDS_KBDC_TREE_COMMON #endif - diff --git a/src/mds-kbdc/validate-tree.c b/src/mds-kbdc/validate-tree.c index 632b9a8..80ef7d5 100644 --- a/src/mds-kbdc/validate-tree.c +++ b/src/mds-kbdc/validate-tree.c @@ -28,12 +28,12 @@ /** * Tree type constant shortener */ -#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE +#define C(TYPE) MDS_KBDC_TREE_TYPE_##TYPE /** * Check the value of `innermost_visit` */ -#define VISITING(TYPE) (innermost_visit == MDS_KBDC_TREE_TYPE_##TYPE) +#define VISITING(TYPE) (innermost_visit == MDS_KBDC_TREE_TYPE_##TYPE) /** * Add an error with “included from here”-notes to the error list @@ -44,20 +44,20 @@ * @param ...:const char*, ... Error description format string and arguments * @scope error:mds_kbdc_parse_error_t* Variable where the new error will be stored */ -#define NEW_ERROR(NODE, PTR, SEVERITY, ...) \ - NEW_ERROR_WITH_INCLUDES(NODE, PTR, SEVERITY, __VA_ARGS__) +#define NEW_ERROR(NODE, PTR, SEVERITY, ...)\ + NEW_ERROR_WITH_INCLUDES(NODE, PTR, SEVERITY, __VA_ARGS__) /** * Variable whether the latest created error is stored */ -static mds_kbdc_parse_error_t* error; +static mds_kbdc_parse_error_t *error; /** * The parameter of `validate_tree` */ -static mds_kbdc_parsed_t* restrict result; +static mds_kbdc_parsed_t *restrict result; /** * The number visited for-statements @@ -67,22 +67,22 @@ static size_t fors = 0; /** * The function definition that is currently being visited */ -static mds_kbdc_tree_function_t* function = NULL; +static mds_kbdc_tree_function_t *function = NULL; /** * The macro definition that is currently being visited */ -static mds_kbdc_tree_macro_t* macro = NULL; +static mds_kbdc_tree_macro_t *macro = NULL; /** * The information clause that is currently being visited */ -static mds_kbdc_tree_information_t* information = NULL; +static mds_kbdc_tree_information_t *information = NULL; /** * The assumption clause that is currently being visited */ -static mds_kbdc_tree_assumption_t* assumption = NULL; +static mds_kbdc_tree_assumption_t *assumption = NULL; /** * The value `includes_ptr` had when `function`, @@ -105,7 +105,7 @@ static int innermost_visit = -1; * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_subtree(mds_kbdc_tree_t* restrict tree); +static int validate_subtree(mds_kbdc_tree_t *restrict tree); @@ -115,17 +115,18 @@ static int validate_subtree(mds_kbdc_tree_t* restrict tree); * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_include(mds_kbdc_tree_include_t* restrict tree) +static int +validate_include(mds_kbdc_tree_include_t *restrict tree) { - void* data; - int r; - fail_if (mds_kbdc_include_stack_push(tree, &data)); - r = validate_subtree(tree->inner); - mds_kbdc_include_stack_pop(data); - fail_if (r); - return 0; - fail: - return -1; + void *data; + int r; + fail_if (mds_kbdc_include_stack_push(tree, &data)); + r = validate_subtree(tree->inner); + mds_kbdc_include_stack_pop(data); + fail_if (r); + return 0; +fail: + return -1; } @@ -135,34 +136,30 @@ static int validate_include(mds_kbdc_tree_include_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_function(mds_kbdc_tree_function_t* restrict tree) +static int +validate_function(mds_kbdc_tree_function_t *restrict tree) { - int r; - if (VISITING(FUNCTION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "nested function definition"); - NEW_ERROR(function, def_includes_ptr, NOTE, "outer function defined here"); - return 0; - } - else if (VISITING(MACRO)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "function definition inside macro definition"); - NEW_ERROR(macro, def_includes_ptr, NOTE, "outer macro defined here"); - return 0; - } - else if (VISITING(INFORMATION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "function definition inside information clause"); - NEW_ERROR(information, def_includes_ptr, NOTE, "outer information clause defined here"); - return 0; - } - innermost_visit = tree->type; - function = tree; - def_includes_ptr = includes_ptr; - r = validate_subtree(tree->inner); - return function = NULL, r; - fail: - return -1; + int r; + if (VISITING(FUNCTION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "nested function definition"); + NEW_ERROR(function, def_includes_ptr, NOTE, "outer function defined here"); + return 0; + } else if (VISITING(MACRO)) { + NEW_ERROR(tree, includes_ptr, ERROR, "function definition inside macro definition"); + NEW_ERROR(macro, def_includes_ptr, NOTE, "outer macro defined here"); + return 0; + } else if (VISITING(INFORMATION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "function definition inside information clause"); + NEW_ERROR(information, def_includes_ptr, NOTE, "outer information clause defined here"); + return 0; + } + innermost_visit = tree->type; + function = tree; + def_includes_ptr = includes_ptr; + r = validate_subtree(tree->inner); + return function = NULL, r; +fail: + return -1; } @@ -172,34 +169,30 @@ static int validate_function(mds_kbdc_tree_function_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_macro(mds_kbdc_tree_macro_t* restrict tree) +static int +validate_macro(mds_kbdc_tree_macro_t *restrict tree) { - int r; - if (VISITING(FUNCTION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "macro definition inside function definition"); - NEW_ERROR(function, def_includes_ptr, NOTE, "outer function definition defined here"); - return 0; - } - else if (VISITING(MACRO)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "nested macro definition"); - NEW_ERROR(macro, def_includes_ptr, NOTE, "outer macro defined here"); - return 0; - } - else if (VISITING(INFORMATION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "macro definition inside information clause"); - NEW_ERROR(information, def_includes_ptr, NOTE, "outer information clause defined here"); - return 0; - } - innermost_visit = tree->type; - macro = tree; - def_includes_ptr = includes_ptr; - r = validate_subtree(tree->inner); - return macro = NULL, r; - fail: - return -1; + int r; + if (VISITING(FUNCTION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "macro definition inside function definition"); + NEW_ERROR(function, def_includes_ptr, NOTE, "outer function definition defined here"); + return 0; + } else if (VISITING(MACRO)) { + NEW_ERROR(tree, includes_ptr, ERROR, "nested macro definition"); + NEW_ERROR(macro, def_includes_ptr, NOTE, "outer macro defined here"); + return 0; + } else if (VISITING(INFORMATION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "macro definition inside information clause"); + NEW_ERROR(information, def_includes_ptr, NOTE, "outer information clause defined here"); + return 0; + } + innermost_visit = tree->type; + macro = tree; + def_includes_ptr = includes_ptr; + r = validate_subtree(tree->inner); + return macro = NULL, r; +fail: + return -1; } @@ -209,40 +202,34 @@ static int validate_macro(mds_kbdc_tree_macro_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_information(mds_kbdc_tree_information_t* restrict tree) +static int +validate_information(mds_kbdc_tree_information_t *restrict tree) { - int r; - if (VISITING(FUNCTION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "information clause inside function definition"); - NEW_ERROR(function, def_includes_ptr, NOTE, "outer function definition defined here"); - return 0; - } - else if (VISITING(MACRO)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "information clause inside macro definition"); - NEW_ERROR(macro, def_includes_ptr, NOTE, "outer macro defined here"); - return 0; - } - else if (VISITING(INFORMATION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "nested information clause"); - NEW_ERROR(information, def_includes_ptr, NOTE, "outer information clause defined here"); - return 0; - } - else if (VISITING(ASSUMPTION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "information clause inside assumption clause"); - NEW_ERROR(assumption, def_includes_ptr, NOTE, "outer assumption clause defined here"); - return 0; - } - innermost_visit = tree->type; - information = tree; - def_includes_ptr = includes_ptr; - r = validate_subtree(tree->inner); - return information = NULL, r; - fail: - return -1; + int r; + if (VISITING(FUNCTION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "information clause inside function definition"); + NEW_ERROR(function, def_includes_ptr, NOTE, "outer function definition defined here"); + return 0; + } else if (VISITING(MACRO)) { + NEW_ERROR(tree, includes_ptr, ERROR, "information clause inside macro definition"); + NEW_ERROR(macro, def_includes_ptr, NOTE, "outer macro defined here"); + return 0; + } else if (VISITING(INFORMATION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "nested information clause"); + NEW_ERROR(information, def_includes_ptr, NOTE, "outer information clause defined here"); + return 0; + } else if (VISITING(ASSUMPTION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "information clause inside assumption clause"); + NEW_ERROR(assumption, def_includes_ptr, NOTE, "outer assumption clause defined here"); + return 0; + } + innermost_visit = tree->type; + information = tree; + def_includes_ptr = includes_ptr; + r = validate_subtree(tree->inner); + return information = NULL, r; +fail: + return -1; } @@ -252,40 +239,34 @@ static int validate_information(mds_kbdc_tree_information_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_assumption(mds_kbdc_tree_assumption_t* restrict tree) +static int +validate_assumption(mds_kbdc_tree_assumption_t *restrict tree) { - int r; - if (VISITING(FUNCTION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "assumption clause inside function definition"); - NEW_ERROR(function, def_includes_ptr, NOTE, "outer function definition defined here"); - return 0; - } - else if (VISITING(MACRO)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "assumption clause inside macro definition"); - NEW_ERROR(macro, def_includes_ptr, NOTE, "outer macro defined here"); - return 0; - } - else if (VISITING(INFORMATION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "assumption clause inside information clause"); - NEW_ERROR(information, def_includes_ptr, NOTE, "outer information clause defined here"); - return 0; - } - else if (VISITING(ASSUMPTION)) - { - NEW_ERROR(tree, includes_ptr, ERROR, "nested assumption clause"); - NEW_ERROR(assumption, def_includes_ptr, NOTE, "outer assumption clause defined here"); - return 0; - } - innermost_visit = tree->type; - assumption = tree; - def_includes_ptr = includes_ptr; - r = validate_subtree(tree->inner); - return assumption = NULL, r; - fail: - return -1; + int r; + if (VISITING(FUNCTION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "assumption clause inside function definition"); + NEW_ERROR(function, def_includes_ptr, NOTE, "outer function definition defined here"); + return 0; + } else if (VISITING(MACRO)) { + NEW_ERROR(tree, includes_ptr, ERROR, "assumption clause inside macro definition"); + NEW_ERROR(macro, def_includes_ptr, NOTE, "outer macro defined here"); + return 0; + } else if (VISITING(INFORMATION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "assumption clause inside information clause"); + NEW_ERROR(information, def_includes_ptr, NOTE, "outer information clause defined here"); + return 0; + } else if (VISITING(ASSUMPTION)) { + NEW_ERROR(tree, includes_ptr, ERROR, "nested assumption clause"); + NEW_ERROR(assumption, def_includes_ptr, NOTE, "outer assumption clause defined here"); + return 0; + } + innermost_visit = tree->type; + assumption = tree; + def_includes_ptr = includes_ptr; + r = validate_subtree(tree->inner); + return assumption = NULL, r; +fail: + return -1; } @@ -295,25 +276,26 @@ static int validate_assumption(mds_kbdc_tree_assumption_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_map(mds_kbdc_tree_map_t* restrict tree) +static int +validate_map(mds_kbdc_tree_map_t *restrict tree) { - int is_value = tree->result == NULL; - if (is_value); - /* We do not want value-statments outside function - * definitions, however, we do want \set/3 to be usable, - * from anywhere, even indirectly, therefore we cannot, - * at this process level, determine whether a - * value-statement is used correctly or not. - */ - else if (VISITING(INFORMATION)) - NEW_ERROR(tree, includes_ptr, ERROR, "mapping-statement inside information clause"); - else if (VISITING(ASSUMPTION)) - NEW_ERROR(tree, includes_ptr, ERROR, "mapping-statement inside assumption clause"); - else if (VISITING(FUNCTION)) - NEW_ERROR(tree, includes_ptr, ERROR, "mapping-statement inside function definition"); - return 0; + int is_value = tree->result == NULL; + if (is_value) + /* We do not want value-statments outside function + * definitions, however, we do want \set/3 to be usable, + * from anywhere, even indirectly, therefore we cannot, + * at this process level, determine whether a + * value-statement is used correctly or not. + */; + else if (VISITING(INFORMATION)) + NEW_ERROR(tree, includes_ptr, ERROR, "mapping-statement inside information clause"); + else if (VISITING(ASSUMPTION)) + NEW_ERROR(tree, includes_ptr, ERROR, "mapping-statement inside assumption clause"); + else if (VISITING(FUNCTION)) + NEW_ERROR(tree, includes_ptr, ERROR, "mapping-statement inside function definition"); + return 0; fail: - return -1; + return -1; } @@ -323,17 +305,18 @@ static int validate_map(mds_kbdc_tree_map_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_macro_call(mds_kbdc_tree_macro_call_t* restrict tree) +static int +validate_macro_call(mds_kbdc_tree_macro_call_t *restrict tree) { - if (VISITING(INFORMATION)) - NEW_ERROR(tree, includes_ptr, ERROR, "macro call inside information clause"); - else if (VISITING(ASSUMPTION)) - NEW_ERROR(tree, includes_ptr, ERROR, "macro call inside assumption clause"); - else if (VISITING(FUNCTION)) - NEW_ERROR(tree, includes_ptr, ERROR, "macro call inside function definition"); - return 0; - fail: - return -1; + if (VISITING(INFORMATION)) + NEW_ERROR(tree, includes_ptr, ERROR, "macro call inside information clause"); + else if (VISITING(ASSUMPTION)) + NEW_ERROR(tree, includes_ptr, ERROR, "macro call inside assumption clause"); + else if (VISITING(FUNCTION)) + NEW_ERROR(tree, includes_ptr, ERROR, "macro call inside function definition"); + return 0; +fail: + return -1; } @@ -343,14 +326,15 @@ static int validate_macro_call(mds_kbdc_tree_macro_call_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_for(mds_kbdc_tree_for_t* restrict tree) +static int +validate_for(mds_kbdc_tree_for_t *restrict tree) { - int r; - fors++, r = validate_subtree(tree->inner), fors--; - fail_if (r); - return 0; - fail: - return -1; + int r; + fors++, r = validate_subtree(tree->inner), fors--; + fail_if (r); + return 0; +fail: + return -1; } @@ -360,12 +344,13 @@ static int validate_for(mds_kbdc_tree_for_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_if(mds_kbdc_tree_if_t* restrict tree) +static int +validate_if(mds_kbdc_tree_if_t *restrict tree) { - fail_if ((validate_subtree(tree->inner) || validate_subtree(tree->otherwise))); - return 0; - fail: - return -1; + fail_if ((validate_subtree(tree->inner) || validate_subtree(tree->otherwise))); + return 0; +fail: + return -1; } @@ -375,13 +360,14 @@ static int validate_if(mds_kbdc_tree_if_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_return(mds_kbdc_tree_return_t* restrict tree) +static int +validate_return(mds_kbdc_tree_return_t *restrict tree) { - if ((function == NULL) && (macro == NULL)) - NEW_ERROR(tree, includes_ptr, ERROR, "‘return’ outside function and macro definition"); - return 0; - fail: - return -1; + if (!function && !macro) + NEW_ERROR(tree, includes_ptr, ERROR, "‘return’ outside function and macro definition"); + return 0; +fail: + return -1; } @@ -391,13 +377,14 @@ static int validate_return(mds_kbdc_tree_return_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_break(mds_kbdc_tree_break_t* restrict tree) +static int +validate_break(mds_kbdc_tree_break_t *restrict tree) { - if (fors == 0) - NEW_ERROR(tree, includes_ptr, ERROR, "‘break’ outside ‘for’"); - return 0; - fail: - return -1; + if (!fors) + NEW_ERROR(tree, includes_ptr, ERROR, "‘break’ outside ‘for’"); + return 0; +fail: + return -1; } @@ -407,13 +394,14 @@ static int validate_break(mds_kbdc_tree_break_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_continue(mds_kbdc_tree_continue_t* restrict tree) +static int +validate_continue(mds_kbdc_tree_continue_t *restrict tree) { - if (fors == 0) - NEW_ERROR(tree, includes_ptr, ERROR, "‘continue’ outside ‘for’"); - return 0; - fail: - return -1; + if (!fors) + NEW_ERROR(tree, includes_ptr, ERROR, "‘continue’ outside ‘for’"); + return 0; +fail: + return -1; } @@ -423,13 +411,14 @@ static int validate_continue(mds_kbdc_tree_continue_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_assumption_data(mds_kbdc_tree_t* restrict tree) +static int +validate_assumption_data(mds_kbdc_tree_t *restrict tree) { - if (assumption == NULL) - NEW_ERROR(tree, includes_ptr, ERROR, "assumption outside assumption clause"); - return 0; - fail: - return -1; + if (!assumption) + NEW_ERROR(tree, includes_ptr, ERROR, "assumption outside assumption clause"); + return 0; +fail: + return -1; } @@ -439,13 +428,14 @@ static int validate_assumption_data(mds_kbdc_tree_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_information_data(mds_kbdc_tree_t* restrict tree) +static int +validate_information_data(mds_kbdc_tree_t *restrict tree) { - if (information == NULL) - NEW_ERROR(tree, includes_ptr, ERROR, "information outside information clause"); - return 0; - fail: - return -1; + if (!information) + NEW_ERROR(tree, includes_ptr, ERROR, "information outside information clause"); + return 0; +fail: + return -1; } @@ -455,48 +445,48 @@ static int validate_information_data(mds_kbdc_tree_t* restrict tree) * @param tree The tree to validate * @return Zero on success, -1 on error */ -static int validate_subtree(mds_kbdc_tree_t* restrict tree) +static int +validate_subtree(mds_kbdc_tree_t *restrict tree) { -#define v(type) fail_if (validate_##type(&(tree->type))) -#define V(type) fail_if (validate_##type(&(tree->type##_))) - int old_innermost_visit = innermost_visit; - again: - if (tree == NULL) - return 0; - - switch (tree->type) - { - case C(INFORMATION): v(information); break; - case C(INCLUDE): v(include); break; - case C(FUNCTION): v(function); break; - case C(MACRO): v(macro); break; - case C(ASSUMPTION): v(assumption); break; - case C(FOR): V(for); break; - case C(IF): V(if); break; - case C(MAP): v(map); break; - case C(MACRO_CALL): v(macro_call); break; - case C(RETURN): V(return); break; - case C(BREAK): V(break); break; - case C(CONTINUE): V(continue); break; - case C(INFORMATION_LANGUAGE): - case C(INFORMATION_COUNTRY): - case C(INFORMATION_VARIANT): - fail_if (validate_information_data(tree)); - break; - case C(ASSUMPTION_HAVE): - case C(ASSUMPTION_HAVE_CHARS): - case C(ASSUMPTION_HAVE_RANGE): - fail_if (validate_assumption_data(tree)); - break; - default: - break; - } - - innermost_visit = old_innermost_visit; - tree = tree->next; - goto again; - fail: - return innermost_visit = old_innermost_visit, -1; +#define v(type) fail_if (validate_##type(&(tree->type))) +#define V(type) fail_if (validate_##type(&(tree->type##_))) + int old_innermost_visit = innermost_visit; +again: + if (!tree) + return 0; + + switch (tree->type) { + case C(INFORMATION): v(information); break; + case C(INCLUDE): v(include); break; + case C(FUNCTION): v(function); break; + case C(MACRO): v(macro); break; + case C(ASSUMPTION): v(assumption); break; + case C(FOR): V(for); break; + case C(IF): V(if); break; + case C(MAP): v(map); break; + case C(MACRO_CALL): v(macro_call); break; + case C(RETURN): V(return); break; + case C(BREAK): V(break); break; + case C(CONTINUE): V(continue); break; + case C(INFORMATION_LANGUAGE): + case C(INFORMATION_COUNTRY): + case C(INFORMATION_VARIANT): + fail_if (validate_information_data(tree)); + break; + case C(ASSUMPTION_HAVE): + case C(ASSUMPTION_HAVE_CHARS): + case C(ASSUMPTION_HAVE_RANGE): + fail_if (validate_assumption_data(tree)); + break; + default: + break; + } + + innermost_visit = old_innermost_visit; + tree = tree->next; + goto again; +fail: + return innermost_visit = old_innermost_visit, -1; #undef V #undef v } @@ -508,17 +498,18 @@ static int validate_subtree(mds_kbdc_tree_t* restrict tree) * @param result_ `result` from `process_includes`, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int validate_tree(mds_kbdc_parsed_t* restrict result_) +int +validate_tree(mds_kbdc_parsed_t *restrict result_) { - int r; - mds_kbdc_include_stack_begin(result = result_); - r = validate_subtree(result_->tree); - fors = 0; - mds_kbdc_include_stack_end(); - fail_if (r); - return 0; - fail: - return -1; + int r; + mds_kbdc_include_stack_begin(result = result_); + r = validate_subtree(result_->tree); + fors = 0; + mds_kbdc_include_stack_end(); + fail_if (r); + return 0; +fail: + return -1; } @@ -526,4 +517,3 @@ int validate_tree(mds_kbdc_parsed_t* restrict result_) #undef NEW_ERROR #undef VISITING #undef C - diff --git a/src/mds-kbdc/validate-tree.h b/src/mds-kbdc/validate-tree.h index e32b2f2..5ca9277 100644 --- a/src/mds-kbdc/validate-tree.h +++ b/src/mds-kbdc/validate-tree.h @@ -28,8 +28,7 @@ * @param result `result` from `process_includes`, will be updated * @return -1 if an error occursed that cannot be stored in `result`, zero otherwise */ -int validate_tree(mds_kbdc_parsed_t* restrict result); +int validate_tree(mds_kbdc_parsed_t *restrict result); #endif - diff --git a/src/mds-kbdc/variables.c b/src/mds-kbdc/variables.c index 3b2e128..15a1cb6 100644 --- a/src/mds-kbdc/variables.c +++ b/src/mds-kbdc/variables.c @@ -27,32 +27,30 @@ /** * The state of a variable */ -typedef struct variable -{ - /** - * The current value of the variable - */ - mds_kbdc_tree_t* value; - - /** - * The previous version of variable, - * before it was shadowed - */ - struct variable* restrict previous; - - /** - * The original scope in which the current - * shadow of the variable was created - */ - size_t scope; - - /** - * The latest scope the in which the - * variable has been used in a for-loop, - * `~0' if never, or below `scope` - */ - size_t used_in_for; - +typedef struct variable { + /** + * The current value of the variable + */ + mds_kbdc_tree_t *value; + + /** + * The previous version of variable, + * before it was shadowed + */ + struct variable *restrict previous; + + /** + * The original scope in which the current + * shadow of the variable was created + */ + size_t scope; + + /** + * The latest scope the in which the + * variable has been used in a for-loop, + * `~0' if never, or below `scope` + */ + size_t used_in_for; } variable_t; @@ -60,7 +58,7 @@ typedef struct variable /** * Map (by index) of defined variables */ -static variable_t** restrict variables = NULL; +static variable_t **restrict variables = NULL; /** * The size of `variables` @@ -79,20 +77,21 @@ static size_t current_scope = 0; /** * Destroy the variable storage */ -void variables_terminate(void) +void +variables_terminate(void) { - size_t i; - variable_t* old; - for (i = 0; i < variable_count; i++) - while (variables[i]) - { - old = variables[i]; - variables[i] = variables[i]->previous; - mds_kbdc_tree_free(old->value); - free(old); - } - free(variables), variables = NULL; - variable_count = current_scope = 0; + size_t i; + variable_t *old; + for (i = 0; i < variable_count; i++) { + while (variables[i]) { + old = variables[i]; + variables[i] = variables[i]->previous; + mds_kbdc_tree_free(old->value); + free(old); + } + } + free(variables), variables = NULL; + variable_count = current_scope = 0; } @@ -100,9 +99,10 @@ void variables_terminate(void) * Push the variable-stack, making it * possible to shadow all variables */ -void variables_stack_push(void) +void +variables_stack_push(void) { - current_scope++; + current_scope++; } @@ -112,19 +112,20 @@ void variables_stack_push(void) * since it was last called (without a * corresponding call to this function) */ -void variables_stack_pop(void) +void +variables_stack_pop(void) { - size_t i; - variable_t* old; - for (i = 0; i < variable_count; i++) - if (variables[i] && (variables[i]->scope == current_scope)) - { - old = variables[i]; - variables[i] = variables[i]->previous; - mds_kbdc_tree_free(old->value); - free(old); - } - current_scope--; + size_t i; + variable_t *old; + for (i = 0; i < variable_count; i++) { + if (variables[i] && variables[i]->scope == current_scope) { + old = variables[i]; + variables[i] = variables[i]->previous; + mds_kbdc_tree_free(old->value); + free(old); + } + } + current_scope--; } @@ -135,11 +136,12 @@ void variables_stack_pop(void) * @param variable The variable index * @return Whether a let will override the variable */ -int variables_let_will_override(size_t variable) +int +variables_let_will_override(size_t variable) { - if (variable >= variable_count) return 0; - if (variables[variable] == NULL) return 0; - return variables[variable]->scope == current_scope; + if (variable >= variable_count) return 0; + if (!variables[variable]) return 0; + return variables[variable]->scope == current_scope; } @@ -150,42 +152,39 @@ int variables_let_will_override(size_t variable) * @param value The variable's new value * @return Zero on success, -1 on error */ -int variables_let(size_t variable, mds_kbdc_tree_t* restrict value) +int +variables_let(size_t variable, mds_kbdc_tree_t *restrict value) { - variable_t** new; - variable_t* previous; - - /* Grow the table if necessary to fit the variable. */ - if (variable >= variable_count) - { - new = variables; - fail_if (xrealloc(new, variable + 1, variable_t*)); - variables = new; - memset(variables + variable_count, 0, (variable + 1 - variable_count) * sizeof(variable_t*)); - variable_count = variable + 1; - } + variable_t **new; + variable_t *previous; + + /* Grow the table if necessary to fit the variable. */ + if (variable >= variable_count) { + new = variables; + fail_if (xrealloc(new, variable + 1, variable_t*)); + variables = new; + memset(variables + variable_count, 0, (variable + 1 - variable_count) * sizeof(variable_t*)); + variable_count = variable + 1; + } + + if (variables_let_will_override(variable)) { + /* Override. */ + mds_kbdc_tree_free(variables[variable]->value); + variables[variable]->value = value; + } else { + /* Shadow or define. */ + previous = variables[variable]; + if (xmalloc(variables[variable], 1, variable_t)) + fail_if (variables[variable] = previous, 1); + variables[variable]->value = value; + variables[variable]->previous = previous; + variables[variable]->scope = current_scope; + variables[variable]->used_in_for = (size_t)(~0LL); + } - if (variables_let_will_override(variable)) - { - /* Override. */ - mds_kbdc_tree_free(variables[variable]->value); - variables[variable]->value = value; - } - else - { - /* Shadow or define. */ - previous = variables[variable]; - if (xmalloc(variables[variable], 1, variable_t)) - fail_if (variables[variable] = previous, 1); - variables[variable]->value = value; - variables[variable]->previous = previous; - variables[variable]->scope = current_scope; - variables[variable]->used_in_for = (size_t)(~0LL); - } - - return 0; - fail: - return -1; + return 0; +fail: + return -1; } @@ -198,11 +197,12 @@ int variables_let(size_t variable, mds_kbdc_tree_t* restrict value) * @param variable The variable index * @return The variable's value, `NULL` if not defined */ -mds_kbdc_tree_t* variables_get(size_t variable) +mds_kbdc_tree_t * +variables_get(size_t variable) { - if (variable >= variable_count) return NULL; - if (variables[variable] == NULL) return NULL; - return variables[variable]->value; + if (variable >= variable_count) return NULL; + if (!variables[variable]) return NULL; + return variables[variable]->value; } @@ -212,31 +212,32 @@ mds_kbdc_tree_t* variables_get(size_t variable) * @param variable The variable index, must already be defined * @return Zero on success, -1 on error */ -int variables_was_used_in_for(size_t variable) +int +variables_was_used_in_for(size_t variable) { - variable_t* previous; - - /* Already marked. */ - if (variables[variable]->used_in_for == current_scope) - return 0; - - /* Not marked. */ - if (variables[variable]->used_in_for == (size_t)(~0LL)) - return variables[variable]->used_in_for = current_scope, 0; - - /* Marked for another scope. */ - previous = variables[variable]; - if (xmalloc(variables[variable], 1, variable_t)) - fail_if (variables[variable] = previous, 1); - variables[variable]->value = mds_kbdc_tree_dup(previous->value); - fail_if (variables[variable]->value == NULL); - variables[variable]->previous = previous; - variables[variable]->scope = current_scope; - variables[variable]->used_in_for = current_scope; - - return 0; - fail: - return -1; + variable_t *previous; + + /* Already marked. */ + if (variables[variable]->used_in_for == current_scope) + return 0; + + /* Not marked. */ + if (variables[variable]->used_in_for == (size_t)(~0LL)) + return variables[variable]->used_in_for = current_scope, 0; + + /* Marked for another scope. */ + previous = variables[variable]; + if (xmalloc(variables[variable], 1, variable_t)) + fail_if (variables[variable] = previous, 1); + variables[variable]->value = mds_kbdc_tree_dup(previous->value); + fail_if (variables[variable]->value == NULL); + variables[variable]->previous = previous; + variables[variable]->scope = current_scope; + variables[variable]->used_in_for = current_scope; + + return 0; +fail: + return -1; } @@ -246,8 +247,8 @@ int variables_was_used_in_for(size_t variable) * @param variable The variable index, must already be defined * @return Whether `variables_was_used_in_for` has been unused on the variable */ -int variables_has_been_used_in_for(size_t variable) +int +variables_has_been_used_in_for(size_t variable) { - return variables[variable]->used_in_for == current_scope; + return variables[variable]->used_in_for == current_scope; } - diff --git a/src/mds-kbdc/variables.h b/src/mds-kbdc/variables.h index 485961b..a175ab7 100644 --- a/src/mds-kbdc/variables.h +++ b/src/mds-kbdc/variables.h @@ -52,7 +52,8 @@ void variables_stack_pop(void); * @param variable The variable index * @return Whether a let will override the variable */ -int variables_let_will_override(size_t variable) __attribute__((pure)); +__attribute__((pure)) +int variables_let_will_override(size_t variable); /** * Assign a value to a variable, and define or shadow it in the process @@ -61,7 +62,7 @@ int variables_let_will_override(size_t variable) __attribute__((pure)); * @param value The variable's new value * @return Zero on success, -1 on error */ -int variables_let(size_t variable, mds_kbdc_tree_t* restrict value); +int variables_let(size_t variable, mds_kbdc_tree_t *restrict value); /** * Get the value currently assigned to a variable @@ -72,7 +73,8 @@ int variables_let(size_t variable, mds_kbdc_tree_t* restrict value); * @param variable The variable index * @return The variable's value, `NULL` if not defined */ -mds_kbdc_tree_t* variables_get(size_t variable) __attribute__((pure)); +__attribute__((pure)) +mds_kbdc_tree_t *variables_get(size_t variable); /** * Mark a variable as having been unsed in a for-loop in the current scope @@ -88,8 +90,8 @@ int variables_was_used_in_for(size_t variable); * @param variable The variable index, must already be defined * @return Whether `variables_was_used_in_for` has been unused on the variable */ -int variables_has_been_used_in_for(size_t variable) __attribute__((pure)); +__attribute__((pure)) +int variables_has_been_used_in_for(size_t variable); #endif - diff --git a/src/mds-kkbd.c b/src/mds-kkbd.c index e57e6b5..31915bd 100644 --- a/src/mds-kkbd.c +++ b/src/mds-kkbd.c @@ -1718,7 +1718,7 @@ void shrink_map(void) { size_t i, greatest_mapping = 0; - int* old; + int *old; for (i = mapping_size; i > 0; i--) { if (mapping[i] != (int)i) { diff --git a/src/mds-libinput.h b/src/mds-libinput.h index 85ad5d5..6474e6d 100644 --- a/src/mds-libinput.h +++ b/src/mds-libinput.h @@ -105,4 +105,3 @@ void dump_info(void); #endif - diff --git a/src/mds-registry/mds-registry.c b/src/mds-registry/mds-registry.c index 57a0b92..3d17247 100644 --- a/src/mds-registry/mds-registry.c +++ b/src/mds-registry/mds-registry.c @@ -66,7 +66,8 @@ server_characteristics_t server_characteristics = { * * @return Non-zero on error */ -int preinitialise_server(void) +int +preinitialise_server(void) { int stage = 0; diff --git a/src/mds-registry/registry.c b/src/mds-registry/registry.c index f5a9b8a..0c4d5a5 100644 --- a/src/mds-registry/registry.c +++ b/src/mds-registry/registry.c @@ -465,7 +465,8 @@ handle_register_message(void) * @return Zero on success, -1 on error or interruption, * `errno` will be set accordingly */ -int handle_message(void) +int +handle_message(void) { size_t i; for (i = 0; i < received.header_count; i++) { @@ -476,6 +477,6 @@ int handle_message(void) } fail_if (handle_close_message()); return 0; - fail: +fail: return -1; } diff --git a/src/mds-registry/signals.c b/src/mds-registry/signals.c index 9b0a7a0..8fb90dd 100644 --- a/src/mds-registry/signals.c +++ b/src/mds-registry/signals.c @@ -34,7 +34,8 @@ * * @param signo The signal */ -void signal_all(int signo) +void +signal_all(int signo) { pthread_t current_thread; ssize_t node; diff --git a/src/mds-registry/slave.h b/src/mds-registry/slave.h index f9f748b..0b4f7b2 100644 --- a/src/mds-registry/slave.h +++ b/src/mds-registry/slave.h @@ -35,8 +35,7 @@ /** * Slave information, a thread waiting for protocols to become available */ -typedef struct slave -{ +typedef struct slave { /** * Set of protocols for which to wait that they become available */ @@ -82,7 +81,6 @@ typedef struct slave * Whether `dethklok` should apply */ int timed; - } slave_t; diff --git a/src/mds-registry/util.c b/src/mds-registry/util.c index c8d2015..77dff5a 100644 --- a/src/mds-registry/util.c +++ b/src/mds-registry/util.c @@ -37,7 +37,8 @@ * * @param obj The key */ -void reg_table_free_key(size_t obj) +void +reg_table_free_key(size_t obj) { char *command = (void *)obj; free(command); @@ -49,7 +50,8 @@ void reg_table_free_key(size_t obj) * * @param obj The value */ -void reg_table_free_value(size_t obj) +void +reg_table_free_value(size_t obj) { client_list_t *list = (void *)obj; client_list_destroy(list); diff --git a/src/mds-respawn.h b/src/mds-respawn.h index c614cf4..b664c05 100644 --- a/src/mds-respawn.h +++ b/src/mds-respawn.h @@ -66,8 +66,7 @@ /** * The state and identifier of a server */ -typedef struct server_state -{ +typedef struct server_state { /** * The server's process ID */ @@ -82,10 +81,8 @@ typedef struct server_state * The time (monotonic) the server started */ struct timespec started; - } server_state_t; #endif - diff --git a/src/mds-server/client.h b/src/mds-server/client.h index 91ab0c2..b003d31 100644 --- a/src/mds-server/client.h +++ b/src/mds-server/client.h @@ -36,8 +36,7 @@ /** * Client information structure */ -typedef struct client -{ +typedef struct client { /** * The client's entry in the list of clients */ @@ -134,7 +133,6 @@ typedef struct client * Whether `modify_cond` has been initialised */ int modify_cond_created; - } client_t; diff --git a/src/mds-server/globals.h b/src/mds-server/globals.h index 94a3651..8083717 100644 --- a/src/mds-server/globals.h +++ b/src/mds-server/globals.h @@ -93,4 +93,3 @@ extern hash_table_t modify_map; #endif - diff --git a/src/mds-server/interception-condition.h b/src/mds-server/interception-condition.h index 1ca3823..78383f4 100644 --- a/src/mds-server/interception-condition.h +++ b/src/mds-server/interception-condition.h @@ -28,8 +28,7 @@ /** * A condition for a message being intercepted by a client */ -typedef struct interception_condition -{ +typedef struct interception_condition { /** * The header of messages to intercept, optionally with a value, * empty (most not be NULL) for all messages. @@ -52,7 +51,6 @@ typedef struct interception_condition * Whether the messages may get modified by the client */ int modifying; - } interception_condition_t; diff --git a/src/mds-server/interceptors.h b/src/mds-server/interceptors.h index 99cd0a3..21f74d4 100644 --- a/src/mds-server/interceptors.h +++ b/src/mds-server/interceptors.h @@ -52,7 +52,7 @@ void add_intercept_condition(client_t *client, char *condition, int64_t priority */ __attribute__((pure, nonnull(1))) int is_condition_matching(interception_condition_t *cond, size_t *hashes, - char **keys, char **headers, size_t count); + char **keys, char **headers, size_t count); /** diff --git a/src/mds-server/multicast.h b/src/mds-server/multicast.h index 611298f..126c4ba 100644 --- a/src/mds-server/multicast.h +++ b/src/mds-server/multicast.h @@ -27,8 +27,7 @@ /** * Message multicast state */ -typedef struct multicast -{ +typedef struct multicast { /** * Queue of clients that is listening this message */ @@ -63,7 +62,6 @@ typedef struct multicast * How much of the message to skip if the recipient is not a modifier */ size_t message_prefix; - } multicast_t; diff --git a/src/mds-server/queued-interception.h b/src/mds-server/queued-interception.h index 2a072bc..1555801 100644 --- a/src/mds-server/queued-interception.h +++ b/src/mds-server/queued-interception.h @@ -29,8 +29,7 @@ /** * A queued interception */ -typedef struct queued_interception -{ +typedef struct queued_interception { /** * The intercepting client */ @@ -50,7 +49,6 @@ typedef struct queued_interception * The file descriptor of the intercepting client's socket (used for unmarshalling) */ int socket_fd; - } queued_interception_t; diff --git a/src/mds-vt.c b/src/mds-vt.c index c009d65..7a34dd6 100644 --- a/src/mds-vt.c +++ b/src/mds-vt.c @@ -38,7 +38,7 @@ -#define MDS_VT_VARS_VERSION 0 +#define MDS_VT_VARS_VERSION 0 @@ -57,7 +57,7 @@ int spawn_and_respawn_server(int fd); * @return Non-zero on error */ __attribute__((nonnull)) -int create_directory_root(const char* pathname); +int create_directory_root(const char *pathname); /** * Create a directory owned by the real user and nobody group @@ -66,7 +66,7 @@ int create_directory_root(const char* pathname); * @return Non-zero on error */ __attribute__((nonnull)) -int create_directory_user(const char* pathname); +int create_directory_user(const char *pathname); /** * Recursively remove a directory @@ -75,8 +75,7 @@ int create_directory_user(const char* pathname); * @return Non-zero on error */ __attribute__((nonnull)) -int unlink_recursive(const char* pathname); +int unlink_recursive(const char *pathname); #endif - |