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

Compiling!

Browse source
This commit is contained in:
Maieul BOYER 2024-04-30 14:20:06 +02:00
parent 019d25174c
commit a22b9ea234
No known key found for this signature in database
24 changed files with 607 additions and 113 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Minishell.mk
View file

@ -6,7 +6,7 @@
# By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2024/04/28 17:28:30 by maiboyer #+# #+# #
# Updated: 2024/04/29 14:08:10 by maiboyer ### ########.fr #
# Updated: 2024/04/30 14:19:46 by maiboyer ### ########.fr #
# #
# **************************************************************************** #
@ -64,7 +64,7 @@ bonus: $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libme.a $(OBJDIRNAME)/libgmr.a
@mkdir -p $(OBJDIRNAME)/$(LIBDIRNAME)
@mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME)
@printf '$(GREY) Be Carefull ur in $(END)$(GREEN)Debug Mode$(END)\n'
@cc $(CFLAGS) -D DEBUG=42 -o $(NAME) $(OBJ) -L$(OBJDIRNAME) -lme -lgmr
@cc $(CFLAGS) -D DEBUG=42 -o $(NAME) $(OBJ) -L$(OBJDIRNAME) -lgmr -lme
# Dependences for all
$(NAME): $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libgmr.a $(OBJDIRNAME)/libme.a
@ -72,7 +72,7 @@ $(NAME): $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libgmr.a $(OBJDIRNAME)/libme.a
@mkdir -p $(OBJDIRNAME)/$(LIBDIRNAME)
@mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME)
@echo "$(GREY) Linking $(END)$(GREEN)$(NAME)$(END)"
@cc $(CFLAGS) -o $(NAME) $(OBJ) $(LIB_OBJ) -L$(OBJDIRNAME) -lme -lgmr
@cc $(CFLAGS) -o $(NAME) $(OBJ) $(LIB_OBJ) -L$(OBJDIRNAME) -lgmr -lme
# Creating the objects
$(OBJDIRNAME)/%.o: %.c

3
gen.list
View file

@ -1,3 +1,6 @@
src/vec/vec_parser_heredoc.c
src/vec/vec_parser_heredoc_functions2.c
src/vec/vec_parser_heredoc_functions3.c
src/vec/vec_parser_range.c
src/vec/vec_parser_range_functions2.c
src/vec/vec_parser_range_functions3.c

8
input.toml
View file

@ -44,3 +44,11 @@ replace.C__TYPENAME__ = "t_parser_range"
replace.C__TYPEHEADER__ = '#include "parser/types/types_parser_range.h"'
replace.C__PREFIX__ = "parser_range"
replace.C__PREFIXUP__ = "PARSER_RANGE"
[[create.vec]]
sources_output = "src/vec/"
headers_output = "include/me/vec/"
replace.C__TYPENAME__ = "t_heredoc"
replace.C__TYPEHEADER__ = '#include "parser/types/types_heredoc.h"'
replace.C__PREFIX__ = "parser_heredoc"
replace.C__PREFIXUP__ = "PARSER_HEREDOC"

58
output/include/me/vec/vec_parser_heredoc.h Normal file
View file

@ -0,0 +1,58 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_parser_heredoc.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_PARSER_HEREDOC_H
#define VEC_PARSER_HEREDOC_H
#include "parser/types/types_heredoc.h"
#include "me/types.h"
typedef bool (*t_vec_parser_heredoc_sort_fn)(t_heredoc *, t_heredoc *);
typedef void (*t_free_parser_heredoc_item)(t_heredoc);
typedef struct s_vec_parser_heredoc
{
t_free_parser_heredoc_item free_func;
t_usize len;
t_usize capacity;
t_heredoc *buffer;
} t_vec_parser_heredoc;
t_vec_parser_heredoc vec_parser_heredoc_new(t_usize capacity,
t_free_parser_heredoc_item free_function);
t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element);
t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec,
t_heredoc element);
t_error vec_parser_heredoc_pop(t_vec_parser_heredoc *vec, t_heredoc *value);
t_error vec_parser_heredoc_pop_front(t_vec_parser_heredoc *vec, t_heredoc *value);
void vec_parser_heredoc_free(t_vec_parser_heredoc vec);
t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec,
t_usize wanted_capacity);
t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), t_usize *index);
t_error vec_parser_heredoc_find_starting(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *),
t_usize starting_index, t_usize *index);
t_error vec_parser_heredoc_all(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), bool *result);
t_error vec_parser_heredoc_any(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), bool *result);
void vec_parser_heredoc_iter(t_vec_parser_heredoc *vec,
void (*fn)(t_usize index, t_heredoc *value,
void *state),
void *state);
void vec_parser_heredoc_reverse(t_vec_parser_heredoc *vec);
void vec_parser_heredoc_sort(t_vec_parser_heredoc *vec,
t_vec_parser_heredoc_sort_fn is_sorted);
t_error vec_parser_heredoc_back(t_vec_parser_heredoc *vec, t_heredoc **out);
#endif

1
output/include/me/vec/vec_parser_range.h
View file

@ -53,5 +53,6 @@ void vec_parser_range_iter(t_vec_parser_range *vec,
void vec_parser_range_reverse(t_vec_parser_range *vec);
void vec_parser_range_sort(t_vec_parser_range *vec,
t_vec_parser_range_sort_fn is_sorted);
t_error vec_parser_range_back(t_vec_parser_range *vec, t_parser_range **out);
#endif

115
output/src/vec/vec_parser_heredoc.c Normal file
View file

@ -0,0 +1,115 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_parser_heredoc.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_alloc_array.h"
#include "me/mem/mem_copy.h"
#include "me/mem/mem_set_zero.h"
#include "me/types.h"
#include "me/vec/vec_parser_heredoc.h"
#include <stdlib.h>
t_vec_parser_heredoc vec_parser_heredoc_new(t_usize capacity,
t_free_parser_heredoc_item free_function)
{
t_vec_parser_heredoc out;
out = (t_vec_parser_heredoc){0};
out.free_func = free_function;
out.buffer = mem_alloc_array(capacity, sizeof(t_heredoc));
if (out.buffer)
out.capacity = capacity;
return (out);
}
/// Return true in case of an error
t_error vec_parser_heredoc_push(t_vec_parser_heredoc *vec, t_heredoc element)
{
t_heredoc *temp_buffer;
size_t new_capacity;
if (vec == NULL)
return (ERROR);
if (vec->len + 1 > vec->capacity)
{
new_capacity = (vec->capacity * 3) / 2 + 1;
while (vec->len + 1 > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1;
temp_buffer = mem_alloc_array(new_capacity, sizeof(t_heredoc));
if (temp_buffer == NULL)
return (ERROR);
mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_heredoc));
free(vec->buffer);
vec->buffer = temp_buffer;
vec->capacity = new_capacity;
}
vec->buffer[vec->len] = element;
vec->len += 1;
return (NO_ERROR);
}
/// Return true in case of an error
t_error vec_parser_heredoc_reserve(t_vec_parser_heredoc *vec, t_usize wanted_capacity)
{
t_heredoc *temp_buffer;
size_t new_capacity;
if (vec == NULL)
return (ERROR);
if (wanted_capacity > vec->capacity)
{
new_capacity = (vec->capacity * 3) / 2 + 1;
while (wanted_capacity > new_capacity)
new_capacity = (new_capacity * 3) / 2 + 1;
temp_buffer = mem_alloc_array(new_capacity, sizeof(t_heredoc));
if (temp_buffer == NULL)
return (ERROR);
mem_copy(temp_buffer, vec->buffer, vec->len * sizeof(t_heredoc));
free(vec->buffer);
vec->buffer = temp_buffer;
vec->capacity = new_capacity;
}
return (NO_ERROR);
}
/// Return true if the vector is empty
/// This function is safe to call with value being NULL
t_error vec_parser_heredoc_pop(t_vec_parser_heredoc *vec, t_heredoc *value)
{
t_heredoc temp_value;
t_heredoc *ptr;
if (vec == NULL)
return (ERROR);
ptr = value;
if (vec->len == 0)
return (ERROR);
if (value == NULL)
ptr = &temp_value;
vec->len--;
*ptr = vec->buffer[vec->len];
mem_set_zero(&vec->buffer[vec->len], sizeof(t_heredoc));
return (NO_ERROR);
}
/// This function is safe to call with `free_elem` being NULL
void vec_parser_heredoc_free(t_vec_parser_heredoc vec)
{
if (vec.free_func)
{
while (vec.len)
{
vec.free_func(vec.buffer[vec.len - 1]);
vec.len--;
}
}
free(vec.buffer);
}

112
output/src/vec/vec_parser_heredoc_functions2.c Normal file
View file

@ -0,0 +1,112 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_parser_heredoc.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_alloc_array.h"
#include "me/mem/mem_copy.h"
#include "me/mem/mem_set_zero.h"
#include "me/types.h"
#include "me/vec/vec_parser_heredoc.h"
#include <stdlib.h>
t_error vec_parser_heredoc_find(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), t_usize *index)
{
t_usize idx;
if (vec == NULL || fn == NULL || index == NULL)
return (ERROR);
idx = 0;
while (idx < vec->len)
{
if (fn(&vec->buffer[idx]))
{
*index = idx;
return (NO_ERROR);
}
idx++;
}
return (ERROR);
}
t_error vec_parser_heredoc_find_starting(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *),
t_usize starting_index, t_usize *index)
{
t_usize idx;
if (vec == NULL || fn == NULL || index == NULL)
return (ERROR);
idx = starting_index;
while (idx < vec->len)
{
if (fn(&vec->buffer[idx]))
{
*index = idx;
return (NO_ERROR);
}
idx++;
}
return (ERROR);
}
t_error vec_parser_heredoc_all(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), bool *result)
{
t_usize idx;
if (vec == NULL || fn == NULL || result == NULL)
return (ERROR);
idx = 0;
*result = true;
while (*result && idx < vec->len)
{
if (!fn(&vec->buffer[idx]))
*result = false;
idx++;
}
return (ERROR);
}
t_error vec_parser_heredoc_any(t_vec_parser_heredoc *vec,
bool (*fn)(const t_heredoc *), bool *result)
{
t_usize idx;
if (vec == NULL || fn == NULL || result == NULL)
return (ERROR);
idx = 0;
*result = false;
while (*result && idx < vec->len)
{
if (fn(&vec->buffer[idx]))
*result = true;
idx++;
}
return (ERROR);
}
void vec_parser_heredoc_iter(t_vec_parser_heredoc *vec,
void (*fn)(t_usize index, t_heredoc *value,
void *state),
void *state)
{
t_usize idx;
if (vec == NULL || fn == NULL)
return;
idx = 0;
while (idx < vec->len)
{
fn(idx, &vec->buffer[idx], state);
idx++;
}
}

84
output/src/vec/vec_parser_heredoc_functions3.c Normal file
View file

@ -0,0 +1,84 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* vec_parser_heredoc.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_alloc_array.h"
#include "me/mem/mem_copy.h"
#include "me/mem/mem_set_zero.h"
#include "me/types.h"
#include "me/vec/vec_parser_heredoc.h"
#include <stdlib.h>
t_error vec_parser_heredoc_push_front(t_vec_parser_heredoc *vec,
t_heredoc element)
{
t_usize i;
if (vec->len == 0)
return (vec_parser_heredoc_push(vec, element));
i = vec->len - 1;
if (vec->capacity < vec->len + 1 &&
vec_parser_heredoc_reserve(vec, 3 * vec->len / 2 + 1))
return (ERROR);
while (i > 0)
{
vec->buffer[i + 1] = vec->buffer[i];
i--;
}
vec->buffer[1] = vec->buffer[0];
vec->buffer[0] = element;
vec->len++;
return (NO_ERROR);
}
t_error vec_parser_heredoc_pop_front(t_vec_parser_heredoc *vec, t_heredoc *value)
{
t_usize i;
if (vec->len <= 1)
return (vec_parser_heredoc_pop(vec, value));
i = 0;
*value = vec->buffer[0];
vec->len--;
while (i < vec->len)
{
vec->buffer[i] = vec->buffer[i + 1];
i++;
}
mem_set_zero(&vec->buffer[i], sizeof(*vec->buffer));
return (NO_ERROR);
}
void vec_parser_heredoc_reverse(t_vec_parser_heredoc *vec)
{
t_heredoc temporary;
t_usize i;
i = 0;
while (i < vec->len / 2)
{
temporary = vec->buffer[vec->len - 1 - i];
vec->buffer[vec->len - 1 - i] = vec->buffer[i];
vec->buffer[i] = temporary;
i++;
}
}
t_error vec_parser_heredoc_back(t_vec_parser_heredoc *vec, t_heredoc **out)
{
t_heredoc *temporary;
if (out == NULL)
out = &temporary;
if (vec->len != 0)
return (*out = &vec->buffer[vec->len - 1], true);
return (false);
}

11
output/src/vec/vec_parser_range_functions3.c
View file

@ -71,3 +71,14 @@ void vec_parser_range_reverse(t_vec_parser_range *vec)
i++;
}
}
t_error vec_parser_range_back(t_vec_parser_range *vec, t_parser_range **out)
{
t_parser_range *temporary;
if (out == NULL)
out = &temporary;
if (vec->len != 0)
return (*out = &vec->buffer[vec->len - 1], true);
return (false);
}

28
parser/includes/types/types_heredoc.h Normal file
View file

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* types_heredoc.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/30 13:47:07 by maiboyer #+# #+# */
/* Updated: 2024/04/30 13:48:19 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef TYPES_HEREDOC_H
#define TYPES_HEREDOC_H
#include "me/buffered_str/buf_str.h"
#include "me/types.h"
typedef struct s_heredoc
{
bool is_raw;
bool started;
bool allows_indent;
t_buffer_str delimiter;
t_buffer_str current_leading_word;
} t_heredoc;
#endif /* TYPES_HEREDOC_H */

11
parser/includes/types/types_scanner_ctx.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/30 13:41:02 by maiboyer #+# #+# */
/* Updated: 2024/04/30 13:41:29 by maiboyer ### ########.fr */
/* Updated: 2024/04/30 13:50:24 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,13 +14,14 @@
#define TYPES_SCANNER_CTX_H
#include "me/types.h"
#include "me/vec/vec_parser_heredoc.h"
typedef struct s_scanner_ctx
{
t_u8 last_glob_paren_depth;
bool ext_was_in_double_quote;
bool ext_saw_outside_quote;
// Array(t_heredoc) heredocs;
t_u8 last_glob_paren_depth;
bool ext_was_in_double_quote;
bool ext_saw_outside_quote;
t_vec_parser_heredoc heredocs;
} t_scanner_ctx;
#endif /* TYPES_SCANNER_CTX_H */

175
parser/src/scanner.c
View file

@ -1,6 +1,7 @@
#include "array.h"
#include "me/mem/mem_alloc.h"
#include "me/types.h"
#include "me/vec/vec_parser_heredoc.h"
#include "parser/types/types_lexer.h"
#include "parser/types/types_scanner.h"
#include "parser/types/types_scanner_ctx.h"
#include <assert.h>
@ -42,26 +43,14 @@ enum TokenType
ERROR_RECOVERY,
};
typedef Array(char) t_string;
// typedef void *String;
typedef struct s_heredoc
{
bool is_raw;
bool started;
bool allows_indent;
t_string delimiter;
t_string current_leading_word;
} t_heredoc;
static inline t_heredoc heredoc_new(void)
{
return ((t_heredoc){
.is_raw = false,
.started = false,
.allows_indent = false,
.delimiter = array_new(),
.current_leading_word = array_new(),
.delimiter = alloc_new_buffer(0),
.current_leading_word = alloc_new_buffer(0),
});
}
@ -80,12 +69,12 @@ static inline bool in_error_recovery(const bool *valid_symbols)
return valid_symbols[ERROR_RECOVERY];
}
static inline void reset_string(t_string *string)
static inline void reset_string(t_buffer_str *string)
{
if (string->size > 0)
if (string->len > 0)
{
memset(string->contents, 0, string->size);
array_clear(string);
memset(string->buf, 0, string->len);
string->len = 0;
}
}
@ -97,19 +86,19 @@ static inline void reset_heredoc(t_heredoc *heredoc)
reset_string(&heredoc->delimiter);
}
static inline void reset(t_scanner *scanner)
static inline void reset(t_scanner_ctx *scanner)
{
t_u32 i;
i = 0;
while (i < scanner->heredocs.size)
while (i < scanner->heredocs.len)
{
reset_heredoc(array_get(&scanner->heredocs, i));
reset_heredoc(&scanner->heredocs.buffer[i]);
i++;
}
}
static unsigned serialize(t_scanner *scanner, char *buffer)
static unsigned serialize(t_scanner_ctx *scanner, char *buffer)
{
t_u32 size;
t_u32 i;
@ -119,31 +108,32 @@ static unsigned serialize(t_scanner *scanner, char *buffer)
buffer[size++] = (char)scanner->last_glob_paren_depth;
buffer[size++] = (char)scanner->ext_was_in_double_quote;
buffer[size++] = (char)scanner->ext_saw_outside_quote;
buffer[size++] = (char)scanner->heredocs.size;
buffer[size++] = (char)scanner->heredocs.len;
i = 0;
while (i < scanner->heredocs.size)
while (i < scanner->heredocs.len)
{
heredoc = array_get(&scanner->heredocs, i);
if (heredoc->delimiter.size + 3 + size >=
heredoc = &scanner->heredocs.buffer[i];
if (heredoc->delimiter.len + 3 + size >=
TREE_SITTER_SERIALIZATION_BUFFER_SIZE)
return 0;
buffer[size++] = (char)heredoc->is_raw;
buffer[size++] = (char)heredoc->started;
buffer[size++] = (char)heredoc->allows_indent;
memcpy(&buffer[size], &heredoc->delimiter.size, sizeof(t_u32));
memcpy(&buffer[size], &heredoc->delimiter.len, sizeof(t_u32));
size += sizeof(t_u32);
if (heredoc->delimiter.size > 0)
if (heredoc->delimiter.len > 0)
{
memcpy(&buffer[size], heredoc->delimiter.contents,
heredoc->delimiter.size);
size += heredoc->delimiter.size;
memcpy(&buffer[size], heredoc->delimiter.buf,
heredoc->delimiter.len);
size += heredoc->delimiter.len;
}
i++;
}
return size;
}
static void deserialize(t_scanner *scanner, const char *buffer, unsigned length)
static void deserialize(t_scanner_ctx *scanner, const char *buffer,
unsigned length)
{
t_u32 size;
t_u32 heredoc_count;
@ -163,24 +153,24 @@ static void deserialize(t_scanner *scanner, const char *buffer, unsigned length)
while (i < heredoc_count)
{
heredoc = NULL;
if (i < scanner->heredocs.size)
heredoc = array_get(&scanner->heredocs, i);
if (i < scanner->heredocs.len)
heredoc = &scanner->heredocs.buffer[i];
else
{
array_push(&scanner->heredocs, heredoc_new());
heredoc = array_back(&scanner->heredocs);
vec_parser_heredoc_push(&scanner->heredocs, heredoc_new());
heredoc = &scanner->heredocs.buffer[scanner->heredocs.len - 1];
}
heredoc->is_raw = buffer[size++];
heredoc->started = buffer[size++];
heredoc->allows_indent = buffer[size++];
memcpy(&heredoc->delimiter.size, &buffer[size], sizeof(t_u32));
memcpy(&heredoc->delimiter.len, &buffer[size], sizeof(t_u32));
size += sizeof(t_u32);
array_reserve(&heredoc->delimiter, heredoc->delimiter.size);
if (heredoc->delimiter.size > 0)
str_reserve(&heredoc->delimiter, heredoc->delimiter.len);
if (heredoc->delimiter.len > 0)
{
memcpy(heredoc->delimiter.contents, &buffer[size],
heredoc->delimiter.size);
size += heredoc->delimiter.size;
memcpy(heredoc->delimiter.buf, &buffer[size],
heredoc->delimiter.len);
size += heredoc->delimiter.len;
}
i++;
}
@ -195,7 +185,7 @@ static void deserialize(t_scanner *scanner, const char *buffer, unsigned length)
* POSIX-mandated substitution, and assumes the default value for
* IFS.
*/
static bool advance_word(t_lexer *lexer, t_string *unquoted_word)
static bool advance_word(t_lexer *lexer, t_buffer_str *unquoted_word)
{
bool empty;
t_i32 quote;
@ -216,10 +206,9 @@ static bool advance_word(t_lexer *lexer, t_string *unquoted_word)
return (false);
}
empty = false;
array_push(unquoted_word, lexer->lookahead);
push_str_char(unquoted_word, lexer->lookahead);
advance(lexer);
}
array_push(unquoted_word, '\0');
if (quote && lexer->lookahead == quote)
advance(lexer);
return (!empty);
@ -269,31 +258,29 @@ static bool scan_heredoc_end_identifier(t_heredoc *heredoc, t_lexer *lexer)
t_i32 size;
size = 0;
if (heredoc->delimiter.size > 0)
if (heredoc->delimiter.len > 0)
{
while (lexer->lookahead != '\0' && lexer->lookahead != '\n' &&
(t_i32)*array_get(&heredoc->delimiter, size) ==
lexer->lookahead &&
heredoc->current_leading_word.size < heredoc->delimiter.size)
(t_i32) * (&heredoc->delimiter.buf[size]) == lexer->lookahead &&
heredoc->current_leading_word.len < heredoc->delimiter.len)
{
array_push(&heredoc->current_leading_word, lexer->lookahead);
push_str_char(&heredoc->current_leading_word, lexer->lookahead);
advance(lexer);
size++;
}
}
array_push(&heredoc->current_leading_word, '\0');
return heredoc->delimiter.size == 0
return heredoc->delimiter.len == 0
? false
: strcmp(heredoc->current_leading_word.contents,
heredoc->delimiter.contents) == 0;
: strcmp(heredoc->current_leading_word.buf,
heredoc->delimiter.buf) == 0;
}
static bool scan_heredoc_content(t_scanner *scanner, t_lexer *lexer,
static bool scan_heredoc_content(t_scanner_ctx *scanner, t_lexer *lexer,
enum TokenType middle_type,
enum TokenType end_type)
{
bool did_advance = false;
t_heredoc *heredoc = array_back(&scanner->heredocs);
t_heredoc *heredoc = (&scanner->heredocs.buffer[scanner->heredocs.len - 1]);
for (;;)
{
@ -368,9 +355,7 @@ static bool scan_heredoc_content(t_scanner *scanner, t_lexer *lexer,
if (scan_heredoc_end_identifier(heredoc, lexer))
{
if (lexer->result_symbol == HEREDOC_END)
{
array_pop(&scanner->heredocs);
}
vec_parser_heredoc_pop(&scanner->heredocs, NULL);
return true;
}
break;
@ -417,7 +402,7 @@ static bool scan_heredoc_content(t_scanner *scanner, t_lexer *lexer,
}
}
}
static bool regex_scan(t_scanner *scanner, t_lexer *lexer,
static bool regex_scan(t_scanner_ctx *scanner, t_lexer *lexer,
const bool *valid_symbols)
{
(void)(scanner);
@ -642,7 +627,7 @@ static bool regex_scan(t_scanner *scanner, t_lexer *lexer,
return (false);
}
static bool extglob_pattern_scan(t_scanner *scanner, t_lexer *lexer,
static bool extglob_pattern_scan(t_scanner_ctx *scanner, t_lexer *lexer,
const bool *valid_symbols)
{
if (valid_symbols[EXTGLOB_PATTERN] && !in_error_recovery(valid_symbols))
@ -918,7 +903,7 @@ static bool extglob_pattern_scan(t_scanner *scanner, t_lexer *lexer,
return (false);
}
static bool expansion_word_scan(t_scanner *scanner, t_lexer *lexer,
static bool expansion_word_scan(t_scanner_ctx *scanner, t_lexer *lexer,
const bool *valid_symbols)
{
(void)(scanner);
@ -1022,7 +1007,7 @@ static bool expansion_word_scan(t_scanner *scanner, t_lexer *lexer,
return (false);
}
static bool brace_start_scan(t_scanner *scanner, t_lexer *lexer,
static bool brace_start_scan(t_scanner_ctx *scanner, t_lexer *lexer,
const bool *valid_symbols)
{
(void)(scanner);
@ -1074,7 +1059,8 @@ static bool brace_start_scan(t_scanner *scanner, t_lexer *lexer,
}
return (false);
}
static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols)
static bool scan(t_scanner_ctx *scanner, t_lexer *lexer,
const bool *valid_symbols)
{
if (valid_symbols[CONCAT] && !in_error_recovery(valid_symbols))
{
@ -1178,38 +1164,41 @@ static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols)
return (true);
}
}
t_heredoc *back;
vec_parser_heredoc_back(&scanner->heredocs, &back);
if ((valid_symbols[HEREDOC_BODY_BEGINNING] ||
valid_symbols[SIMPLE_HEREDOC_BODY]) &&
scanner->heredocs.size > 0 &&
!array_back(&scanner->heredocs)->started &&
scanner->heredocs.len > 0 && !back->started &&
!in_error_recovery(valid_symbols))
return (scan_heredoc_content(scanner, lexer, HEREDOC_BODY_BEGINNING,
SIMPLE_HEREDOC_BODY));
if (valid_symbols[HEREDOC_END] && scanner->heredocs.size > 0)
if (valid_symbols[HEREDOC_END] && scanner->heredocs.len > 0)
{
t_heredoc *heredoc = array_back(&scanner->heredocs);
t_heredoc *heredoc;
vec_parser_heredoc_back(&scanner->heredocs, &heredoc);
if (scan_heredoc_end_identifier(heredoc, lexer))
{
array_delete(&heredoc->current_leading_word);
array_delete(&heredoc->delimiter);
array_pop(&scanner->heredocs);
str_free(heredoc->current_leading_word);
str_free(heredoc->delimiter);
scanner->heredocs.len -= 1;
lexer->result_symbol = HEREDOC_END;
return (true);
}
}
if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.size > 0 &&
array_back(&scanner->heredocs)->started &&
!in_error_recovery(valid_symbols))
vec_parser_heredoc_back(&scanner->heredocs, &back);
if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.len > 0 &&
back->started && !in_error_recovery(valid_symbols))
return (
scan_heredoc_content(scanner, lexer, HEREDOC_CONTENT, HEREDOC_END));
if (valid_symbols[HEREDOC_START] && !in_error_recovery(valid_symbols) &&
scanner->heredocs.size > 0)
return (scan_heredoc_start(array_back(&scanner->heredocs), lexer));
scanner->heredocs.len > 0)
{
vec_parser_heredoc_back(&scanner->heredocs, &back);
return (scan_heredoc_start(back, lexer));
}
if (valid_symbols[TEST_OPERATOR] && !valid_symbols[EXPANSION_WORD])
{
while (isspace(lexer->lookahead) && lexer->lookahead != '\n')
@ -1368,7 +1357,7 @@ static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols)
advance(lexer);
t_heredoc heredoc = heredoc_new();
heredoc.allows_indent = true;
array_push(&scanner->heredocs, heredoc);
vec_parser_heredoc_push(&scanner->heredocs, heredoc);
lexer->result_symbol = HEREDOC_ARROW_DASH;
}
else if (lexer->lookahead == '<' || lexer->lookahead == '=')
@ -1376,7 +1365,7 @@ static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols)
else
{
t_heredoc heredoc = heredoc_new();
array_push(&scanner->heredocs, heredoc);
vec_parser_heredoc_push(&scanner->heredocs, heredoc);
lexer->result_symbol = HEREDOC_ARROW;
}
return (true);
@ -1475,21 +1464,21 @@ static bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols)
void *tree_sitter_bash_external_scanner_create()
{
t_scanner *scanner = calloc(1, sizeof(t_scanner));
array_init(&scanner->heredocs);
t_scanner_ctx *scanner = mem_alloc(sizeof(t_scanner_ctx));
scanner->heredocs = vec_parser_heredoc_new(5, NULL);
return (scanner);
}
bool tree_sitter_bash_external_scanner_scan(void *payload, t_lexer *lexer,
const bool *valid_symbols)
{
t_scanner *scanner = (t_scanner *)payload;
t_scanner_ctx *scanner = (t_scanner_ctx *)payload;
return (scan(scanner, lexer, valid_symbols));
}
unsigned tree_sitter_bash_external_scanner_serialize(void *payload, char *state)
{
t_scanner *scanner = (t_scanner *)payload;
t_scanner_ctx *scanner = (t_scanner_ctx *)payload;
return (serialize(scanner, state));
}
@ -1497,19 +1486,19 @@ void tree_sitter_bash_external_scanner_deserialize(void *payload,
const char *state,
unsigned length)
{
t_scanner *scanner = (t_scanner *)payload;
t_scanner_ctx *scanner = (t_scanner_ctx *)payload;
deserialize(scanner, state, length);
}
void tree_sitter_bash_external_scanner_destroy(void *payload)
{
t_scanner *scanner = (t_scanner *)payload;
for (size_t i = 0; i < scanner->heredocs.size; i++)
t_scanner_ctx *scanner = (t_scanner_ctx *)payload;
for (size_t i = 0; i < scanner->heredocs.len; i++)
{
t_heredoc *heredoc = array_get(&scanner->heredocs, i);
array_delete(&heredoc->current_leading_word);
array_delete(&heredoc->delimiter);
t_heredoc *heredoc = &scanner->heredocs.buffer[i];
str_free(heredoc->current_leading_word);
str_free(heredoc->delimiter);
}
array_delete(&scanner->heredocs);
vec_parser_heredoc_free(scanner->heredocs);
free(scanner);
}

1
stdme/generic_sources/header/vec_C__PREFIX__.h__TEMPLATE__
View file

@ -53,5 +53,6 @@ void vec_C__PREFIX___iter(t_vec_C__PREFIX__ *vec,
void vec_C__PREFIX___reverse(t_vec_C__PREFIX__ *vec);
void vec_C__PREFIX___sort(t_vec_C__PREFIX__ *vec,
t_vec_C__PREFIX___sort_fn is_sorted);
t_error vec_C__PREFIX___back(t_vec_C__PREFIX__ *vec, C__TYPENAME__ **out);
#endif

11
stdme/generic_sources/src/vec_C__PREFIX___functions3.c__TEMPLATE__
View file

@ -71,3 +71,14 @@ void vec_C__PREFIX___reverse(t_vec_C__PREFIX__ *vec)
i++;
}
}
t_error vec_C__PREFIX___back(t_vec_C__PREFIX__ *vec, C__TYPENAME__ **out)
{
C__TYPENAME__ *temporary;
if (out == NULL)
out = &temporary;
if (vec->len != 0)
return (*out = &vec->buffer[vec->len - 1], true);
return (false);
}

3
stdme/include/me/buffered_str/buf_str.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 17:54:28 by maiboyer #+# #+# */
/* Updated: 2023/12/31 15:34:29 by maiboyer ### ########.fr */
/* Updated: 2024/04/30 14:14:42 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -25,6 +25,7 @@ bool push_str_buffer(t_buffer_str *buf, t_const_str to_push);
bool push_str_char(t_buffer_str *buf, char to_push);
void str_clear(t_buffer_str *buf);
t_buffer_str alloc_new_buffer(t_usize capacity);
t_error str_reserve(t_buffer_str *buf, t_usize size);
static inline void str_free(t_buffer_str buf)
{

1
stdme/output/include/me/vec/vec_buf_str.h
View file

@ -53,5 +53,6 @@ void vec_buf_str_iter(t_vec_buf_str *vec,
void vec_buf_str_reverse(t_vec_buf_str *vec);
void vec_buf_str_sort(t_vec_buf_str *vec,
t_vec_buf_str_sort_fn is_sorted);
t_error vec_buf_str_back(t_vec_buf_str *vec, t_buffer_str **out);
#endif

1
stdme/output/include/me/vec/vec_str.h
View file

@ -53,5 +53,6 @@ void vec_str_iter(t_vec_str *vec,
void vec_str_reverse(t_vec_str *vec);
void vec_str_sort(t_vec_str *vec,
t_vec_str_sort_fn is_sorted);
t_error vec_str_back(t_vec_str *vec, t_str **out);
#endif

1
stdme/output/include/me/vec/vec_u8.h
View file

@ -53,5 +53,6 @@ void vec_u8_iter(t_vec_u8 *vec,
void vec_u8_reverse(t_vec_u8 *vec);
void vec_u8_sort(t_vec_u8 *vec,
t_vec_u8_sort_fn is_sorted);
t_error vec_u8_back(t_vec_u8 *vec, t_u8 **out);
#endif

11
stdme/output/src/vec/vec_buf_str_functions3.c
View file

@ -71,3 +71,14 @@ void vec_buf_str_reverse(t_vec_buf_str *vec)
i++;
}
}
t_error vec_buf_str_back(t_vec_buf_str *vec, t_buffer_str **out)
{
t_buffer_str *temporary;
if (out == NULL)
out = &temporary;
if (vec->len != 0)
return (*out = &vec->buffer[vec->len - 1], true);
return (false);
}

11
stdme/output/src/vec/vec_str_functions3.c
View file

@ -71,3 +71,14 @@ void vec_str_reverse(t_vec_str *vec)
i++;
}
}
t_error vec_str_back(t_vec_str *vec, t_str **out)
{
t_str *temporary;
if (out == NULL)
out = &temporary;
if (vec->len != 0)
return (*out = &vec->buffer[vec->len - 1], true);
return (false);
}

11
stdme/output/src/vec/vec_u8_functions3.c
View file

@ -71,3 +71,14 @@ void vec_u8_reverse(t_vec_u8 *vec)
i++;
}
}
t_error vec_u8_back(t_vec_u8 *vec, t_u8 **out)
{
t_u8 *temporary;
if (out == NULL)
out = &temporary;
if (vec->len != 0)
return (*out = &vec->buffer[vec->len - 1], true);
return (false);
}

1
stdme/src.list
View file

@ -16,6 +16,7 @@ blx/sprite/get_pixel
blx/sprite/new_image
blx/sprite/sprite_draw_onto_sprite
buffered_str/mod
buffered_str/push_char
char/isalnum
char/isalpha
char/isascii

43
stdme/src/buffered_str/mod.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2023/11/16 17:52:12 by maiboyer #+# #+# */
/* Updated: 2024/04/28 20:05:41 by maiboyer ### ########.fr */
/* Updated: 2024/04/30 14:14:03 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -19,11 +19,32 @@
#include "me/types.h"
#include <stdlib.h>
bool push_str_buffer(t_buffer_str *buf, t_const_str to_push)
t_error str_reserve(t_buffer_str *buf, t_usize size)
{
t_usize to_push_len;
t_str temp_buffer;
t_usize new_capacity;
t_usize new_capacity;
if (buf == NULL)
return (ERROR);
while (size > buf->capacity)
{
new_capacity = (buf->capacity * 3) / 2 + 1;
temp_buffer = mem_alloc(new_capacity);
if (temp_buffer == NULL)
return (true);
str_l_copy(temp_buffer, buf->buf, new_capacity);
free(buf->buf);
buf->buf = temp_buffer;
buf->capacity = new_capacity;
}
return (NO_ERROR);
}
bool push_str_buffer(t_buffer_str *buf, t_const_str to_push)
{
t_usize to_push_len;
t_str temp_buffer;
t_usize new_capacity;
if (buf == NULL || to_push == NULL)
return (true);
@ -44,26 +65,26 @@ bool push_str_buffer(t_buffer_str *buf, t_const_str to_push)
return (false);
}
bool push_str_char(t_buffer_str *buf, char to_push)
bool push_str_char(t_buffer_str *buf, char to_push)
{
char push_str[2];
char push_str[2];
push_str[0] = to_push;
push_str[1] = 0;
return (push_str_buffer(buf, push_str));
}
void str_clear(t_buffer_str *buf)
void str_clear(t_buffer_str *buf)
{
mem_set_zero(buf->buf, buf->capacity);
buf->len = 0;
return ;
return;
}
t_buffer_str alloc_new_buffer(t_usize capacity)
t_buffer_str alloc_new_buffer(t_usize capacity)
{
t_buffer_str out;
t_str buf;
t_buffer_str out;
t_str buf;
if (capacity == 0)
capacity = 16;

13
stdme/src/buffered_str/push_char.c Normal file
View file

@ -0,0 +1,13 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* push_char.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/30 14:17:47 by maiboyer #+# #+# */
/* Updated: 2024/04/30 14:17:47 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */