diff --git a/gen.list b/gen.list index 82ebe88f..1bca00f9 100644 --- a/gen.list +++ b/gen.list @@ -4,3 +4,6 @@ src/vec/vec_parser_heredoc_functions3.c src/vec/vec_parser_range.c src/vec/vec_parser_range_functions2.c src/vec/vec_parser_range_functions3.c +src/vec/vec_reduce_action.c +src/vec/vec_reduce_action_functions2.c +src/vec/vec_reduce_action_functions3.c diff --git a/input.toml b/input.toml index c2f4d221..8afc11ce 100644 --- a/input.toml +++ b/input.toml @@ -52,3 +52,11 @@ replace.C__TYPENAME__ = "t_heredoc" replace.C__TYPEHEADER__ = '#include "parser/types/types_heredoc.h"' replace.C__PREFIX__ = "parser_heredoc" replace.C__PREFIXUP__ = "PARSER_HEREDOC" + +[[create.vec]] +sources_output = "src/vec/" +headers_output = "include/me/vec/" +replace.C__TYPENAME__ = "t_reduce_action" +replace.C__TYPEHEADER__ = '#include "parser/types/types_reduce_action.h"' +replace.C__PREFIX__ = "reduce_action" +replace.C__PREFIXUP__ = "REDUCE_ACTION" diff --git a/output/include/me/vec/vec_reduce_action.h b/output/include/me/vec/vec_reduce_action.h new file mode 100644 index 00000000..6b6362a0 --- /dev/null +++ b/output/include/me/vec/vec_reduce_action.h @@ -0,0 +1,58 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_reduce_action.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2023/12/04 18:46:53 by maiboyer #+# #+# */ +/* Updated: 2023/12/09 17:53:00 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef VEC_REDUCE_ACTION_H +#define VEC_REDUCE_ACTION_H + +#include "parser/types/types_reduce_action.h" +#include "me/types.h" + +typedef bool (*t_vec_reduce_action_sort_fn)(t_reduce_action *, t_reduce_action *); +typedef void (*t_free_reduce_action_item)(t_reduce_action); + +typedef struct s_vec_reduce_action +{ + t_free_reduce_action_item free_func; + t_usize len; + t_usize capacity; + t_reduce_action *buffer; +} t_vec_reduce_action; + +t_vec_reduce_action vec_reduce_action_new(t_usize capacity, + t_free_reduce_action_item free_function); +t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element); +t_error vec_reduce_action_push_front(t_vec_reduce_action *vec, + t_reduce_action element); +t_error vec_reduce_action_pop(t_vec_reduce_action *vec, t_reduce_action *value); +t_error vec_reduce_action_pop_front(t_vec_reduce_action *vec, t_reduce_action *value); +void vec_reduce_action_free(t_vec_reduce_action vec); +t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, + t_usize wanted_capacity); +t_error vec_reduce_action_find(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), t_usize *index); +t_error vec_reduce_action_find_starting(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), + t_usize starting_index, t_usize *index); +t_error vec_reduce_action_all(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), bool *result); +t_error vec_reduce_action_any(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), bool *result); +void vec_reduce_action_iter(t_vec_reduce_action *vec, + void (*fn)(t_usize index, t_reduce_action *value, + void *state), + void *state); +void vec_reduce_action_reverse(t_vec_reduce_action *vec); +void vec_reduce_action_sort(t_vec_reduce_action *vec, + t_vec_reduce_action_sort_fn is_sorted); +t_error vec_reduce_action_back(t_vec_reduce_action *vec, t_reduce_action **out); + +#endif diff --git a/output/src/vec/vec_reduce_action.c b/output/src/vec/vec_reduce_action.c new file mode 100644 index 00000000..cfbe90d4 --- /dev/null +++ b/output/src/vec/vec_reduce_action.c @@ -0,0 +1,115 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_reduce_action.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2023/12/05 18:46:28 by maiboyer #+# #+# */ +/* Updated: 2023/12/09 17:54:11 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/mem/mem_alloc_array.h" +#include "me/mem/mem_copy.h" +#include "me/mem/mem_set_zero.h" +#include "me/types.h" +#include "me/vec/vec_reduce_action.h" +#include + +t_vec_reduce_action vec_reduce_action_new(t_usize capacity, + t_free_reduce_action_item free_function) +{ + t_vec_reduce_action out; + + out = (t_vec_reduce_action){0}; + out.free_func = free_function; + out.buffer = mem_alloc_array(capacity, sizeof(t_reduce_action)); + if (out.buffer) + out.capacity = capacity; + return (out); +} + +/// Return true in case of an error +t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element) +{ + t_reduce_action *temp_buffer; + size_t new_capacity; + + if (vec == NULL) + return (ERROR); + if (vec->len + 1 > vec->capacity) + { + new_capacity = (vec->capacity * 3) / 2 + 1; + while (vec->len + 1 > new_capacity) + new_capacity = (new_capacity * 3) / 2 + 1; + temp_buffer = mem_alloc_array(new_capacity, sizeof(t_reduce_action)); + if (temp_buffer == NULL) + return (ERROR); + mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_reduce_action)); + free(vec->buffer); + vec->buffer = temp_buffer; + vec->capacity = new_capacity; + } + vec->buffer[vec->len] = element; + vec->len += 1; + return (NO_ERROR); +} + +/// Return true in case of an error +t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, t_usize wanted_capacity) +{ + t_reduce_action *temp_buffer; + size_t new_capacity; + + if (vec == NULL) + return (ERROR); + if (wanted_capacity > vec->capacity) + { + new_capacity = (vec->capacity * 3) / 2 + 1; + while (wanted_capacity > new_capacity) + new_capacity = (new_capacity * 3) / 2 + 1; + temp_buffer = mem_alloc_array(new_capacity, sizeof(t_reduce_action)); + if (temp_buffer == NULL) + return (ERROR); + mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_reduce_action)); + free(vec->buffer); + vec->buffer = temp_buffer; + vec->capacity = new_capacity; + } + return (NO_ERROR); +} + +/// Return true if the vector is empty +/// This function is safe to call with value being NULL +t_error vec_reduce_action_pop(t_vec_reduce_action *vec, t_reduce_action *value) +{ + t_reduce_action temp_value; + t_reduce_action *ptr; + + if (vec == NULL) + return (ERROR); + ptr = value; + if (vec->len == 0) + return (ERROR); + if (value == NULL) + ptr = &temp_value; + vec->len--; + *ptr = vec->buffer[vec->len]; + mem_set_zero(&vec->buffer[vec->len], sizeof(t_reduce_action)); + return (NO_ERROR); +} + +/// This function is safe to call with `free_elem` being NULL +void vec_reduce_action_free(t_vec_reduce_action vec) +{ + if (vec.free_func) + { + while (vec.len) + { + vec.free_func(vec.buffer[vec.len - 1]); + vec.len--; + } + } + free(vec.buffer); +} diff --git a/output/src/vec/vec_reduce_action_functions2.c b/output/src/vec/vec_reduce_action_functions2.c new file mode 100644 index 00000000..29025453 --- /dev/null +++ b/output/src/vec/vec_reduce_action_functions2.c @@ -0,0 +1,112 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_reduce_action.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2023/12/30 17:59:28 by maiboyer #+# #+# */ +/* Updated: 2023/12/30 17:59:28 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/mem/mem_alloc_array.h" +#include "me/mem/mem_copy.h" +#include "me/mem/mem_set_zero.h" +#include "me/types.h" +#include "me/vec/vec_reduce_action.h" +#include + +t_error vec_reduce_action_find(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), t_usize *index) +{ + t_usize idx; + + if (vec == NULL || fn == NULL || index == NULL) + return (ERROR); + idx = 0; + while (idx < vec->len) + { + if (fn(&vec->buffer[idx])) + { + *index = idx; + return (NO_ERROR); + } + idx++; + } + return (ERROR); +} + +t_error vec_reduce_action_find_starting(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), + t_usize starting_index, t_usize *index) +{ + t_usize idx; + + if (vec == NULL || fn == NULL || index == NULL) + return (ERROR); + idx = starting_index; + while (idx < vec->len) + { + if (fn(&vec->buffer[idx])) + { + *index = idx; + return (NO_ERROR); + } + idx++; + } + return (ERROR); +} + +t_error vec_reduce_action_all(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), bool *result) +{ + t_usize idx; + + if (vec == NULL || fn == NULL || result == NULL) + return (ERROR); + idx = 0; + *result = true; + while (*result && idx < vec->len) + { + if (!fn(&vec->buffer[idx])) + *result = false; + idx++; + } + return (ERROR); +} + +t_error vec_reduce_action_any(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), bool *result) +{ + t_usize idx; + + if (vec == NULL || fn == NULL || result == NULL) + return (ERROR); + idx = 0; + *result = false; + while (*result && idx < vec->len) + { + if (fn(&vec->buffer[idx])) + *result = true; + idx++; + } + return (ERROR); +} + +void vec_reduce_action_iter(t_vec_reduce_action *vec, + void (*fn)(t_usize index, t_reduce_action *value, + void *state), + void *state) +{ + t_usize idx; + + if (vec == NULL || fn == NULL) + return; + idx = 0; + while (idx < vec->len) + { + fn(idx, &vec->buffer[idx], state); + idx++; + } +} diff --git a/output/src/vec/vec_reduce_action_functions3.c b/output/src/vec/vec_reduce_action_functions3.c new file mode 100644 index 00000000..2dc18ad3 --- /dev/null +++ b/output/src/vec/vec_reduce_action_functions3.c @@ -0,0 +1,84 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_reduce_action.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2023/12/30 17:59:28 by maiboyer #+# #+# */ +/* Updated: 2023/12/30 17:59:28 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/mem/mem_alloc_array.h" +#include "me/mem/mem_copy.h" +#include "me/mem/mem_set_zero.h" +#include "me/types.h" +#include "me/vec/vec_reduce_action.h" +#include + +t_error vec_reduce_action_push_front(t_vec_reduce_action *vec, + t_reduce_action element) +{ + t_usize i; + + if (vec->len == 0) + return (vec_reduce_action_push(vec, element)); + i = vec->len - 1; + if (vec->capacity < vec->len + 1 && + vec_reduce_action_reserve(vec, 3 * vec->len / 2 + 1)) + return (ERROR); + while (i > 0) + { + vec->buffer[i + 1] = vec->buffer[i]; + i--; + } + vec->buffer[1] = vec->buffer[0]; + vec->buffer[0] = element; + vec->len++; + return (NO_ERROR); +} + +t_error vec_reduce_action_pop_front(t_vec_reduce_action *vec, t_reduce_action *value) +{ + t_usize i; + + if (vec->len <= 1) + return (vec_reduce_action_pop(vec, value)); + i = 0; + *value = vec->buffer[0]; + vec->len--; + while (i < vec->len) + { + vec->buffer[i] = vec->buffer[i + 1]; + i++; + } + mem_set_zero(&vec->buffer[i], sizeof(*vec->buffer)); + return (NO_ERROR); +} + +void vec_reduce_action_reverse(t_vec_reduce_action *vec) +{ + t_reduce_action temporary; + t_usize i; + + i = 0; + while (i < vec->len / 2) + { + temporary = vec->buffer[vec->len - 1 - i]; + vec->buffer[vec->len - 1 - i] = vec->buffer[i]; + vec->buffer[i] = temporary; + i++; + } +} + +t_error vec_reduce_action_back(t_vec_reduce_action *vec, t_reduce_action **out) +{ + t_reduce_action *temporary; + + if (out == NULL) + out = &temporary; + if (vec->len != 0) + return (*out = &vec->buffer[vec->len - 1], true); + return (false); +} diff --git a/parser/includes/api.h b/parser/includes/api.h index fdfd61b6..712c57fb 100644 --- a/parser/includes/api.h +++ b/parser/includes/api.h @@ -33,10 +33,10 @@ /*******************/ typedef struct s_parser t_parser; -typedef struct t_parse_tree t_parse_tree; -typedef struct t_query t_query; -typedef struct t_query_cursor t_query_cursor; -typedef struct t_lookahead_iterator t_lookahead_iterator; +typedef struct s_parse_tree t_parse_tree; +typedef struct s_query t_query; +typedef struct s_query_cursor t_query_cursor; +typedef struct s_lookahead_iterator t_lookahead_iterator; typedef enum t_input_encoding { diff --git a/parser/includes/reduce_action.h b/parser/includes/reduce_action.h new file mode 100644 index 00000000..53295342 --- /dev/null +++ b/parser/includes/reduce_action.h @@ -0,0 +1,36 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* reduce_action.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/04/30 15:25:12 by maiboyer #+# #+# */ +/* Updated: 2024/04/30 15:25:38 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef REDUCE_ACTION_H +#define REDUCE_ACTION_H + +#include "me/types.h" +#include "me/vec/vec_reduce_action.h" +#include "parser/api.h" +#include "parser/types/types_reduce_action.h" + +static inline void ts_reduce_action_set_add(t_vec_reduce_action *self, + t_reduce_action new_action) +{ + t_reduce_action action; + + for (t_u32 i = 0; i < self->len; i++) + { + action = self->buffer[i]; + if (action.symbol == new_action.symbol && + action.count == new_action.count) + return; + } + vec_reduce_action_push(self, new_action); +} + +#endif /* REDUCE_ACTION_H */ diff --git a/parser/includes/types/types_reduce_action.h b/parser/includes/types/types_reduce_action.h new file mode 100644 index 00000000..6c98455e --- /dev/null +++ b/parser/includes/types/types_reduce_action.h @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* types_reduce_action.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/04/30 15:21:59 by maiboyer #+# #+# */ +/* Updated: 2024/04/30 15:22:18 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef TYPES_REDUCE_ACTION_H +#define TYPES_REDUCE_ACTION_H + +#include "me/types.h" +#include "parser/types/types_symbol.h" + +typedef struct s_reduce_action +{ + t_u32 count; + t_symbol symbol; + t_i32 dynamic_precedence; + t_u16 production_id; +} t_reduce_action; + +#endif /* TYPES_REDUCE_ACTION_H */ diff --git a/parser/src/language.c b/parser/src/language.c index 3f5acb60..c08707c4 100644 --- a/parser/src/language.c +++ b/parser/src/language.c @@ -30,7 +30,7 @@ void ts_language_table_entry( const t_language *self, t_state_id state, t_symbol symbol, - TableEntry *result + t_table_entry *result ) { if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) { result->action_count = 0; @@ -171,7 +171,7 @@ t_field_id ts_language_field_id_for_name( t_lookahead_iterator *ts_lookahead_iterator_new(const t_language *self, t_state_id state) { if (state >= self->state_count) return NULL; - LookaheadIterator *iterator = malloc(sizeof(LookaheadIterator)); + t_lookahead_iterator *iterator = malloc(sizeof(t_lookahead_iterator)); *iterator = ts_language_lookaheads(self, state); return (t_lookahead_iterator *)iterator; } @@ -181,35 +181,35 @@ void ts_lookahead_iterator_delete(t_lookahead_iterator *self) { } bool ts_lookahead_iterator_reset_state(t_lookahead_iterator * self, t_state_id state) { - LookaheadIterator *iterator = (LookaheadIterator *)self; + t_lookahead_iterator *iterator = (t_lookahead_iterator *)self; if (state >= iterator->language->state_count) return false; *iterator = ts_language_lookaheads(iterator->language, state); return true; } const t_language *ts_lookahead_iterator_language(const t_lookahead_iterator *self) { - const LookaheadIterator *iterator = (const LookaheadIterator *)self; + const t_lookahead_iterator *iterator = (const t_lookahead_iterator *)self; return iterator->language; } bool ts_lookahead_iterator_reset(t_lookahead_iterator *self, const t_language *language, t_state_id state) { if (state >= language->state_count) return false; - LookaheadIterator *iterator = (LookaheadIterator *)self; + t_lookahead_iterator *iterator = (t_lookahead_iterator *)self; *iterator = ts_language_lookaheads(language, state); return true; } bool ts_lookahead_iterator_next(t_lookahead_iterator *self) { - LookaheadIterator *iterator = (LookaheadIterator *)self; + t_lookahead_iterator *iterator = (t_lookahead_iterator *)self; return ts_lookahead_iterator__next(iterator); } t_symbol ts_lookahead_iterator_current_symbol(const t_lookahead_iterator *self) { - const LookaheadIterator *iterator = (const LookaheadIterator *)self; + const t_lookahead_iterator *iterator = (const t_lookahead_iterator *)self; return iterator->symbol; } const char *ts_lookahead_iterator_current_symbol_name(const t_lookahead_iterator *self) { - const LookaheadIterator *iterator = (const LookaheadIterator *)self; + const t_lookahead_iterator *iterator = (const t_lookahead_iterator *)self; return ts_language_symbol_name(iterator->language, iterator->symbol); } diff --git a/parser/src/language.h b/parser/src/language.h index eb7edcfa..a26c9f6c 100644 --- a/parser/src/language.h +++ b/parser/src/language.h @@ -1,7 +1,6 @@ #ifndef TREE_SITTER_LANGUAGE_H_ #define TREE_SITTER_LANGUAGE_H_ -#include "./parser.h" #include "./subtree.h" #include "parser/types/types_parse_action_type.h" #include "parser/types/types_state_id.h" @@ -12,14 +11,14 @@ #define LANGUAGE_VERSION_WITH_PRIMARY_STATES 14 #define LANGUAGE_VERSION_USABLE_VIA_WASM 13 -typedef struct +typedef struct s_table_entry { const t_parse_actions *actions; t_u32 action_count; bool is_reusable; -} TableEntry; +} t_table_entry; -typedef struct +typedef struct s_lookahead_iterator { const t_language *language; const t_u16 *data; @@ -34,17 +33,17 @@ typedef struct t_symbol symbol; t_state_id next_state; t_u16 action_count; -} LookaheadIterator; +} t_lookahead_iterator; void ts_language_table_entry(const t_language *, t_state_id, t_symbol, - TableEntry *); + t_table_entry *); t_symbol_metadata ts_language_symbol_metadata(const t_language *, t_symbol); t_symbol ts_language_public_symbol(const t_language *, t_symbol); t_state_id ts_language_next_state(const t_language *self, t_state_id state, - t_symbol symbol); + t_symbol symbol); static inline bool ts_language_is_symbol_external(const t_language *self, t_symbol symbol) @@ -54,10 +53,10 @@ static inline bool ts_language_is_symbol_external(const t_language *self, static inline const t_parse_actions *ts_language_actions(const t_language *self, t_state_id state, - t_symbol symbol, - t_u32 *count) + t_symbol symbol, + t_u32 *count) { - TableEntry entry; + t_table_entry entry; ts_language_table_entry(self, state, symbol, &entry); *count = entry.action_count; return entry.actions; @@ -67,7 +66,7 @@ static inline bool ts_language_has_reduce_action(const t_language *self, t_state_id state, t_symbol symbol) { - TableEntry entry; + t_table_entry entry; ts_language_table_entry(self, state, symbol, &entry); return entry.action_count > 0 && entry.actions[0].type == ActionTypeReduce; } @@ -118,8 +117,8 @@ static inline bool ts_language_has_actions(const t_language *self, // all possible symbols and checking the parse table for each one. // For 'small' parse states, this exploits the structure of the // table to only visit the valid symbols. -static inline LookaheadIterator ts_language_lookaheads(const t_language *self, - t_state_id state) +static inline t_lookahead_iterator ts_language_lookaheads( + const t_language *self, t_state_id state) { bool is_small_state = state >= self->large_state_count; const t_u16 *data; @@ -137,7 +136,7 @@ static inline LookaheadIterator ts_language_lookaheads(const t_language *self, { data = &self->parse_table[state * self->symbol_count] - 1; } - return (LookaheadIterator){ + return (t_lookahead_iterator){ .language = self, .data = data, .group_end = group_end, @@ -148,7 +147,7 @@ static inline LookaheadIterator ts_language_lookaheads(const t_language *self, }; } -static inline bool ts_lookahead_iterator__next(LookaheadIterator *self) +static inline bool ts_lookahead_iterator__next(t_lookahead_iterator *self) { // For small parse states, valid symbols are listed explicitly, // grouped by their value. There's no need to look up the actions diff --git a/parser/src/parser.c b/parser/src/parser.c index 3c0e1c91..05eab7ef 100644 --- a/parser/src/parser.c +++ b/parser/src/parser.c @@ -1,15 +1,9 @@ -#include "./array.h" -#include "parser/error_costs.h" #include "./language.h" -#include "parser/parser_length.h" -#include "parser/lexer.h" -#include "./reduce_action.h" #include "./reusable_node.h" #include "./stack.h" #include "./subtree.h" #include "./tree.h" -#include "parser/api.h" #include #include #include @@ -18,6 +12,12 @@ #include #include "me/vec/vec_parser_range.h" +#include "me/vec/vec_reduce_action.h" +#include "parser/api.h" +#include "parser/error_costs.h" +#include "parser/lexer.h" +#include "parser/parser_length.h" +#include "parser/reduce_action.h" #include "parser/types/types_language.h" typedef t_u64 t_duration; @@ -117,7 +117,7 @@ typedef struct s_parser SubtreePool tree_pool; const t_language *language; void *wasm_store; - ReduceActionSet reduce_actions; + t_vec_reduce_action reduce_actions; Subtree finished_tree; SubtreeArray trailing_extras; SubtreeArray trailing_extras2; @@ -157,13 +157,13 @@ typedef enum e_error_comparison typedef struct s_string_input { const char *string; - t_u32 length; + t_u32 length; } t_string_input; // StringInput -static const char *ts_string_inpt_read(void *_self, t_u32 byte, - t_point point, t_u32 *length) +static const char *ts_string_inpt_read(void *_self, t_u32 byte, t_point point, + t_u32 *length) { (void)point; t_string_input *self = (t_string_input *)_self; @@ -219,7 +219,7 @@ static bool ts_parser__breakdown_top_of_stack(t_parser *self, for (t_u32 i = 0; i < pop.size; i++) { StackSlice slice = pop.contents[i]; - t_state_id state = ts_stack_state(self->stack, slice.version); + t_state_id state = ts_stack_state(self->stack, slice.version); Subtree parent = *array_front(&slice.subtrees); for (t_u32 j = 0, n = ts_subtree_child_count(parent); j < n; j++) @@ -367,7 +367,7 @@ static bool ts_parser__better_version_exists(t_parser *self, return true; } - t_parse_length position = ts_stack_position(self->stack, version); + t_parse_length position = ts_stack_position(self->stack, version); t_error_status status = { .cost = cost, .is_in_error = is_in_error, @@ -440,7 +440,7 @@ static void ts_parser__external_scanner_deserialize(t_parser *self, Subtree external_token) { const char *data = NULL; - t_u32 length = 0; + t_u32 length = 0; if (external_token.ptr) { data = ts_external_scanner_state_data( @@ -452,7 +452,7 @@ static void ts_parser__external_scanner_deserialize(t_parser *self, data, length); } -static bool ts_parser__external_scanner_scan(t_parser *self, +static bool ts_parser__external_scanner_scan(t_parser *self, t_state_id external_lex_state) { const bool *valid_external_tokens = @@ -463,12 +463,12 @@ static bool ts_parser__external_scanner_scan(t_parser *self, } static bool ts_parser__can_reuse_first_leaf(t_parser *self, t_state_id state, - Subtree tree, - TableEntry *table_entry) + Subtree tree, + t_table_entry *table_entry) { t_lex_modes current_lex_mode = self->language->lex_modes[state]; - t_symbol leaf_symbol = ts_subtree_leaf_symbol(tree); - t_state_id leaf_state = ts_subtree_leaf_parse_state(tree); + t_symbol leaf_symbol = ts_subtree_leaf_symbol(tree); + t_state_id leaf_state = ts_subtree_leaf_parse_state(tree); t_lex_modes leaf_lex_mode = self->language->lex_modes[leaf_state]; // At the end of a non-terminal extra node, the lexer normally returns @@ -506,25 +506,26 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version, return NULL_SUBTREE; } - const t_parse_length start_position = ts_stack_position(self->stack, version); + const t_parse_length start_position = + ts_stack_position(self->stack, version); const Subtree external_token = ts_stack_last_external_token(self->stack, version); - bool found_external_token = false; - bool error_mode = parse_state == ERROR_STATE; - bool skipped_error = false; - bool called_get_column = false; - t_i32 first_error_character = 0; - t_parse_length error_start_position = length_zero(); - t_parse_length error_end_position = length_zero(); - t_i32 lookahead_end_byte = 0; - t_i32 external_scanner_state_len = 0; - bool external_scanner_state_changed = false; + bool found_external_token = false; + bool error_mode = parse_state == ERROR_STATE; + bool skipped_error = false; + bool called_get_column = false; + t_i32 first_error_character = 0; + t_parse_length error_start_position = length_zero(); + t_parse_length error_end_position = length_zero(); + t_i32 lookahead_end_byte = 0; + t_i32 external_scanner_state_len = 0; + bool external_scanner_state_changed = false; ts_lexer_reset(&self->lexer, start_position); for (;;) { - bool found_token = false; + bool found_token = false; t_parse_length current_position = self->lexer.current_position; if (lex_mode.external_lex_state != 0) @@ -626,23 +627,24 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version, Subtree result; if (skipped_error) { - t_parse_length padding = length_sub(error_start_position, start_position); - t_parse_length size = length_sub(error_end_position, error_start_position); - t_u32 lookahead_bytes = - lookahead_end_byte - error_end_position.bytes; + t_parse_length padding = + length_sub(error_start_position, start_position); + t_parse_length size = + length_sub(error_end_position, error_start_position); + t_u32 lookahead_bytes = lookahead_end_byte - error_end_position.bytes; result = ts_subtree_new_error(&self->tree_pool, first_error_character, padding, size, lookahead_bytes, parse_state, self->language); } else { - bool is_keyword = false; - t_symbol symbol = self->lexer.data.result_symbol; - t_parse_length padding = + bool is_keyword = false; + t_symbol symbol = self->lexer.data.result_symbol; + t_parse_length padding = length_sub(self->lexer.token_start_position, start_position); - t_parse_length size = length_sub(self->lexer.token_end_position, - self->lexer.token_start_position); - t_u32 lookahead_bytes = + t_parse_length size = length_sub(self->lexer.token_end_position, + self->lexer.token_start_position); + t_u32 lookahead_bytes = lookahead_end_byte - self->lexer.token_end_position.bytes; if (found_external_token) @@ -688,9 +690,9 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version, } static Subtree ts_parser__get_cached_token(t_parser *self, t_state_id state, - size_t position, - Subtree last_external_token, - TableEntry *table_entry) + size_t position, + Subtree last_external_token, + t_table_entry *table_entry) { t_token_cache *cache = &self->token_cache; if (cache->token.ptr && cache->byte_index == position && @@ -729,8 +731,8 @@ static void ts_parser__set_cached_token(t_parser *self, t_u32 byte_index, static Subtree ts_parser__reuse_node(t_parser *self, StackVersion version, t_state_id *state, t_u32 position, - Subtree last_external_token, - TableEntry *table_entry) + Subtree last_external_token, + t_table_entry *table_entry) { Subtree result; while ((result = reusable_node_tree(&self->reusable_node)).ptr) @@ -823,7 +825,8 @@ static Subtree ts_parser__reuse_node(t_parser *self, StackVersion version, // The decision is based on the trees' error costs (if any), their dynamic // precedence, and finally, as a default, by a recursive comparison of the // trees' symbols. -static bool ts_parser__select_parse_tree(t_parser *self, Subtree left, Subtree right) +static bool ts_parser__select_parse_tree(t_parser *self, Subtree left, + Subtree right) { if (!left.ptr) return true; @@ -901,7 +904,7 @@ static bool ts_parser__select_children(t_parser *self, Subtree left, ts_subtree_symbol(left), &self->scratch_trees, 0, self->language); return ts_parser__select_parse_tree(self, left, - ts_subtree_from_mut(scratch_tree)); + ts_subtree_from_mut(scratch_tree)); } static void ts_parser__shift(t_parser *self, StackVersion version, @@ -928,7 +931,7 @@ static void ts_parser__shift(t_parser *self, StackVersion version, static StackVersion ts_parser__reduce(t_parser *self, StackVersion version, t_symbol symbol, t_u32 count, - int dynamic_precedence, + int dynamic_precedence, t_u16 production_id, bool is_fragile, bool end_of_non_terminal_extra) { @@ -940,7 +943,7 @@ static StackVersion ts_parser__reduce(t_parser *self, StackVersion version, // contain the popped children, and push it onto the stack in place of the // children. StackSliceArray pop = ts_stack_pop_count(self->stack, version, count); - t_u32 removed_version_count = 0; + t_u32 removed_version_count = 0; for (t_u32 i = 0; i < pop.size; i++) { StackSlice slice = pop.contents[i]; @@ -1074,7 +1077,7 @@ static void ts_parser__accept(t_parser *self, StackVersion version, if (!ts_subtree_extra(tree)) { assert(!tree.data.is_inline); - t_u32 child_count = ts_subtree_child_count(tree); + t_u32 child_count = ts_subtree_child_count(tree); const Subtree *children = ts_subtree_children(tree); for (t_u32 k = 0; k < child_count; k++) { @@ -1140,8 +1143,8 @@ static bool ts_parser__do_all_potential_reductions( continue; t_state_id state = ts_stack_state(self->stack, version); - bool has_shift_action = false; - array_clear(&self->reduce_actions); + bool has_shift_action = false; + self->reduce_actions.len = 0; t_symbol first_symbol, end_symbol; if (lookahead_symbol != 0) @@ -1157,7 +1160,7 @@ static bool ts_parser__do_all_potential_reductions( for (t_symbol symbol = first_symbol; symbol < end_symbol; symbol++) { - TableEntry entry; + t_table_entry entry; ts_language_table_entry(self->language, state, symbol, &entry); for (t_u32 j = 0; j < entry.action_count; j++) { @@ -1173,7 +1176,7 @@ static bool ts_parser__do_all_potential_reductions( if (action.reduce.child_count > 0) ts_reduce_action_set_add( &self->reduce_actions, - (ReduceAction){ + (t_reduce_action){ .symbol = action.reduce.symbol, .count = action.reduce.child_count, .dynamic_precedence = @@ -1188,9 +1191,9 @@ static bool ts_parser__do_all_potential_reductions( } StackVersion reduction_version = STACK_VERSION_NONE; - for (t_u32 j = 0; j < self->reduce_actions.size; j++) + for (t_u32 j = 0; j < self->reduce_actions.len; j++) { - ReduceAction action = self->reduce_actions.contents[j]; + t_reduce_action action = self->reduce_actions.buffer[j]; reduction_version = ts_parser__reduce( self, version, action.symbol, action.count, @@ -1255,8 +1258,8 @@ static bool ts_parser__recover_to_state(t_parser *self, StackVersion version, if (error_trees.size > 0) { assert(error_trees.size == 1); - Subtree error_tree = error_trees.contents[0]; - t_u32 error_child_count = ts_subtree_child_count(error_tree); + Subtree error_tree = error_trees.contents[0]; + t_u32 error_child_count = ts_subtree_child_count(error_tree); if (error_child_count > 0) { array_splice(&slice.subtrees, 0, 0, error_child_count, @@ -1298,11 +1301,11 @@ static bool ts_parser__recover_to_state(t_parser *self, StackVersion version, static void ts_parser__recover(t_parser *self, StackVersion version, Subtree lookahead) { - bool did_recover = false; - unsigned previous_version_count = ts_stack_version_count(self->stack); - t_parse_length position = ts_stack_position(self->stack, version); - StackSummary *summary = ts_stack_get_summary(self->stack, version); - unsigned node_count_since_error = + bool did_recover = false; + unsigned previous_version_count = ts_stack_version_count(self->stack); + t_parse_length position = ts_stack_position(self->stack, version); + StackSummary *summary = ts_stack_get_summary(self->stack, version); + unsigned node_count_since_error = ts_stack_node_count_since_error(self->stack, version); unsigned current_error_cost = ts_stack_error_cost(self->stack, version); @@ -1440,7 +1443,7 @@ static void ts_parser__recover(t_parser *self, StackVersion version, // If the current lookahead token is an extra token, mark it as extra. This // means it won't be counted in error cost calculations. - unsigned n; + unsigned n; const t_parse_actions *actions = ts_language_actions( self->language, 1, ts_subtree_symbol(lookahead), &n); if (n > 0 && actions[n - 1].type == ActionTypeShift && @@ -1514,8 +1517,8 @@ static void ts_parser__handle_error(t_parser *self, StackVersion version, // lookahead. After skipping one or more invalid tokens, the parser might // find a token that would have allowed a reduction to take place. ts_parser__do_all_potential_reductions(self, version, 0); - t_u32 version_count = ts_stack_version_count(self->stack); - t_parse_length position = ts_stack_position(self->stack, version); + t_u32 version_count = ts_stack_version_count(self->stack); + t_parse_length position = ts_stack_position(self->stack, version); // Push a discontinuity onto the stack. Merge all of the stack versions that // were created in the previous step. @@ -1610,13 +1613,13 @@ static bool ts_parser__advance(t_parser *self, StackVersion version, bool allow_node_reuse) { t_state_id state = ts_stack_state(self->stack, version); - t_u32 position = ts_stack_position(self->stack, version).bytes; - Subtree last_external_token = + t_u32 position = ts_stack_position(self->stack, version).bytes; + Subtree last_external_token = ts_stack_last_external_token(self->stack, version); - bool did_reuse = true; - Subtree lookahead = NULL_SUBTREE; - TableEntry table_entry = {.action_count = 0}; + bool did_reuse = true; + Subtree lookahead = NULL_SUBTREE; + t_table_entry table_entry = {.action_count = 0}; // If possible, reuse a node from the previous syntax tree. if (allow_node_reuse) @@ -1980,8 +1983,7 @@ t_parser *ts_parser_new(void) { t_parser *self = calloc(1, sizeof(t_parser)); ts_lexer_init(&self->lexer); - array_init(&self->reduce_actions); - array_reserve(&self->reduce_actions, 4); + self->reduce_actions = vec_reduce_action_new(4, NULL); self->tree_pool = ts_subtree_pool_new(32); self->stack = ts_stack_new(&self->tree_pool); self->finished_tree = NULL_SUBTREE; @@ -2008,7 +2010,7 @@ void ts_parser_delete(t_parser *self) ts_parser_set_language(self, NULL); ts_stack_delete(self->stack); - if (self->reduce_actions.contents) + if (self->reduce_actions.buffer) { array_delete(&self->reduce_actions); } @@ -2113,7 +2115,7 @@ bool ts_parser_set_included_ranges(t_parser *self, const t_parser_range *ranges, } const t_parser_range *ts_parser_included_ranges(const t_parser *self, - t_u32 *count) + t_u32 *count) { return ts_lexer_included_ranges(&self->lexer, count); } @@ -2141,7 +2143,8 @@ void ts_parser_reset(t_parser *self) self->has_scanner_error = false; } -t_parse_tree *ts_parser_parse(t_parser *self, const t_parse_tree *old_tree, t_parse_input input) +t_parse_tree *ts_parser_parse(t_parser *self, const t_parse_tree *old_tree, + t_parse_input input) { t_parse_tree *result = NULL; old_tree = NULL; @@ -2254,16 +2257,18 @@ exit: return result; } -t_parse_tree *ts_parser_parse_string(t_parser *self, const t_parse_tree *old_tree, - const char *string, t_u32 length) +t_parse_tree *ts_parser_parse_string(t_parser *self, + const t_parse_tree *old_tree, + const char *string, t_u32 length) { return ts_parser_parse_string_encoding(self, old_tree, string, length, InputEncoding8); } -t_parse_tree *ts_parser_parse_string_encoding(t_parser *self, const t_parse_tree *old_tree, - const char *string, t_u32 length, - t_input_encoding encoding) +t_parse_tree *ts_parser_parse_string_encoding(t_parser *self, + const t_parse_tree *old_tree, + const char *string, t_u32 length, + t_input_encoding encoding) { t_string_input input = {string, length}; return ts_parser_parse(self, old_tree, diff --git a/parser/src/reduce_action.h b/parser/src/reduce_action.h deleted file mode 100644 index 0cdb1e52..00000000 --- a/parser/src/reduce_action.h +++ /dev/null @@ -1,34 +0,0 @@ -#ifndef TREE_SITTER_REDUCE_ACTION_H_ -#define TREE_SITTER_REDUCE_ACTION_H_ - -#ifdef __cplusplus -extern "C" { -#endif - -#include "./array.h" -#include "parser/api.h" - -typedef struct { - t_u32 count; - t_symbol symbol; - int dynamic_precedence; - unsigned short production_id; -} ReduceAction; - -typedef Array(ReduceAction) ReduceActionSet; - -static inline void ts_reduce_action_set_add(ReduceActionSet *self, - ReduceAction new_action) { - for (t_u32 i = 0; i < self->size; i++) { - ReduceAction action = self->contents[i]; - if (action.symbol == new_action.symbol && action.count == new_action.count) - return; - } - array_push(self, new_action); -} - -#ifdef __cplusplus -} -#endif - -#endif // TREE_SITTER_REDUCE_ACTION_H_ diff --git a/parser/src/subtree.h b/parser/src/subtree.h index c748c5c8..3fbe3eb1 100644 --- a/parser/src/subtree.h +++ b/parser/src/subtree.h @@ -7,7 +7,6 @@ #include "./array.h" #include "parser/error_costs.h" #include "parser/parser_length.h" -#include "./parser.h" #include "parser/api.h" #include #include diff --git a/parser/src/tree.h b/parser/src/tree.h index e13c7d41..360974f0 100644 --- a/parser/src/tree.h +++ b/parser/src/tree.h @@ -3,29 +3,25 @@ #include "./subtree.h" -#ifdef __cplusplus -extern "C" { -#endif - -typedef struct { - const Subtree *child; - const Subtree *parent; - t_parse_length position; - t_symbol alias_symbol; +typedef struct +{ + const Subtree *child; + const Subtree *parent; + t_parse_length position; + t_symbol alias_symbol; } ParentCacheEntry; -struct t_parse_tree { - Subtree root; - const t_language *language; - t_parser_range *included_ranges; - unsigned included_range_count; +struct s_parse_tree +{ + Subtree root; + const t_language *language; + t_parser_range *included_ranges; + t_u32 included_range_count; }; -t_parse_tree *ts_tree_new(Subtree root, const t_language *language, const t_parser_range *, unsigned); -t_parse_node ts_node_new(const t_parse_tree *, const Subtree *, t_parse_length, t_symbol); +t_parse_tree *ts_tree_new(Subtree root, const t_language *language, + const t_parser_range *, t_u32); +t_parse_node ts_node_new(const t_parse_tree *, const Subtree *, t_parse_length, + t_symbol); -#ifdef __cplusplus -} -#endif - -#endif // TREE_SITTER_TREE_H_ +#endif // TREE_SITTER_TREE_H_