From c9baa2b4990c8ac54d9fd006e2c1808d927cd9ec Mon Sep 17 00:00:00 2001 From: Maix0 Date: Sun, 16 Jun 2024 18:46:17 +0200 Subject: [PATCH] Small Update to ast... --- ast/include/ast/ast.h | 133 ++++++----------- ast/include/ast/ast_forward_def.h | 95 ++++++++++-- ast/include/ast/ast_raw_structs.h | 222 ++++++++++++++++++++++++++++ input.toml | 2 +- output/include/me/vec/vec_ast.h | 32 ++-- output/src/vec/ast/ast.c | 14 +- output/src/vec/ast/ast_functions2.c | 18 +-- output/src/vec/ast/ast_functions3.c | 10 +- 8 files changed, 393 insertions(+), 133 deletions(-) create mode 100644 ast/include/ast/ast_raw_structs.h diff --git a/ast/include/ast/ast.h b/ast/include/ast/ast.h index 20dd29be..5fabf6bc 100644 --- a/ast/include/ast/ast.h +++ b/ast/include/ast/ast.h @@ -14,98 +14,63 @@ #define AST_H #include "ast/ast_forward_def.h" -#include "me/types.h" -#include "me/vec/vec_ast.h" - -/* - ast_statement: - case_statement - command - compound_statement - for_statement - function_definition - if_statement - list - negated_command - pipeline - redirected_statement - subshell - variable_assignment - variable_assignments - while_statement - - ast_statement_not_pipeline == ast_statement - pipeline - ast_statement_not_subshell == ast_statement - subshell -*/ - -struct s_ast_empty -{ -}; - -enum e_ast_list_kind -{ - AST_LIST_AND, - AST_LIST_OR, -}; +#include "ast/ast_raw_structs.h" enum e_ast_node_kind { + AST_ARITHMETIC_EXPANSION, + AST_CASE_ITEM, + AST_CASE, + AST_COMMAND_SUBSTITUTION, + AST_COMMAND, + AST_COMPOUND_STATEMENT, + AST_ELIF, + AST_ELSE, AST_EMPTY, -}; + AST_EXPANSION, + AST_FILE_REDIRECTION, + AST_FOR, + AST_FUNCTION_DEFINITION, + AST_HEREDOC_REDIRECTION, + AST_IF, + AST_LIST, + AST_PIPELINE, + AST_RAW_STRING, + AST_STRING, + AST_SUBSHELL, + AST_UNTIL, + AST_VARIABLE_ASSIGNMENT, + AST_WHILE, + AST_WORD, -enum e_ast_word_kind -{ - AST_WORD_NO_QUOTE, - AST_WORD_SINGLE_STRING, - AST_WORD_DOUBLE_QUOTED, - AST_WORD_BACK_QUOTED, -}; - -struct s_ast_raw_string -{ - t_str str; - t_usize len; -}; - -struct s_ast_list -{ - t_ast_node *left; - t_ast_list_kind op; - t_ast_node *right; -}; - -/// @brief A string that is may be quoted or not -/// @param parts this can be multiple things: -/// - a "raw" string (no processing needed) -/// - a expension (variable, command substitution, artihmetic expansion, etc.) -/// @param parts_len the number of parts in the string -/// @note if the string isn't quoted, it needs to be split into parts using $IFS -struct s_ast_string -{ - t_vec_ast parts; -}; - -struct s_ast_pipeline -{ - t_vec_ast statements; -}; - -struct s_ast_word -{ - t_ast_word_kind kind; - t_ast_node *inner; -}; - -struct s_ast_command -{ - t_vec_ast prefixes; - t_vec_ast cmd_word; - t_vec_ast suffixes; + __AST_LAST_NODETYPE__, }; union u_ast_node_data { - t_ast_empty empty; - t_ast_command command; + t_ast_arithmetic_expansion arithmetic_expansion; + t_ast_case_item case_item; + t_ast_case case_; + t_ast_command_substitution command_substitution; + t_ast_command command; + t_ast_compound_statement compound_statement; + t_ast_elif elif; + t_ast_else else_; + t_ast_empty empty; + t_ast_expansion expansion; + t_ast_file_redirection file_redirection; + t_ast_for for_; + t_ast_function_definition function_definition; + t_ast_heredoc_redirection heredoc_redirection; + t_ast_if if_; + t_ast_list list; + t_ast_pipeline pipeline; + t_ast_raw_string raw_string; + t_ast_string string; + t_ast_subshell subshell; + t_ast_until until; + t_ast_variable_assignment variable_assignment; + t_ast_while while_; + t_ast_word word; }; struct s_ast_node diff --git a/ast/include/ast/ast_forward_def.h b/ast/include/ast/ast_forward_def.h index 9e583244..e524b64e 100644 --- a/ast/include/ast/ast_forward_def.h +++ b/ast/include/ast/ast_forward_def.h @@ -13,20 +13,93 @@ #ifndef AST_FORWARD_DEF_H #define AST_FORWARD_DEF_H -typedef enum e_ast_node_kind t_ast_node_kind; -typedef enum e_ast_word_kind t_ast_word_kind; -typedef enum e_ast_list_kind t_ast_list_kind; +typedef enum e_ast_node_kind t_ast_node_kind; +typedef enum e_ast_word_kind t_ast_word_kind; +typedef enum e_ast_list_kind t_ast_list_kind; +typedef enum e_ast_expansion_operator t_ast_expansion_operator; typedef union u_ast_node_data t_ast_node_data; -typedef struct s_ast_node t_ast_node; +typedef struct s_ast_node *t_ast_node; -typedef struct s_ast_empty t_ast_empty; -typedef struct s_ast_command t_ast_command; -typedef struct s_ast_word t_ast_word; -typedef struct s_ast_pipeline t_ast_pipeline; -typedef struct s_ast_raw_string t_ast_raw_string; -typedef struct s_ast_built_string t_ast_built_string; -typedef struct s_ast_list t_ast_list; +typedef struct s_ast_arithmetic_expansion t_ast_arithmetic_expansion; +typedef struct s_ast_case_item t_ast_case_item; +typedef struct s_ast_case t_ast_case; +typedef struct s_ast_command_substitution t_ast_command_substitution; +typedef struct s_ast_command t_ast_command; +typedef struct s_ast_compound_statement t_ast_compound_statement; +typedef struct s_ast_elif t_ast_elif; +typedef struct s_ast_else t_ast_else; +typedef struct s_ast_empty t_ast_empty; +typedef struct s_ast_expansion t_ast_expansion; +typedef struct s_ast_file_redirection t_ast_file_redirection; +typedef struct s_ast_for t_ast_for; +typedef struct s_ast_function_definition t_ast_function_definition; +typedef struct s_ast_heredoc_redirection t_ast_heredoc_redirection; +typedef struct s_ast_if t_ast_if; +typedef struct s_ast_list t_ast_list; +typedef struct s_ast_pipeline t_ast_pipeline; +typedef struct s_ast_raw_string t_ast_raw_string; +typedef struct s_ast_string t_ast_string; +typedef struct s_ast_subshell t_ast_subshell; +typedef struct s_ast_until t_ast_until; +typedef struct s_ast_variable_assignment t_ast_variable_assignment; +typedef struct s_ast_while t_ast_while; +typedef struct s_ast_word t_ast_word; + + +/* +t_ast_arithmetic_expansion arithmetic_expansion; +t_ast_case_item case_item; +t_ast_case case; +t_ast_command_substitution command_substitution; +t_ast_command command; +t_ast_compound_statement compound_statement; +t_ast_elif elif; +t_ast_else else; +t_ast_empty empty; +t_ast_expansion expansion; +t_ast_file_redirection file_redirection; +t_ast_for for; +t_ast_function_definition function_definition; +t_ast_heredoc_redirection heredoc_redirection; +t_ast_if if; +t_ast_list list; +t_ast_pipeline pipeline; +t_ast_raw_string raw_string; +t_ast_string string; +t_ast_subshell subshell; +t_ast_until until; +t_ast_variable_assignment variable_assignment; +t_ast_while while; +t_ast_word word; +*/ + +/* +AST_ARITHMETIC_EXPANSION, +AST_CASE_ITEM, +AST_CASE, +AST_COMMAND_SUBSTITUTION, +AST_COMMAND, +AST_COMPOUND_STATEMENT, +AST_ELIF, +AST_ELSE, +AST_EMPTY, +AST_EXPANSION, +AST_FILE_REDIRECTION, +AST_FOR, +AST_FUNCTION_DEFINITION, +AST_HEREDOC_REDIRECTION, +AST_IF, +AST_LIST, +AST_PIPELINE, +AST_RAW_STRING, +AST_STRING, +AST_SUBSHELL, +AST_UNTIL, +AST_VARIABLE_ASSIGNMENT, +AST_WHILE, +AST_WORD, +*/ #endif /* AST_FORWARD_DEF_H */ diff --git a/ast/include/ast/ast_raw_structs.h b/ast/include/ast/ast_raw_structs.h new file mode 100644 index 00000000..2b503dd6 --- /dev/null +++ b/ast/include/ast/ast_raw_structs.h @@ -0,0 +1,222 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* ast_raw_structs.h :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: maiboyer +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2024/06/14 17:46:58 by maiboyer #+# #+# */ +/* Updated: 2024/06/14 17:46:58 by maiboyer ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#ifndef AST_RAW_STRUCTS_H +#define AST_RAW_STRUCTS_H + +#include "ast/ast_forward_def.h" +#include "me/types.h" +#include "me/vec/vec_ast.h" + +/* + ast_statement: + case_statement + command + compound_statement + for_statement + function_definition + if_statement + list + negated_command + pipeline + redirected_statement + subshell + variable_assignment + variable_assignments + while_statement + + ast_statement_not_pipeline == ast_statement - pipeline + ast_statement_not_subshell == ast_statement - subshell +*/ + +struct s_ast_empty +{ +}; + +enum e_ast_list_kind +{ + AST_LIST_AND, + AST_LIST_OR, +}; + +enum e_ast_word_kind +{ + AST_WORD_NO_QUOTE, + AST_WORD_SINGLE_STRING, + AST_WORD_DOUBLE_QUOTED, + AST_WORD_BACK_QUOTED, +}; + +struct s_ast_raw_string +{ + t_str str; + t_usize len; +}; + +struct s_ast_list +{ + t_ast_node left; + t_ast_list_kind op; + t_ast_node right; +}; + +/// @brief A string that is may be quoted or not +/// @param parts this can be multiple things: +/// - a "raw" string (no processing needed) +/// - a expension (variable, command substitution, artihmetic expansion, etc.) +/// @param parts_len the number of parts in the string +/// @note if the string isn't quoted, it needs to be split into parts using $IFS +struct s_ast_string +{ + t_vec_ast parts; +}; + +struct s_ast_pipeline +{ + bool bang; + t_vec_ast statements; +}; + +struct s_ast_word +{ + t_ast_word_kind kind; + t_vec_ast inner; +}; + +struct s_ast_command +{ + t_vec_ast prefixes; + t_vec_ast cmd_word; + t_vec_ast suffixes; +}; + +struct s_ast_if +{ + t_vec_ast condition; + t_vec_ast then; + t_vec_ast elif_; + t_ast_node else_; +}; + +struct s_ast_elif +{ + t_vec_ast condition; + t_vec_ast then; +}; + +struct s_ast_else +{ + t_vec_ast then; +}; + +struct s_ast_while +{ + t_vec_ast condition; + t_vec_ast do_; +}; + +struct s_ast_for +{ + t_str var_name; + t_vec_ast words; + t_vec_ast do_; +}; + +struct s_ast_case +{ + t_ast_node word; + t_vec_ast cases; +}; + +struct s_ast_case_item +{ + t_vec_ast pattern; + t_vec_ast body; +}; + +struct s_ast_until +{ + t_vec_ast condition; + t_vec_ast do_; +}; + +struct s_ast_function_definition +{ + t_str name; + t_vec_ast body; +}; + +struct s_ast_subshell +{ + t_vec_ast body; +}; + +struct s_ast_compound_statement +{ + t_vec_ast body; +}; + +struct s_ast_variable_assignment +{ + t_str name; + t_ast_node value; +}; + +struct s_ast_file_redirection +{ + t_ast_node output; + t_ast_node input; +}; + +struct s_ast_heredoc_redirection +{ + t_ast_node output; + t_ast_node delimiter; +}; + +enum e_ast_expansion_operator +{ + + E_OP_NONE = 0, // ${var} + E_OP_DEFAULT, // ${var-word} + E_OP_ASSIGN_DEFAULT, // ${var=word} + E_OP_ERROR, // ${var?word} + E_OP_ALTERNATE, // ${var+word} + E_OP_DEFAULT_COLON, // ${var:-word} + E_OP_ASSIGN_DEFAULT_COLON, // ${var:=word} + E_OP_ERROR_COLON, // ${var:?word} + E_OP_ALTERNATE_COLON, // ${var:+word} + E_OP_LENGTH, // ${#var} + E_OP_SMALLEST_PREFIX, // ${var#pattern} + E_OP_LARGEST_PREFIX, // ${var##pattern} + E_OP_SMALLEST_SUFFIX, // ${var%pattern} + E_OP_LARGEST_SUFFIX, // ${var%%pattern} +}; + +struct s_ast_expansion +{ + t_str var_name; + t_ast_expansion_operator kind; + t_vec_ast args; +}; + +struct s_ast_arithmetic_expansion +{ + t_ast_node expr; +}; + +struct s_ast_command_substitution +{ + t_ast_node cmd; +}; + +#endif /* AST_RAW_STRUCTS_H */ diff --git a/input.toml b/input.toml index ecb48845..d1d0608f 100644 --- a/input.toml +++ b/input.toml @@ -82,7 +82,7 @@ replace.C__PREFIXUP__ = "ENV" [[create.vec]] sources_output = "src/vec/C__PREFIX__/" headers_output = "include/me/vec/" -replace.C__TYPENAME__ = "t_ast_node *" +replace.C__TYPENAME__ = "t_ast_node" replace.C__TYPEHEADER__ = '#include "ast/ast_forward_def.h"' replace.C__PREFIX__ = "ast" replace.C__PREFIXUP__ = "AST" diff --git a/output/include/me/vec/vec_ast.h b/output/include/me/vec/vec_ast.h index 3c9caca3..bf46ad02 100644 --- a/output/include/me/vec/vec_ast.h +++ b/output/include/me/vec/vec_ast.h @@ -16,18 +16,18 @@ #include "ast/ast_forward_def.h" #include "me/types.h" -/// @brief A function that takes two t_ast_node * and compare them -typedef bool (*t_vec_ast_sort_fn)(t_ast_node * *, t_ast_node * *); -/// @brief A function that free an t_ast_node * -typedef void (*t_free_ast_item)(t_ast_node *); +/// @brief A function that takes two t_ast_node and compare them +typedef bool (*t_vec_ast_sort_fn)(t_ast_node *, t_ast_node *); +/// @brief A function that free an t_ast_node +typedef void (*t_free_ast_item)(t_ast_node); -/// @brief A dynamic array of t_ast_node * +/// @brief A dynamic array of t_ast_node typedef struct s_vec_ast { t_free_ast_item free_func; t_usize len; t_usize capacity; - t_ast_node * *buffer; + t_ast_node *buffer; } t_vec_ast; /// @brief Create a new vec_ast with a given capacity @@ -37,19 +37,19 @@ t_vec_ast vec_ast_new(t_usize capacity, t_free_ast_item free_function); /// @brief Push an element to the last position of the vec_ast /// @param vec The vec_ast to push the element to /// @param element The element to push -t_error vec_ast_push(t_vec_ast *vec, t_ast_node * element); +t_error vec_ast_push(t_vec_ast *vec, t_ast_node element); /// @brief Push an element to the first position of the vec_ast /// @param vec The vec_ast to push the element to /// @param element The element to push /// @note This operation is O(n) -t_error vec_ast_push_front(t_vec_ast *vec, t_ast_node * element); +t_error vec_ast_push_front(t_vec_ast *vec, t_ast_node element); /// @brief Get the last element from the vec_ast, and remove it from the vec_ast /// @param vec The vec_ast to get the element from /// @param[out] out The last element of the vec_ast /// @return true if the operation failed, false otherwise -t_error vec_ast_pop(t_vec_ast *vec, t_ast_node * *value); +t_error vec_ast_pop(t_vec_ast *vec, t_ast_node *value); /// @brief Get the first element from the vec_ast, and remove it from the vec_ast @@ -57,7 +57,7 @@ t_error vec_ast_pop(t_vec_ast *vec, t_ast_node * *value); /// @param[out] out The first element of the vec_ast /// @return true if the operation failed, false otherwise /// @note This operation is O(n) -t_error vec_ast_pop_front(t_vec_ast *vec, t_ast_node * *value); +t_error vec_ast_pop_front(t_vec_ast *vec, t_ast_node *value); /// @brief Free the vector and all its elements /// @param vec The vec_ast to free @@ -73,7 +73,7 @@ t_error vec_ast_reserve(t_vec_ast *vec, t_usize wanted_capacity); /// @param vec The vec_ast 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_ast_find(t_vec_ast *vec, bool (*fn)(const t_ast_node * *), t_usize *index); +t_error vec_ast_find(t_vec_ast *vec, bool (*fn)(const t_ast_node *), t_usize *index); /// @brief Run the function and returns the index of the first element that returns true, but starting at index starting_index @@ -81,7 +81,7 @@ t_error vec_ast_find(t_vec_ast *vec, bool (*fn)(const t_ast_node * *), t_usize * /// @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_ast_find_starting(t_vec_ast *vec, bool (*fn)(const t_ast_node * *), t_usize starting_index, t_usize *index); +t_error vec_ast_find_starting(t_vec_ast *vec, bool (*fn)(const t_ast_node *), t_usize starting_index, t_usize *index); /// @brief Run the function on every element of the vec_ast and returns if all elements returned true /// @param vec The vec_ast to search in @@ -89,7 +89,7 @@ t_error vec_ast_find_starting(t_vec_ast *vec, bool (*fn)(const t_ast_node * *), /// @param[out] result The result of the operation /// @return true if the operation failed, false otherwise /// @note If the vec_ast is empty, result will be true -t_error vec_ast_all(t_vec_ast *vec, bool (*fn)(const t_ast_node * *), bool *result); +t_error vec_ast_all(t_vec_ast *vec, bool (*fn)(const t_ast_node *), bool *result); /// @brief Run the function on every element of the vec_ast and returns if any element returned true /// @param vec The vec_ast to search in @@ -97,13 +97,13 @@ t_error vec_ast_all(t_vec_ast *vec, bool (*fn)(const t_ast_node * *), bool *resu /// @param[out] result The result of the operation /// @return true if the operation failed, false otherwise /// @note If the vec_ast is empty, result will be false -t_error vec_ast_any(t_vec_ast *vec, bool (*fn)(const t_ast_node * *), bool *result); +t_error vec_ast_any(t_vec_ast *vec, bool (*fn)(const t_ast_node *), bool *result); /// @brief Run the function on every element of the vec_ast /// @param vec The vec_ast to iterate over /// @param fn The function to run on each element /// @param state The state to pass to the function -void vec_ast_iter(t_vec_ast *vec, void (*fn)(t_usize index, t_ast_node * *value, void *state), void *state); +void vec_ast_iter(t_vec_ast *vec, void (*fn)(t_usize index, t_ast_node *value, void *state), void *state); /// @brief Reverse the order of the elements in the vec_ast /// @param vec The vec_ast to reverse @@ -118,6 +118,6 @@ void vec_ast_sort(t_vec_ast *vec, t_vec_ast_sort_fn is_sorted); /// @param vec The vec_ast to get the element from /// @param[out] out A pointer to the last element of the vec_ast /// @return true if the operation failed, false otherwise -t_error vec_ast_back(t_vec_ast *vec, t_ast_node * **out); +t_error vec_ast_back(t_vec_ast *vec, t_ast_node **out); #endif diff --git a/output/src/vec/ast/ast.c b/output/src/vec/ast/ast.c index 12bfe585..e75d2235 100644 --- a/output/src/vec/ast/ast.c +++ b/output/src/vec/ast/ast.c @@ -25,14 +25,14 @@ t_vec_ast vec_ast_new(t_usize capacity, out = (t_vec_ast){0}; out.free_func = free_function; - out.buffer = mem_alloc_array(capacity, sizeof(t_ast_node *)); + out.buffer = mem_alloc_array(capacity, sizeof(t_ast_node)); if (out.buffer) out.capacity = capacity; return (out); } /// Return true in case of an error -t_error vec_ast_push(t_vec_ast *vec, t_ast_node * element) +t_error vec_ast_push(t_vec_ast *vec, t_ast_node element) { if (vec == NULL) return (ERROR); @@ -54,7 +54,7 @@ t_error vec_ast_reserve(t_vec_ast *vec, t_usize wanted_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_ast_node *)); + vec->buffer = mem_realloc_array(vec->buffer, new_capacity, sizeof(t_ast_node)); vec->capacity = new_capacity; } return (NO_ERROR); @@ -62,10 +62,10 @@ t_error vec_ast_reserve(t_vec_ast *vec, t_usize wanted_capacity) /// Return true if the vector is empty /// This function is safe to call with value being NULL -t_error vec_ast_pop(t_vec_ast *vec, t_ast_node * *value) +t_error vec_ast_pop(t_vec_ast *vec, t_ast_node *value) { - t_ast_node * temp_value; - t_ast_node * *ptr; + t_ast_node temp_value; + t_ast_node *ptr; if (vec == NULL) return (ERROR); @@ -76,7 +76,7 @@ t_error vec_ast_pop(t_vec_ast *vec, t_ast_node * *value) ptr = &temp_value; vec->len--; *ptr = vec->buffer[vec->len]; - mem_set_zero(&vec->buffer[vec->len], sizeof(t_ast_node *)); + mem_set_zero(&vec->buffer[vec->len], sizeof(t_ast_node)); return (NO_ERROR); } diff --git a/output/src/vec/ast/ast_functions2.c b/output/src/vec/ast/ast_functions2.c index 51c7dee9..6f741fd0 100644 --- a/output/src/vec/ast/ast_functions2.c +++ b/output/src/vec/ast/ast_functions2.c @@ -18,7 +18,7 @@ #include t_error vec_ast_find(t_vec_ast *vec, - bool (*fn)(const t_ast_node * *), t_usize *index) + bool (*fn)(const t_ast_node *), t_usize *index) { t_usize idx; @@ -27,7 +27,7 @@ t_error vec_ast_find(t_vec_ast *vec, idx = 0; while (idx < vec->len) { - if (fn((const t_ast_node * *)&vec->buffer[idx])) + if (fn((const t_ast_node *)&vec->buffer[idx])) { *index = idx; return (NO_ERROR); @@ -38,7 +38,7 @@ t_error vec_ast_find(t_vec_ast *vec, } t_error vec_ast_find_starting(t_vec_ast *vec, - bool (*fn)(const t_ast_node * *), + bool (*fn)(const t_ast_node *), t_usize starting_index, t_usize *index) { t_usize idx; @@ -48,7 +48,7 @@ t_error vec_ast_find_starting(t_vec_ast *vec, idx = starting_index; while (idx < vec->len) { - if (fn((const t_ast_node * *)&vec->buffer[idx])) + if (fn((const t_ast_node *)&vec->buffer[idx])) { *index = idx; return (NO_ERROR); @@ -59,7 +59,7 @@ t_error vec_ast_find_starting(t_vec_ast *vec, } t_error vec_ast_all(t_vec_ast *vec, - bool (*fn)(const t_ast_node * *), bool *result) + bool (*fn)(const t_ast_node *), bool *result) { t_usize idx; @@ -69,7 +69,7 @@ t_error vec_ast_all(t_vec_ast *vec, *result = true; while (*result && idx < vec->len) { - if (!fn((const t_ast_node * *)&vec->buffer[idx])) + if (!fn((const t_ast_node *)&vec->buffer[idx])) *result = false; idx++; } @@ -77,7 +77,7 @@ t_error vec_ast_all(t_vec_ast *vec, } t_error vec_ast_any(t_vec_ast *vec, - bool (*fn)(const t_ast_node * *), bool *result) + bool (*fn)(const t_ast_node *), bool *result) { t_usize idx; @@ -87,7 +87,7 @@ t_error vec_ast_any(t_vec_ast *vec, *result = false; while (*result && idx < vec->len) { - if (fn((const t_ast_node * *)&vec->buffer[idx])) + if (fn((const t_ast_node *)&vec->buffer[idx])) *result = true; idx++; } @@ -95,7 +95,7 @@ t_error vec_ast_any(t_vec_ast *vec, } void vec_ast_iter(t_vec_ast *vec, - void (*fn)(t_usize index, t_ast_node * *value, + void (*fn)(t_usize index, t_ast_node *value, void *state), void *state) { diff --git a/output/src/vec/ast/ast_functions3.c b/output/src/vec/ast/ast_functions3.c index 26b25912..e4d8f2c3 100644 --- a/output/src/vec/ast/ast_functions3.c +++ b/output/src/vec/ast/ast_functions3.c @@ -18,7 +18,7 @@ #include t_error vec_ast_push_front(t_vec_ast *vec, - t_ast_node * element) + t_ast_node element) { t_usize i; @@ -39,7 +39,7 @@ t_error vec_ast_push_front(t_vec_ast *vec, return (NO_ERROR); } -t_error vec_ast_pop_front(t_vec_ast *vec, t_ast_node * *value) +t_error vec_ast_pop_front(t_vec_ast *vec, t_ast_node *value) { t_usize i; @@ -59,7 +59,7 @@ t_error vec_ast_pop_front(t_vec_ast *vec, t_ast_node * *value) void vec_ast_reverse(t_vec_ast *vec) { - t_ast_node * temporary; + t_ast_node temporary; t_usize i; i = 0; @@ -72,9 +72,9 @@ void vec_ast_reverse(t_vec_ast *vec) } } -t_error vec_ast_back(t_vec_ast *vec, t_ast_node * **out) +t_error vec_ast_back(t_vec_ast *vec, t_ast_node **out) { - t_ast_node * *temporary; + t_ast_node *temporary; if (out == NULL) out = &temporary;