raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

update: Updated stuff so the scanner works great now

Browse source
This commit is contained in:
Maieul BOYER 2024-09-06 18:04:22 +02:00
parent 475038e2b7
commit 163db2241f
No known key found for this signature in database
15 changed files with 738 additions and 648 deletions
Download patch file Download diff file Expand all files Collapse all files

9
Filelist.sh.mk
View file

@ -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 \

8
input.toml
View file

@ -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"

174
output/include/me/vec/vec_reduce_action.h Normal file
View file

@ -0,0 +1,174 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_reduce_action.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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

93
output/src/vec/reduce_action/reduce_action.c Normal file
View file

@ -0,0 +1,93 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_reduce_action.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 <stdlib.h>
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);
}

112
output/src/vec/reduce_action/reduce_action_functions2.c Normal file
View file

@ -0,0 +1,112 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_reduce_action.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 <stdlib.h>
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++;
}
}

82
output/src/vec/reduce_action/reduce_action_functions3.c Normal file
View file

@ -0,0 +1,82 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_reduce_action.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 <stdlib.h>
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);
}

77
output/src/vec/reduce_action/reduce_action_functions4.c Normal file
View file

@ -0,0 +1,77 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_reduce_action.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 <stdlib.h>
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;
}

41
output/src/vec/reduce_action/reduce_action_sort.c Normal file
View file

@ -0,0 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* best_move.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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--;
}
}

28
parser/include/parser/inner/reduce_action_inner.h Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* reduce_action_inner.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 */

63
parser/include/parser/inner/scanner.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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

24
parser/include/parser/inner/subtree_inner.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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`)

19
parser/include/parser/reduce_action.h
View file

@ -6,28 +6,21 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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

13
parser/src/misc/reduce_action.c
View file

@ -6,25 +6,26 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);
}

30
parser/src/parser.c
View file

@ -6,12 +6,13 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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);

613
parser/src/scanner.c
View file

@ -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);
}