From 163db2241fd6057dabaec3a430054a25b3dd8088 Mon Sep 17 00:00:00 2001 From: Maieul BOYER Date: Fri, 6 Sep 2024 18:04:22 +0200 Subject: [PATCH] update: Updated stuff so the scanner works great now --- Filelist.sh.mk | 9 +- input.toml | 8 + output/include/me/vec/vec_reduce_action.h | 174 +++++ output/src/vec/reduce_action/reduce_action.c | 93 +++ .../reduce_action/reduce_action_functions2.c | 112 ++++ .../reduce_action/reduce_action_functions3.c | 82 +++ .../reduce_action/reduce_action_functions4.c | 77 +++ .../vec/reduce_action/reduce_action_sort.c | 41 ++ .../parser/inner/reduce_action_inner.h | 28 + parser/include/parser/inner/scanner.h | 63 +- parser/include/parser/inner/subtree_inner.h | 24 +- parser/include/parser/reduce_action.h | 19 +- parser/src/misc/reduce_action.c | 13 +- parser/src/parser.c | 30 +- parser/src/scanner.c | 613 +++--------------- 15 files changed, 738 insertions(+), 648 deletions(-) create mode 100644 output/include/me/vec/vec_reduce_action.h create mode 100644 output/src/vec/reduce_action/reduce_action.c create mode 100644 output/src/vec/reduce_action/reduce_action_functions2.c create mode 100644 output/src/vec/reduce_action/reduce_action_functions3.c create mode 100644 output/src/vec/reduce_action/reduce_action_functions4.c create mode 100644 output/src/vec/reduce_action/reduce_action_sort.c create mode 100644 parser/include/parser/inner/reduce_action_inner.h diff --git a/Filelist.sh.mk b/Filelist.sh.mk index af82cf21..2a7c700f 100644 --- a/Filelist.sh.mk +++ b/Filelist.sh.mk @@ -1,8 +1,8 @@ SRC_FILES = \ -env \ _env_norm_helper \ -ft_exit \ _helper_main \ +env \ +ft_exit \ main \ node/node \ signal_handler \ @@ -33,6 +33,11 @@ src/vec/pid/pid_functions2 \ src/vec/pid/pid_functions3 \ src/vec/pid/pid_functions4 \ src/vec/pid/pid_sort \ +src/vec/reduce_action/reduce_action \ +src/vec/reduce_action/reduce_action_functions2 \ +src/vec/reduce_action/reduce_action_functions3 \ +src/vec/reduce_action/reduce_action_functions4 \ +src/vec/reduce_action/reduce_action_sort \ src/vec/str/str \ src/vec/str/str_functions2 \ src/vec/str/str_functions3 \ diff --git a/input.toml b/input.toml index 316323b8..ab463dff 100644 --- a/input.toml +++ b/input.toml @@ -98,3 +98,11 @@ replace.C__TYPENAME__ = "t_subtree" replace.C__TYPEHEADER__ = '#include "parser/inner/subtree_inner.h"' replace.C__PREFIX__ = "subtree" replace.C__PREFIXUP__ = "SUBTREE" + +[[create.vec]] +sources_output = "src/vec/C__PREFIX__/" +headers_output = "include/me/vec/" +replace.C__TYPENAME__ = "t_reduce_action" +replace.C__TYPEHEADER__ = '#include "parser/inner/reduce_action_inner.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..ea1cee36 --- /dev/null +++ b/output/include/me/vec/vec_reduce_action.h @@ -0,0 +1,174 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* 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/inner/reduce_action_inner.h" +#include "me/types.h" + +/// @brief A function that takes two t_reduce_action and compare them +typedef bool (*t_vec_reduce_action_sort_fn)(t_reduce_action *, t_reduce_action *); +/// @brief A function that free an t_reduce_action +typedef void (*t_free_reduce_action_item)(t_reduce_action); + +/// @brief A dynamic array of t_reduce_action +typedef struct s_vec_reduce_action t_vec_reduce_action; + +struct s_vec_reduce_action +{ + t_free_reduce_action_item free_func; + t_usize len; + t_usize capacity; + t_reduce_action *buffer; +}; + +struct s_vec_reduce_action_splice_arguments +{ + t_usize index; + t_usize old_count; + t_usize new_count; + const t_reduce_action *elements; +}; + +/// @brief Create a new vec_reduce_action with a given capacity +/// @param capacity The capacity of the new vec_reduce_action (in terms of +/// elements) +/// @param free_function The function that will be used to free the elements of +/// the vec_reduce_action +t_vec_reduce_action vec_reduce_action_new(t_usize capacity, + t_free_reduce_action_item free_function); +/// @brief Push an element to the last position of the vec_reduce_action +/// @param vec The vec_reduce_action to push the element to +/// @param element The element to push +t_error vec_reduce_action_push(t_vec_reduce_action *vec, t_reduce_action element); + +/// @brief Push an element to the first position of the vec_reduce_action +/// @param vec The vec_reduce_action to push the element to +/// @param element The element to push +/// @note This operation is O(n) +t_error vec_reduce_action_push_front(t_vec_reduce_action *vec, + t_reduce_action element); + +/// @brief Get the last element from the vec_reduce_action, and remove it from the +/// vec_reduce_action +/// @param vec The vec_reduce_action to get the element from +/// @param[out] out The last element of the vec_reduce_action +/// @return true if the operation failed, false otherwise +t_error vec_reduce_action_pop(t_vec_reduce_action *vec, t_reduce_action *value); + +/// @brief Get the first element from the vec_reduce_action, and remove it from +/// the vec_reduce_action +/// @param vec The vec_reduce_action to get the element from +/// @param[out] out The first element of the vec_reduce_action +/// @return true if the operation failed, false otherwise +/// @note This operation is O(n) +t_error vec_reduce_action_pop_front(t_vec_reduce_action *vec, t_reduce_action *value); + +/// @brief Free the vector and all its elements +/// @param vec The vec_reduce_action to free +void vec_reduce_action_free(t_vec_reduce_action vec); + +/// @brief Make the vec_reduce_action at least the given capacity +/// @param vec The vec_reduce_action to reserve +/// @param wanted_capacity The minimum capacity to reserve +/// @return true if the operation failed, false otherwise +t_error vec_reduce_action_reserve(t_vec_reduce_action *vec, + t_usize wanted_capacity); + +/// @brief Run the function and returns the index of the first element that +/// returns true +/// @param vec The vec_reduce_action to search in +/// @param fn The function to run on each element +/// @param[out] index The index of the first element that returns true +t_error vec_reduce_action_find(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), t_usize *index); + +/// @brief Run the function and returns the index of the first element that +/// returns true, but starting at index starting_index +/// @param vec The vec_reduce_action to search in +/// @param fn The function to run on each element +/// @param starting_index The index to start the search from +/// @param[out] index The index of the first element that returns true +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); + +/// @brief Run the function on every element of the vec_reduce_action and returns +/// if all elements returned true +/// @param vec The vec_reduce_action to search in +/// @param fn The function to run on each element +/// @param[out] result The result of the operation +/// @return true if the operation failed, false otherwise +/// @note If the vec_reduce_action is empty, result will be true +t_error vec_reduce_action_all(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), bool *result); + +/// @brief Run the function on every element of the vec_reduce_action and returns +/// if any element returned true +/// @param vec The vec_reduce_action to search in +/// @param fn The function to run on each element +/// @param[out] result The result of the operation +/// @return true if the operation failed, false otherwise +/// @note If the vec_reduce_action is empty, result will be false +t_error vec_reduce_action_any(t_vec_reduce_action *vec, + bool (*fn)(const t_reduce_action *), bool *result); + +/// @brief Run the function on every element of the vec_reduce_action +/// @param vec The vec_reduce_action to iterate over +/// @param fn The function to run on each element +/// @param state The state to pass to the function +void vec_reduce_action_iter(t_vec_reduce_action *vec, + void (*fn)(t_usize index, t_reduce_action *value, + void *state), + void *state); + +/// @brief Reverse the order of the elements in the vec_reduce_action +/// @param vec The vec_reduce_action to reverse +void vec_reduce_action_reverse(t_vec_reduce_action *vec); + +/// @brief Sort the elements of the vec_reduce_action +/// @param vec The vec_reduce_action to sort +/// @param is_sorted The function to use to compare the elements +void vec_reduce_action_sort(t_vec_reduce_action *vec, + t_vec_reduce_action_sort_fn is_sorted); + +/// @brief Get a pointer to the last element of the vec_reduce_action +/// @param vec The vec_reduce_action to get the element from +/// @param[out] out A pointer to the last element of the vec_reduce_action +/// @return true if the operation failed, false otherwise +t_error vec_reduce_action_back(t_vec_reduce_action *vec, t_reduce_action **out); + +/// @brief Get a pointer to the i'th element, or NULL otherwise +/// @param vec The vec_reduce_action to get the element from +/// @return A pointer to the element or NULL +t_reduce_action *vec_reduce_action_get(t_vec_reduce_action *vec, t_usize i); + +/// @brief Get a pointer to the last element, or NULL otherwise +/// @param vec The vec_reduce_action to get the element from +/// @return A pointer to the last element or NULL +t_reduce_action *vec_reduce_action_last(t_vec_reduce_action *vec); + +/// @brief Perform a simple bytewise copy into the other vector +/// @param vec The vec_reduce_action to be copied from +/// @param dest The vec_reduce_action to be copied to +void vec_reduce_action_copy_into(t_vec_reduce_action *vec, t_vec_reduce_action *dest); + +/// read code lol +void vec_reduce_action_splice(t_vec_reduce_action *self, + struct s_vec_reduce_action_splice_arguments args); + +struct s_vec_reduce_action_splice_arguments vec_reduce_action_splice_args( + t_usize index, t_usize old_count, t_usize new_count, + const t_reduce_action *elements); + +#endif diff --git a/output/src/vec/reduce_action/reduce_action.c b/output/src/vec/reduce_action/reduce_action.c new file mode 100644 index 00000000..e97b4804 --- /dev/null +++ b/output/src/vec/reduce_action/reduce_action.c @@ -0,0 +1,93 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* 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.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) +{ + if (vec == NULL) + return (ERROR); + vec_reduce_action_reserve(vec, vec->len + 1); + 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) +{ + 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; + vec->buffer = + mem_realloc_array(vec->buffer, new_capacity, sizeof(t_reduce_action)); + 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 || vec->len == 0) + return (ERROR); + ptr = value; + 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.buffer == NULL) + return; + if (vec.free_func) + { + while (vec.len) + { + vec.free_func(vec.buffer[vec.len - 1]); + vec.len--; + } + } + mem_free(vec.buffer); +} diff --git a/output/src/vec/reduce_action/reduce_action_functions2.c b/output/src/vec/reduce_action/reduce_action_functions2.c new file mode 100644 index 00000000..3fdfcebb --- /dev/null +++ b/output/src/vec/reduce_action/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.h" +#include "me/mem/mem.h" +#include "me/mem/mem.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((const t_reduce_action *)&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((const t_reduce_action *)&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((const t_reduce_action *)&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((const t_reduce_action *)&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/reduce_action/reduce_action_functions3.c b/output/src/vec/reduce_action/reduce_action_functions3.c new file mode 100644 index 00000000..ab46793b --- /dev/null +++ b/output/src/vec/reduce_action/reduce_action_functions3.c @@ -0,0 +1,82 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* 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.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/output/src/vec/reduce_action/reduce_action_functions4.c b/output/src/vec/reduce_action/reduce_action_functions4.c new file mode 100644 index 00000000..78790127 --- /dev/null +++ b/output/src/vec/reduce_action/reduce_action_functions4.c @@ -0,0 +1,77 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* 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.h" +#include "me/types.h" +#include "me/vec/vec_reduce_action.h" +#include + +t_reduce_action *vec_reduce_action_get(t_vec_reduce_action *vec, t_usize i) +{ + if (vec == NULL || vec->buffer == NULL) + return (NULL); + if (i < vec->len) + return (&vec->buffer[i]); + return (NULL); +} + +t_reduce_action *vec_reduce_action_last(t_vec_reduce_action *vec) +{ + if (vec == NULL || vec->len == 0) + return (NULL); + return (&vec->buffer[vec->len - 1]); +} + +void vec_reduce_action_copy_into(t_vec_reduce_action *vec, t_vec_reduce_action *dest) +{ + if (vec == NULL || dest == NULL) + return ; + vec_reduce_action_reserve(dest, vec->capacity); + mem_copy(dest->buffer, vec->buffer, vec->len * sizeof(t_reduce_action)); +} + +struct s_vec_reduce_action_splice_arguments vec_reduce_action_splice_args( + t_usize index, t_usize old_count, t_usize new_count, + const t_reduce_action *elements) +{ + return ((struct s_vec_reduce_action_splice_arguments){index, old_count, + new_count, elements}); +} + +void vec_reduce_action_splice(t_vec_reduce_action *self, + struct s_vec_reduce_action_splice_arguments args) +{ + t_reduce_action *contents; + t_u32 new_size; + t_u32 old_end; + t_u32 new_end; + + new_size = self->len + args.new_count - args.old_count; + old_end = args.index + args.old_count; + new_end = args.index + args.new_count; + vec_reduce_action_reserve(self, new_size); + contents = self->buffer; + if (self->len > old_end) + mem_move(contents + new_end, + contents + old_end, + (self->len - old_end) * sizeof(t_reduce_action)); + if (args.new_count > 0) + { + if (args.elements) + mem_copy((contents + args.index * sizeof(t_reduce_action)), + args.elements, args.new_count * sizeof(t_reduce_action)); + else + mem_set_zero((contents + args.index * sizeof(t_reduce_action)), + args.new_count * sizeof(t_reduce_action)); + } + self->len += args.new_count - args.old_count; +} diff --git a/output/src/vec/reduce_action/reduce_action_sort.c b/output/src/vec/reduce_action/reduce_action_sort.c new file mode 100644 index 00000000..459956bf --- /dev/null +++ b/output/src/vec/reduce_action/reduce_action_sort.c @@ -0,0 +1,41 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* best_move.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/01/29 20:04:33 by maiboyer #+# #+# */ +/* Updated: 2024/01/31 14:25:00 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "me/types.h" +#include "me/vec/vec_reduce_action.h" + +void vec_reduce_action_sort(t_vec_reduce_action *v, + t_vec_reduce_action_sort_fn is_sorted_fn) +{ + t_usize sorted_part; + t_usize i; + t_reduce_action tmp; + + if (v == NULL) + return; + sorted_part = v->len; + while (sorted_part > 0) + { + i = 0; + while (i < sorted_part - 1) + { + if (!is_sorted_fn(&v->buffer[i], &v->buffer[i + 1])) + { + tmp = v->buffer[i]; + v->buffer[i] = v->buffer[i + 1]; + v->buffer[i + 1] = tmp; + } + i++; + } + sorted_part--; + } +} diff --git a/parser/include/parser/inner/reduce_action_inner.h b/parser/include/parser/inner/reduce_action_inner.h new file mode 100644 index 00000000..34876ab7 --- /dev/null +++ b/parser/include/parser/inner/reduce_action_inner.h @@ -0,0 +1,28 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* reduce_action_inner.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/09/06 16:56:42 by maiboyer #+# #+# */ +/* Updated: 2024/09/06 16:57:13 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef REDUCE_ACTION_INNER_H +#define REDUCE_ACTION_INNER_H + +#include "me/types.h" +#include "parser/inner/ptypes.h" + +struct s_reduce_action +{ + t_u32 count; + TSSymbol symbol; + int dynamic_precedence; + t_u16 production_id; +}; +typedef struct s_reduce_action t_reduce_action; + +#endif /* REDUCE_ACTION_INNER_H */ diff --git a/parser/include/parser/inner/scanner.h b/parser/include/parser/inner/scanner.h index 1180df99..65b4d875 100755 --- a/parser/include/parser/inner/scanner.h +++ b/parser/include/parser/inner/scanner.h @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/09/02 13:22:04 by maiboyer #+# #+# */ -/* Updated: 2024/09/02 17:40:15 by maiboyer ### ########.fr */ +/* Updated: 2024/09/06 16:57:20 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -17,65 +17,4 @@ #include "me/vec/vec_heredoc.h" #include "parser/parser.h" -// typedef struct s_scanner t_scanner; - -// struct s_scanner -// { -// t_u8 last_glob_paren_depth; -// bool ext_was_in_double_quote; -// bool ext_saw_outside_quote; -// t_vec_heredoc heredocs; -// }; - -// enum e_token_type -// { -// HEREDOC_START, -// SIMPLE_HEREDOC_BODY, -// HEREDOC_BODY_BEGINNING, -// HEREDOC_CONTENT, -// HEREDOC_END, -// FILE_DESCRIPTOR, -// EMPTY_VALUE, -// CONCAT, -// VARIABLE_NAME, -// REGEX, -// EXPANSION_WORD, -// EXTGLOB_PATTERN, -// BARE_DOLLAR, -// IMMEDIATE_DOUBLE_HASH, -// HEREDOC_ARROW, -// HEREDOC_ARROW_DASH, -// NEWLINE, -// OPENING_PAREN, -// ESAC, -// ERROR_RECOVERY, -// }; - -// struct s_heredoc_scan_state -// { -// t_scanner *scanner; -// TSLexer *lexer; -// enum e_token_type middle_type; -// enum e_token_type end_type; -// bool did_advance; -// t_heredoc *heredoc; -// bool return_value; -// }; - -// typedef bool (*t_heredoc_content_func)(struct s_heredoc_scan_state *state); - -// bool advance_word(TSLexer *lexer, t_string *unquoted_word); -// bool check_scan_concat(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols); -// bool scan(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols); -// bool scan_bare_dollar(TSLexer *lexer); -// bool scan_concat(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols); -// bool scan_double_hash(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols); -// bool scan_expansion_word(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols); -// bool scan_heredoc_content(t_scanner *scanner, TSLexer *lexer, enum e_token_type middle_type, enum e_token_type end_type); -// bool scan_heredoc_end(t_scanner *scanner, TSLexer *lexer); -// bool scan_heredoc_end_identifier(t_heredoc *heredoc, TSLexer *lexer); -// bool scan_heredoc_start(t_heredoc *heredoc, TSLexer *lexer); -// bool scan_varname(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols); -// void reset(t_scanner *scanner); - #endif diff --git a/parser/include/parser/inner/subtree_inner.h b/parser/include/parser/inner/subtree_inner.h index 775352f3..7775ce52 100644 --- a/parser/include/parser/inner/subtree_inner.h +++ b/parser/include/parser/inner/subtree_inner.h @@ -6,7 +6,7 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/09/02 20:01:50 by maiboyer #+# #+# */ -/* Updated: 2024/09/02 20:16:23 by maiboyer ### ########.fr */ +/* Updated: 2024/09/06 17:00:26 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ @@ -36,17 +36,17 @@ struct s_subtree_data TSSymbol symbol; TSStateId parse_state; - bool visible : 1; - bool named : 1; - bool extra : 1; - bool fragile_left : 1; - bool fragile_right : 1; - bool has_changes : 1; - bool has_external_tokens : 1; - bool has_external_scanner_state_change : 1; - bool depends_on_column : 1; - bool is_missing : 1; - bool is_keyword : 1; + bool visible; + bool named; + bool extra; + bool fragile_left; + bool fragile_right; + bool has_changes; + bool has_external_tokens; + bool has_external_scanner_state_change; + bool depends_on_column; + bool is_missing; + bool is_keyword; union { // Non-terminal subtrees (`child_count > 0`) diff --git a/parser/include/parser/reduce_action.h b/parser/include/parser/reduce_action.h index 1dc2aeae..ca0208e8 100644 --- a/parser/include/parser/reduce_action.h +++ b/parser/include/parser/reduce_action.h @@ -6,28 +6,21 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 12:03:09 by maiboyer #+# #+# */ -/* Updated: 2024/08/31 18:31:33 by maiboyer ### ########.fr */ +/* Updated: 2024/09/06 17:08:38 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ #ifndef REDUCE_ACTION_H #define REDUCE_ACTION_H +#include "me/types.h" #include "parser/api.h" #include "parser/array.h" -#include "me/types.h" +#include "parser/inner/reduce_action_inner.h" +#include "me/vec/vec_reduce_action.h" -struct s_reduce_action -{ - t_u32 count; - TSSymbol symbol; - int dynamic_precedence; - t_u16 production_id; -}; +typedef t_vec_reduce_action ReduceActionSet; -typedef struct s_reduce_action ReduceAction; -typedef Array(ReduceAction) ReduceActionSet; - -void ts_reduce_action_set_add(ReduceActionSet *self, ReduceAction new_action); +void ts_reduce_action_set_add(ReduceActionSet *self, t_reduce_action new_action); #endif // REDUCE_ACTION_H diff --git a/parser/src/misc/reduce_action.c b/parser/src/misc/reduce_action.c index 99641d93..18c98860 100644 --- a/parser/src/misc/reduce_action.c +++ b/parser/src/misc/reduce_action.c @@ -6,25 +6,26 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/08/31 17:33:11 by maiboyer #+# #+# */ -/* Updated: 2024/08/31 17:33:32 by maiboyer ### ########.fr */ +/* Updated: 2024/09/06 17:11:17 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ #include "parser/reduce_action.h" +#include "me/vec/vec_reduce_action.h" -void ts_reduce_action_set_add(ReduceActionSet *self, ReduceAction new_action) +void ts_reduce_action_set_add(ReduceActionSet *self, t_reduce_action new_action) { - ReduceAction action; + t_reduce_action action; t_u32 i; i = 0; - while (i < self->size) + while (i < self->len) { - action = self->contents[i]; + action = self->buffer[i]; if (action.symbol == new_action.symbol \ && action.count == new_action.count) return ; i++; } - array_push(self, new_action); + vec_reduce_action_push(self, new_action); } diff --git a/parser/src/parser.c b/parser/src/parser.c index 4fd17351..83be805c 100644 --- a/parser/src/parser.c +++ b/parser/src/parser.c @@ -6,12 +6,13 @@ /* By: maiboyer +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2024/09/03 14:08:00 by maiboyer #+# #+# */ -/* Updated: 2024/09/03 14:08:01 by maiboyer ### ########.fr */ +/* Updated: 2024/09/06 17:10:43 by maiboyer ### ########.fr */ /* */ /* ************************************************************************** */ #include "me/mem/mem.h" #include "me/types.h" +#include "me/vec/vec_reduce_action.h" #include "me/vec/vec_subtree.h" #include "parser/api.h" #include "parser/array.h" @@ -627,18 +628,15 @@ static t_stack_version ts_parser__reduce(TSParser *self, t_stack_version version ts_subtree_array_remove_trailing_extras(&next_slice_children, &self->trailing_extras2); if (ts_parser__select_children(self, (parent), &next_slice_children)) { - ts_subtree_array_clear( - /*&self->tree_pool,*/ &self->trailing_extras); - ts_subtree_release( - /*&self->tree_pool,*/ (parent)); + ts_subtree_array_clear(&self->trailing_extras); + ts_subtree_release(parent); array_swap(&self->trailing_extras, &self->trailing_extras2); parent = ts_subtree_new_node(symbol, &next_slice_children, production_id, self->language); } else { self->trailing_extras2.len = 0; - ts_subtree_array_delete( - /*&self->tree_pool,*/ &next_slice.subtrees); + ts_subtree_array_delete(&next_slice.subtrees); } } state = ts_stack_state(self->stack, slice_version); @@ -747,7 +745,7 @@ static bool ts_parser__do_all_potential_reductions(TSParser *self, t_stack_versi TSSymbol first_symbol; TSSymbol end_symbol; t_stack_version reduction_version; - ReduceAction reduce_action; + t_reduce_action reduce_action; t_u32 k; TSSymbol symbol; TableEntry entry; @@ -774,7 +772,7 @@ static bool ts_parser__do_all_potential_reductions(TSParser *self, t_stack_versi continue; state = ts_stack_state(self->stack, version); has_shift_action = false; - array_clear(&self->reduce_actions); + self->reduce_actions.len = 0; if (lookahead_symbol != 0) { first_symbol = lookahead_symbol; @@ -800,7 +798,7 @@ static bool ts_parser__do_all_potential_reductions(TSParser *self, t_stack_versi break; case TSParseActionTypeReduce: if (action.reduce.child_count > 0) - ts_reduce_action_set_add(&self->reduce_actions, (ReduceAction){ + ts_reduce_action_set_add(&self->reduce_actions, (t_reduce_action){ .symbol = action.reduce.symbol, .count = action.reduce.child_count, .dynamic_precedence = action.reduce.dynamic_precedence, @@ -813,9 +811,9 @@ static bool ts_parser__do_all_potential_reductions(TSParser *self, t_stack_versi } } reduction_version = STACK_VERSION_NONE; - for (k = 0; k < self->reduce_actions.size; k++) + for (k = 0; k < self->reduce_actions.len; k++) { - reduce_action = self->reduce_actions.contents[k]; + reduce_action = self->reduce_actions.buffer[k]; reduction_version = ts_parser__reduce(self, version, reduce_action.symbol, reduce_action.count, reduce_action.dynamic_precedence, reduce_action.production_id, true, false); } @@ -1461,8 +1459,7 @@ TSParser *ts_parser_new(void) self = mem_alloc(sizeof(*self)); 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->stack = ts_stack_new(); self->finished_tree = NULL; self->language = NULL; @@ -1478,10 +1475,7 @@ void ts_parser_delete(TSParser *self) return; ts_parser_set_language(self, NULL); ts_stack_delete(self->stack); - if (self->reduce_actions.contents) - { - array_delete(&self->reduce_actions); - } + vec_reduce_action_free(self->reduce_actions); array_delete(&self->trailing_extras); array_delete(&self->trailing_extras2); array_delete(&self->scratch_trees); diff --git a/parser/src/scanner.c b/parser/src/scanner.c index 60c465ec..d25eb8c0 100644 --- a/parser/src/scanner.c +++ b/parser/src/scanner.c @@ -1,12 +1,12 @@ #include "me/char/char.h" +#include "me/mem/mem.h" +#include "me/str/str.h" #include "me/string/string.h" #include "me/types.h" -#include "me/mem/mem.h" #include "me/vec/vec_heredoc.h" #include "parser/inner/heredoc.h" #include "parser/lexer.h" #include "parser/parser.h" -#include "me/str/str.h" typedef struct s_heredoc t_heredoc; typedef struct s_scanner t_scanner; @@ -37,9 +37,9 @@ enum e_token_type struct s_scanner { - t_u8 last_glob_paren_depth; - bool ext_was_in_double_quote; - bool ext_saw_outside_quote; + t_u8 last_glob_paren_depth; + bool ext_was_in_double_quote; + bool ext_saw_outside_quote; t_vec_heredoc heredocs; }; @@ -360,62 +360,31 @@ bool scan_heredoc_content(t_scanner *scanner, t_lexer *lexer, enum e_token_type } } -bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) +bool scan_concat(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) { - if (valid_symbols[CONCAT] && !(valid_symbols[ERROR_RECOVERY])) + (void)(scanner); + (void)(lexer); + (void)(valid_symbols); + lexer->data.result_symbol = CONCAT; + if (lexer->data.lookahead == '\\') { - if (!(lexer->data.lookahead == 0 || me_isspace(lexer->data.lookahead) || lexer->data.lookahead == '>' || - lexer->data.lookahead == '<' || lexer->data.lookahead == ')' || lexer->data.lookahead == '(' || - lexer->data.lookahead == ';' || lexer->data.lookahead == '&' || lexer->data.lookahead == '|' || - lexer->data.lookahead == '{' || lexer->data.lookahead == '}')) - { - lexer->data.result_symbol = CONCAT; - // So for a`b`, we want to return a concat. We check if the - // 2nd backtick has whitespace after it, and if it does we - // return concat. - if (lexer->data.lookahead == '`') - { - lexer->data.mark_end((void *)lexer); - lexer->data.advance((void *)lexer, false); - while (lexer->data.lookahead != '`' && !lexer->data.eof((void *)lexer)) - { - lexer->data.advance((void *)lexer, false); - } - if (lexer->data.eof((void *)lexer)) - { - return false; - } - if (lexer->data.lookahead == '`') - { - lexer->data.advance((void *)lexer, false); - } - return me_isspace(lexer->data.lookahead) || lexer->data.eof((void *)lexer); - } - // strings w/ expansions that contains escaped quotes or - // backslashes need this to return a concat - if (lexer->data.lookahead == '\\') - { - lexer->data.mark_end((void *)lexer); - lexer->data.advance((void *)lexer, false); - if (lexer->data.lookahead == '"' || lexer->data.lookahead == '\'' || lexer->data.lookahead == '\\') - { - return true; - } - if (lexer->data.eof((void *)lexer)) - { - return false; - } - } - else - { - return true; - } - } + lexer->data.mark_end((void *)lexer); + lexer->data.advance((void *)lexer, false); + if (lexer->data.lookahead == '"' || lexer->data.lookahead == '\'' || lexer->data.lookahead == '\\') + return true; + if (lexer->data.eof((void *)lexer)) + return false; } + return true; +} +bool scan_double_hash(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) +{ + (void)(scanner); + (void)(lexer); + (void)(valid_symbols); if (valid_symbols[IMMEDIATE_DOUBLE_HASH] && !(valid_symbols[ERROR_RECOVERY])) { - // advance two # and ensure not } after if (lexer->data.lookahead == '#') { lexer->data.mark_end((void *)lexer); @@ -432,41 +401,50 @@ bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) } } } + return (false); +} - if (valid_symbols[EMPTY_VALUE]) - { - if (me_isspace(lexer->data.lookahead) || lexer->data.eof((void *)lexer) || lexer->data.lookahead == ';' || - lexer->data.lookahead == '&') - { - lexer->data.result_symbol = EMPTY_VALUE; - return true; - } - } - - if ((valid_symbols[HEREDOC_BODY_BEGINNING] || valid_symbols[SIMPLE_HEREDOC_BODY]) && scanner->heredocs.len > 0 && - !vec_heredoc_last(&scanner->heredocs)->started && !(valid_symbols[ERROR_RECOVERY])) - return (scan_heredoc_content(scanner, lexer, HEREDOC_BODY_BEGINNING, SIMPLE_HEREDOC_BODY)); +bool scan_heredoc_end(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) +{ + t_heredoc *heredoc; if (valid_symbols[HEREDOC_END] && scanner->heredocs.len > 0) { - t_heredoc *heredoc = vec_heredoc_last(&scanner->heredocs); + heredoc = vec_heredoc_last(&scanner->heredocs); if (scan_heredoc_end_identifier(heredoc, lexer)) { string_free(heredoc->current_leading_word); string_free(heredoc->delimiter); vec_heredoc_pop(&scanner->heredocs, NULL); lexer->data.result_symbol = HEREDOC_END; - return true; + return (true); } } + return (false); +} +bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) +{ + if (valid_symbols[CONCAT] && !(valid_symbols[ERROR_RECOVERY]) && + (!(lexer->data.lookahead == 0 || me_isspace(lexer->data.lookahead) || lexer->data.lookahead == '>' || + lexer->data.lookahead == '<' || lexer->data.lookahead == ')' || lexer->data.lookahead == '(' || lexer->data.lookahead == ';' || + lexer->data.lookahead == '&' || lexer->data.lookahead == '|' || lexer->data.lookahead == '{' || lexer->data.lookahead == '}'))) + return (scan_concat(scanner, lexer, valid_symbols)); + if (scan_double_hash(scanner, lexer, valid_symbols)) + return (true); + if (valid_symbols[EMPTY_VALUE] && (me_isspace(lexer->data.lookahead) || lexer->data.eof((void *)lexer) || + lexer->data.lookahead == ';' || lexer->data.lookahead == '&')) + return (lexer->data.result_symbol = EMPTY_VALUE, true); + if ((valid_symbols[HEREDOC_BODY_BEGINNING] || valid_symbols[SIMPLE_HEREDOC_BODY]) && scanner->heredocs.len > 0 && + !vec_heredoc_last(&scanner->heredocs)->started && !(valid_symbols[ERROR_RECOVERY])) + return (scan_heredoc_content(scanner, lexer, HEREDOC_BODY_BEGINNING, SIMPLE_HEREDOC_BODY)); + if (scan_heredoc_end(scanner, lexer, valid_symbols)) + return (true); if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.len > 0 && vec_heredoc_last(&scanner->heredocs)->started && !(valid_symbols[ERROR_RECOVERY])) return (scan_heredoc_content(scanner, lexer, HEREDOC_CONTENT, HEREDOC_END)); - if (valid_symbols[HEREDOC_START] && !(valid_symbols[ERROR_RECOVERY]) && scanner->heredocs.len > 0) return (scan_heredoc_start(vec_heredoc_last(&scanner->heredocs), lexer)); - if ((valid_symbols[VARIABLE_NAME] || valid_symbols[FILE_DESCRIPTOR] || valid_symbols[HEREDOC_ARROW]) && !(valid_symbols[ERROR_RECOVERY])) { @@ -475,44 +453,30 @@ bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) if ((lexer->data.lookahead == ' ' || lexer->data.lookahead == '\t' || lexer->data.lookahead == '\r' || (lexer->data.lookahead == '\n' && !valid_symbols[NEWLINE])) && !valid_symbols[EXPANSION_WORD]) - { lexer->data.advance((void *)lexer, true); - } else if (lexer->data.lookahead == '\\') { lexer->data.advance((void *)lexer, true); - if (lexer->data.eof((void *)lexer)) { lexer->data.mark_end((void *)lexer); lexer->data.result_symbol = VARIABLE_NAME; - return true; + return (true); } - if (lexer->data.lookahead == '\r') - { lexer->data.advance((void *)lexer, true); - } if (lexer->data.lookahead == '\n') - { lexer->data.advance((void *)lexer, true); - } else { if (lexer->data.lookahead == '\\' && valid_symbols[EXPANSION_WORD]) - { goto expansion_word; - } - return false; + return (false); } } else - { break; - } } - - // no '*', '@', '?', '-', '$', '0', '_' if (!valid_symbols[EXPANSION_WORD] && (lexer->data.lookahead == '*' || lexer->data.lookahead == '@' || lexer->data.lookahead == '?' || lexer->data.lookahead == '-' || lexer->data.lookahead == '0' || lexer->data.lookahead == '_')) @@ -522,9 +486,7 @@ bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) if (lexer->data.lookahead == '=' || lexer->data.lookahead == '[' || lexer->data.lookahead == ':' || lexer->data.lookahead == '-' || lexer->data.lookahead == '%' || lexer->data.lookahead == '#' || lexer->data.lookahead == '/') - { return false; - } if (valid_symbols[EXTGLOB_PATTERN] && me_isspace(lexer->data.lookahead)) { lexer->data.mark_end((void *)lexer); @@ -539,34 +501,17 @@ bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) if (lexer->data.lookahead == '<') { lexer->data.advance((void *)lexer, false); - if (lexer->data.lookahead == '-') - { - lexer->data.advance((void *)lexer, false); - t_heredoc heredoc = heredoc_new(); - heredoc.allows_indent = true; - vec_heredoc_push(&scanner->heredocs, heredoc); - lexer->data.result_symbol = HEREDOC_ARROW_DASH; - } - // else if (lexer->data.lookahead == '<' || lexer->data.lookahead == '=') - // { - // return false; - // } - else - { - t_heredoc heredoc = heredoc_new(); - vec_heredoc_push(&scanner->heredocs, heredoc); - lexer->data.result_symbol = HEREDOC_ARROW; - } - return true; + t_heredoc heredoc = heredoc_new(); + vec_heredoc_push(&scanner->heredocs, heredoc); + lexer->data.result_symbol = HEREDOC_ARROW; + return (true); } - return false; + return (false); } bool is_number = true; if (me_isdigit(lexer->data.lookahead)) - { lexer->data.advance((void *)lexer, false); - } else if (me_isalpha(lexer->data.lookahead) || lexer->data.lookahead == '_') { is_number = false; @@ -576,42 +521,30 @@ bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) { if (lexer->data.lookahead == '{') { - goto brace_start; + return (false); } if (valid_symbols[EXPANSION_WORD]) { goto expansion_word; } - if (valid_symbols[EXTGLOB_PATTERN]) - { - goto extglob_pattern; - } - return false; + return (false); } for (;;) { if (me_isdigit(lexer->data.lookahead)) - { lexer->data.advance((void *)lexer, false); - } else if (me_isalpha(lexer->data.lookahead) || lexer->data.lookahead == '_') { is_number = false; lexer->data.advance((void *)lexer, false); } else - { break; - } } if (is_number && valid_symbols[FILE_DESCRIPTOR] && (lexer->data.lookahead == '>' || lexer->data.lookahead == '<')) - { - lexer->data.result_symbol = FILE_DESCRIPTOR; - return true; - } - + return (lexer->data.result_symbol = FILE_DESCRIPTOR, true); if (valid_symbols[VARIABLE_NAME]) { if (lexer->data.lookahead == '+') @@ -619,28 +552,19 @@ bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) lexer->data.mark_end((void *)lexer); lexer->data.advance((void *)lexer, false); if (lexer->data.lookahead == '=' || lexer->data.lookahead == ':') - { - lexer->data.result_symbol = VARIABLE_NAME; - return true; - } + return (lexer->data.result_symbol = VARIABLE_NAME, true); return false; } if (lexer->data.lookahead == '/') - { return false; - } if (lexer->data.lookahead == '=' || lexer->data.lookahead == '[' || - (lexer->data.lookahead == ':' && - !valid_symbols[OPENING_PAREN]) || // TODO(amaanq): more cases for regular word chars but not variable - // names for function words, only handling : for now? #235 - lexer->data.lookahead == '%' || + (lexer->data.lookahead == ':' && !valid_symbols[OPENING_PAREN]) || lexer->data.lookahead == '%' || (lexer->data.lookahead == '#' && !is_number) || lexer->data.lookahead == '@' || (lexer->data.lookahead == '-')) { lexer->data.mark_end((void *)lexer); lexer->data.result_symbol = VARIABLE_NAME; return true; } - if (lexer->data.lookahead == '?') { lexer->data.mark_end((void *)lexer); @@ -649,396 +573,12 @@ bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols) return me_isalpha(lexer->data.lookahead); } } - return false; } if (valid_symbols[BARE_DOLLAR] && !(valid_symbols[ERROR_RECOVERY]) && scan_bare_dollar(lexer)) return (true); - // if ((valid_symbols[REGEX]) && !(valid_symbols[ERROR_RECOVERY])) - // { - // if (valid_symbols[REGEX]) - // { - // while (me_isspace(lexer->data.lookahead)) - // { - // lexer->data.advance((void *)lexer, true); - // } - // } - // - // if ((lexer->data.lookahead != '"' && lexer->data.lookahead != '\'') || ((lexer->data.lookahead == '$' || lexer->data.lookahead == - // '\'')) || (lexer->data.lookahead == '\'')) - // { - // typedef struct - // { - // 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; - // } State; - // - // if (lexer->data.lookahead == '$') - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.advance((void *)lexer, false); - // if (lexer->data.lookahead == '(') - // { - // return false; - // } - // } - // - // lexer->data.mark_end((void *)lexer); - // - // State state = {false, false, false, false, false, 0, 0, 0}; - // while (!state.done) - // { - // if (state.in_single_quote) - // { - // if (lexer->data.lookahead == '\'') - // { - // state.in_single_quote = false; - // lexer->data.advance((void *)lexer, false); - // lexer->data.mark_end((void *)lexer); - // } - // } - // switch (lexer->data.lookahead) - // { - // case '\\': - // state.last_was_escape = true; - // break; - // case '\0': - // return false; - // case '(': - // state.paren_depth++; - // state.last_was_escape = false; - // break; - // case '[': - // state.bracket_depth++; - // state.last_was_escape = false; - // break; - // case '{': - // if (!state.last_was_escape) - // state.brace_depth++; - // state.last_was_escape = false; - // break; - // case ')': - // if (state.paren_depth == 0) - // state.done = true; - // state.paren_depth--; - // state.last_was_escape = false; - // break; - // case ']': - // if (state.bracket_depth == 0) - // state.done = true; - // state.bracket_depth--; - // state.last_was_escape = false; - // break; - // case '}': - // if (state.brace_depth == 0) - // state.done = true; - // state.brace_depth--; - // state.last_was_escape = false; - // break; - // case '\'': - // // Enter or exit a single-quoted string. - // state.in_single_quote = !state.in_single_quote; - // lexer->data.advance((void *)lexer, false); - // state.advanced_once = true; - // state.last_was_escape = false; - // continue; - // default: - // state.last_was_escape = false; - // break; - // } - // - // if (!state.done) - // { - // if (valid_symbols[REGEX]) - // { - // bool was_space = !state.in_single_quote && me_isspace(lexer->data.lookahead); - // lexer->data.advance((void *)lexer, false); - // state.advanced_once = true; - // if (!was_space || state.paren_depth > 0) - // { - // lexer->data.mark_end((void *)lexer); - // } - // } - // } - // } - // - // lexer->data.result_symbol = REGEX; - // if (valid_symbols[REGEX] && !state.advanced_once) - // { - // return false; - // } - // return true; - // } - // } - -extglob_pattern: - // if (valid_symbols[EXTGLOB_PATTERN] && !(valid_symbols[ERROR_RECOVERY])) - // { - // // first skip ws, then check for ? * + @ ! - // while (me_isspace(lexer->data.lookahead)) - // { - // lexer->data.advance((void *)lexer, true); - // } - // - // if (lexer->data.lookahead == '?' || lexer->data.lookahead == '*' || lexer->data.lookahead == '+' || lexer->data.lookahead == '@' || - // lexer->data.lookahead == '!' || lexer->data.lookahead == '-' || lexer->data.lookahead == ')' || lexer->data.lookahead == '\\' || - // lexer->data.lookahead == '.' || lexer->data.lookahead == '[' || (me_isalpha(lexer->data.lookahead))) - // { - // if (lexer->data.lookahead == '\\') - // { - // lexer->data.advance((void *)lexer, false); - // if ((me_isspace(lexer->data.lookahead) || lexer->data.lookahead == '"') && lexer->data.lookahead != '\r' && - // lexer->data.lookahead != '\n') - // { - // lexer->data.advance((void *)lexer, false); - // } - // else - // { - // return false; - // } - // } - // - // if (lexer->data.lookahead == ')' && scanner->last_glob_paren_depth == 0) - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.advance((void *)lexer, false); - // - // if (me_isspace(lexer->data.lookahead)) - // { - // return false; - // } - // } - // - // lexer->data.mark_end((void *)lexer); - // bool was_non_alpha = !me_isalpha(lexer->data.lookahead); - // if (lexer->data.lookahead != '[') - // { - // // no esac - // if (lexer->data.lookahead == 'e') - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.advance((void *)lexer, false); - // if (lexer->data.lookahead == 's') - // { - // lexer->data.advance((void *)lexer, false); - // if (lexer->data.lookahead == 'a') - // { - // lexer->data.advance((void *)lexer, false); - // if (lexer->data.lookahead == 'c') - // { - // lexer->data.advance((void *)lexer, false); - // if (me_isspace(lexer->data.lookahead)) - // { - // return false; - // } - // } - // } - // } - // } - // else - // { - // lexer->data.advance((void *)lexer, false); - // } - // } - // - // // -\w is just a word, find something else special - // if (lexer->data.lookahead == '-') - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.advance((void *)lexer, false); - // while (me_isalnum(lexer->data.lookahead)) - // { - // lexer->data.advance((void *)lexer, false); - // } - // - // if (lexer->data.lookahead == ')' || lexer->data.lookahead == '\\' || lexer->data.lookahead == '.') - // { - // return false; - // } - // lexer->data.mark_end((void *)lexer); - // } - // - // // case item -) or *) - // if (lexer->data.lookahead == ')' && scanner->last_glob_paren_depth == 0) - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.advance((void *)lexer, false); - // if (me_isspace(lexer->data.lookahead)) - // { - // lexer->data.result_symbol = EXTGLOB_PATTERN; - // return was_non_alpha; - // } - // } - // - // if (me_isspace(lexer->data.lookahead)) - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.result_symbol = EXTGLOB_PATTERN; - // scanner->last_glob_paren_depth = 0; - // return true; - // } - // - // if (lexer->data.lookahead == '$') - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.advance((void *)lexer, false); - // if (lexer->data.lookahead == '{' || lexer->data.lookahead == '(') - // { - // lexer->data.result_symbol = EXTGLOB_PATTERN; - // return true; - // } - // } - // - // if (lexer->data.lookahead == '|') - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.advance((void *)lexer, false); - // lexer->data.result_symbol = EXTGLOB_PATTERN; - // return true; - // } - // - // if (!me_isalnum(lexer->data.lookahead) && lexer->data.lookahead != '(' && lexer->data.lookahead != '"' && lexer->data.lookahead - // != '[' && lexer->data.lookahead != '?' && lexer->data.lookahead != '/' && lexer->data.lookahead != '\\' && lexer->data.lookahead != - // '_' && lexer->data.lookahead != '*') - // { - // return false; - // } - // - // typedef struct - // { - // bool done; - // bool saw_non_alphadot; - // t_u32 paren_depth; - // t_u32 bracket_depth; - // t_u32 brace_depth; - // } State; - // - // State state = {false, was_non_alpha, scanner->last_glob_paren_depth, 0, 0}; - // while (!state.done) - // { - // switch (lexer->data.lookahead) - // { - // case '\0': - // return false; - // case '(': - // state.paren_depth++; - // break; - // case '[': - // state.bracket_depth++; - // break; - // case '{': - // state.brace_depth++; - // break; - // case ')': - // if (state.paren_depth == 0) - // { - // state.done = true; - // } - // state.paren_depth--; - // break; - // case ']': - // if (state.bracket_depth == 0) - // { - // state.done = true; - // } - // state.bracket_depth--; - // break; - // case '}': - // if (state.brace_depth == 0) - // { - // state.done = true; - // } - // state.brace_depth--; - // break; - // } - // - // if (lexer->data.lookahead == '|') - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.advance((void *)lexer, false); - // if (state.paren_depth == 0 && state.bracket_depth == 0 && state.brace_depth == 0) - // { - // lexer->data.result_symbol = EXTGLOB_PATTERN; - // return true; - // } - // } - // - // if (!state.done) - // { - // bool was_space = me_isspace(lexer->data.lookahead); - // if (lexer->data.lookahead == '$') - // { - // lexer->data.mark_end((void *)lexer); - // if (!me_isalpha(lexer->data.lookahead) && lexer->data.lookahead != '.' && lexer->data.lookahead != '\\') - // { - // state.saw_non_alphadot = true; - // } - // lexer->data.advance((void *)lexer, false); - // if (lexer->data.lookahead == '(' || lexer->data.lookahead == '{') - // { - // lexer->data.result_symbol = EXTGLOB_PATTERN; - // scanner->last_glob_paren_depth = state.paren_depth; - // return state.saw_non_alphadot; - // } - // } - // if (was_space) - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.result_symbol = EXTGLOB_PATTERN; - // scanner->last_glob_paren_depth = 0; - // return state.saw_non_alphadot; - // } - // if (lexer->data.lookahead == '"') - // { - // lexer->data.mark_end((void *)lexer); - // lexer->data.result_symbol = EXTGLOB_PATTERN; - // scanner->last_glob_paren_depth = 0; - // return state.saw_non_alphadot; - // } - // if (lexer->data.lookahead == '\\') - // { - // if (!me_isalpha(lexer->data.lookahead) && lexer->data.lookahead != '.' && lexer->data.lookahead != '\\') - // { - // state.saw_non_alphadot = true; - // } - // lexer->data.advance((void *)lexer, false); - // if (me_isspace(lexer->data.lookahead) || lexer->data.lookahead == '"') - // { - // lexer->data.advance((void *)lexer, false); - // } - // } - // else - // { - // if (!me_isalpha(lexer->data.lookahead) && lexer->data.lookahead != '.' && lexer->data.lookahead != '\\') - // { - // state.saw_non_alphadot = true; - // } - // lexer->data.advance((void *)lexer, false); - // } - // if (!was_space) - // { - // lexer->data.mark_end((void *)lexer); - // } - // } - // } - // - // lexer->data.result_symbol = EXTGLOB_PATTERN; - // scanner->last_glob_paren_depth = 0; - // return state.saw_non_alphadot; - // } - // scanner->last_glob_paren_depth = 0; - // - // return false; - // } - expansion_word: if (valid_symbols[EXPANSION_WORD]) { @@ -1120,44 +660,47 @@ expansion_word: } } -brace_start: return false; } void *tree_sitter_sh_external_scanner_create() { - t_scanner *scanner = mem_alloc(sizeof(t_scanner)); - scanner->heredocs = vec_heredoc_new(0, NULL); + t_scanner *scanner; + + scanner = mem_alloc(sizeof(*scanner)); + scanner->heredocs = vec_heredoc_new(0, heredoc_free); return (scanner); } bool tree_sitter_sh_external_scanner_scan(void *payload, t_lexer *lexer, const bool *valid_symbols) { - t_scanner *scanner = (t_scanner *)payload; + t_scanner *scanner; + + scanner = (t_scanner *)payload; return scan(scanner, lexer, valid_symbols); } t_u32 tree_sitter_sh_external_scanner_serialize(void *payload, t_u8 *state) { - t_scanner *scanner = (t_scanner *)payload; + t_scanner *scanner; + + scanner = (t_scanner *)payload; return serialize(scanner, state); } void tree_sitter_sh_external_scanner_deserialize(void *payload, const t_u8 *state, t_u32 length) { - t_scanner *scanner = (t_scanner *)payload; + t_scanner *scanner; + + scanner = (t_scanner *)payload; deserialize(scanner, state, length); } void tree_sitter_sh_external_scanner_destroy(void *payload) { - t_scanner *scanner = (t_scanner *)payload; - for (size_t i = 0; i < scanner->heredocs.len; i++) - { - t_heredoc *heredoc = vec_heredoc_get(&scanner->heredocs, i); - string_free(heredoc->current_leading_word); - string_free(heredoc->delimiter); - } + t_scanner *scanner; + + scanner = (t_scanner *)payload; vec_heredoc_free(scanner->heredocs); mem_free(scanner); }