Compiling!

Minishell.mk

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

gen.list

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

input.toml

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

output/include/me/vec/vec_parser_heredoc.h

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

output/include/me/vec/vec_parser_range.h

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

output/src/vec/vec_parser_heredoc.c

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

output/src/vec/vec_parser_heredoc_functions2.c

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

output/src/vec/vec_parser_heredoc_functions3.c

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

output/src/vec/vec_parser_range_functions3.c

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

parser/includes/types/types_heredoc.h

@@ -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 */

parser/includes/types/types_scanner_ctx.h

@@ -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;
+	t_u8				 last_glob_paren_depth;
-	bool ext_was_in_double_quote;
+	bool				 ext_was_in_double_quote;
-	bool ext_saw_outside_quote;
+	bool				 ext_saw_outside_quote;
-	// Array(t_heredoc) heredocs;
+	t_vec_parser_heredoc heredocs;
 } t_scanner_ctx;
 
 #endif /* TYPES_SCANNER_CTX_H */

parser/src/scanner.c

@@ -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(),
+		.delimiter = alloc_new_buffer(0),
-		.current_leading_word = array_new(),
+		.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);
+		memset(string->buf, 0, string->len);
-		array_clear(string);
+		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);
+		heredoc = &scanner->heredocs.buffer[i];
-		if (heredoc->delimiter.size + 3 + size >=
+		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,
+			memcpy(&buffer[size], heredoc->delimiter.buf,
-				   heredoc->delimiter.size);
+				   heredoc->delimiter.len);
-			size += heredoc->delimiter.size;
+			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)
+			if (i < scanner->heredocs.len)
-				heredoc = array_get(&scanner->heredocs, i);
+				heredoc = &scanner->heredocs.buffer[i];
 			else
 			{
-				array_push(&scanner->heredocs, heredoc_new());
+				vec_parser_heredoc_push(&scanner->heredocs, heredoc_new());
-				heredoc = array_back(&scanner->heredocs);
+				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);
+			str_reserve(&heredoc->delimiter, heredoc->delimiter.len);
-			if (heredoc->delimiter.size > 0)
+			if (heredoc->delimiter.len > 0)
 			{
-				memcpy(heredoc->delimiter.contents, &buffer[size],
+				memcpy(heredoc->delimiter.buf, &buffer[size],
-					   heredoc->delimiter.size);
+					   heredoc->delimiter.len);
-				size += heredoc->delimiter.size;
+				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) ==
+			   (t_i32) * (&heredoc->delimiter.buf[size]) == lexer->lookahead &&
-				   lexer->lookahead &&
+			   heredoc->current_leading_word.len < heredoc->delimiter.len)
-			   heredoc->current_leading_word.size < heredoc->delimiter.size)
 		{
-			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.len == 0
-	return heredoc->delimiter.size == 0
 			   ? false
-			   : strcmp(heredoc->current_leading_word.contents,
+			   : strcmp(heredoc->current_leading_word.buf,
-						heredoc->delimiter.contents) == 0;
+						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)
-				{
+					vec_parser_heredoc_pop(&scanner->heredocs, NULL);
-					array_pop(&scanner->heredocs);
-				}
 				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 &&
+		scanner->heredocs.len > 0 && !back->started &&
-		!array_back(&scanner->heredocs)->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);
+			str_free(heredoc->current_leading_word);
-			array_delete(&heredoc->delimiter);
+			str_free(heredoc->delimiter);
-			array_pop(&scanner->heredocs);
+			scanner->heredocs.len -= 1;
 			lexer->result_symbol = HEREDOC_END;
 			return (true);
 		}
 	}
 
-	if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.size > 0 &&
+	vec_parser_heredoc_back(&scanner->heredocs, &back);
-		array_back(&scanner->heredocs)->started &&
+	if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.len > 0 &&
-		!in_error_recovery(valid_symbols))
+		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)
+		scanner->heredocs.len > 0)
-		return (scan_heredoc_start(array_back(&scanner->heredocs), lexer));
+	{
-
+		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));
+	t_scanner_ctx *scanner = mem_alloc(sizeof(t_scanner_ctx));
-	array_init(&scanner->heredocs);
+	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;
+	t_scanner_ctx *scanner = (t_scanner_ctx *)payload;
-	for (size_t i = 0; i < scanner->heredocs.size; i++)
+	for (size_t i = 0; i < scanner->heredocs.len; i++)
 	{
-		t_heredoc *heredoc = array_get(&scanner->heredocs, i);
+		t_heredoc *heredoc = &scanner->heredocs.buffer[i];
-		array_delete(&heredoc->current_leading_word);
+		str_free(heredoc->current_leading_word);
-		array_delete(&heredoc->delimiter);
+		str_free(heredoc->delimiter);
 	}
-	array_delete(&scanner->heredocs);
+	vec_parser_heredoc_free(scanner->heredocs);
 	free(scanner);
 }

stdme/generic_sources/header/vec_C__PREFIX__.h__TEMPLATE__

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

stdme/generic_sources/src/vec_C__PREFIX___functions3.c__TEMPLATE__

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

stdme/include/me/buffered_str/buf_str.h

@@ -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)
 {

stdme/output/include/me/vec/vec_buf_str.h

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

stdme/output/include/me/vec/vec_str.h

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

stdme/output/include/me/vec/vec_u8.h

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

stdme/output/src/vec/vec_buf_str_functions3.c

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

stdme/output/src/vec/vec_str_functions3.c

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

stdme/output/src/vec/vec_u8_functions3.c

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

stdme/src.list

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

stdme/src/buffered_str/mod.c

@@ -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_buffer_str out;
-	t_str			buf;
+	t_str		 buf;
 
 	if (capacity == 0)
 		capacity = 16;

stdme/src/buffered_str/push_char.c

@@ -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       */
+/*                                                                            */
+/* ************************************************************************** */
+
+