diff --git a/Minishell.mk b/Minishell.mk index 4baef4b2..f4ebf28a 100644 --- a/Minishell.mk +++ b/Minishell.mk @@ -6,7 +6,7 @@ # By: maiboyer +#+ +:+ +#+ # # +#+#+#+#+#+ +#+ # # Created: 2024/04/28 17:28:30 by maiboyer #+# #+# # -# Updated: 2024/04/29 14:08:10 by maiboyer ### ########.fr # +# Updated: 2024/04/30 14:19:46 by maiboyer ### ########.fr # # # # **************************************************************************** # @@ -64,7 +64,7 @@ bonus: $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libme.a $(OBJDIRNAME)/libgmr.a @mkdir -p $(OBJDIRNAME)/$(LIBDIRNAME) @mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME) @printf '$(GREY) Be Carefull ur in $(END)$(GREEN)Debug Mode$(END)\n' - @cc $(CFLAGS) -D DEBUG=42 -o $(NAME) $(OBJ) -L$(OBJDIRNAME) -lme -lgmr + @cc $(CFLAGS) -D DEBUG=42 -o $(NAME) $(OBJ) -L$(OBJDIRNAME) -lgmr -lme # Dependences for all $(NAME): $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libgmr.a $(OBJDIRNAME)/libme.a @@ -72,7 +72,7 @@ $(NAME): $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libgmr.a $(OBJDIRNAME)/libme.a @mkdir -p $(OBJDIRNAME)/$(LIBDIRNAME) @mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME) @echo "$(GREY) Linking $(END)$(GREEN)$(NAME)$(END)" - @cc $(CFLAGS) -o $(NAME) $(OBJ) $(LIB_OBJ) -L$(OBJDIRNAME) -lme -lgmr + @cc $(CFLAGS) -o $(NAME) $(OBJ) $(LIB_OBJ) -L$(OBJDIRNAME) -lgmr -lme # Creating the objects $(OBJDIRNAME)/%.o: %.c diff --git a/gen.list b/gen.list index 9d07c83a..82ebe88f 100644 --- a/gen.list +++ b/gen.list @@ -1,3 +1,6 @@ +src/vec/vec_parser_heredoc.c +src/vec/vec_parser_heredoc_functions2.c +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 diff --git a/includes/app/node.h b/includes/app/node.h index b37bebb6..e44c339e 100644 --- a/includes/app/node.h +++ b/includes/app/node.h @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/04/28 18:35:22 by maiboyer #+# #+# */ -/* Updated: 2024/04/28 18:53:13 by maiboyer ### ########.fr */ +/* Updated: 2024/04/30 13:02:06 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -28,7 +28,7 @@ typedef struct s_node struct s_node *childs; } t_node; -t_node build_node(TSNode curr, t_const_str input); +t_node build_node(t_parse_node curr, t_const_str input); t_str node_getstr(t_node *node); void free_node(t_node t); diff --git a/input.toml b/input.toml index 86e0ac3f..c2f4d221 100644 --- a/input.toml +++ b/input.toml @@ -44,3 +44,11 @@ replace.C__TYPENAME__ = "t_parser_range" replace.C__TYPEHEADER__ = '#include "parser/types/types_parser_range.h"' replace.C__PREFIX__ = "parser_range" replace.C__PREFIXUP__ = "PARSER_RANGE" + +[[create.vec]] +sources_output = "src/vec/" +headers_output = "include/me/vec/" +replace.C__TYPENAME__ = "t_heredoc" +replace.C__TYPEHEADER__ = '#include "parser/types/types_heredoc.h"' +replace.C__PREFIX__ = "parser_heredoc" +replace.C__PREFIXUP__ = "PARSER_HEREDOC" diff --git a/output/include/me/vec/vec_parser_heredoc.h b/output/include/me/vec/vec_parser_heredoc.h new file mode 100644 index 00000000..b6780051 --- /dev/null +++ b/output/include/me/vec/vec_parser_heredoc.h @@ -0,0 +1,58 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_parser_heredoc.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2023/12/04 18:46:53 by maiboyer #+# #+# */ +/* Updated: 2023/12/09 17:53:00 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef VEC_PARSER_HEREDOC_H +#define VEC_PARSER_HEREDOC_H + +#include "parser/types/types_heredoc.h" +#include "me/types.h" + +typedef bool (*t_vec_parser_heredoc_sort_fn)(t_heredoc *, t_heredoc *); +typedef void (*t_free_parser_heredoc_item)(t_heredoc); + +typedef struct s_vec_parser_heredoc +{ + t_free_parser_heredoc_item free_func; + t_usize len; + t_usize capacity; + t_heredoc *buffer; +} t_vec_parser_heredoc; + +t_vec_parser_heredoc vec_parser_heredoc_new(t_usize capacity, + t_free_parser_heredoc_item free_function); +t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element); +t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec, + t_heredoc element); +t_error vec_parser_heredoc_pop(t_vec_parser_heredoc *vec, t_heredoc *value); +t_error vec_parser_heredoc_pop_front(t_vec_parser_heredoc *vec, t_heredoc *value); +void vec_parser_heredoc_free(t_vec_parser_heredoc vec); +t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec, + t_usize wanted_capacity); +t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec, + bool (*fn)(const t_heredoc *), t_usize *index); +t_error vec_parser_heredoc_find_starting(t_vec_parser_heredoc *vec, + bool (*fn)(const t_heredoc *), + t_usize starting_index, t_usize *index); +t_error vec_parser_heredoc_all(t_vec_parser_heredoc *vec, + bool (*fn)(const t_heredoc *), bool *result); +t_error vec_parser_heredoc_any(t_vec_parser_heredoc *vec, + bool (*fn)(const t_heredoc *), bool *result); +void vec_parser_heredoc_iter(t_vec_parser_heredoc *vec, + void (*fn)(t_usize index, t_heredoc *value, + void *state), + void *state); +void vec_parser_heredoc_reverse(t_vec_parser_heredoc *vec); +void vec_parser_heredoc_sort(t_vec_parser_heredoc *vec, + t_vec_parser_heredoc_sort_fn is_sorted); +t_error vec_parser_heredoc_back(t_vec_parser_heredoc *vec, t_heredoc **out); + +#endif diff --git a/output/include/me/vec/vec_parser_range.h b/output/include/me/vec/vec_parser_range.h index 1eac9f77..7beecdad 100644 --- a/output/include/me/vec/vec_parser_range.h +++ b/output/include/me/vec/vec_parser_range.h @@ -53,5 +53,6 @@ void vec_parser_range_iter(t_vec_parser_range *vec, void vec_parser_range_reverse(t_vec_parser_range *vec); void vec_parser_range_sort(t_vec_parser_range *vec, t_vec_parser_range_sort_fn is_sorted); +t_error vec_parser_range_back(t_vec_parser_range *vec, t_parser_range **out); #endif diff --git a/output/src/vec/vec_parser_heredoc.c b/output/src/vec/vec_parser_heredoc.c new file mode 100644 index 00000000..34db7c57 --- /dev/null +++ b/output/src/vec/vec_parser_heredoc.c @@ -0,0 +1,115 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_parser_heredoc.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_parser_heredoc.h" +#include + +t_vec_parser_heredoc vec_parser_heredoc_new(t_usize capacity, + t_free_parser_heredoc_item free_function) +{ + t_vec_parser_heredoc out; + + out = (t_vec_parser_heredoc){0}; + out.free_func = free_function; + out.buffer = mem_alloc_array(capacity, sizeof(t_heredoc)); + if (out.buffer) + out.capacity = capacity; + return (out); +} + +/// Return true in case of an error +t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element) +{ + t_heredoc *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_heredoc)); + if (temp_buffer == NULL) + return (ERROR); + mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_heredoc)); + 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_parser_heredoc_reserve(t_vec_parser_heredoc *vec, t_usize wanted_capacity) +{ + t_heredoc *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_heredoc)); + if (temp_buffer == NULL) + return (ERROR); + mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_heredoc)); + 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_parser_heredoc_pop(t_vec_parser_heredoc *vec, t_heredoc *value) +{ + t_heredoc temp_value; + t_heredoc *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_heredoc)); + return (NO_ERROR); +} + +/// This function is safe to call with `free_elem` being NULL +void vec_parser_heredoc_free(t_vec_parser_heredoc 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_parser_heredoc_functions2.c b/output/src/vec/vec_parser_heredoc_functions2.c new file mode 100644 index 00000000..f38b9f24 --- /dev/null +++ b/output/src/vec/vec_parser_heredoc_functions2.c @@ -0,0 +1,112 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_parser_heredoc.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_parser_heredoc.h" +#include + +t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec, + bool (*fn)(const t_heredoc *), 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_parser_heredoc_find_starting(t_vec_parser_heredoc *vec, + bool (*fn)(const t_heredoc *), + 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_parser_heredoc_all(t_vec_parser_heredoc *vec, + bool (*fn)(const t_heredoc *), 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_parser_heredoc_any(t_vec_parser_heredoc *vec, + bool (*fn)(const t_heredoc *), 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_parser_heredoc_iter(t_vec_parser_heredoc *vec, + void (*fn)(t_usize index, t_heredoc *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_parser_heredoc_functions3.c b/output/src/vec/vec_parser_heredoc_functions3.c new file mode 100644 index 00000000..f9677148 --- /dev/null +++ b/output/src/vec/vec_parser_heredoc_functions3.c @@ -0,0 +1,84 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* vec_parser_heredoc.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_parser_heredoc.h" +#include + +t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec, + t_heredoc element) +{ + t_usize i; + + if (vec->len == 0) + return (vec_parser_heredoc_push(vec, element)); + i = vec->len - 1; + if (vec->capacity < vec->len + 1 && + vec_parser_heredoc_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_parser_heredoc_pop_front(t_vec_parser_heredoc *vec, t_heredoc *value) +{ + t_usize i; + + if (vec->len <= 1) + return (vec_parser_heredoc_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_parser_heredoc_reverse(t_vec_parser_heredoc *vec) +{ + t_heredoc 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_parser_heredoc_back(t_vec_parser_heredoc *vec, t_heredoc **out) +{ + t_heredoc *temporary; + + if (out == NULL) + out = &temporary; + if (vec->len != 0) + return (*out = &vec->buffer[vec->len - 1], true); + return (false); +} diff --git a/output/src/vec/vec_parser_range_functions3.c b/output/src/vec/vec_parser_range_functions3.c index b7c4446e..a7ac9012 100644 --- a/output/src/vec/vec_parser_range_functions3.c +++ b/output/src/vec/vec_parser_range_functions3.c @@ -71,3 +71,14 @@ void vec_parser_range_reverse(t_vec_parser_range *vec) i++; } } + +t_error vec_parser_range_back(t_vec_parser_range *vec, t_parser_range **out) +{ + t_parser_range *temporary; + + if (out == NULL) + out = &temporary; + if (vec->len != 0) + return (*out = &vec->buffer[vec->len - 1], true); + return (false); +} diff --git a/parser/Makefile b/parser/Makefile index 91965b94..2aa6a50d 100644 --- a/parser/Makefile +++ b/parser/Makefile @@ -6,7 +6,7 @@ # By: maiboyer +#+ +:+ +#+ # # +#+#+#+#+#+ +#+ # # Created: 2023/11/03 13:20:01 by maiboyer #+# #+# # -# Updated: 2024/04/29 14:31:52 by maiboyer ### ########.fr # +# Updated: 2024/04/30 13:35:56 by maiboyer ### ########.fr # # # # **************************************************************************** # @@ -18,7 +18,7 @@ NAME = libgmr.a LIB_NAME ?= TARGET = $(BUILD_DIR)/$(NAME) CC = cc -CFLAGS = -Wall -Wextra -Werror -g3 -MMD -I./includes -I../includes -I../output/include +CFLAGS = -Wall -Wextra -Werror -MMD -I./includes -I../includes -I../output/include include ./Filelist.mk diff --git a/parser/includes/api.h b/parser/includes/api.h index e7c9ace5..fdfd61b6 100644 --- a/parser/includes/api.h +++ b/parser/includes/api.h @@ -36,13 +36,13 @@ 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 TSLookaheadIterator TSLookaheadIterator; +typedef struct t_lookahead_iterator t_lookahead_iterator; -typedef enum TSInputEncoding +typedef enum t_input_encoding { - TSInputEncodingUTF8, - TSInputEncodingUTF16, -} TSInputEncoding; + InputEncoding8, + InputEncoding16, +} t_input_encoding; typedef enum t_symbol_type { @@ -51,25 +51,25 @@ typedef enum t_symbol_type SymbolTypeAuxiliary, } t_symbol_type; -typedef struct TSInput +typedef struct t_parse_input { void *payload; const char *(*read)(void *payload, t_u32 byte_index, t_point position, t_u32 *bytes_read); - TSInputEncoding encoding; -} TSInput; + t_input_encoding encoding; +} t_parse_input; -typedef enum TSLogType +typedef enum t_parse_log_type { - TSLogTypeParse, - TSLogTypeLex, -} TSLogType; + LogTypeParse, + LogTypeLex, +} t_parse_log_type; -typedef struct TSLogger +typedef struct t_parse_logger { void *payload; - void (*log)(void *payload, TSLogType log_type, const char *buffer); -} TSLogger; + void (*log)(void *payload, t_parse_log_type log_type, const char *buffer); +} t_parse_logger; typedef struct t_input_edit { @@ -101,14 +101,14 @@ typedef struct t_queryCapture t_u32 index; } t_queryCapture; -typedef enum TSQuantifier +typedef enum t_parse_quantifier { - TSQuantifierZero = 0, // must match the array initialization value - TSQuantifierZeroOrOne, - TSQuantifierZeroOrMore, - TSQuantifierOne, - TSQuantifierOneOrMore, -} TSQuantifier; + ParseQuantifierZero = 0, // must match the array initialization value + ParseQuantifierZeroOrOne, + ParseQuantifierZeroOrMore, + ParseQuantifierOne, + ParseQuantifierOneOrMore, +} t_parse_quantifier; typedef struct t_query_match { @@ -221,7 +221,7 @@ const t_parser_range *ts_parser_included_ranges(const t_parser *self, a * way that exactly matches the source code changes. * - * The [`TSInput`] parameter lets you specify how to read the text. It has + * The [`t_parse_input`] parameter lets you specify how to read the text. It has the * following three fields: * 1. [`read`]: A function to retrieve a chunk of text at a given byte @@ -237,7 +237,7 @@ const t_parser_range *ts_parser_included_ranges(const t_parser *self, invocation * of the [`read`] function. * 3. [`encoding`]: An indication of how the text is encoded. Either - * `TSInputEncodingUTF8` or `TSInputEncodingUTF16`. + * `InputEncoding8` or `InputEncoding16`. * * This function returns a syntax tree on success, and `NULL` on failure. There @@ -259,13 +259,13 @@ const t_parser_range *ts_parser_included_ranges(const t_parser *self, with * the same arguments. * - * [`read`]: TSInput::read - * [`payload`]: TSInput::payload - * [`encoding`]: TSInput::encoding - * [`bytes_read`]: TSInput::read + * [`read`]: t_parse_input::read + * [`payload`]: t_parse_input::payload + * [`encoding`]: t_parse_input::encoding + * [`bytes_read`]: t_parse_input::read */ t_parse_tree *ts_parser_parse(t_parser *self, const t_parse_tree *old_tree, - TSInput input); + t_parse_input input); /** * Use the parser to parse some source code stored in one contiguous buffer. @@ -286,7 +286,7 @@ t_parse_tree *ts_parser_parse_string(t_parser *self, t_parse_tree *ts_parser_parse_string_encoding(t_parser *self, const t_parse_tree *old_tree, const char *string, t_u32 length, - TSInputEncoding encoding); + t_input_encoding encoding); /** * Instruct the parser to start the next parse from the beginning. @@ -334,12 +334,12 @@ const size_t *ts_parser_cancellation_flag(const t_parser *self); * was previously assigned, the caller is responsible for releasing any * memory owned by the previous logger. */ -void ts_parser_set_logger(t_parser *self, TSLogger logger); +void ts_parser_set_logger(t_parser *self, t_parse_logger logger); /** * Get the parser's current logger. */ -TSLogger ts_parser_logger(const t_parser *self); +t_parse_logger ts_parser_logger(const t_parser *self); /** * Set the file descriptor to which the parser should write debugging graphs @@ -888,7 +888,7 @@ const char *ts_query_capture_name_for_id(const t_query *self, t_u32 index, * with a numeric id based on the order that it appeared in the query's * source. */ -TSQuantifier ts_query_capture_quantifier_for_id(const t_query *self, +t_parse_quantifier ts_query_capture_quantifier_for_id(const t_query *self, t_u32 pattern_index, t_u32 capture_index); @@ -1110,13 +1110,13 @@ t_state_id ts_language_next_state(const t_language *self, t_state_id state, * lookahead iterator created on the previous non-extra leaf node may be * appropriate. */ -TSLookaheadIterator *ts_lookahead_iterator_new(const t_language *self, +t_lookahead_iterator *ts_lookahead_iterator_new(const t_language *self, t_state_id state); /** * Delete a lookahead iterator freeing all the memory used. */ -void ts_lookahead_iterator_delete(TSLookaheadIterator *self); +void ts_lookahead_iterator_delete(t_lookahead_iterator *self); /** * Reset the lookahead iterator to another state. @@ -1124,7 +1124,7 @@ void ts_lookahead_iterator_delete(TSLookaheadIterator *self); * This returns `true` if the iterator was reset to the given state and * `false` otherwise. */ -bool ts_lookahead_iterator_reset_state(TSLookaheadIterator *self, +bool ts_lookahead_iterator_reset_state(t_lookahead_iterator *self, t_state_id state); /** @@ -1133,33 +1133,33 @@ bool ts_lookahead_iterator_reset_state(TSLookaheadIterator *self, * This returns `true` if the language was set successfully and `false` * otherwise. */ -bool ts_lookahead_iterator_reset(TSLookaheadIterator *self, +bool ts_lookahead_iterator_reset(t_lookahead_iterator *self, const t_language *language, t_state_id state); /** * Get the current language of the lookahead iterator. */ const t_language *ts_lookahead_iterator_language( - const TSLookaheadIterator *self); + const t_lookahead_iterator *self); /** * Advance the lookahead iterator to the next symbol. * * This returns `true` if there is a new symbol and `false` otherwise. */ -bool ts_lookahead_iterator_next(TSLookaheadIterator *self); +bool ts_lookahead_iterator_next(t_lookahead_iterator *self); /** * Get the current symbol of the lookahead iterator; */ -t_symbol ts_lookahead_iterator_current_symbol(const TSLookaheadIterator *self); +t_symbol ts_lookahead_iterator_current_symbol(const t_lookahead_iterator *self); /** * Get the current symbol type of the lookahead iterator as a null * terminated string. */ const char *ts_lookahead_iterator_current_symbol_name( - const TSLookaheadIterator *self); + const t_lookahead_iterator *self); /**********************************/ /* Section - Global Configuration */ diff --git a/parser/includes/parser_length.h b/parser/includes/parser_length.h new file mode 100644 index 00000000..5a9137d8 --- /dev/null +++ b/parser/includes/parser_length.h @@ -0,0 +1,64 @@ +#ifndef TREE_SITTER_LENGTH_H_ +#define TREE_SITTER_LENGTH_H_ + +#include "../src/point.h" +#include "parser/api.h" +#include +#include + +typedef struct s_parse_length +{ + t_u32 bytes; + t_point extent; +} t_parse_length; + +static const t_parse_length LENGTH_UNDEFINED = {0, {0, 1}}; +static const t_parse_length LENGTH_MAX = {UINT32_MAX, {UINT32_MAX, UINT32_MAX}}; + +static inline bool length_is_undefined(t_parse_length length) +{ + return (length.bytes == 0 && length.extent.column != 0); +} + +static inline t_parse_length length_min(t_parse_length len1, + t_parse_length len2) +{ + if (len1.bytes < len2.bytes) + return (len1); + else + return (len2); +} + +static inline t_parse_length length_add(t_parse_length len1, + t_parse_length len2) +{ + t_parse_length result; + result.bytes = len1.bytes + len2.bytes; + result.extent = point_add(len1.extent, len2.extent); + return (result); +} + +static inline t_parse_length length_sub(t_parse_length len1, + t_parse_length len2) +{ + t_parse_length result; + result.bytes = len1.bytes - len2.bytes; + result.extent = point_sub(len1.extent, len2.extent); + return (result); +} + +static inline t_parse_length length_zero(void) +{ + return ((t_parse_length){0, {0, 0}}); +} + +static inline t_parse_length length_saturating_sub(t_parse_length len1, + t_parse_length len2) +{ + if (len1.bytes > len2.bytes) + return (length_sub(len1, len2)); + else + return (length_zero()); +} + +#endif diff --git a/parser/includes/types/types_heredoc.h b/parser/includes/types/types_heredoc.h new file mode 100644 index 00000000..6d34f004 --- /dev/null +++ b/parser/includes/types/types_heredoc.h @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* types_heredoc.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/04/30 13:47:07 by maiboyer #+# #+# */ +/* Updated: 2024/04/30 13:48:19 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef TYPES_HEREDOC_H +#define TYPES_HEREDOC_H + +#include "me/buffered_str/buf_str.h" +#include "me/types.h" + +typedef struct s_heredoc +{ + bool is_raw; + bool started; + bool allows_indent; + t_buffer_str delimiter; + t_buffer_str current_leading_word; +} t_heredoc; + +#endif /* TYPES_HEREDOC_H */ diff --git a/parser/includes/types/types_scanner_ctx.h b/parser/includes/types/types_scanner_ctx.h new file mode 100644 index 00000000..0aba3d08 --- /dev/null +++ b/parser/includes/types/types_scanner_ctx.h @@ -0,0 +1,27 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* types_scanner_ctx.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/04/30 13:41:02 by maiboyer #+# #+# */ +/* Updated: 2024/04/30 13:50:24 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef TYPES_SCANNER_CTX_H +#define TYPES_SCANNER_CTX_H + +#include "me/types.h" +#include "me/vec/vec_parser_heredoc.h" + +typedef struct s_scanner_ctx +{ + t_u8 last_glob_paren_depth; + bool ext_was_in_double_quote; + bool ext_saw_outside_quote; + t_vec_parser_heredoc heredocs; +} t_scanner_ctx; + +#endif /* TYPES_SCANNER_CTX_H */ diff --git a/parser/src/host.h b/parser/src/host.h deleted file mode 100644 index a07e9f89..00000000 --- a/parser/src/host.h +++ /dev/null @@ -1,21 +0,0 @@ - -// Determine endian and pointer size based on known defines. -// TS_BIG_ENDIAN and TS_PTR_SIZE can be set as -D compiler arguments -// to override this. - -#if !defined(TS_BIG_ENDIAN) -#if (defined(__BYTE_ORDER__) && __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__) \ - || (defined( __APPLE_CC__) && (defined(__ppc__) || defined(__ppc64__))) -#define TS_BIG_ENDIAN 1 -#else -#define TS_BIG_ENDIAN 0 -#endif -#endif - -#if !defined(TS_PTR_SIZE) -#if UINTPTR_MAX == 0xFFFFFFFF -#define TS_PTR_SIZE 32 -#else -#define TS_PTR_SIZE 64 -#endif -#endif diff --git a/parser/src/language.c b/parser/src/language.c index 658e38fd..3f5acb60 100644 --- a/parser/src/language.c +++ b/parser/src/language.c @@ -169,47 +169,47 @@ t_field_id ts_language_field_id_for_name( return 0; } -TSLookaheadIterator *ts_lookahead_iterator_new(const t_language *self, t_state_id state) { +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)); *iterator = ts_language_lookaheads(self, state); - return (TSLookaheadIterator *)iterator; + return (t_lookahead_iterator *)iterator; } -void ts_lookahead_iterator_delete(TSLookaheadIterator *self) { +void ts_lookahead_iterator_delete(t_lookahead_iterator *self) { free(self); } -bool ts_lookahead_iterator_reset_state(TSLookaheadIterator * self, t_state_id state) { +bool ts_lookahead_iterator_reset_state(t_lookahead_iterator * self, t_state_id state) { LookaheadIterator *iterator = (LookaheadIterator *)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 TSLookaheadIterator *self) { +const t_language *ts_lookahead_iterator_language(const t_lookahead_iterator *self) { const LookaheadIterator *iterator = (const LookaheadIterator *)self; return iterator->language; } -bool ts_lookahead_iterator_reset(TSLookaheadIterator *self, const t_language *language, t_state_id state) { +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; *iterator = ts_language_lookaheads(language, state); return true; } -bool ts_lookahead_iterator_next(TSLookaheadIterator *self) { +bool ts_lookahead_iterator_next(t_lookahead_iterator *self) { LookaheadIterator *iterator = (LookaheadIterator *)self; return ts_lookahead_iterator__next(iterator); } -t_symbol ts_lookahead_iterator_current_symbol(const TSLookaheadIterator *self) { +t_symbol ts_lookahead_iterator_current_symbol(const t_lookahead_iterator *self) { const LookaheadIterator *iterator = (const LookaheadIterator *)self; return iterator->symbol; } -const char *ts_lookahead_iterator_current_symbol_name(const TSLookaheadIterator *self) { +const char *ts_lookahead_iterator_current_symbol_name(const t_lookahead_iterator *self) { const LookaheadIterator *iterator = (const LookaheadIterator *)self; return ts_language_symbol_name(iterator->language, iterator->symbol); } diff --git a/parser/src/length.h b/parser/src/length.h deleted file mode 100644 index 708d5961..00000000 --- a/parser/src/length.h +++ /dev/null @@ -1,52 +0,0 @@ -#ifndef TREE_SITTER_LENGTH_H_ -#define TREE_SITTER_LENGTH_H_ - -#include -#include -#include "./point.h" -#include "parser/api.h" - -typedef struct { - t_u32 bytes; - t_point extent; -} Length; - -static const Length LENGTH_UNDEFINED = {0, {0, 1}}; -static const Length LENGTH_MAX = {UINT32_MAX, {UINT32_MAX, UINT32_MAX}}; - -static inline bool length_is_undefined(Length length) { - return length.bytes == 0 && length.extent.column != 0; -} - -static inline Length length_min(Length len1, Length len2) { - return (len1.bytes < len2.bytes) ? len1 : len2; -} - -static inline Length length_add(Length len1, Length len2) { - Length result; - result.bytes = len1.bytes + len2.bytes; - result.extent = point_add(len1.extent, len2.extent); - return result; -} - -static inline Length length_sub(Length len1, Length len2) { - Length result; - result.bytes = len1.bytes - len2.bytes; - result.extent = point_sub(len1.extent, len2.extent); - return result; -} - -static inline Length length_zero(void) { - Length result = {0, {0, 0}}; - return result; -} - -static inline Length length_saturating_sub(Length len1, Length len2) { - if (len1.bytes > len2.bytes) { - return length_sub(len1, len2); - } else { - return length_zero(); - } -} - -#endif diff --git a/parser/src/lexer.c b/parser/src/lexer.c index ee5dcdff..208244da 100644 --- a/parser/src/lexer.c +++ b/parser/src/lexer.c @@ -1,5 +1,5 @@ #include "./lexer.h" -#include "./length.h" +#include "parser/parser_length.h" #include "./subtree.h" #include #include @@ -12,7 +12,7 @@ " character:'%c'" \ : message " character:%d", \ character); \ - self->logger.log(self->logger.payload, TSLogTypeLex, \ + self->logger.log(self->logger.payload, LogTypeLex, \ self->debug_buffer); \ } @@ -113,7 +113,7 @@ static void ts_lexer__get_lookahead(t_liblexer *self) } } -static void ts_lexer_goto(t_liblexer *self, Length position) +static void ts_lexer_goto(t_liblexer *self, t_parse_length position) { self->current_position = position; @@ -127,7 +127,7 @@ static void ts_lexer_goto(t_liblexer *self, Length position) { if (included_range->start_byte >= self->current_position.bytes) { - self->current_position = (Length){ + self->current_position = (t_parse_length){ .bytes = included_range->start_byte, .extent = included_range->start_point, }; @@ -161,7 +161,7 @@ static void ts_lexer_goto(t_liblexer *self, Length position) self->current_included_range_index = self->included_range_count; t_parser_range *last_included_range = &self->included_ranges[self->included_range_count - 1]; - self->current_position = (Length){ + self->current_position = (t_parse_length){ .bytes = last_included_range->end_byte, .extent = last_included_range->end_point, }; @@ -200,7 +200,7 @@ static void ts_lexer__do_advance(t_liblexer *self, bool skip) if (self->current_included_range_index < self->included_range_count) { current_range++; - self->current_position = (Length){ + self->current_position = (t_parse_length){ current_range->start_byte, current_range->start_point, }; @@ -260,7 +260,7 @@ static void ts_lexer__mark_end(t_lexer *_self) { t_parser_range *previous_included_range = current_included_range - 1; - self->token_end_position = (Length){ + self->token_end_position = (t_parse_length){ previous_included_range->end_byte, previous_included_range->end_point, }; @@ -355,7 +355,7 @@ void ts_lexer_delete(t_liblexer *self) free(self->included_ranges); } -void ts_lexer_set_input(t_liblexer *self, TSInput input) +void ts_lexer_set_input(t_liblexer *self, t_parse_input input) { self->input = input; ts_lexer__clear_chunk(self); @@ -364,7 +364,7 @@ void ts_lexer_set_input(t_liblexer *self, TSInput input) // Move the lexer to the given position. This doesn't do any work // if the parser is already at the given position. -void ts_lexer_reset(t_liblexer *self, Length position) +void ts_lexer_reset(t_liblexer *self, t_parse_length position) { if (position.bytes != self->current_position.bytes) { diff --git a/parser/src/lexer.h b/parser/src/lexer.h index 634d1c0e..4a29c288 100644 --- a/parser/src/lexer.h +++ b/parser/src/lexer.h @@ -13,7 +13,7 @@ #ifndef TREE_SITTER_LEXER_H_ #define TREE_SITTER_LEXER_H_ -#include "./length.h" +#include "parser/parser_length.h" #include "./parser.h" #include "./subtree.h" #include "parser/api.h" @@ -26,14 +26,14 @@ typedef struct s_liblexer { t_lexer data; - Length current_position; - Length token_start_position; - Length token_end_position; + t_parse_length current_position; + t_parse_length token_start_position; + t_parse_length token_end_position; t_parser_range *included_ranges; const char *chunk; - TSInput input; - TSLogger logger; + t_parse_input input; + t_parse_logger logger; t_u32 included_range_count; t_u32 current_included_range_index; @@ -47,8 +47,8 @@ typedef struct s_liblexer void ts_lexer_init(t_liblexer *); void ts_lexer_delete(t_liblexer *); -void ts_lexer_set_input(t_liblexer *, TSInput); -void ts_lexer_reset(t_liblexer *, Length); +void ts_lexer_set_input(t_liblexer *, t_parse_input); +void ts_lexer_reset(t_liblexer *, t_parse_length); void ts_lexer_start(t_liblexer *); void ts_lexer_finish(t_liblexer *, t_i32 *); void ts_lexer_advance_to_end(t_liblexer *); diff --git a/parser/src/node.c b/parser/src/node.c index a5b93288..44da00ae 100644 --- a/parser/src/node.c +++ b/parser/src/node.c @@ -7,7 +7,7 @@ typedef struct { Subtree parent; const t_parse_tree *tree; - Length position; + t_parse_length position; t_u32 child_index; t_u32 structural_child_index; const t_symbol *alias_sequence; @@ -16,7 +16,7 @@ typedef struct // t_parse_node - constructors t_parse_node ts_node_new(const t_parse_tree *tree, const Subtree *subtree, - Length position, t_symbol alias) + t_parse_length position, t_symbol alias) { return (t_parse_node){ {position.bytes, position.extent.row, position.extent.column, alias}, diff --git a/parser/src/parser.c b/parser/src/parser.c index 4591ad93..15f1dfb0 100644 --- a/parser/src/parser.c +++ b/parser/src/parser.c @@ -1,7 +1,7 @@ #include "./array.h" #include "./error_costs.h" #include "./language.h" -#include "./length.h" +#include "parser/parser_length.h" #include "./lexer.h" #include "./reduce_action.h" #include "./reusable_node.h" @@ -185,7 +185,7 @@ static void ts_parser__log(t_parser *self) { if (self->lexer.logger.log) { - self->lexer.logger.log(self->lexer.logger.payload, TSLogTypeParse, + self->lexer.logger.log(self->lexer.logger.payload, LogTypeParse, self->lexer.debug_buffer); } @@ -367,7 +367,7 @@ static bool ts_parser__better_version_exists(t_parser *self, return true; } - 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, @@ -506,7 +506,7 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version, return NULL_SUBTREE; } - const 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); @@ -515,8 +515,8 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version, bool skipped_error = false; bool called_get_column = false; t_i32 first_error_character = 0; - Length error_start_position = length_zero(); - Length error_end_position = length_zero(); + 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; @@ -525,7 +525,7 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version, for (;;) { bool found_token = false; - Length current_position = self->lexer.current_position; + t_parse_length current_position = self->lexer.current_position; if (lex_mode.external_lex_state != 0) { @@ -626,8 +626,8 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version, Subtree result; if (skipped_error) { - Length padding = length_sub(error_start_position, start_position); - Length size = length_sub(error_end_position, error_start_position); + 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, @@ -638,9 +638,9 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version, { bool is_keyword = false; t_symbol symbol = self->lexer.data.result_symbol; - Length padding = + t_parse_length padding = length_sub(self->lexer.token_start_position, start_position); - Length size = length_sub(self->lexer.token_end_position, + 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; @@ -1300,7 +1300,7 @@ static void ts_parser__recover(t_parser *self, StackVersion version, { bool did_recover = false; unsigned previous_version_count = ts_stack_version_count(self->stack); - Length position = ts_stack_position(self->stack, version); + 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); @@ -1515,7 +1515,7 @@ static void ts_parser__handle_error(t_parser *self, StackVersion version, // 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); - Length position = ts_stack_position(self->stack, version); + 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. @@ -1547,7 +1547,7 @@ static void ts_parser__handle_error(t_parser *self, StackVersion version, // assigned to position it within the next included range. ts_lexer_reset(&self->lexer, position); ts_lexer_mark_end(&self->lexer); - Length padding = + t_parse_length padding = length_sub(self->lexer.token_end_position, position); t_u32 lookahead_bytes = ts_subtree_total_bytes(lookahead) + @@ -2053,12 +2053,12 @@ bool ts_parser_set_language(t_parser *self, const t_language *language) return true; } -TSLogger ts_parser_logger(const t_parser *self) +t_parse_logger ts_parser_logger(const t_parser *self) { return self->lexer.logger; } -void ts_parser_set_logger(t_parser *self, TSLogger logger) +void ts_parser_set_logger(t_parser *self, t_parse_logger logger) { self->lexer.logger = logger; } @@ -2141,7 +2141,7 @@ 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, TSInput 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; @@ -2258,16 +2258,16 @@ t_parse_tree *ts_parser_parse_string(t_parser *self, const t_parse_tree *old_tre const char *string, t_u32 length) { return ts_parser_parse_string_encoding(self, old_tree, string, length, - TSInputEncodingUTF8); + InputEncoding8); } t_parse_tree *ts_parser_parse_string_encoding(t_parser *self, const t_parse_tree *old_tree, const char *string, t_u32 length, - TSInputEncoding encoding) + t_input_encoding encoding) { t_string_input input = {string, length}; return ts_parser_parse(self, old_tree, - (TSInput){ + (t_parse_input){ &input, ts_string_inpt_read, encoding, diff --git a/parser/src/parser.h b/parser/src/parser.h deleted file mode 100644 index e69de29b..00000000 diff --git a/parser/src/scanner.c b/parser/src/scanner.c index e703b571..4657955c 100644 --- a/parser/src/scanner.c +++ b/parser/src/scanner.c @@ -1,11 +1,12 @@ -#include "array.h" -#include "parser.h" +#include "me/mem/mem_alloc.h" +#include "me/types.h" +#include "me/vec/vec_parser_heredoc.h" #include "parser/types/types_lexer.h" +#include "parser/types/types_scanner_ctx.h" #include #include #include -#include #define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 @@ -42,37 +43,17 @@ enum TokenType ERROR_RECOVERY, }; -typedef Array(char) t_string; -// typedef void *String; - -typedef struct s_heredoc -{ - bool is_raw; - bool started; - bool allows_indent; - t_string delimiter; - t_string current_leading_word; -} t_heredoc; - static inline t_heredoc heredoc_new(void) { return ((t_heredoc){ .is_raw = false, .started = false, .allows_indent = false, - .delimiter = array_new(), - .current_leading_word = array_new(), + .delimiter = alloc_new_buffer(0), + .current_leading_word = alloc_new_buffer(0), }); } -typedef struct s_scanner -{ - t_u8 last_glob_paren_depth; - bool ext_was_in_double_quote; - bool ext_saw_outside_quote; - Array(t_heredoc) heredocs; -} t_scanner; - static inline void advance(t_lexer *lexer) { lexer->advance(lexer, false); @@ -88,12 +69,12 @@ static inline bool in_error_recovery(const bool *valid_symbols) return valid_symbols[ERROR_RECOVERY]; } -static inline void reset_string(t_string *string) +static inline void reset_string(t_buffer_str *string) { - if (string->size > 0) + if (string->len > 0) { - memset(string->contents, 0, string->size); - array_clear(string); + memset(string->buf, 0, string->len); + string->len = 0; } } @@ -105,58 +86,59 @@ static inline void reset_heredoc(t_heredoc *heredoc) reset_string(&heredoc->delimiter); } -static inline void reset(t_scanner *scanner) +static inline void reset(t_scanner_ctx *scanner) { t_u32 i; i = 0; - while (i < scanner->heredocs.size) + while (i < scanner->heredocs.len) { - reset_heredoc(array_get(&scanner->heredocs, i)); + reset_heredoc(&scanner->heredocs.buffer[i]); i++; } } -static unsigned serialize(t_scanner *scanner, char *buffer) +static unsigned serialize(t_scanner_ctx *scanner, char *buffer) { - t_u32 size; - t_u32 i; + t_u32 size; + t_u32 i; t_heredoc *heredoc; size = 0; buffer[size++] = (char)scanner->last_glob_paren_depth; buffer[size++] = (char)scanner->ext_was_in_double_quote; buffer[size++] = (char)scanner->ext_saw_outside_quote; - buffer[size++] = (char)scanner->heredocs.size; + buffer[size++] = (char)scanner->heredocs.len; i = 0; - while (i < scanner->heredocs.size) + while (i < scanner->heredocs.len) { - heredoc = array_get(&scanner->heredocs, i); - if (heredoc->delimiter.size + 3 + size >= + heredoc = &scanner->heredocs.buffer[i]; + if (heredoc->delimiter.len + 3 + size >= TREE_SITTER_SERIALIZATION_BUFFER_SIZE) return 0; buffer[size++] = (char)heredoc->is_raw; buffer[size++] = (char)heredoc->started; buffer[size++] = (char)heredoc->allows_indent; - memcpy(&buffer[size], &heredoc->delimiter.size, sizeof(t_u32)); + memcpy(&buffer[size], &heredoc->delimiter.len, sizeof(t_u32)); size += sizeof(t_u32); - if (heredoc->delimiter.size > 0) + if (heredoc->delimiter.len > 0) { - memcpy(&buffer[size], heredoc->delimiter.contents, - heredoc->delimiter.size); - size += heredoc->delimiter.size; + memcpy(&buffer[size], heredoc->delimiter.buf, + heredoc->delimiter.len); + size += heredoc->delimiter.len; } i++; } return size; } -static void deserialize(t_scanner *scanner, const char *buffer, unsigned length) +static void deserialize(t_scanner_ctx *scanner, const char *buffer, + unsigned length) { - t_u32 size; - t_u32 heredoc_count; + t_u32 size; + t_u32 heredoc_count; t_heredoc *heredoc; - t_u32 i; + t_u32 i; size = 0; if (length == 0) @@ -171,24 +153,24 @@ static void deserialize(t_scanner *scanner, const char *buffer, unsigned length) while (i < heredoc_count) { heredoc = NULL; - if (i < scanner->heredocs.size) - heredoc = array_get(&scanner->heredocs, i); + if (i < scanner->heredocs.len) + heredoc = &scanner->heredocs.buffer[i]; else { - array_push(&scanner->heredocs, heredoc_new()); - heredoc = array_back(&scanner->heredocs); + vec_parser_heredoc_push(&scanner->heredocs, heredoc_new()); + heredoc = &scanner->heredocs.buffer[scanner->heredocs.len - 1]; } heredoc->is_raw = buffer[size++]; heredoc->started = buffer[size++]; heredoc->allows_indent = buffer[size++]; - memcpy(&heredoc->delimiter.size, &buffer[size], sizeof(t_u32)); + memcpy(&heredoc->delimiter.len, &buffer[size], sizeof(t_u32)); size += sizeof(t_u32); - array_reserve(&heredoc->delimiter, heredoc->delimiter.size); - if (heredoc->delimiter.size > 0) + str_reserve(&heredoc->delimiter, heredoc->delimiter.len); + if (heredoc->delimiter.len > 0) { - memcpy(heredoc->delimiter.contents, &buffer[size], - heredoc->delimiter.size); - size += heredoc->delimiter.size; + memcpy(heredoc->delimiter.buf, &buffer[size], + heredoc->delimiter.len); + size += heredoc->delimiter.len; } i++; } @@ -203,9 +185,9 @@ static void deserialize(t_scanner *scanner, const char *buffer, unsigned length) * POSIX-mandated substitution, and assumes the default value for * IFS. */ -static bool advance_word(t_lexer *lexer, t_string *unquoted_word) +static bool advance_word(t_lexer *lexer, t_buffer_str *unquoted_word) { - bool empty; + bool empty; t_i32 quote; quote = 0; @@ -224,10 +206,9 @@ static bool advance_word(t_lexer *lexer, t_string *unquoted_word) return (false); } empty = false; - array_push(unquoted_word, lexer->lookahead); + push_str_char(unquoted_word, lexer->lookahead); advance(lexer); } - array_push(unquoted_word, '\0'); if (quote && lexer->lookahead == quote) advance(lexer); return (!empty); @@ -277,31 +258,29 @@ static bool scan_heredoc_end_identifier(t_heredoc *heredoc, t_lexer *lexer) t_i32 size; size = 0; - if (heredoc->delimiter.size > 0) + if (heredoc->delimiter.len > 0) { while (lexer->lookahead != '\0' && lexer->lookahead != '\n' && - (t_i32)*array_get(&heredoc->delimiter, size) == - lexer->lookahead && - heredoc->current_leading_word.size < heredoc->delimiter.size) + (t_i32) * (&heredoc->delimiter.buf[size]) == lexer->lookahead && + heredoc->current_leading_word.len < heredoc->delimiter.len) { - array_push(&heredoc->current_leading_word, lexer->lookahead); + push_str_char(&heredoc->current_leading_word, lexer->lookahead); advance(lexer); size++; } } - array_push(&heredoc->current_leading_word, '\0'); - return heredoc->delimiter.size == 0 + return heredoc->delimiter.len == 0 ? false - : strcmp(heredoc->current_leading_word.contents, - heredoc->delimiter.contents) == 0; + : strcmp(heredoc->current_leading_word.buf, + heredoc->delimiter.buf) == 0; } -static bool scan_heredoc_content(t_scanner *scanner, t_lexer *lexer, +static bool scan_heredoc_content(t_scanner_ctx *scanner, t_lexer *lexer, enum TokenType middle_type, enum TokenType end_type) { bool did_advance = false; - t_heredoc *heredoc = array_back(&scanner->heredocs); + t_heredoc *heredoc = (&scanner->heredocs.buffer[scanner->heredocs.len - 1]); for (;;) { @@ -376,9 +355,7 @@ static bool scan_heredoc_content(t_scanner *scanner, t_lexer *lexer, if (scan_heredoc_end_identifier(heredoc, lexer)) { if (lexer->result_symbol == HEREDOC_END) - { - array_pop(&scanner->heredocs); - } + vec_parser_heredoc_pop(&scanner->heredocs, NULL); return true; } break; @@ -425,7 +402,7 @@ static bool scan_heredoc_content(t_scanner *scanner, t_lexer *lexer, } } } -static bool regex_scan(t_scanner *scanner, t_lexer *lexer, +static bool regex_scan(t_scanner_ctx *scanner, t_lexer *lexer, const bool *valid_symbols) { (void)(scanner); @@ -449,11 +426,11 @@ static bool regex_scan(t_scanner *scanner, t_lexer *lexer, { typedef struct { - bool done; - bool advanced_once; - bool found_non_alnumdollarunderdash; - bool last_was_escape; - bool in_single_quote; + bool done; + bool advanced_once; + bool found_non_alnumdollarunderdash; + bool last_was_escape; + bool in_single_quote; t_u32 paren_depth; t_u32 bracket_depth; t_u32 brace_depth; @@ -650,7 +627,7 @@ static bool regex_scan(t_scanner *scanner, t_lexer *lexer, return (false); } -static bool extglob_pattern_scan(t_scanner *scanner, t_lexer *lexer, +static bool extglob_pattern_scan(t_scanner_ctx *scanner, t_lexer *lexer, const bool *valid_symbols) { if (valid_symbols[EXTGLOB_PATTERN] && !in_error_recovery(valid_symbols)) @@ -793,8 +770,8 @@ static bool extglob_pattern_scan(t_scanner *scanner, t_lexer *lexer, typedef struct { - bool done; - bool saw_non_alphadot; + bool done; + bool saw_non_alphadot; t_u32 paren_depth; t_u32 bracket_depth; t_u32 brace_depth; @@ -926,11 +903,11 @@ static bool extglob_pattern_scan(t_scanner *scanner, t_lexer *lexer, return (false); } -static bool expansion_word_scan(t_scanner *scanner, t_lexer *lexer, +static bool expansion_word_scan(t_scanner_ctx *scanner, t_lexer *lexer, const bool *valid_symbols) { (void)(scanner); - + if (valid_symbols[EXPANSION_WORD]) { bool advanced_once = false; @@ -1027,14 +1004,14 @@ static bool expansion_word_scan(t_scanner *scanner, t_lexer *lexer, advance(lexer); } } - return (false); + return (false); } -static bool brace_start_scan(t_scanner *scanner, t_lexer *lexer, +static bool brace_start_scan(t_scanner_ctx *scanner, t_lexer *lexer, const bool *valid_symbols) { (void)(scanner); - + if (valid_symbols[BRACE_START] && !in_error_recovery(valid_symbols)) { while (isspace(lexer->lookahead)) @@ -1082,7 +1059,8 @@ static bool brace_start_scan(t_scanner *scanner, t_lexer *lexer, } return (false); } -static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) +static bool scan(t_scanner_ctx *scanner, t_lexer *lexer, + const bool *valid_symbols) { if (valid_symbols[CONCAT] && !in_error_recovery(valid_symbols)) { @@ -1186,38 +1164,41 @@ static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) return (true); } } - + t_heredoc *back; + vec_parser_heredoc_back(&scanner->heredocs, &back); if ((valid_symbols[HEREDOC_BODY_BEGINNING] || valid_symbols[SIMPLE_HEREDOC_BODY]) && - scanner->heredocs.size > 0 && - !array_back(&scanner->heredocs)->started && + scanner->heredocs.len > 0 && !back->started && !in_error_recovery(valid_symbols)) return (scan_heredoc_content(scanner, lexer, HEREDOC_BODY_BEGINNING, SIMPLE_HEREDOC_BODY)); - if (valid_symbols[HEREDOC_END] && scanner->heredocs.size > 0) + if (valid_symbols[HEREDOC_END] && scanner->heredocs.len > 0) { - t_heredoc *heredoc = array_back(&scanner->heredocs); + t_heredoc *heredoc; + vec_parser_heredoc_back(&scanner->heredocs, &heredoc); if (scan_heredoc_end_identifier(heredoc, lexer)) { - array_delete(&heredoc->current_leading_word); - array_delete(&heredoc->delimiter); - array_pop(&scanner->heredocs); + str_free(heredoc->current_leading_word); + str_free(heredoc->delimiter); + scanner->heredocs.len -= 1; lexer->result_symbol = HEREDOC_END; return (true); } } - if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.size > 0 && - array_back(&scanner->heredocs)->started && - !in_error_recovery(valid_symbols)) + vec_parser_heredoc_back(&scanner->heredocs, &back); + if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.len > 0 && + back->started && !in_error_recovery(valid_symbols)) return ( scan_heredoc_content(scanner, lexer, HEREDOC_CONTENT, HEREDOC_END)); if (valid_symbols[HEREDOC_START] && !in_error_recovery(valid_symbols) && - scanner->heredocs.size > 0) - return (scan_heredoc_start(array_back(&scanner->heredocs), lexer)); - + scanner->heredocs.len > 0) + { + vec_parser_heredoc_back(&scanner->heredocs, &back); + return (scan_heredoc_start(back, lexer)); + } if (valid_symbols[TEST_OPERATOR] && !valid_symbols[EXPANSION_WORD]) { while (isspace(lexer->lookahead) && lexer->lookahead != '\n') @@ -1376,7 +1357,7 @@ static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) advance(lexer); t_heredoc heredoc = heredoc_new(); heredoc.allows_indent = true; - array_push(&scanner->heredocs, heredoc); + vec_parser_heredoc_push(&scanner->heredocs, heredoc); lexer->result_symbol = HEREDOC_ARROW_DASH; } else if (lexer->lookahead == '<' || lexer->lookahead == '=') @@ -1384,7 +1365,7 @@ static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) else { t_heredoc heredoc = heredoc_new(); - array_push(&scanner->heredocs, heredoc); + vec_parser_heredoc_push(&scanner->heredocs, heredoc); lexer->result_symbol = HEREDOC_ARROW; } return (true); @@ -1483,21 +1464,21 @@ static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) void *tree_sitter_bash_external_scanner_create() { - t_scanner *scanner = calloc(1, sizeof(t_scanner)); - array_init(&scanner->heredocs); + t_scanner_ctx *scanner = mem_alloc(sizeof(t_scanner_ctx)); + scanner->heredocs = vec_parser_heredoc_new(5, NULL); return (scanner); } bool tree_sitter_bash_external_scanner_scan(void *payload, t_lexer *lexer, const bool *valid_symbols) { - t_scanner *scanner = (t_scanner *)payload; + t_scanner_ctx *scanner = (t_scanner_ctx *)payload; return (scan(scanner, lexer, valid_symbols)); } unsigned tree_sitter_bash_external_scanner_serialize(void *payload, char *state) { - t_scanner *scanner = (t_scanner *)payload; + t_scanner_ctx *scanner = (t_scanner_ctx *)payload; return (serialize(scanner, state)); } @@ -1505,19 +1486,19 @@ void tree_sitter_bash_external_scanner_deserialize(void *payload, const char *state, unsigned length) { - t_scanner *scanner = (t_scanner *)payload; + t_scanner_ctx *scanner = (t_scanner_ctx *)payload; deserialize(scanner, state, length); } void tree_sitter_bash_external_scanner_destroy(void *payload) { - t_scanner *scanner = (t_scanner *)payload; - for (size_t i = 0; i < scanner->heredocs.size; i++) + t_scanner_ctx *scanner = (t_scanner_ctx *)payload; + for (size_t i = 0; i < scanner->heredocs.len; i++) { - t_heredoc *heredoc = array_get(&scanner->heredocs, i); - array_delete(&heredoc->current_leading_word); - array_delete(&heredoc->delimiter); + t_heredoc *heredoc = &scanner->heredocs.buffer[i]; + str_free(heredoc->current_leading_word); + str_free(heredoc->delimiter); } - array_delete(&scanner->heredocs); + vec_parser_heredoc_free(scanner->heredocs); free(scanner); } diff --git a/parser/src/stack.c b/parser/src/stack.c index 48b6ad25..c02c6ad6 100644 --- a/parser/src/stack.c +++ b/parser/src/stack.c @@ -3,7 +3,7 @@ #include "./subtree.h" #include "./array.h" #include "./stack.h" -#include "./length.h" +#include "parser/parser_length.h" #include #include #include @@ -28,7 +28,7 @@ typedef struct { struct StackNode { t_state_id state; - Length position; + t_parse_length position; StackLink links[MAX_LINK_COUNT]; short unsigned int link_count; t_u32 ref_count; @@ -464,7 +464,7 @@ t_state_id ts_stack_state(const Stack *self, StackVersion version) { return array_get(&self->heads, version)->node->state; } -Length ts_stack_position(const Stack *self, StackVersion version) { +t_parse_length ts_stack_position(const Stack *self, StackVersion version) { return array_get(&self->heads, version)->node->position; } diff --git a/parser/src/stack.h b/parser/src/stack.h index fb5fbb23..f3f64bac 100644 --- a/parser/src/stack.h +++ b/parser/src/stack.h @@ -22,7 +22,7 @@ typedef struct { typedef Array(StackSlice) StackSliceArray; typedef struct { - Length position; + t_parse_length position; unsigned depth; t_state_id state; } StackSummaryEntry; @@ -48,7 +48,7 @@ Subtree ts_stack_last_external_token(const Stack *, StackVersion); void ts_stack_set_last_external_token(Stack *, StackVersion, Subtree ); // Get the position of the given version of the stack within the document. -Length ts_stack_position(const Stack *, StackVersion); +t_parse_length ts_stack_position(const Stack *, StackVersion); // Push a tree and state onto the given version of the stack. // diff --git a/parser/src/subtree.c b/parser/src/subtree.c index c8008465..e63308f5 100644 --- a/parser/src/subtree.c +++ b/parser/src/subtree.c @@ -9,15 +9,15 @@ #include "./error_costs.h" #include "./language.h" -#include "./length.h" +#include "parser/parser_length.h" #include "./subtree.h" #include typedef struct { - Length start; - Length old_end; - Length new_end; + t_parse_length start; + t_parse_length old_end; + t_parse_length new_end; } Edit; #define TS_MAX_INLINE_TREE_LENGTH UINT8_MAX @@ -193,7 +193,7 @@ static void ts_subtree_pool_free(SubtreePool *self, SubtreeHeapData *tree) // Subtree -static inline bool ts_subtree_can_inline(Length padding, Length size, +static inline bool ts_subtree_can_inline(t_parse_length padding, t_parse_length size, t_u32 lookahead_bytes) { return padding.bytes < TS_MAX_INLINE_TREE_LENGTH && @@ -204,8 +204,8 @@ static inline bool ts_subtree_can_inline(Length padding, Length size, lookahead_bytes < 16; } -Subtree ts_subtree_new_leaf(SubtreePool *pool, t_symbol symbol, Length padding, - Length size, t_u32 lookahead_bytes, +Subtree ts_subtree_new_leaf(SubtreePool *pool, t_symbol symbol, t_parse_length padding, + t_parse_length size, t_u32 lookahead_bytes, t_state_id parse_state, bool has_external_tokens, bool depends_on_column, bool is_keyword, const t_language *language) @@ -283,7 +283,7 @@ void ts_subtree_set_symbol(MutableSubtree *self, t_symbol symbol, } Subtree ts_subtree_new_error(SubtreePool *pool, t_i32 lookahead_char, - Length padding, Length size, + t_parse_length padding, t_parse_length size, t_u32 bytes_scanned, t_state_id parse_state, const t_language *language) { @@ -654,7 +654,7 @@ Subtree ts_subtree_new_error_node(SubtreeArray *children, bool extra, // This node is treated as 'extra'. Its children are prevented from having // having any effect on the parse state. Subtree ts_subtree_new_missing_leaf(SubtreePool *pool, t_symbol symbol, - Length padding, t_u32 lookahead_bytes, + t_parse_length padding, t_u32 lookahead_bytes, const t_language *language) { Subtree result = @@ -807,9 +807,9 @@ Subtree ts_subtree_edit(Subtree self, const t_input_edit *inpt_edit, bool is_pure_insertion = edit.old_end.bytes == edit.start.bytes; bool invalidate_first_row = ts_subtree_depends_on_column(*entry.tree); - Length size = ts_subtree_size(*entry.tree); - Length padding = ts_subtree_padding(*entry.tree); - Length total_size = length_add(padding, size); + t_parse_length size = ts_subtree_size(*entry.tree); + t_parse_length padding = ts_subtree_padding(*entry.tree); + t_parse_length total_size = length_add(padding, size); t_u32 lookahead_bytes = ts_subtree_lookahead_bytes(*entry.tree); t_u32 end_byte = total_size.bytes + lookahead_bytes; if (edit.start.bytes > end_byte || @@ -895,12 +895,12 @@ Subtree ts_subtree_edit(Subtree self, const t_input_edit *inpt_edit, ts_subtree_set_has_changes(&result); *entry.tree = ts_subtree_from_mut(result); - Length child_left, child_right = length_zero(); + t_parse_length child_left, child_right = length_zero(); for (t_u32 i = 0, n = ts_subtree_child_count(*entry.tree); i < n; i++) { Subtree *child = &ts_subtree_children(*entry.tree)[i]; - Length child_size = ts_subtree_total_size(*child); + t_parse_length child_size = ts_subtree_total_size(*child); child_left = child_right; child_right = length_add(child_left, child_size); diff --git a/parser/src/subtree.h b/parser/src/subtree.h index 110660d7..1955fa83 100644 --- a/parser/src/subtree.h +++ b/parser/src/subtree.h @@ -6,8 +6,7 @@ #include "./array.h" #include "./error_costs.h" -#include "./host.h" -#include "./length.h" +#include "parser/parser_length.h" #include "./parser.h" #include "parser/api.h" #include @@ -75,8 +74,8 @@ struct s_subtree_inline_data typedef struct { volatile t_u32 ref_count; - Length padding; - Length size; + t_parse_length padding; + t_parse_length size; t_u32 lookahead_bytes; t_u32 error_cost; t_u32 child_count; @@ -159,14 +158,14 @@ void ts_subtree_array_reverse(SubtreeArray *); SubtreePool ts_subtree_pool_new(t_u32 capacity); void ts_subtree_pool_delete(SubtreePool *); -Subtree ts_subtree_new_leaf(SubtreePool *, t_symbol, Length, Length, t_u32, +Subtree ts_subtree_new_leaf(SubtreePool *, t_symbol, t_parse_length, t_parse_length, t_u32, t_state_id, bool, bool, bool, const t_language *); -Subtree ts_subtree_new_error(SubtreePool *, t_i32, Length, Length, t_u32, +Subtree ts_subtree_new_error(SubtreePool *, t_i32, t_parse_length, t_parse_length, t_u32, t_state_id, const t_language *); MutableSubtree ts_subtree_new_node(t_symbol, SubtreeArray *, unsigned, const t_language *); Subtree ts_subtree_new_error_node(SubtreeArray *, bool, const t_language *); -Subtree ts_subtree_new_missing_leaf(SubtreePool *, t_symbol, Length, t_u32, +Subtree ts_subtree_new_missing_leaf(SubtreePool *, t_symbol, t_parse_length, t_u32, const t_language *); MutableSubtree ts_subtree_make_mut(SubtreePool *, Subtree); void ts_subtree_retain(Subtree); @@ -271,11 +270,11 @@ static inline t_state_id ts_subtree_leaf_parse_state(Subtree self) return self.ptr->first_leaf.parse_state; } -static inline Length ts_subtree_padding(Subtree self) +static inline t_parse_length ts_subtree_padding(Subtree self) { if (self.data.is_inline) { - Length result = {self.data.padding_bytes, + t_parse_length result = {self.data.padding_bytes, {self.data.padding_rows, self.data.padding_columns}}; return result; } @@ -285,11 +284,11 @@ static inline Length ts_subtree_padding(Subtree self) } } -static inline Length ts_subtree_size(Subtree self) +static inline t_parse_length ts_subtree_size(Subtree self) { if (self.data.is_inline) { - Length result = {self.data.size_bytes, {0, self.data.size_bytes}}; + t_parse_length result = {self.data.size_bytes, {0, self.data.size_bytes}}; return result; } else @@ -298,7 +297,7 @@ static inline Length ts_subtree_size(Subtree self) } } -static inline Length ts_subtree_total_size(Subtree self) +static inline t_parse_length ts_subtree_total_size(Subtree self) { return length_add(ts_subtree_padding(self), ts_subtree_size(self)); } diff --git a/parser/src/tree.c b/parser/src/tree.c index a90aa6fc..0b033126 100644 --- a/parser/src/tree.c +++ b/parser/src/tree.c @@ -3,7 +3,7 @@ #include "parser/api.h" #include "./array.h" -#include "./length.h" +#include "parser/parser_length.h" #include "./subtree.h" #include "./tree_cursor.h" #include "./tree.h" @@ -46,7 +46,7 @@ t_parse_node ts_tree_root_node_with_offset( t_u32 offset_bytes, t_point offset_extent ) { - Length offset = {offset_bytes, offset_extent}; + t_parse_length offset = {offset_bytes, offset_extent}; return ts_node_new(self, &self->root, length_add(offset, ts_subtree_padding(self->root)), 0); } diff --git a/parser/src/tree.h b/parser/src/tree.h index c88c0ba8..e13c7d41 100644 --- a/parser/src/tree.h +++ b/parser/src/tree.h @@ -10,7 +10,7 @@ extern "C" { typedef struct { const Subtree *child; const Subtree *parent; - Length position; + t_parse_length position; t_symbol alias_symbol; } ParentCacheEntry; @@ -22,7 +22,7 @@ struct t_parse_tree { }; 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 *, Length, t_symbol); +t_parse_node ts_node_new(const t_parse_tree *, const Subtree *, t_parse_length, t_symbol); #ifdef __cplusplus } diff --git a/parser/src/tree_cursor.c b/parser/src/tree_cursor.c index bcc95155..7f7b129a 100644 --- a/parser/src/tree_cursor.c +++ b/parser/src/tree_cursor.c @@ -7,7 +7,7 @@ typedef struct { Subtree parent; const t_parse_tree *tree; - Length position; + t_parse_length position; t_u32 child_index; t_u32 structural_child_index; t_u32 descendant_index; @@ -101,12 +101,12 @@ static inline bool ts_tree_cursor_child_iterator_next( // can only be computed if `b` has zero rows. Otherwise, this function // returns `LENGTH_UNDEFINED`, and the caller needs to recompute // the position some other way. -static inline Length length_backtrack(Length a, Length b) { +static inline t_parse_length length_backtrack(t_parse_length a, t_parse_length b) { if (length_is_undefined(a) || b.extent.row != 0) { return LENGTH_UNDEFINED; } - Length result; + t_parse_length result; result.bytes = a.bytes - b.bytes; result.extent.row = a.extent.row; result.extent.column = a.extent.column - b.extent.column; @@ -141,7 +141,7 @@ static inline bool ts_tree_cursor_child_iterator_previous( // unsigned can underflow so compare it to child_count if (self->child_index < self->parent.ptr->child_count) { Subtree previous_child = ts_subtree_children(self->parent)[self->child_index]; - Length size = ts_subtree_size(previous_child); + t_parse_length size = ts_subtree_size(previous_child); self->position = length_backtrack(self->position, size); } @@ -273,7 +273,7 @@ static inline t_i64 ts_tree_cursor_goto_first_child_for_byte_and_point( TreeCursorEntry entry; CursorChildIterator iterator = ts_tree_cursor_iterate_children(self); while (ts_tree_cursor_child_iterator_next(&iterator, &entry, &visible)) { - Length entry_end = length_add(entry.position, ts_subtree_size(*entry.subtree)); + t_parse_length entry_end = length_add(entry.position, ts_subtree_size(*entry.subtree)); bool at_goal = entry_end.bytes >= goal_byte && point_gte(entry_end.extent, goal_point); t_u32 visible_child_count = ts_subtree_visible_child_count(*entry.subtree); if (at_goal) { @@ -374,7 +374,7 @@ TreeCursorStep ts_tree_cursor_goto_previous_sibling_internal(t_parse_tree_cursor // restore position from the parent node const TreeCursorEntry *parent = &self->stack.contents[self->stack.size - 2]; - Length position = parent->position; + t_parse_length position = parent->position; t_u32 child_index = array_back(&self->stack)->child_index; const Subtree *children = ts_subtree_children((*(parent->subtree))); diff --git a/parser/src/tree_cursor.h b/parser/src/tree_cursor.h index 6e8dd7a5..e63c9757 100644 --- a/parser/src/tree_cursor.h +++ b/parser/src/tree_cursor.h @@ -5,7 +5,7 @@ typedef struct { const Subtree *subtree; - Length position; + t_parse_length position; t_u32 child_index; t_u32 structural_child_index; t_u32 descendant_index; diff --git a/sources/main.c b/sources/main.c index 66dd9e4b..26c24532 100644 --- a/sources/main.c +++ b/sources/main.c @@ -6,11 +6,10 @@ /* By: rparodi +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/03/28 14:40:38 by rparodi #+# #+# */ -/* Updated: 2024/04/29 16:06:33 by rparodi ### ########.fr */ +/* Updated: 2024/04/30 13:02:39 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ - #include "app/node.h" #include "me/string/str_len.h" #include "parser/api.h" @@ -74,50 +73,58 @@ void ft_find_path(t_str arge[], t_utils *utils) utils->path = ft_split(PATH_FILES, ':'); } -TSLanguage *tree_sitter_bash(void); +t_language *tree_sitter_bash(void); -t_node parse_to_nodes(TSParser *parser, t_const_str input) { - TSTree *tree; - TSNode node; - t_node ret; +t_node parse_to_nodes(t_parser *parser, t_const_str input) +{ + t_parse_tree *tree; + t_parse_node node; + t_node ret; - tree = ts_parser_parse_string(parser, NULL, input, str_len(input)); - node = ts_tree_root_node(tree); - ret = build_node(node, input); - ts_tree_delete(tree); - return (ret); + tree = ts_parser_parse_string(parser, NULL, input, str_len(input)); + node = ts_tree_root_node(tree); + ret = build_node(node, input); + ts_tree_delete(tree); + return (ret); } -void print_node_data(t_node *t, t_usize depth) { - t_usize idx; +void print_node_data(t_node *t, t_usize depth) +{ + t_usize idx; - idx = 0; - while (idx++ < depth) - printf("\t"); - idx = 0; - printf("%s = %s\n", t->kind_str, node_getstr(t)); - while (idx < t->childs_count) - print_node_data(&t->childs[idx++], depth + 1); + idx = 0; + while (idx++ < depth) + printf("\t"); + idx = 0; + printf("%s = %s\n", t->kind_str, node_getstr(t)); + while (idx < t->childs_count) + print_node_data(&t->childs[idx++], depth + 1); } -typedef struct s_myparser { - TSParser *parser; +typedef struct s_myparser +{ + t_parser *parser; } t_myparser; -t_myparser create_myparser(void) { - TSLanguage *lang; - TSParser *parser; +t_myparser create_myparser(void) +{ + t_language *lang; + t_parser *parser; - lang = tree_sitter_bash(); - parser = ts_parser_new(); - ts_parser_set_language(parser, lang); - return ((t_myparser){.parser = parser}); + lang = tree_sitter_bash(); + parser = ts_parser_new(); + ts_parser_set_language(parser, lang); + return ((t_myparser){.parser = parser}); } -void free_myparser(t_myparser self) { ts_parser_delete(self.parser); } +void free_myparser(t_myparser self) +{ + ts_parser_delete(self.parser); +} -t_node parse_string(t_myparser *parser, t_const_str input) { - return (parse_to_nodes(parser->parser, input)); +t_node parse_string(t_myparser *parser, t_const_str input) +{ + return (parse_to_nodes(parser->parser, input)); } t_i32 main(t_i32 argc, t_str argv[], t_str arge[]) diff --git a/sources/node/node.c b/sources/node/node.c index 6c1cfc85..776ba23b 100644 --- a/sources/node/node.c +++ b/sources/node/node.c @@ -16,13 +16,13 @@ #include "me/string/str_l_copy.h" #include "parser/api.h" -t_node build_node(TSNode curr, t_const_str input); +t_node build_node(t_parse_node curr, t_const_str input); -t_node *build_childs(TSNode parent, t_const_str input, t_usize count) +t_node *build_childs(t_parse_node parent, t_const_str input, t_usize count) { t_node *ret; t_usize idx; - TSNode child; + t_parse_node child; ret = mem_alloc_array(sizeof(*ret), count); if (ret == NULL) @@ -37,7 +37,7 @@ t_node *build_childs(TSNode parent, t_const_str input, t_usize count) return (ret); } -t_node build_node(TSNode curr, t_const_str input) +t_node build_node(t_parse_node curr, t_const_str input) { t_node out; diff --git a/stdme/generic_sources/header/vec_C__PREFIX__.h__TEMPLATE__ b/stdme/generic_sources/header/vec_C__PREFIX__.h__TEMPLATE__ index ea5be649..312c0967 100644 --- a/stdme/generic_sources/header/vec_C__PREFIX__.h__TEMPLATE__ +++ b/stdme/generic_sources/header/vec_C__PREFIX__.h__TEMPLATE__ @@ -53,5 +53,6 @@ void vec_C__PREFIX___iter(t_vec_C__PREFIX__ *vec, void vec_C__PREFIX___reverse(t_vec_C__PREFIX__ *vec); void vec_C__PREFIX___sort(t_vec_C__PREFIX__ *vec, t_vec_C__PREFIX___sort_fn is_sorted); +t_error vec_C__PREFIX___back(t_vec_C__PREFIX__ *vec, C__TYPENAME__ **out); #endif diff --git a/stdme/generic_sources/src/vec_C__PREFIX___functions3.c__TEMPLATE__ b/stdme/generic_sources/src/vec_C__PREFIX___functions3.c__TEMPLATE__ index 0051d6e6..d743a407 100644 --- a/stdme/generic_sources/src/vec_C__PREFIX___functions3.c__TEMPLATE__ +++ b/stdme/generic_sources/src/vec_C__PREFIX___functions3.c__TEMPLATE__ @@ -71,3 +71,14 @@ void vec_C__PREFIX___reverse(t_vec_C__PREFIX__ *vec) i++; } } + +t_error vec_C__PREFIX___back(t_vec_C__PREFIX__ *vec, C__TYPENAME__ **out) +{ + C__TYPENAME__ *temporary; + + if (out == NULL) + out = &temporary; + if (vec->len != 0) + return (*out = &vec->buffer[vec->len - 1], true); + return (false); +} diff --git a/stdme/include/me/buffered_str/buf_str.h b/stdme/include/me/buffered_str/buf_str.h index 6bf1092e..568b1975 100644 --- a/stdme/include/me/buffered_str/buf_str.h +++ b/stdme/include/me/buffered_str/buf_str.h @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/11/16 17:54:28 by maiboyer #+# #+# */ -/* Updated: 2023/12/31 15:34:29 by maiboyer ### ########.fr */ +/* Updated: 2024/04/30 14:14:42 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -25,6 +25,7 @@ bool push_str_buffer(t_buffer_str *buf, t_const_str to_push); bool push_str_char(t_buffer_str *buf, char to_push); void str_clear(t_buffer_str *buf); t_buffer_str alloc_new_buffer(t_usize capacity); +t_error str_reserve(t_buffer_str *buf, t_usize size); static inline void str_free(t_buffer_str buf) { diff --git a/stdme/output/include/me/vec/vec_buf_str.h b/stdme/output/include/me/vec/vec_buf_str.h index fe01b85a..ff230fc3 100644 --- a/stdme/output/include/me/vec/vec_buf_str.h +++ b/stdme/output/include/me/vec/vec_buf_str.h @@ -53,5 +53,6 @@ void vec_buf_str_iter(t_vec_buf_str *vec, void vec_buf_str_reverse(t_vec_buf_str *vec); void vec_buf_str_sort(t_vec_buf_str *vec, t_vec_buf_str_sort_fn is_sorted); +t_error vec_buf_str_back(t_vec_buf_str *vec, t_buffer_str **out); #endif diff --git a/stdme/output/include/me/vec/vec_str.h b/stdme/output/include/me/vec/vec_str.h index d8d11fc3..deaf0727 100644 --- a/stdme/output/include/me/vec/vec_str.h +++ b/stdme/output/include/me/vec/vec_str.h @@ -53,5 +53,6 @@ void vec_str_iter(t_vec_str *vec, void vec_str_reverse(t_vec_str *vec); void vec_str_sort(t_vec_str *vec, t_vec_str_sort_fn is_sorted); +t_error vec_str_back(t_vec_str *vec, t_str **out); #endif diff --git a/stdme/output/include/me/vec/vec_u8.h b/stdme/output/include/me/vec/vec_u8.h index 7eaa06dd..ec7fbedf 100644 --- a/stdme/output/include/me/vec/vec_u8.h +++ b/stdme/output/include/me/vec/vec_u8.h @@ -53,5 +53,6 @@ void vec_u8_iter(t_vec_u8 *vec, void vec_u8_reverse(t_vec_u8 *vec); void vec_u8_sort(t_vec_u8 *vec, t_vec_u8_sort_fn is_sorted); +t_error vec_u8_back(t_vec_u8 *vec, t_u8 **out); #endif diff --git a/stdme/output/src/vec/vec_buf_str_functions3.c b/stdme/output/src/vec/vec_buf_str_functions3.c index b468dac1..8b2205b4 100644 --- a/stdme/output/src/vec/vec_buf_str_functions3.c +++ b/stdme/output/src/vec/vec_buf_str_functions3.c @@ -71,3 +71,14 @@ void vec_buf_str_reverse(t_vec_buf_str *vec) i++; } } + +t_error vec_buf_str_back(t_vec_buf_str *vec, t_buffer_str **out) +{ + t_buffer_str *temporary; + + if (out == NULL) + out = &temporary; + if (vec->len != 0) + return (*out = &vec->buffer[vec->len - 1], true); + return (false); +} diff --git a/stdme/output/src/vec/vec_str_functions3.c b/stdme/output/src/vec/vec_str_functions3.c index 0ac7153f..b0fd48e7 100644 --- a/stdme/output/src/vec/vec_str_functions3.c +++ b/stdme/output/src/vec/vec_str_functions3.c @@ -71,3 +71,14 @@ void vec_str_reverse(t_vec_str *vec) i++; } } + +t_error vec_str_back(t_vec_str *vec, t_str **out) +{ + t_str *temporary; + + if (out == NULL) + out = &temporary; + if (vec->len != 0) + return (*out = &vec->buffer[vec->len - 1], true); + return (false); +} diff --git a/stdme/output/src/vec/vec_u8_functions3.c b/stdme/output/src/vec/vec_u8_functions3.c index 32994a01..f244463c 100644 --- a/stdme/output/src/vec/vec_u8_functions3.c +++ b/stdme/output/src/vec/vec_u8_functions3.c @@ -71,3 +71,14 @@ void vec_u8_reverse(t_vec_u8 *vec) i++; } } + +t_error vec_u8_back(t_vec_u8 *vec, t_u8 **out) +{ + t_u8 *temporary; + + if (out == NULL) + out = &temporary; + if (vec->len != 0) + return (*out = &vec->buffer[vec->len - 1], true); + return (false); +} diff --git a/stdme/src.list b/stdme/src.list index a36af7c7..cb42365a 100644 --- a/stdme/src.list +++ b/stdme/src.list @@ -16,6 +16,7 @@ blx/sprite/get_pixel blx/sprite/new_image blx/sprite/sprite_draw_onto_sprite buffered_str/mod +buffered_str/push_char char/isalnum char/isalpha char/isascii diff --git a/stdme/src/buffered_str/mod.c b/stdme/src/buffered_str/mod.c index 4301d3ce..deb4ff8c 100644 --- a/stdme/src/buffered_str/mod.c +++ b/stdme/src/buffered_str/mod.c @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2023/11/16 17:52:12 by maiboyer #+# #+# */ -/* Updated: 2024/04/28 20:05:41 by maiboyer ### ########.fr */ +/* Updated: 2024/04/30 14:14:03 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -19,11 +19,32 @@ #include "me/types.h" #include -bool push_str_buffer(t_buffer_str *buf, t_const_str to_push) +t_error str_reserve(t_buffer_str *buf, t_usize size) { - t_usize to_push_len; t_str temp_buffer; - t_usize new_capacity; + t_usize new_capacity; + + if (buf == NULL) + return (ERROR); + while (size > buf->capacity) + { + new_capacity = (buf->capacity * 3) / 2 + 1; + temp_buffer = mem_alloc(new_capacity); + if (temp_buffer == NULL) + return (true); + str_l_copy(temp_buffer, buf->buf, new_capacity); + free(buf->buf); + buf->buf = temp_buffer; + buf->capacity = new_capacity; + } + return (NO_ERROR); +} + +bool push_str_buffer(t_buffer_str *buf, t_const_str to_push) +{ + t_usize to_push_len; + t_str temp_buffer; + t_usize new_capacity; if (buf == NULL || to_push == NULL) return (true); @@ -44,26 +65,26 @@ bool push_str_buffer(t_buffer_str *buf, t_const_str to_push) return (false); } -bool push_str_char(t_buffer_str *buf, char to_push) +bool push_str_char(t_buffer_str *buf, char to_push) { - char push_str[2]; + char push_str[2]; push_str[0] = to_push; push_str[1] = 0; return (push_str_buffer(buf, push_str)); } -void str_clear(t_buffer_str *buf) +void str_clear(t_buffer_str *buf) { mem_set_zero(buf->buf, buf->capacity); buf->len = 0; - return ; + return; } -t_buffer_str alloc_new_buffer(t_usize capacity) +t_buffer_str alloc_new_buffer(t_usize capacity) { - t_buffer_str out; - t_str buf; + t_buffer_str out; + t_str buf; if (capacity == 0) capacity = 16; diff --git a/stdme/src/buffered_str/push_char.c b/stdme/src/buffered_str/push_char.c new file mode 100644 index 00000000..730580b5 --- /dev/null +++ b/stdme/src/buffered_str/push_char.c @@ -0,0 +1,13 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* push_char.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/04/30 14:17:47 by maiboyer #+# #+# */ +/* Updated: 2024/04/30 14:17:47 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +