Update: Added Parser and Stdme

shcat_c/Makefile

@@ -6,7 +6,7 @@
 #    By: rparodi <rparodi@student.42.fr>            +#+  +:+       +#+         #
 #                                                 +#+#+#+#+#+   +#+            #
 #    Created: 2023/11/12 11:05:05 by rparodi           #+#    #+#              #
-#    Updated: 2024/04/28 17:05:10 by maiboyer         ###   ########.fr        #
+#    Updated: 2024/04/28 17:24:41 by maiboyer         ###   ########.fr        #
 #                                                                              #
 # **************************************************************************** #
 
@@ -22,8 +22,10 @@ SRCDIRNAME = sources
 CC = cc
 RM = rm -rf
 
+# Objdir
+OBJDIRNAME = ./objects
 # Flags
-CFLAGS = -Werror -Wextra -Wall -Wno-unused-command-line-argument -g3 -MMD -lreadline -I./libft
+CFLAGS = -Werror -Wextra -Wall -Wno-unused-command-line-argument -g3 -MMD -lreadline -L$(OBJDIRNAME) -lme -lgmr -I./includes -I./stdme/includes -I./parser_src/includes 
 
 # Sources
 LIB =	./libft/ft_bzero.c \
@@ -43,7 +45,6 @@ SRC =	./sources/ft_cmd.c \
 		./sources/main.c
 
 # Objects
-OBJDIRNAME = ./objects
 OBJ = $(addprefix $(OBJDIRNAME)/,$(SRC:.c=.o))
 LIB_OBJ = $(addprefix $(OBJDIRNAME)/,$(LIB:.c=.o))
 
@@ -66,7 +67,7 @@ bonus: header $(OBJ) $(LIB_OBJ) footer
 	@mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME)
 	@printf '$(GREY) Creating $(END)$(GREEN)$(OBJDIRNAME)$(END)\n'
 	@printf '$(GREY) Be Carefull ur in $(END)$(GREEN)Debug Mode$(END)\n'
-	@cc $(CFLAGS) -D DEBUG=42 -o $(NAME) $(OBJ) ./stdme/build/libft.a
+	@cc $(CFLAGS) -D DEBUG=42 -o $(NAME) $(OBJ)
 
 # Clean (make clean)
 clean:
@@ -81,10 +82,12 @@ fclean: clean
 	@echo ""
 
 # Restart (make re)
-re: header fclean all
+re: header 
+	$(MAKE) fclean
+	$(MAKE) all
 
 # Dependences for all
-$(NAME): $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libme.a
+$(NAME): $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libme.a $(OBJDIRNAME)/libgmr.a
 	@mkdir -p $(OBJDIRNAME)
 	@mkdir -p $(OBJDIRNAME)/$(LIBDIRNAME)
 	@mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME)
@@ -129,7 +132,10 @@ footer:
 		@printf '              $(GREY)The compilation is$(END) $(GOLD)finish$(END)\n               $(GREY)Have a good $(END)$(GOLD)correction !$(END)\n'
 
 $(OBJDIRNAME)/libme.a:
-	@$(MAKE) --no-print-directory -C ./stdme/ LIB_NAME="$(realpath ./$(stdme))/" "BUILD_DIR=$(shell realpath ./$(OBJDIRNAME))"
+	@$(MAKE) --no-print-directory -C ./stdme/ LIB_NAME="$(realpath ./$(stdme))/" "BUILD_DIR=$(shell realpath ./$(OBJDIRNAME))" libme.a
+
+$(OBJDIRNAME)/libgmr.a:
+	@$(MAKE) --no-print-directory -C ./parser/ LIB_NAME="$(realpath ./$(stdme))/" "BUILD_DIR=$(shell realpath ./$(OBJDIRNAME))" libgmr.a
 
 
 pull:
@@ -138,6 +144,6 @@ pull:
 	@git submodule update
 
 #	Phony
-.PHONY: all bonus clean fclean re
+.PHONY: all bonus clean fclean re $(OBJDIRNAME)/libme.a $(OBJDIRNAME)/libgmr.a
 
 -include	${OBJ:.o=.d}

shcat_c/parser/Makefile

@@ -0,0 +1,80 @@
+# **************************************************************************** #
+#                                                                              #
+#                                                         :::      ::::::::    #
+#    Makefile                                           :+:      :+:    :+:    #
+#                                                     +:+ +:+         +:+      #
+#    By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+         #
+#                                                 +#+#+#+#+#+   +#+            #
+#    Created: 2023/11/03 13:20:01 by maiboyer          #+#    #+#              #
+#    Updated: 2024/04/28 17:23:03 by maiboyer         ###   ########.fr        #
+#                                                                              #
+# **************************************************************************** #
+
+BUILD_DIR		=	./build
+SRC_DIR			=   ./
+
+BONUS_FLAGS		=
+NAME			=	libgmr.a
+LIB_NAME		?=
+TARGET			=	$(BUILD_DIR)/$(NAME)
+CC				=	clang
+CFLAGS			=	-Wall -Wextra -Werror -g3 -MMD
+
+include ./Filelist.mk
+
+SRC				=	$(addsuffix .c,$(addprefix $(SRC_DIR)/,$(SRC_FILES)))
+OBJ				=	$(addsuffix .o,$(addprefix $(BUILD_DIR)/,$(SRC_FILES)))
+DEPS			=	$(addsuffix .d,$(addprefix $(BUILD_DIR)/,$(SRC_FILES)))
+
+INCLUDES		=	
+COL_GRAY		=	\\e[90m
+COL_WHITE		=	\\e[37m
+COL_GREEN		=	\\e[32m
+COL_BOLD		=	\\e[1m
+COL_RESET		=	\\e[0m
+
+.PHONY: all
+.PHONY: libs_build
+.PHONY: bonus
+.PHONY: clean
+.PHONY: fclean
+.PHONY: re
+.PHONY: format
+.PHONY: subject
+.PHONY: submit
+.PHONY: so
+
+all: $(NAME)
+
+$(NAME): $(TARGET)
+
+$(TARGET): $(OBJ)
+	@echo "ar rcs $(BUILD_DIR)/$(NAME) <OBJS...>"
+	@ar rcs $(BUILD_DIR)/$(NAME) $(OBJ)
+
+$(BUILD_DIR)/%.o: $(SRC_DIR)/%.c
+	@mkdir -p $(dir $@)
+	$(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@
+
+clean:
+	@- $(foreach LIB,$(LIBS), \
+		make clean LIB_NAME=$(LIB)/ BUILD_DIR=$(realpath $(BUILD_DIR)) -C $(LIB) --no-print-directory || true;\
+	)
+	$(if $(LIB_NAME),,\
+		rm -rf $(BUILD_DIR) \
+	)
+
+fclean: clean
+	@- $(foreach LIB,$(LIBS), \
+		make fclean LIB_NAME=$(LIB)/ BUILD_DIR=$(realpath $(BUILD_DIR)) -C $(LIB) --no-print-directory || true;\
+	)
+	rm -f $(BUILD_DIR)/$(NAME)
+
+re:
+	$(MAKE) --no-print-directory fclean
+	$(MAKE) --no-print-directory all
+
+generate_filelist:
+	@/usr/bin/env zsh -c "tree -iFf --noreport $(SRC_DIR) | rg '^$(SRC_DIR)/(.*)\.c\$$' --replace '\$$1' | sort -u" > ./source_files.list
+
+-include $(DEPS)

shcat_c/parser/create_language.c

@@ -0,0 +1,101 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_language.c                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/25 16:13:52 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/28 17:15:16 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./includes/parser.h"
+#include "./src/headers/constants.h"
+#include "./src/headers/symbols.h"
+#include "./parse_types.h"
+
+const uint16_t			   *create_parse_table(void);
+const uint16_t			   *create_small_parse_table(void);
+const uint32_t			   *create_small_parse_table_map(void);
+const t_parse_action_entry *create_parse_actions_entries(void);
+const char *const		   *create_symbols_names(void);
+const char *const		   *create_field_names(void);
+const t_field_map_slice	   *create_field_map_slices(void);
+const t_field_map_entry	   *create_field_map_entries(void);
+const t_symbol_metadata	   *create_symbols_metadata(void);
+const t_symbol			   *create_unique_symbols_map(void);
+const t_symbol			   *create_non_terminal_alias_map(void);
+const t_symbol			   *create_alias_sequences(void);
+const t_lex_modes		   *create_lex_modes(void);
+const t_state_id		   *create_primary_state_ids(void);
+const bool				   *create_external_scanner_states(void);
+const t_symbol			   *create_external_scanner_symbol_map(void);
+bool						lex_normal_main(t_lexer *lexer, t_state_id state);
+bool						lex_keywords_main(t_lexer *lexer, t_state_id state);
+void					   *tree_sitter_bash_external_scanner_create(void);
+void	 tree_sitter_bash_external_scanner_destroy(void *ctx);
+bool	 tree_sitter_bash_external_scanner_scan(void *ctx, t_lexer *lexer,
+												const bool *ret);
+uint32_t tree_sitter_bash_external_scanner_serialize(void *ctx, char *s);
+void	 tree_sitter_bash_external_scanner_deserialize(void *ctx, const char *s,
+													   uint32_t val);
+
+static t_scanner init_scanner(void)
+{
+	return ((t_scanner){
+		create_external_scanner_states(),
+		create_external_scanner_symbol_map(),
+		tree_sitter_bash_external_scanner_create,
+		tree_sitter_bash_external_scanner_destroy,
+		tree_sitter_bash_external_scanner_scan,
+		tree_sitter_bash_external_scanner_serialize,
+		tree_sitter_bash_external_scanner_deserialize,
+	});
+}
+
+static void init_language(t_language *language)
+{
+	language->parse_table = create_parse_table();
+	language->small_parse_table = create_small_parse_table();
+	language->small_parse_table_map = create_small_parse_table_map();
+	language->parse_actions = create_parse_actions_entries();
+	language->symbol_names = create_symbols_names();
+	language->field_names = create_field_names();
+	language->field_map_slices = create_field_map_slices();
+	language->field_map_entries = create_field_map_entries();
+	language->symbol_metadata = create_symbols_metadata();
+	language->public_symbol_map = create_unique_symbols_map();
+	language->alias_map = create_non_terminal_alias_map();
+	language->alias_sequences = create_alias_sequences();
+	language->lex_modes = create_lex_modes();
+	language->primary_state_ids = create_primary_state_ids();
+	language->lex_fn = lex_normal_main;
+	language->keyword_lex_fn = lex_keywords_main;
+	language->keyword_capture_token = sym_word;
+	language->external_scanner = init_scanner();
+}
+
+const t_language *tree_sitter_bash(void)
+{
+	static bool		  init = false;
+	static t_language language = {
+		.version = LANGUAGE_VERSION,
+		.symbol_count = SYMBOL_COUNT,
+		.alias_count = ALIAS_COUNT,
+		.token_count = TOKEN_COUNT,
+		.external_token_count = EXTERNAL_TOKEN_COUNT,
+		.state_count = STATE_COUNT,
+		.large_state_count = LARGE_STATE_COUNT,
+		.production_id_count = PRODUCTION_ID_COUNT,
+		.field_count = FIELD_COUNT,
+		.max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH,
+	};
+
+	if (!init)
+	{
+		init_language(&language);
+		init = true;
+	}
+	return ((t_language *)&language);
+}

shcat_c/parser/includes/alloc.h

@@ -0,0 +1,54 @@
+#ifndef TREE_SITTER_ALLOC_H_
+#define TREE_SITTER_ALLOC_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdbool.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+// Allow clients to override allocation functions
+#ifdef TREE_SITTER_REUSE_ALLOCATOR
+
+extern void *(*ts_current_malloc)(size_t);
+extern void *(*ts_current_calloc)(size_t, size_t);
+extern void *(*ts_current_realloc)(void *, size_t);
+extern void (*ts_current_free)(void *);
+
+#ifndef malloc
+#define malloc  ts_current_malloc
+#endif
+#ifndef calloc
+#define calloc  ts_current_calloc
+#endif
+#ifndef realloc
+#define realloc ts_current_realloc
+#endif
+#ifndef free
+#define free    ts_current_free
+#endif
+
+#else
+
+#ifndef malloc
+#define malloc  malloc
+#endif
+#ifndef calloc
+#define calloc  calloc
+#endif
+#ifndef realloc
+#define realloc realloc
+#endif
+#ifndef free
+#define free    free
+#endif
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif // TREE_SITTER_ALLOC_H_

shcat_c/parser/includes/array.h

@@ -0,0 +1,287 @@
+#ifndef TREE_SITTER_ARRAY_H_
+#define TREE_SITTER_ARRAY_H_
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+#ifdef _MSC_VER
+#pragma warning(disable : 4101)
+#elif defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-variable"
+#endif
+
+#define Array(T)       \
+  struct {             \
+    T *contents;       \
+    uint32_t size;     \
+    uint32_t capacity; \
+  }
+
+/// Initialize an array.
+#define array_init(self) \
+  ((self)->size = 0, (self)->capacity = 0, (self)->contents = NULL)
+
+/// Create an empty array.
+#define array_new() \
+  { NULL, 0, 0 }
+
+/// Get a pointer to the element at a given `index` in the array.
+#define array_get(self, _index) \
+  (assert((uint32_t)(_index) < (self)->size), &(self)->contents[_index])
+
+/// Get a pointer to the first element in the array.
+#define array_front(self) array_get(self, 0)
+
+/// Get a pointer to the last element in the array.
+#define array_back(self) array_get(self, (self)->size - 1)
+
+/// Clear the array, setting its size to zero. Note that this does not free any
+/// memory allocated for the array's contents.
+#define array_clear(self) ((self)->size = 0)
+
+/// Reserve `new_capacity` elements of space in the array. If `new_capacity` is
+/// less than the array's current capacity, this function has no effect.
+#define array_reserve(self, new_capacity) \
+  _array__reserve((Array *)(self), array_elem_size(self), new_capacity)
+
+/// Free any memory allocated for this array. Note that this does not free any
+/// memory allocated for the array's contents.
+#define array_delete(self) _array__delete((Array *)(self))
+
+/// Push a new `element` onto the end of the array.
+#define array_push(self, element)                            \
+  (_array__grow((Array *)(self), 1, array_elem_size(self)), \
+   (self)->contents[(self)->size++] = (element))
+
+/// Increase the array's size by `count` elements.
+/// New elements are zero-initialized.
+#define array_grow_by(self, count) \
+  (_array__grow((Array *)(self), count, array_elem_size(self)), \
+   memset((self)->contents + (self)->size, 0, (count) * array_elem_size(self)), \
+   (self)->size += (count))
+
+/// Append all elements from one array to the end of another.
+#define array_push_all(self, other)                                       \
+  array_extend((self), (other)->size, (other)->contents)
+
+/// Append `count` elements to the end of the array, reading their values from the
+/// `contents` pointer.
+#define array_extend(self, count, contents)                    \
+  _array__splice(                                               \
+    (Array *)(self), array_elem_size(self), (self)->size, \
+    0, count,  contents                                        \
+  )
+
+/// Remove `old_count` elements from the array starting at the given `index`. At
+/// the same index, insert `new_count` new elements, reading their values from the
+/// `new_contents` pointer.
+#define array_splice(self, _index, old_count, new_count, new_contents)  \
+  _array__splice(                                                       \
+    (Array *)(self), array_elem_size(self), _index,                \
+    old_count, new_count, new_contents                                 \
+  )
+
+/// Insert one `element` into the array at the given `index`.
+#define array_insert(self, _index, element) \
+  _array__splice((Array *)(self), array_elem_size(self), _index, 0, 1, &(element))
+
+/// Remove one element from the array at the given `index`.
+#define array_erase(self, _index) \
+  _array__erase((Array *)(self), array_elem_size(self), _index)
+
+/// Pop the last element off the array, returning the element by value.
+#define array_pop(self) ((self)->contents[--(self)->size])
+
+/// Assign the contents of one array to another, reallocating if necessary.
+#define array_assign(self, other) \
+  _array__assign((Array *)(self), (const Array *)(other), array_elem_size(self))
+
+/// Swap one array with another
+#define array_swap(self, other) \
+  _array__swap((Array *)(self), (Array *)(other))
+
+/// Get the size of the array contents
+#define array_elem_size(self) (sizeof *(self)->contents)
+
+/// Search a sorted array for a given `needle` value, using the given `compare`
+/// callback to determine the order.
+///
+/// If an existing element is found to be equal to `needle`, then the `index`
+/// out-parameter is set to the existing value's index, and the `exists`
+/// out-parameter is set to true. Otherwise, `index` is set to an index where
+/// `needle` should be inserted in order to preserve the sorting, and `exists`
+/// is set to false.
+#define array_search_sorted_with(self, compare, needle, _index, _exists) \
+  _array__search_sorted(self, 0, compare, , needle, _index, _exists)
+
+/// Search a sorted array for a given `needle` value, using integer comparisons
+/// of a given struct field (specified with a leading dot) to determine the order.
+///
+/// See also `array_search_sorted_with`.
+#define array_search_sorted_by(self, field, needle, _index, _exists) \
+  _array__search_sorted(self, 0, _compare_int, field, needle, _index, _exists)
+
+/// Insert a given `value` into a sorted array, using the given `compare`
+/// callback to determine the order.
+#define array_insert_sorted_with(self, compare, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_with(self, compare, &(value), &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
+
+/// Insert a given `value` into a sorted array, using integer comparisons of
+/// a given struct field (specified with a leading dot) to determine the order.
+///
+/// See also `array_search_sorted_by`.
+#define array_insert_sorted_by(self, field, value) \
+  do { \
+    unsigned _index, _exists; \
+    array_search_sorted_by(self, field, (value) field, &_index, &_exists); \
+    if (!_exists) array_insert(self, _index, value); \
+  } while (0)
+
+// Private
+
+typedef Array(void) Array;
+
+/// This is not what you're looking for, see `array_delete`.
+static inline void _array__delete(Array *self) {
+  if (self->contents) {
+    free(self->contents);
+    self->contents = NULL;
+    self->size = 0;
+    self->capacity = 0;
+  }
+}
+
+/// This is not what you're looking for, see `array_erase`.
+static inline void _array__erase(Array *self, size_t element_size,
+                                uint32_t index) {
+  assert(index < self->size);
+  char *contents = (char *)self->contents;
+  memmove(contents + index * element_size, contents + (index + 1) * element_size,
+          (self->size - index - 1) * element_size);
+  self->size--;
+}
+
+/// This is not what you're looking for, see `array_reserve`.
+static inline void _array__reserve(Array *self, size_t element_size, uint32_t new_capacity) {
+  if (new_capacity > self->capacity) {
+    if (self->contents) {
+      self->contents = realloc(self->contents, new_capacity * element_size);
+    } else {
+      self->contents = malloc(new_capacity * element_size);
+    }
+    self->capacity = new_capacity;
+  }
+}
+
+/// This is not what you're looking for, see `array_assign`.
+static inline void _array__assign(Array *self, const Array *other, size_t element_size) {
+  _array__reserve(self, element_size, other->size);
+  self->size = other->size;
+  memcpy(self->contents, other->contents, self->size * element_size);
+}
+
+/// This is not what you're looking for, see `array_swap`.
+static inline void _array__swap(Array *self, Array *other) {
+  Array swap = *other;
+  *other = *self;
+  *self = swap;
+}
+
+/// This is not what you're looking for, see `array_push` or `array_grow_by`.
+static inline void _array__grow(Array *self, uint32_t count, size_t element_size) {
+  uint32_t new_size = self->size + count;
+  if (new_size > self->capacity) {
+    uint32_t new_capacity = self->capacity * 2;
+    if (new_capacity < 8) new_capacity = 8;
+    if (new_capacity < new_size) new_capacity = new_size;
+    _array__reserve(self, element_size, new_capacity);
+  }
+}
+
+/// This is not what you're looking for, see `array_splice`.
+static inline void _array__splice(Array *self, size_t element_size,
+                                 uint32_t index, uint32_t old_count,
+                                 uint32_t new_count, const void *elements) {
+  uint32_t new_size = self->size + new_count - old_count;
+  uint32_t old_end = index + old_count;
+  uint32_t new_end = index + new_count;
+  assert(old_end <= self->size);
+
+  _array__reserve(self, element_size, new_size);
+
+  char *contents = (char *)self->contents;
+  if (self->size > old_end) {
+    memmove(
+      contents + new_end * element_size,
+      contents + old_end * element_size,
+      (self->size - old_end) * element_size
+    );
+  }
+  if (new_count > 0) {
+    if (elements) {
+      memcpy(
+        (contents + index * element_size),
+        elements,
+        new_count * element_size
+      );
+    } else {
+      memset(
+        (contents + index * element_size),
+        0,
+        new_count * element_size
+      );
+    }
+  }
+  self->size += new_count - old_count;
+}
+
+/// A binary search routine, based on Rust's `std::slice::binary_search_by`.
+/// This is not what you're looking for, see `array_search_sorted_with` or `array_search_sorted_by`.
+#define _array__search_sorted(self, start, compare, suffix, needle, _index, _exists) \
+  do { \
+    *(_index) = start; \
+    *(_exists) = false; \
+    uint32_t size = (self)->size - *(_index); \
+    if (size == 0) break; \
+    int comparison; \
+    while (size > 1) { \
+      uint32_t half_size = size / 2; \
+      uint32_t mid_index = *(_index) + half_size; \
+      comparison = compare(&((self)->contents[mid_index] suffix), (needle)); \
+      if (comparison <= 0) *(_index) = mid_index; \
+      size -= half_size; \
+    } \
+    comparison = compare(&((self)->contents[*(_index)] suffix), (needle)); \
+    if (comparison == 0) *(_exists) = true; \
+    else if (comparison < 0) *(_index) += 1; \
+  } while (0)
+
+/// Helper macro for the `_sorted_by` routines below. This takes the left (existing)
+/// parameter by reference in order to work with the generic sorting function above.
+#define _compare_int(a, b) ((int)*(a) - (int)(b))
+
+#ifdef _MSC_VER
+#pragma warning(default : 4101)
+#elif defined(__GNUC__) || defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  // TREE_SITTER_ARRAY_H_

shcat_c/parser/includes/lexer.h

@@ -0,0 +1,26 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lexer.h                                            :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/23 19:51:24 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/24 23:03:33 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef LEXER_H
+#define LEXER_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#ifndef TREE_SITTER_API_H_
+typedef uint16_t		  t_state_id;
+typedef uint16_t		  t_symbol;
+typedef uint16_t		  t_field_id;
+typedef struct s_language t_language;
+#endif
+
+#endif /* LEXER_H */

shcat_c/parser/includes/parser.h

@@ -0,0 +1,56 @@
+#ifndef TREE_SITTER_PARSER_H_
+#define TREE_SITTER_PARSER_H_
+
+#include "../parse_types.h"
+#include "./lexer.h"
+#include <stdbool.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
+
+typedef struct s_language t_language;
+typedef struct s_scanner
+{
+	const bool	   *states;
+	const t_symbol *symbol_map;
+	void *(*create)(void);
+	void (*destroy)(void *);
+	bool (*scan)(void *, t_lexer *, const bool *symbol_whitelist);
+	unsigned (*serialize)(void *, char *);
+	void (*deserialize)(void *, const char *, unsigned);
+} t_scanner;
+
+struct s_language
+{
+	uint32_t					version;
+	uint32_t					symbol_count;
+	uint32_t					alias_count;
+	uint32_t					token_count;
+	uint32_t					external_token_count;
+	uint32_t					state_count;
+	uint32_t					large_state_count;
+	uint32_t					production_id_count;
+	uint32_t					field_count;
+	uint16_t					max_alias_sequence_length;
+	const uint16_t			   *parse_table;
+	const uint16_t			   *small_parse_table;
+	const uint32_t			   *small_parse_table_map;
+	const t_parse_action_entry *parse_actions;
+	const char *const		   *symbol_names;
+	const char *const		   *field_names;
+	const t_field_map_slice	   *field_map_slices;
+	const t_field_map_entry	   *field_map_entries;
+	const t_symbol_metadata	   *symbol_metadata;
+	const t_symbol			   *public_symbol_map;
+	const uint16_t			   *alias_map;
+	const t_symbol			   *alias_sequences;
+	const t_lex_modes		   *lex_modes;
+	bool (*lex_fn)(t_lexer *, t_state_id);
+	bool (*keyword_lex_fn)(t_lexer *, t_state_id);
+	t_symbol		  keyword_capture_token;
+	t_scanner		  external_scanner;
+	const t_state_id *primary_state_ids;
+};
+
+#endif // TREE_SITTER_PARSER_H_

shcat_c/parser/includes/parser_raw_types.h

@@ -0,0 +1,18 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   parser_raw_types.h                                 :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/24 17:44:47 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/24 17:44:48 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef PARSER_RAW_TYPES_H
+#define PARSER_RAW_TYPES_H
+
+
+
+#endif /* PARSER_RAW_TYPES_H */

shcat_c/parser/parse_types.h

@@ -0,0 +1,298 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   parse_types.h                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/24 23:01:45 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/26 18:05:40 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef PARSETYPES_H
+#define PARSETYPES_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+typedef uint16_t t_state_id;
+typedef uint16_t t_symbol;
+typedef uint16_t t_field_id;
+
+typedef struct s_lexer t_lexer;
+
+#define ts_builtin_sym_end 0
+#define ts_builtin_sym_error -1
+
+struct s_lexer
+{
+	int32_t	 lookahead;
+	t_symbol result_symbol;
+	void (*advance)(t_lexer *, bool);
+	void (*mark_end)(t_lexer *);
+	uint32_t (*get_column)(t_lexer *);
+	bool (*is_at_included_range_start)(const t_lexer *);
+	bool (*eof)(const t_lexer *);
+};
+
+typedef struct s_lexer_state
+{
+	int32_t	   lookahead;
+	t_state_id state;
+	bool	   result;
+	bool	   skip;
+	bool	   eof;
+} t_lexer_state;
+
+static inline bool lex_skip(t_state_id state_value, t_lexer *lexer,
+							t_lexer_state *s)
+{
+	(void)(lexer);
+	s->skip = true;
+	s->state = state_value;
+	return (true);
+};
+
+static inline bool lex_advance(t_state_id state_value, t_lexer *lexer,
+							   t_lexer_state *s)
+{
+	(void)(lexer);
+	s->state = state_value;
+	return (true);
+};
+
+static inline bool lex_accept_token(t_symbol symbol_value, t_lexer *lexer,
+									t_lexer_state *s)
+{
+	s->result = true;
+	lexer->result_symbol = symbol_value;
+	lexer->mark_end(lexer);
+	return (true);
+};
+
+static inline bool lex_end_state(t_lexer *lexer, t_lexer_state *s)
+{
+	(void)(lexer);
+	(void)(s);
+	return (false);
+};
+
+typedef struct
+{
+	t_field_id field_id;
+	uint8_t	   child_index;
+	bool	   inherited;
+} t_field_map_entry;
+
+static inline t_field_map_entry fmap_entry(t_field_id field_id,
+										   uint8_t child_index, bool inherited)
+{
+	return ((t_field_map_entry){
+		.field_id = field_id,
+		.child_index = child_index,
+		.inherited = inherited,
+	});
+};
+
+typedef struct
+{
+	uint16_t index;
+	uint16_t length;
+} t_field_map_slice;
+
+static inline t_field_map_slice fmap_slice(uint16_t index, uint16_t length)
+{
+	return ((t_field_map_slice){
+		.index = index,
+		.length = length,
+	});
+};
+
+typedef struct
+{
+	bool visible;
+	bool named;
+	bool supertype;
+} t_symbol_metadata;
+
+static inline t_symbol_metadata sym_metadata(bool visible, bool named,
+												bool supertype)
+{
+	return ((t_symbol_metadata){
+		.visible = visible,
+		.named = named,
+		.supertype = supertype,
+	});
+};
+
+typedef enum
+{
+	ActionTypeShift,
+	ActionTypeReduce,
+	ActionTypeAccept,
+	ActionTypeRecover,
+} t_parse_action_type;
+
+typedef union {
+	struct
+	{
+		uint8_t	   type;
+		t_state_id state;
+		bool	   extra;
+		bool	   repetition;
+	} shift;
+	struct
+	{
+		uint8_t	 type;
+		uint8_t	 child_count;
+		t_symbol symbol;
+		int16_t	 dynamic_precedence;
+		uint16_t production_id;
+	} reduce;
+	uint8_t type;
+} t_parse_actions;
+
+typedef struct
+{
+	uint16_t lex_state;
+	uint16_t external_lex_state;
+} t_lex_modes;
+
+typedef union {
+	t_parse_actions action;
+	struct
+	{
+		uint8_t count;
+		bool	reusable;
+	} entry;
+} t_parse_action_entry;
+
+static inline t_parse_action_entry entry(uint8_t count, bool reusable)
+{
+	return ((t_parse_action_entry){
+		.entry = {.count = count, .reusable = reusable}});
+};
+
+static inline t_parse_action_entry shift(t_state_id state_value)
+{
+	return ((t_parse_action_entry){{.shift = {
+										.type = ActionTypeShift,
+										.state = (state_value),
+									}}});
+};
+
+static inline t_parse_action_entry shift_repeat(t_state_id state_value)
+{
+	return ((t_parse_action_entry){{.shift = {.type = ActionTypeShift,
+											  .state = (state_value),
+											  .repetition = true}}});
+};
+
+static inline t_parse_action_entry shift_extra(void)
+{
+	return ((t_parse_action_entry){
+		{.shift = {.type = ActionTypeShift, .extra = true}}});
+};
+
+static inline t_parse_action_entry reduce(
+
+	t_symbol symbol, uint8_t child_count, int16_t dynamic_precedence,
+	uint16_t production_id)
+{
+	return (
+		(t_parse_action_entry){{.reduce = {
+									.type = ActionTypeReduce,
+									.child_count = child_count,
+									.symbol = symbol,
+									.dynamic_precedence = dynamic_precedence,
+									.production_id = production_id,
+								}}});
+};
+
+static inline t_parse_action_entry recover(void)
+{
+	return ((t_parse_action_entry){{.type = ActionTypeRecover}});
+};
+
+static inline t_parse_action_entry accept(void)
+{
+	return ((t_parse_action_entry){{.type = ActionTypeAccept}});
+};
+
+typedef struct s_char_range
+{
+	int32_t start;
+	int32_t end;
+} t_char_range;
+
+static inline bool set_contains(t_char_range *ranges, uint32_t len,
+								int32_t lookahead)
+{
+	uint32_t index = 0;
+	uint32_t size = len - index;
+	while (size > 1)
+	{
+		uint32_t	  half_size = size / 2;
+		uint32_t	  mid_index = index + half_size;
+		t_char_range *range = &ranges[mid_index];
+		if (lookahead >= range->start && lookahead <= range->end)
+		{
+			return true;
+		}
+		else if (lookahead > range->end)
+		{
+			index = mid_index;
+		}
+		size -= half_size;
+	}
+	t_char_range *range = &ranges[index];
+	return (lookahead >= range->start && lookahead <= range->end);
+};
+
+static inline bool advance_map_inner(uint32_t *map, uint32_t elems, t_lexer *l,
+									 t_lexer_state *s)
+{
+	uint32_t i;
+	
+	(void)(l);
+	i = 0;
+	while (i < elems)
+	{
+		if (map[i] == (uint32_t)s->lookahead)
+		{
+			s->state = map[i + 1];
+			return true;
+		}
+		i += 2;
+	}
+	return (false);
+};
+
+static inline t_lex_modes lex_mode_external(uint16_t lex_state,
+											uint16_t ext_lex_state)
+{
+	return ((t_lex_modes){
+		.lex_state = lex_state,
+		.external_lex_state = ext_lex_state,
+	});
+};
+
+static inline t_lex_modes lex_mode_normal(uint16_t lex_state)
+{
+	return ((t_lex_modes){
+		.lex_state = lex_state,
+	});
+};
+
+static inline uint16_t actions(uint16_t val)
+{
+	return (val);
+};
+
+static inline uint16_t state(uint16_t val)
+{
+	return (val);
+};
+
+#endif /* PARSETYPES_H */

shcat_c/parser/src/alias_sequences/alias_sequences.h

@@ -0,0 +1,27 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   alias_sequences.h                                  :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef ALIAS_SEQUENCES_H
+# define ALIAS_SEQUENCES_H
+
+# include "../types/type_alias_sequences.h"
+# include "../headers/symbols.h"
+# include "../headers/external_scanner_symbol_identifiers.h"
+# include "../headers/field_identifiers.h"
+
+# include "../headers/constants.h"
+
+void	alias_sequences_0(t_alias_sequences_array *v);
+void	alias_sequences_1(t_alias_sequences_array *v);
+void	alias_sequences_2(t_alias_sequences_array *v);
+
+#endif // ALIAS_SEQUENCES_H

shcat_c/parser/src/alias_sequences/alias_sequences_0.c

@@ -0,0 +1,75 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   alias_sequences_0.c                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./alias_sequences.h"
+
+void	alias_sequences_0(t_alias_sequences_array *v)
+{
+	v->a[1][0] = sym_word;
+	v->a[9][1] = sym_word;
+	v->a[10][1] = sym_word;
+	v->a[11][1] = anon_sym_AT2;
+	v->a[13][0] = anon_sym_AT2;
+	v->a[16][0] = sym_word;
+	v->a[22][2] = sym_word;
+	v->a[23][2] = sym_word;
+	v->a[25][2] = sym_word;
+	v->a[32][0] = anon_sym_AT2;
+	v->a[33][1] = anon_sym_AT2;
+	v->a[36][1] = sym_word;
+	v->a[40][2] = sym_word;
+	v->a[45][1] = sym_word;
+	v->a[48][0] = sym_regex;
+	v->a[53][1] = anon_sym_AT2;
+	v->a[55][0] = sym_variable_name;
+	v->a[59][0] = sym_word;
+	v->a[62][2] = sym_word;
+	v->a[77][0] = sym_word;
+	alias_sequences_1(v);
+}
+
+void	alias_sequences_1(t_alias_sequences_array *v)
+{
+	v->a[78][0] = sym_word;
+	v->a[79][0] = sym_word;
+	v->a[85][3] = sym_word;
+	v->a[86][2] = sym_word;
+	v->a[88][3] = sym_word;
+	v->a[103][0] = sym_word;
+	v->a[104][0] = sym_word;
+	v->a[105][0] = sym_word;
+	v->a[106][0] = sym_word;
+	v->a[107][1] = sym_word;
+	v->a[108][1] = sym_word;
+	v->a[109][1] = sym_word;
+	v->a[117][3] = sym_word;
+	v->a[119][4] = sym_word;
+	v->a[120][3] = sym_word;
+	v->a[121][4] = sym_word;
+	v->a[134][0] = sym_word;
+	v->a[135][0] = sym_word;
+	v->a[136][1] = sym_word;
+	v->a[137][1] = sym_word;
+	alias_sequences_2(v);
+}
+
+void	alias_sequences_2(t_alias_sequences_array *v)
+{
+	v->a[138][1] = sym_word;
+	v->a[139][1] = sym_word;
+	v->a[146][4] = sym_word;
+	v->a[147][4] = sym_word;
+	v->a[153][1] = sym_word;
+	v->a[154][1] = sym_word;
+}
+
+/* EOF alias_sequences_0.c */

shcat_c/parser/src/char_set/charset_inline.h

@@ -0,0 +1,38 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   charset_inline.h                                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef CHARSET_INLINE_H
+# define CHARSET_INLINE_H
+# include "../../parse_types.h"
+# include <stdint.h>
+
+static inline t_char_range	*sym__comment_word_character_set_1(void)
+{
+	static t_char_range	val[12] = {{0, 0x08}, {0x0e, 0x1f}, \
+		{'!', '!'}, {'#', '#'}, {'%', '%'}, {'*', ':'}, {'=', \
+		'='}, {'?', 'Z'}, {'\\', '\\'}, {'^', '_'}, {'a', 'z'}, \
+		{'~', 0x10ffff}};
+
+	return (val);
+}
+
+static inline t_char_range	*sym_word_character_set_1(void)
+{
+	static t_char_range	val[11] = {{0, 0x08}, {0x0e, 0x1f}, \
+		{'!', '!'}, {'%', '%'}, {'*', ':'}, {'=', '='}, {'?', \
+		'Z'}, {'\\', '\\'}, {'^', '_'}, {'a', 'z'}, {'~', \
+		0x10ffff}};
+
+	return (val);
+}
+
+#endif // CHARSET_INLINE_H

shcat_c/parser/src/create/create_alias_sequences.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_alias_sequences.c                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_alias_sequences.h"
+#include "../alias_sequences/alias_sequences.h"
+
+t_alias_sequences_array	*create_alias_sequences(void)
+{
+	static t_alias_sequences_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		alias_sequences_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_alias_sequences.c */

shcat_c/parser/src/create/create_external_scanner_states.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_external_scanner_states.c                   :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_external_scanner_states.h"
+#include "../external_scanner_states/external_scanner_states.h"
+
+t_external_scanner_states_array	*create_external_scanner_states(void)
+{
+	static t_external_scanner_states_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		external_scanner_states_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_external_scanner_states.c */

shcat_c/parser/src/create/create_external_scanner_symbol_map.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_external_scanner_symbol_map.c               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_external_scanner_symbol_map.h"
+#include "../external_scanner_symbol_map/external_scanner_symbol_map.h"
+
+t_external_scanner_symbol_map_array	*create_external_scanner_symbol_map(void)
+{
+	static t_external_scanner_symbol_map_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		external_scanner_symbol_map_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_external_scanner_symbol_map.c */

shcat_c/parser/src/create/create_field_map_entries.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_field_map_entries.c                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_field_map_entries.h"
+#include "../field_map_entries/field_map_entries.h"
+
+t_field_map_entries_array	*create_field_map_entries(void)
+{
+	static t_field_map_entries_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		field_map_entries_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_field_map_entries.c */

shcat_c/parser/src/create/create_field_map_slices.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_field_map_slices.c                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_field_map_slices.h"
+#include "../field_map_slices/field_map_slices.h"
+
+t_field_map_slices_array	*create_field_map_slices(void)
+{
+	static t_field_map_slices_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		field_map_slices_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_field_map_slices.c */

shcat_c/parser/src/create/create_field_names.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_field_names.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_field_names.h"
+#include "../field_names/field_names.h"
+
+t_field_names_array	*create_field_names(void)
+{
+	static t_field_names_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		field_names_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_field_names.c */

shcat_c/parser/src/create/create_lex_keywords.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_lex_keywords.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_lex_keywords.h"
+#include "../lex_funcs/lex_keywords/create_table/lex_keywords_array.h"
+
+t_lex_keywords_array	*create_lex_keywords(void)
+{
+	static t_lex_keywords_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		lex_keywords_array_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_lex_keywords.c */

shcat_c/parser/src/create/create_lex_modes.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_lex_modes.c                                 :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_lex_modes.h"
+#include "../lex_modes/lex_modes.h"
+
+t_lex_modes_array	*create_lex_modes(void)
+{
+	static t_lex_modes_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		lex_modes_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_lex_modes.c */

shcat_c/parser/src/create/create_lex_normal.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_lex_normal.c                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_lex_normal.h"
+#include "../lex_funcs/lex_normal/create_table/lex_normal_array.h"
+
+t_lex_normal_array	*create_lex_normal(void)
+{
+	static t_lex_normal_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		lex_normal_array_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_lex_normal.c */

shcat_c/parser/src/create/create_non_terminal_alias_map.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_non_terminal_alias_map.c                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_non_terminal_alias_map.h"
+#include "../non_terminal_alias_map/non_terminal_alias_map.h"
+
+t_non_terminal_alias_map_array	*create_non_terminal_alias_map(void)
+{
+	static t_non_terminal_alias_map_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		non_terminal_alias_map_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_non_terminal_alias_map.c */

shcat_c/parser/src/create/create_parse_actions_entries.c

@@ -0,0 +1,30 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_parse_actions_entries.c                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_parse_actions_entries.h"
+#include "../types/type_parse_actions_entries.h"
+#include "../parse_actions_entries/parse_actions_entries.h"
+
+t_parse_actions_entries_array	*create_parse_actions_entries(void)
+{
+	static t_parse_actions_entries_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		parse_actions_entries_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_parse_actions_entries.c */

shcat_c/parser/src/create/create_parse_table.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_parse_table.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_parse_table.h"
+#include "../parse_table/parse_table.h"
+
+t_parse_table_array	*create_parse_table(void)
+{
+	static t_parse_table_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		parse_table_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_parse_table.c */

shcat_c/parser/src/create/create_primary_state_ids.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_primary_state_ids.c                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_primary_state_ids.h"
+#include "../primary_state_ids/primary_state_ids.h"
+
+t_primary_state_ids_array	*create_primary_state_ids(void)
+{
+	static t_primary_state_ids_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		primary_state_ids_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_primary_state_ids.c */

shcat_c/parser/src/create/create_small_parse_table.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_small_parse_table.c                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_small_parse_table.h"
+#include "../small_parse_table/small_parse_table.h"
+
+t_small_parse_table_array	*create_small_parse_table(void)
+{
+	static t_small_parse_table_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		small_parse_table_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_small_parse_table.c */

shcat_c/parser/src/create/create_small_parse_table_map.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_small_parse_table_map.c                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_small_parse_table_map.h"
+#include "../small_parse_table_map/small_parse_table_map.h"
+
+t_small_parse_table_map_array	*create_small_parse_table_map(void)
+{
+	static t_small_parse_table_map_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		small_parse_table_map_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_small_parse_table_map.c */

shcat_c/parser/src/create/create_symbols_metadata.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_symbols_metadata.c                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_symbols_metadata.h"
+#include "../symbols_metadata/symbols_metadata.h"
+
+t_symbols_metadata_array	*create_symbols_metadata(void)
+{
+	static t_symbols_metadata_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		symbols_metadata_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_symbols_metadata.c */

shcat_c/parser/src/create/create_symbols_names.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_symbols_names.c                             :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_symbols_names.h"
+#include "../symbols_names/symbols_names.h"
+
+t_symbols_names_array	*create_symbols_names(void)
+{
+	static t_symbols_names_array	table = {};
+	static bool	init = false;
+
+	if (!init)
+	{
+		symbols_names_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_symbols_names.c */

shcat_c/parser/src/create/create_unique_symbols_map.c

@@ -0,0 +1,29 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   create_unique_symbols_map.c                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../types/type_unique_symbols_map.h"
+#include "../unique_symbols_map/unique_symbols_map.h"
+
+t_unique_symbols_map_array	*create_unique_symbols_map(void)
+{
+	static t_unique_symbols_map_array	table = {};
+	static bool							init = false;
+
+	if (!init)
+	{
+		unique_symbols_map_0(&table);
+		init = true;
+	}
+	return (&table);
+}
+
+/* create_unique_symbols_map.c */

shcat_c/parser/src/external_scanner_states/external_scanner_states.h

@@ -0,0 +1,56 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_states.h                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef EXTERNAL_SCANNER_STATES_H
+# define EXTERNAL_SCANNER_STATES_H
+
+# include "../types/type_external_scanner_states.h"
+# include "../headers/symbols.h"
+# include "../headers/external_scanner_symbol_identifiers.h"
+# include "../headers/field_identifiers.h"
+
+# include "../headers/constants.h"
+
+void	external_scanner_states_0(t_external_scanner_states_array *v);
+void	external_scanner_states_1(t_external_scanner_states_array *v);
+void	external_scanner_states_2(t_external_scanner_states_array *v);
+void	external_scanner_states_3(t_external_scanner_states_array *v);
+void	external_scanner_states_4(t_external_scanner_states_array *v);
+void	external_scanner_states_5(t_external_scanner_states_array *v);
+void	external_scanner_states_6(t_external_scanner_states_array *v);
+void	external_scanner_states_7(t_external_scanner_states_array *v);
+void	external_scanner_states_8(t_external_scanner_states_array *v);
+void	external_scanner_states_9(t_external_scanner_states_array *v);
+void	external_scanner_states_10(t_external_scanner_states_array *v);
+void	external_scanner_states_11(t_external_scanner_states_array *v);
+void	external_scanner_states_12(t_external_scanner_states_array *v);
+void	external_scanner_states_13(t_external_scanner_states_array *v);
+void	external_scanner_states_14(t_external_scanner_states_array *v);
+void	external_scanner_states_15(t_external_scanner_states_array *v);
+void	external_scanner_states_16(t_external_scanner_states_array *v);
+void	external_scanner_states_17(t_external_scanner_states_array *v);
+void	external_scanner_states_18(t_external_scanner_states_array *v);
+void	external_scanner_states_19(t_external_scanner_states_array *v);
+void	external_scanner_states_20(t_external_scanner_states_array *v);
+void	external_scanner_states_21(t_external_scanner_states_array *v);
+void	external_scanner_states_22(t_external_scanner_states_array *v);
+void	external_scanner_states_23(t_external_scanner_states_array *v);
+void	external_scanner_states_24(t_external_scanner_states_array *v);
+void	external_scanner_states_25(t_external_scanner_states_array *v);
+void	external_scanner_states_26(t_external_scanner_states_array *v);
+void	external_scanner_states_27(t_external_scanner_states_array *v);
+void	external_scanner_states_28(t_external_scanner_states_array *v);
+void	external_scanner_states_29(t_external_scanner_states_array *v);
+void	external_scanner_states_30(t_external_scanner_states_array *v);
+void	external_scanner_states_31(t_external_scanner_states_array *v);
+
+#endif // EXTERNAL_SCANNER_STATES_H

shcat_c/parser/src/external_scanner_states/external_scanner_states_0.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_states_0.c                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./external_scanner_states.h"
+
+void	external_scanner_states_0(t_external_scanner_states_array *v)
+{
+	v->a[1][ts_external_token_heredoc_start] = true;
+	v->a[1][ts_external_token_simple_heredoc_body] = true;
+	v->a[1][ts_external_token__heredoc_body_beginning] = true;
+	v->a[1][ts_external_token_heredoc_content] = true;
+	v->a[1][ts_external_token_heredoc_end] = true;
+	v->a[1][ts_external_token_file_descriptor] = true;
+	v->a[1][ts_external_token__empty_value] = true;
+	v->a[1][ts_external_token__concat] = true;
+	v->a[1][ts_external_token_variable_name] = true;
+	v->a[1][ts_external_token_test_operator] = true;
+	v->a[1][ts_external_token_regex] = true;
+	v->a[1][ts_external_token__regex_no_slash] = true;
+	v->a[1][ts_external_token__regex_no_space] = true;
+	v->a[1][ts_external_token__expansion_word] = true;
+	v->a[1][ts_external_token_extglob_pattern] = true;
+	v->a[1][ts_external_token__bare_dollar] = true;
+	v->a[1][ts_external_token__brace_start] = true;
+	v->a[1][ts_external_token__immediate_double_hash] = true;
+	v->a[1][ts_external_token__external_expansion_sym_hash] = true;
+	v->a[1][ts_external_token__external_expansion_sym_bang] = true;
+	external_scanner_states_1(v);
+}
+
+void	external_scanner_states_1(t_external_scanner_states_array *v)
+{
+	v->a[1][ts_external_token__external_expansion_sym_equal] = true;
+	v->a[1][ts_external_token_RBRACE] = true;
+	v->a[1][ts_external_token_RBRACK] = true;
+	v->a[1][ts_external_token_LT_LT] = true;
+	v->a[1][ts_external_token_LT_LT_DASH] = true;
+	v->a[1][ts_external_token_LPAREN] = true;
+	v->a[1][ts_external_token_esac] = true;
+	v->a[1][ts_external_token___error_recovery] = true;
+	v->a[2][ts_external_token_file_descriptor] = true;
+	v->a[2][ts_external_token_variable_name] = true;
+	v->a[2][ts_external_token_test_operator] = true;
+	v->a[2][ts_external_token__brace_start] = true;
+	v->a[2][ts_external_token_LPAREN] = true;
+	v->a[3][ts_external_token_file_descriptor] = true;
+	v->a[3][ts_external_token_variable_name] = true;
+	v->a[3][ts_external_token_test_operator] = true;
+	v->a[3][ts_external_token__brace_start] = true;
+	v->a[3][ts_external_token_RBRACK] = true;
+	v->a[3][ts_external_token_LPAREN] = true;
+	v->a[4][ts_external_token_file_descriptor] = true;
+	external_scanner_states_2(v);
+}
+
+void	external_scanner_states_2(t_external_scanner_states_array *v)
+{
+	v->a[4][ts_external_token__concat] = true;
+	v->a[4][ts_external_token_test_operator] = true;
+	v->a[4][ts_external_token__bare_dollar] = true;
+	v->a[4][ts_external_token__brace_start] = true;
+	v->a[4][ts_external_token_LT_LT] = true;
+	v->a[4][ts_external_token_LT_LT_DASH] = true;
+	v->a[4][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[4][ts_external_token_LPAREN] = true;
+	v->a[5][ts_external_token_file_descriptor] = true;
+	v->a[5][ts_external_token__concat] = true;
+	v->a[5][ts_external_token_test_operator] = true;
+	v->a[5][ts_external_token__bare_dollar] = true;
+	v->a[5][ts_external_token__brace_start] = true;
+	v->a[5][ts_external_token_RBRACK] = true;
+	v->a[5][ts_external_token_LT_LT] = true;
+	v->a[5][ts_external_token_LT_LT_DASH] = true;
+	v->a[5][ts_external_token_LPAREN] = true;
+	v->a[6][ts_external_token_file_descriptor] = true;
+	v->a[6][ts_external_token_variable_name] = true;
+	v->a[6][ts_external_token_test_operator] = true;
+	external_scanner_states_3(v);
+}
+
+void	external_scanner_states_3(t_external_scanner_states_array *v)
+{
+	v->a[6][ts_external_token__brace_start] = true;
+	v->a[6][ts_external_token_LPAREN] = true;
+	v->a[6][ts_external_token_esac] = true;
+	v->a[7][ts_external_token__concat] = true;
+	v->a[7][ts_external_token_test_operator] = true;
+	v->a[7][ts_external_token__brace_start] = true;
+	v->a[7][ts_external_token_LT_LT] = true;
+	v->a[7][ts_external_token_LPAREN] = true;
+	v->a[8][ts_external_token__concat] = true;
+	v->a[8][ts_external_token_test_operator] = true;
+	v->a[8][ts_external_token__brace_start] = true;
+	v->a[8][ts_external_token_RBRACK] = true;
+	v->a[8][ts_external_token_LT_LT] = true;
+	v->a[8][ts_external_token_LPAREN] = true;
+	v->a[9][ts_external_token_file_descriptor] = true;
+	v->a[9][ts_external_token_variable_name] = true;
+	v->a[9][ts_external_token_test_operator] = true;
+	v->a[9][ts_external_token__bare_dollar] = true;
+	v->a[9][ts_external_token__brace_start] = true;
+	v->a[9][ts_external_token_LT_LT] = true;
+	external_scanner_states_4(v);
+}
+
+void	external_scanner_states_4(t_external_scanner_states_array *v)
+{
+	v->a[9][ts_external_token_LT_LT_DASH] = true;
+	v->a[9][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[9][ts_external_token_LPAREN] = true;
+	v->a[10][ts_external_token_file_descriptor] = true;
+	v->a[10][ts_external_token_variable_name] = true;
+	v->a[10][ts_external_token_test_operator] = true;
+	v->a[10][ts_external_token__bare_dollar] = true;
+	v->a[10][ts_external_token__brace_start] = true;
+	v->a[10][ts_external_token_RBRACK] = true;
+	v->a[10][ts_external_token_LT_LT] = true;
+	v->a[10][ts_external_token_LT_LT_DASH] = true;
+	v->a[10][ts_external_token_LPAREN] = true;
+	v->a[11][ts_external_token_file_descriptor] = true;
+	v->a[11][ts_external_token_test_operator] = true;
+	v->a[11][ts_external_token__bare_dollar] = true;
+	v->a[11][ts_external_token__brace_start] = true;
+	v->a[11][ts_external_token_LT_LT] = true;
+	v->a[11][ts_external_token_LT_LT_DASH] = true;
+	v->a[11][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[11][ts_external_token_LPAREN] = true;
+	external_scanner_states_5(v);
+}
+
+/* EOF external_scanner_states_0.c */

shcat_c/parser/src/external_scanner_states/external_scanner_states_1.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_states_1.c                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./external_scanner_states.h"
+
+void	external_scanner_states_5(t_external_scanner_states_array *v)
+{
+	v->a[12][ts_external_token_file_descriptor] = true;
+	v->a[12][ts_external_token_test_operator] = true;
+	v->a[12][ts_external_token__bare_dollar] = true;
+	v->a[12][ts_external_token__brace_start] = true;
+	v->a[12][ts_external_token_RBRACK] = true;
+	v->a[12][ts_external_token_LT_LT] = true;
+	v->a[12][ts_external_token_LT_LT_DASH] = true;
+	v->a[12][ts_external_token_LPAREN] = true;
+	v->a[13][ts_external_token_file_descriptor] = true;
+	v->a[13][ts_external_token_test_operator] = true;
+	v->a[13][ts_external_token__bare_dollar] = true;
+	v->a[13][ts_external_token__brace_start] = true;
+	v->a[13][ts_external_token_LT_LT] = true;
+	v->a[13][ts_external_token_LT_LT_DASH] = true;
+	v->a[13][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[13][ts_external_token_LPAREN] = true;
+	v->a[13][ts_external_token_esac] = true;
+	v->a[14][ts_external_token_file_descriptor] = true;
+	v->a[14][ts_external_token_test_operator] = true;
+	v->a[14][ts_external_token__bare_dollar] = true;
+	external_scanner_states_6(v);
+}
+
+void	external_scanner_states_6(t_external_scanner_states_array *v)
+{
+	v->a[14][ts_external_token__brace_start] = true;
+	v->a[14][ts_external_token_LT_LT] = true;
+	v->a[14][ts_external_token_LT_LT_DASH] = true;
+	v->a[14][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[14][ts_external_token_esac] = true;
+	v->a[15][ts_external_token_file_descriptor] = true;
+	v->a[15][ts_external_token_variable_name] = true;
+	v->a[15][ts_external_token_test_operator] = true;
+	v->a[15][ts_external_token__bare_dollar] = true;
+	v->a[15][ts_external_token__brace_start] = true;
+	v->a[15][ts_external_token_LT_LT] = true;
+	v->a[15][ts_external_token_LT_LT_DASH] = true;
+	v->a[15][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[15][ts_external_token_LPAREN] = true;
+	v->a[15][ts_external_token_esac] = true;
+	v->a[16][ts_external_token_file_descriptor] = true;
+	v->a[16][ts_external_token_test_operator] = true;
+	v->a[16][ts_external_token__bare_dollar] = true;
+	v->a[16][ts_external_token__brace_start] = true;
+	v->a[16][ts_external_token_LT_LT] = true;
+	external_scanner_states_7(v);
+}
+
+void	external_scanner_states_7(t_external_scanner_states_array *v)
+{
+	v->a[16][ts_external_token_LT_LT_DASH] = true;
+	v->a[16][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[17][ts_external_token_file_descriptor] = true;
+	v->a[17][ts_external_token_variable_name] = true;
+	v->a[17][ts_external_token_test_operator] = true;
+	v->a[17][ts_external_token__brace_start] = true;
+	v->a[17][ts_external_token_LT_LT] = true;
+	v->a[17][ts_external_token_LT_LT_DASH] = true;
+	v->a[17][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[17][ts_external_token_esac] = true;
+	v->a[18][ts_external_token_file_descriptor] = true;
+	v->a[18][ts_external_token_variable_name] = true;
+	v->a[18][ts_external_token_test_operator] = true;
+	v->a[18][ts_external_token__bare_dollar] = true;
+	v->a[18][ts_external_token__brace_start] = true;
+	v->a[18][ts_external_token_LT_LT] = true;
+	v->a[18][ts_external_token_LT_LT_DASH] = true;
+	v->a[18][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[18][ts_external_token_esac] = true;
+	v->a[19][ts_external_token_file_descriptor] = true;
+	external_scanner_states_8(v);
+}
+
+void	external_scanner_states_8(t_external_scanner_states_array *v)
+{
+	v->a[19][ts_external_token_variable_name] = true;
+	v->a[19][ts_external_token_test_operator] = true;
+	v->a[19][ts_external_token__brace_start] = true;
+	v->a[19][ts_external_token_LT_LT] = true;
+	v->a[19][ts_external_token_LT_LT_DASH] = true;
+	v->a[19][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[20][ts_external_token_file_descriptor] = true;
+	v->a[20][ts_external_token_variable_name] = true;
+	v->a[20][ts_external_token_test_operator] = true;
+	v->a[20][ts_external_token__bare_dollar] = true;
+	v->a[20][ts_external_token__brace_start] = true;
+	v->a[20][ts_external_token_LT_LT] = true;
+	v->a[20][ts_external_token_LT_LT_DASH] = true;
+	v->a[20][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[21][ts_external_token_file_descriptor] = true;
+	v->a[21][ts_external_token_test_operator] = true;
+	v->a[21][ts_external_token__brace_start] = true;
+	v->a[21][ts_external_token_LT_LT] = true;
+	v->a[21][ts_external_token_LT_LT_DASH] = true;
+	v->a[21][ts_external_token_heredoc_redirect_token1] = true;
+	external_scanner_states_9(v);
+}
+
+void	external_scanner_states_9(t_external_scanner_states_array *v)
+{
+	v->a[21][ts_external_token_esac] = true;
+	v->a[22][ts_external_token_file_descriptor] = true;
+	v->a[22][ts_external_token_test_operator] = true;
+	v->a[22][ts_external_token__brace_start] = true;
+	v->a[22][ts_external_token_LT_LT] = true;
+	v->a[22][ts_external_token_LT_LT_DASH] = true;
+	v->a[22][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[23][ts_external_token_file_descriptor] = true;
+	v->a[23][ts_external_token_test_operator] = true;
+	v->a[23][ts_external_token__bare_dollar] = true;
+	v->a[23][ts_external_token__brace_start] = true;
+	v->a[23][ts_external_token_LT_LT] = true;
+	v->a[23][ts_external_token_LT_LT_DASH] = true;
+	v->a[23][ts_external_token_LPAREN] = true;
+	v->a[24][ts_external_token_variable_name] = true;
+	v->a[24][ts_external_token_test_operator] = true;
+	v->a[24][ts_external_token__brace_start] = true;
+	v->a[24][ts_external_token_LPAREN] = true;
+	v->a[25][ts_external_token_file_descriptor] = true;
+	v->a[25][ts_external_token_test_operator] = true;
+	external_scanner_states_10(v);
+}
+
+/* EOF external_scanner_states_1.c */

shcat_c/parser/src/external_scanner_states/external_scanner_states_2.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_states_2.c                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./external_scanner_states.h"
+
+void	external_scanner_states_10(t_external_scanner_states_array *v)
+{
+	v->a[25][ts_external_token__bare_dollar] = true;
+	v->a[25][ts_external_token__brace_start] = true;
+	v->a[25][ts_external_token_LT_LT] = true;
+	v->a[25][ts_external_token_LT_LT_DASH] = true;
+	v->a[26][ts_external_token_file_descriptor] = true;
+	v->a[26][ts_external_token_test_operator] = true;
+	v->a[26][ts_external_token__brace_start] = true;
+	v->a[26][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[27][ts_external_token_file_descriptor] = true;
+	v->a[27][ts_external_token_variable_name] = true;
+	v->a[27][ts_external_token_test_operator] = true;
+	v->a[27][ts_external_token__bare_dollar] = true;
+	v->a[27][ts_external_token__brace_start] = true;
+	v->a[27][ts_external_token_LT_LT] = true;
+	v->a[27][ts_external_token_LT_LT_DASH] = true;
+	v->a[27][ts_external_token_LPAREN] = true;
+	v->a[28][ts_external_token_file_descriptor] = true;
+	v->a[28][ts_external_token_variable_name] = true;
+	v->a[28][ts_external_token_test_operator] = true;
+	v->a[28][ts_external_token__bare_dollar] = true;
+	external_scanner_states_11(v);
+}
+
+void	external_scanner_states_11(t_external_scanner_states_array *v)
+{
+	v->a[28][ts_external_token__brace_start] = true;
+	v->a[28][ts_external_token_LT_LT] = true;
+	v->a[28][ts_external_token_LT_LT_DASH] = true;
+	v->a[29][ts_external_token_file_descriptor] = true;
+	v->a[29][ts_external_token_variable_name] = true;
+	v->a[29][ts_external_token_test_operator] = true;
+	v->a[29][ts_external_token__brace_start] = true;
+	v->a[29][ts_external_token_LT_LT] = true;
+	v->a[29][ts_external_token_LT_LT_DASH] = true;
+	v->a[30][ts_external_token_file_descriptor] = true;
+	v->a[30][ts_external_token__concat] = true;
+	v->a[30][ts_external_token_test_operator] = true;
+	v->a[30][ts_external_token__bare_dollar] = true;
+	v->a[30][ts_external_token__brace_start] = true;
+	v->a[30][ts_external_token_LT_LT] = true;
+	v->a[30][ts_external_token_LT_LT_DASH] = true;
+	v->a[30][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[30][ts_external_token_LPAREN] = true;
+	v->a[30][ts_external_token_esac] = true;
+	v->a[31][ts_external_token_file_descriptor] = true;
+	external_scanner_states_12(v);
+}
+
+void	external_scanner_states_12(t_external_scanner_states_array *v)
+{
+	v->a[31][ts_external_token_variable_name] = true;
+	v->a[31][ts_external_token_test_operator] = true;
+	v->a[31][ts_external_token__brace_start] = true;
+	v->a[31][ts_external_token_RBRACK] = true;
+	v->a[31][ts_external_token_LT_LT] = true;
+	v->a[31][ts_external_token_LT_LT_DASH] = true;
+	v->a[32][ts_external_token_file_descriptor] = true;
+	v->a[32][ts_external_token__concat] = true;
+	v->a[32][ts_external_token_test_operator] = true;
+	v->a[32][ts_external_token__bare_dollar] = true;
+	v->a[32][ts_external_token__brace_start] = true;
+	v->a[32][ts_external_token_LT_LT] = true;
+	v->a[32][ts_external_token_LT_LT_DASH] = true;
+	v->a[32][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[32][ts_external_token_esac] = true;
+	v->a[33][ts_external_token_file_descriptor] = true;
+	v->a[33][ts_external_token_test_operator] = true;
+	v->a[33][ts_external_token__brace_start] = true;
+	v->a[33][ts_external_token_RBRACK] = true;
+	v->a[33][ts_external_token_LT_LT] = true;
+	external_scanner_states_13(v);
+}
+
+void	external_scanner_states_13(t_external_scanner_states_array *v)
+{
+	v->a[33][ts_external_token_LT_LT_DASH] = true;
+	v->a[34][ts_external_token_file_descriptor] = true;
+	v->a[34][ts_external_token_test_operator] = true;
+	v->a[34][ts_external_token__brace_start] = true;
+	v->a[34][ts_external_token_LT_LT] = true;
+	v->a[34][ts_external_token_LT_LT_DASH] = true;
+	v->a[35][ts_external_token__concat] = true;
+	v->a[35][ts_external_token_variable_name] = true;
+	v->a[35][ts_external_token_test_operator] = true;
+	v->a[35][ts_external_token_RBRACK] = true;
+	v->a[35][ts_external_token_LT_LT] = true;
+	v->a[36][ts_external_token_file_descriptor] = true;
+	v->a[36][ts_external_token_variable_name] = true;
+	v->a[36][ts_external_token_test_operator] = true;
+	v->a[36][ts_external_token__brace_start] = true;
+	v->a[37][ts_external_token_file_descriptor] = true;
+	v->a[37][ts_external_token__concat] = true;
+	v->a[37][ts_external_token_test_operator] = true;
+	v->a[37][ts_external_token__bare_dollar] = true;
+	v->a[37][ts_external_token__brace_start] = true;
+	external_scanner_states_14(v);
+}
+
+void	external_scanner_states_14(t_external_scanner_states_array *v)
+{
+	v->a[37][ts_external_token_LT_LT] = true;
+	v->a[37][ts_external_token_LT_LT_DASH] = true;
+	v->a[37][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[38][ts_external_token_file_descriptor] = true;
+	v->a[38][ts_external_token__concat] = true;
+	v->a[38][ts_external_token_variable_name] = true;
+	v->a[38][ts_external_token_test_operator] = true;
+	v->a[38][ts_external_token__brace_start] = true;
+	v->a[38][ts_external_token_LT_LT] = true;
+	v->a[38][ts_external_token_LT_LT_DASH] = true;
+	v->a[38][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[38][ts_external_token_esac] = true;
+	v->a[39][ts_external_token_variable_name] = true;
+	v->a[39][ts_external_token_test_operator] = true;
+	v->a[39][ts_external_token_LT_LT] = true;
+	v->a[40][ts_external_token_variable_name] = true;
+	v->a[40][ts_external_token_test_operator] = true;
+	v->a[40][ts_external_token_RBRACK] = true;
+	v->a[40][ts_external_token_LT_LT] = true;
+	v->a[41][ts_external_token_file_descriptor] = true;
+	external_scanner_states_15(v);
+}
+
+/* EOF external_scanner_states_2.c */

shcat_c/parser/src/external_scanner_states/external_scanner_states_3.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_states_3.c                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./external_scanner_states.h"
+
+void	external_scanner_states_15(t_external_scanner_states_array *v)
+{
+	v->a[41][ts_external_token__concat] = true;
+	v->a[41][ts_external_token_variable_name] = true;
+	v->a[41][ts_external_token_test_operator] = true;
+	v->a[41][ts_external_token__brace_start] = true;
+	v->a[41][ts_external_token_LT_LT] = true;
+	v->a[41][ts_external_token_LT_LT_DASH] = true;
+	v->a[41][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[42][ts_external_token_test_operator] = true;
+	v->a[42][ts_external_token_LT_LT] = true;
+	v->a[43][ts_external_token_file_descriptor] = true;
+	v->a[43][ts_external_token__concat] = true;
+	v->a[43][ts_external_token_test_operator] = true;
+	v->a[43][ts_external_token__brace_start] = true;
+	v->a[43][ts_external_token_LT_LT] = true;
+	v->a[43][ts_external_token_LT_LT_DASH] = true;
+	v->a[43][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[43][ts_external_token_esac] = true;
+	v->a[44][ts_external_token_file_descriptor] = true;
+	v->a[44][ts_external_token__concat] = true;
+	v->a[44][ts_external_token_test_operator] = true;
+	external_scanner_states_16(v);
+}
+
+void	external_scanner_states_16(t_external_scanner_states_array *v)
+{
+	v->a[44][ts_external_token__brace_start] = true;
+	v->a[44][ts_external_token_LT_LT] = true;
+	v->a[44][ts_external_token_LT_LT_DASH] = true;
+	v->a[44][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[45][ts_external_token__concat] = true;
+	v->a[45][ts_external_token_test_operator] = true;
+	v->a[45][ts_external_token_RBRACK] = true;
+	v->a[45][ts_external_token_LT_LT] = true;
+	v->a[46][ts_external_token_file_descriptor] = true;
+	v->a[46][ts_external_token_variable_name] = true;
+	v->a[46][ts_external_token_test_operator] = true;
+	v->a[46][ts_external_token__brace_start] = true;
+	v->a[46][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[47][ts_external_token_test_operator] = true;
+	v->a[47][ts_external_token_extglob_pattern] = true;
+	v->a[47][ts_external_token__brace_start] = true;
+	v->a[47][ts_external_token_LPAREN] = true;
+	v->a[48][ts_external_token_test_operator] = true;
+	v->a[48][ts_external_token_RBRACK] = true;
+	v->a[48][ts_external_token_LT_LT] = true;
+	external_scanner_states_17(v);
+}
+
+void	external_scanner_states_17(t_external_scanner_states_array *v)
+{
+	v->a[49][ts_external_token_test_operator] = true;
+	v->a[49][ts_external_token__brace_start] = true;
+	v->a[49][ts_external_token_LPAREN] = true;
+	v->a[50][ts_external_token_test_operator] = true;
+	v->a[50][ts_external_token__regex_no_space] = true;
+	v->a[50][ts_external_token__brace_start] = true;
+	v->a[50][ts_external_token_LPAREN] = true;
+	v->a[51][ts_external_token_file_descriptor] = true;
+	v->a[51][ts_external_token__concat] = true;
+	v->a[51][ts_external_token_test_operator] = true;
+	v->a[51][ts_external_token__bare_dollar] = true;
+	v->a[51][ts_external_token__brace_start] = true;
+	v->a[51][ts_external_token_LT_LT] = true;
+	v->a[51][ts_external_token_LT_LT_DASH] = true;
+	v->a[51][ts_external_token_LPAREN] = true;
+	v->a[52][ts_external_token_file_descriptor] = true;
+	v->a[52][ts_external_token__concat] = true;
+	v->a[52][ts_external_token_test_operator] = true;
+	v->a[52][ts_external_token__bare_dollar] = true;
+	v->a[52][ts_external_token__brace_start] = true;
+	external_scanner_states_18(v);
+}
+
+void	external_scanner_states_18(t_external_scanner_states_array *v)
+{
+	v->a[52][ts_external_token_LT_LT] = true;
+	v->a[52][ts_external_token_LT_LT_DASH] = true;
+	v->a[53][ts_external_token_file_descriptor] = true;
+	v->a[53][ts_external_token__concat] = true;
+	v->a[53][ts_external_token_variable_name] = true;
+	v->a[53][ts_external_token_test_operator] = true;
+	v->a[53][ts_external_token__brace_start] = true;
+	v->a[53][ts_external_token_RBRACK] = true;
+	v->a[53][ts_external_token_LT_LT] = true;
+	v->a[53][ts_external_token_LT_LT_DASH] = true;
+	v->a[54][ts_external_token__concat] = true;
+	v->a[54][ts_external_token_test_operator] = true;
+	v->a[54][ts_external_token_LT_LT] = true;
+	v->a[55][ts_external_token_test_operator] = true;
+	v->a[55][ts_external_token_extglob_pattern] = true;
+	v->a[55][ts_external_token__brace_start] = true;
+	v->a[55][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[55][ts_external_token_LPAREN] = true;
+	v->a[55][ts_external_token_esac] = true;
+	v->a[56][ts_external_token_file_descriptor] = true;
+	external_scanner_states_19(v);
+}
+
+void	external_scanner_states_19(t_external_scanner_states_array *v)
+{
+	v->a[56][ts_external_token__concat] = true;
+	v->a[56][ts_external_token_variable_name] = true;
+	v->a[56][ts_external_token_test_operator] = true;
+	v->a[56][ts_external_token__brace_start] = true;
+	v->a[56][ts_external_token_LT_LT] = true;
+	v->a[56][ts_external_token_LT_LT_DASH] = true;
+	v->a[57][ts_external_token_file_descriptor] = true;
+	v->a[57][ts_external_token__concat] = true;
+	v->a[57][ts_external_token_test_operator] = true;
+	v->a[57][ts_external_token__brace_start] = true;
+	v->a[57][ts_external_token_RBRACK] = true;
+	v->a[57][ts_external_token_LT_LT] = true;
+	v->a[57][ts_external_token_LT_LT_DASH] = true;
+	v->a[58][ts_external_token_test_operator] = true;
+	v->a[58][ts_external_token_extglob_pattern] = true;
+	v->a[58][ts_external_token_LT_LT] = true;
+	v->a[59][ts_external_token_file_descriptor] = true;
+	v->a[59][ts_external_token__concat] = true;
+	v->a[59][ts_external_token_test_operator] = true;
+	v->a[59][ts_external_token__brace_start] = true;
+	external_scanner_states_20(v);
+}
+
+/* EOF external_scanner_states_3.c */

shcat_c/parser/src/external_scanner_states/external_scanner_states_4.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_states_4.c                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./external_scanner_states.h"
+
+void	external_scanner_states_20(t_external_scanner_states_array *v)
+{
+	v->a[59][ts_external_token_LT_LT] = true;
+	v->a[59][ts_external_token_LT_LT_DASH] = true;
+	v->a[60][ts_external_token_LT_LT] = true;
+	v->a[61][ts_external_token__concat] = true;
+	v->a[61][ts_external_token_test_operator] = true;
+	v->a[61][ts_external_token_extglob_pattern] = true;
+	v->a[61][ts_external_token_RBRACK] = true;
+	v->a[61][ts_external_token_LT_LT] = true;
+	v->a[62][ts_external_token__concat] = true;
+	v->a[62][ts_external_token_LT_LT] = true;
+	v->a[63][ts_external_token_file_descriptor] = true;
+	v->a[63][ts_external_token_variable_name] = true;
+	v->a[63][ts_external_token_LT_LT] = true;
+	v->a[63][ts_external_token_LT_LT_DASH] = true;
+	v->a[63][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[63][ts_external_token_esac] = true;
+	v->a[64][ts_external_token_LT_LT] = true;
+	v->a[64][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[65][ts_external_token_test_operator] = true;
+	v->a[65][ts_external_token_extglob_pattern] = true;
+	external_scanner_states_21(v);
+}
+
+void	external_scanner_states_21(t_external_scanner_states_array *v)
+{
+	v->a[65][ts_external_token_RBRACK] = true;
+	v->a[65][ts_external_token_LT_LT] = true;
+	v->a[66][ts_external_token_file_descriptor] = true;
+	v->a[66][ts_external_token_variable_name] = true;
+	v->a[66][ts_external_token_LT_LT] = true;
+	v->a[66][ts_external_token_LT_LT_DASH] = true;
+	v->a[66][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[67][ts_external_token_test_operator] = true;
+	v->a[67][ts_external_token_extglob_pattern] = true;
+	v->a[67][ts_external_token__brace_start] = true;
+	v->a[67][ts_external_token_LPAREN] = true;
+	v->a[67][ts_external_token_esac] = true;
+	v->a[68][ts_external_token__concat] = true;
+	v->a[68][ts_external_token_RBRACK] = true;
+	v->a[68][ts_external_token_LT_LT] = true;
+	v->a[69][ts_external_token_RBRACK] = true;
+	v->a[69][ts_external_token_LT_LT] = true;
+	v->a[70][ts_external_token_file_descriptor] = true;
+	v->a[70][ts_external_token__concat] = true;
+	v->a[70][ts_external_token_test_operator] = true;
+	external_scanner_states_22(v);
+}
+
+void	external_scanner_states_22(t_external_scanner_states_array *v)
+{
+	v->a[70][ts_external_token__brace_start] = true;
+	v->a[70][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[71][ts_external_token_file_descriptor] = true;
+	v->a[71][ts_external_token__concat] = true;
+	v->a[71][ts_external_token_variable_name] = true;
+	v->a[71][ts_external_token_test_operator] = true;
+	v->a[71][ts_external_token__brace_start] = true;
+	v->a[72][ts_external_token_variable_name] = true;
+	v->a[72][ts_external_token_test_operator] = true;
+	v->a[72][ts_external_token__brace_start] = true;
+	v->a[72][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[73][ts_external_token_test_operator] = true;
+	v->a[73][ts_external_token__brace_start] = true;
+	v->a[73][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[74][ts_external_token_variable_name] = true;
+	v->a[74][ts_external_token_test_operator] = true;
+	v->a[74][ts_external_token__expansion_word] = true;
+	v->a[74][ts_external_token__brace_start] = true;
+	v->a[74][ts_external_token_RBRACE] = true;
+	v->a[74][ts_external_token_LPAREN] = true;
+	external_scanner_states_23(v);
+}
+
+void	external_scanner_states_23(t_external_scanner_states_array *v)
+{
+	v->a[75][ts_external_token__empty_value] = true;
+	v->a[75][ts_external_token_test_operator] = true;
+	v->a[75][ts_external_token__brace_start] = true;
+	v->a[75][ts_external_token_LPAREN] = true;
+	v->a[76][ts_external_token__immediate_double_hash] = true;
+	v->a[76][ts_external_token__external_expansion_sym_hash] = true;
+	v->a[76][ts_external_token__external_expansion_sym_bang] = true;
+	v->a[76][ts_external_token__external_expansion_sym_equal] = true;
+	v->a[76][ts_external_token_RBRACE] = true;
+	v->a[77][ts_external_token_file_descriptor] = true;
+	v->a[77][ts_external_token_variable_name] = true;
+	v->a[77][ts_external_token_RBRACK] = true;
+	v->a[77][ts_external_token_LT_LT] = true;
+	v->a[77][ts_external_token_LT_LT_DASH] = true;
+	v->a[78][ts_external_token_test_operator] = true;
+	v->a[78][ts_external_token__brace_start] = true;
+	v->a[79][ts_external_token_test_operator] = true;
+	v->a[79][ts_external_token_extglob_pattern] = true;
+	v->a[79][ts_external_token__brace_start] = true;
+	v->a[80][ts_external_token_variable_name] = true;
+	external_scanner_states_24(v);
+}
+
+void	external_scanner_states_24(t_external_scanner_states_array *v)
+{
+	v->a[80][ts_external_token_test_operator] = true;
+	v->a[80][ts_external_token__brace_start] = true;
+	v->a[81][ts_external_token_file_descriptor] = true;
+	v->a[81][ts_external_token_variable_name] = true;
+	v->a[81][ts_external_token_LT_LT] = true;
+	v->a[81][ts_external_token_LT_LT_DASH] = true;
+	v->a[82][ts_external_token_test_operator] = true;
+	v->a[82][ts_external_token__bare_dollar] = true;
+	v->a[82][ts_external_token__brace_start] = true;
+	v->a[82][ts_external_token_RBRACK] = true;
+	v->a[83][ts_external_token_test_operator] = true;
+	v->a[83][ts_external_token_regex] = true;
+	v->a[83][ts_external_token__brace_start] = true;
+	v->a[84][ts_external_token__immediate_double_hash] = true;
+	v->a[84][ts_external_token_RBRACE] = true;
+	v->a[85][ts_external_token_test_operator] = true;
+	v->a[85][ts_external_token__bare_dollar] = true;
+	v->a[85][ts_external_token__brace_start] = true;
+	v->a[86][ts_external_token_variable_name] = true;
+	v->a[86][ts_external_token_LPAREN] = true;
+	external_scanner_states_25(v);
+}
+
+/* EOF external_scanner_states_4.c */

shcat_c/parser/src/external_scanner_states/external_scanner_states_5.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_states_5.c                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./external_scanner_states.h"
+
+void	external_scanner_states_25(t_external_scanner_states_array *v)
+{
+	v->a[87][ts_external_token_file_descriptor] = true;
+	v->a[87][ts_external_token_variable_name] = true;
+	v->a[87][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[88][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[88][ts_external_token_LPAREN] = true;
+	v->a[89][ts_external_token_file_descriptor] = true;
+	v->a[89][ts_external_token__concat] = true;
+	v->a[89][ts_external_token_LT_LT] = true;
+	v->a[89][ts_external_token_LT_LT_DASH] = true;
+	v->a[89][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[89][ts_external_token_esac] = true;
+	v->a[90][ts_external_token__immediate_double_hash] = true;
+	v->a[91][ts_external_token_file_descriptor] = true;
+	v->a[91][ts_external_token__concat] = true;
+	v->a[91][ts_external_token_variable_name] = true;
+	v->a[91][ts_external_token_LT_LT] = true;
+	v->a[91][ts_external_token_LT_LT_DASH] = true;
+	v->a[91][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[91][ts_external_token_esac] = true;
+	v->a[92][ts_external_token_file_descriptor] = true;
+	external_scanner_states_26(v);
+}
+
+void	external_scanner_states_26(t_external_scanner_states_array *v)
+{
+	v->a[92][ts_external_token_LT_LT] = true;
+	v->a[92][ts_external_token_LT_LT_DASH] = true;
+	v->a[92][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[92][ts_external_token_esac] = true;
+	v->a[93][ts_external_token_file_descriptor] = true;
+	v->a[93][ts_external_token__concat] = true;
+	v->a[93][ts_external_token_LT_LT] = true;
+	v->a[93][ts_external_token_LT_LT_DASH] = true;
+	v->a[93][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[94][ts_external_token_file_descriptor] = true;
+	v->a[94][ts_external_token_LT_LT] = true;
+	v->a[94][ts_external_token_LT_LT_DASH] = true;
+	v->a[94][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[95][ts_external_token_file_descriptor] = true;
+	v->a[95][ts_external_token__concat] = true;
+	v->a[95][ts_external_token_variable_name] = true;
+	v->a[95][ts_external_token_LT_LT] = true;
+	v->a[95][ts_external_token_LT_LT_DASH] = true;
+	v->a[95][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[96][ts_external_token__concat] = true;
+	external_scanner_states_27(v);
+}
+
+void	external_scanner_states_27(t_external_scanner_states_array *v)
+{
+	v->a[96][ts_external_token__immediate_double_hash] = true;
+	v->a[96][ts_external_token__external_expansion_sym_hash] = true;
+	v->a[96][ts_external_token__external_expansion_sym_bang] = true;
+	v->a[96][ts_external_token__external_expansion_sym_equal] = true;
+	v->a[96][ts_external_token_RBRACE] = true;
+	v->a[97][ts_external_token__concat] = true;
+	v->a[97][ts_external_token_test_operator] = true;
+	v->a[97][ts_external_token__brace_start] = true;
+	v->a[97][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[98][ts_external_token_variable_name] = true;
+	v->a[98][ts_external_token__external_expansion_sym_hash] = true;
+	v->a[98][ts_external_token__external_expansion_sym_bang] = true;
+	v->a[98][ts_external_token__external_expansion_sym_equal] = true;
+	v->a[98][ts_external_token_RBRACE] = true;
+	v->a[99][ts_external_token_LPAREN] = true;
+	v->a[100][ts_external_token__concat] = true;
+	v->a[100][ts_external_token_test_operator] = true;
+	v->a[100][ts_external_token__brace_start] = true;
+	v->a[101][ts_external_token_file_descriptor] = true;
+	v->a[101][ts_external_token__concat] = true;
+	external_scanner_states_28(v);
+}
+
+void	external_scanner_states_28(t_external_scanner_states_array *v)
+{
+	v->a[101][ts_external_token_RBRACK] = true;
+	v->a[101][ts_external_token_LT_LT] = true;
+	v->a[101][ts_external_token_LT_LT_DASH] = true;
+	v->a[102][ts_external_token_file_descriptor] = true;
+	v->a[102][ts_external_token_RBRACK] = true;
+	v->a[102][ts_external_token_LT_LT] = true;
+	v->a[102][ts_external_token_LT_LT_DASH] = true;
+	v->a[103][ts_external_token_file_descriptor] = true;
+	v->a[103][ts_external_token_LT_LT] = true;
+	v->a[103][ts_external_token_LT_LT_DASH] = true;
+	v->a[104][ts_external_token_RBRACE] = true;
+	v->a[104][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[104][ts_external_token_LPAREN] = true;
+	v->a[105][ts_external_token_file_descriptor] = true;
+	v->a[105][ts_external_token__concat] = true;
+	v->a[105][ts_external_token_variable_name] = true;
+	v->a[105][ts_external_token_LT_LT] = true;
+	v->a[105][ts_external_token_LT_LT_DASH] = true;
+	v->a[106][ts_external_token_file_descriptor] = true;
+	v->a[106][ts_external_token__concat] = true;
+	external_scanner_states_29(v);
+}
+
+void	external_scanner_states_29(t_external_scanner_states_array *v)
+{
+	v->a[106][ts_external_token_LT_LT] = true;
+	v->a[106][ts_external_token_LT_LT_DASH] = true;
+	v->a[107][ts_external_token_variable_name] = true;
+	v->a[107][ts_external_token__expansion_word] = true;
+	v->a[107][ts_external_token_RBRACE] = true;
+	v->a[107][ts_external_token_LPAREN] = true;
+	v->a[108][ts_external_token_variable_name] = true;
+	v->a[108][ts_external_token__expansion_word] = true;
+	v->a[108][ts_external_token_LPAREN] = true;
+	v->a[109][ts_external_token_variable_name] = true;
+	v->a[109][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[110][ts_external_token_file_descriptor] = true;
+	v->a[110][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[111][ts_external_token_file_descriptor] = true;
+	v->a[111][ts_external_token__concat] = true;
+	v->a[111][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[112][ts_external_token_variable_name] = true;
+	v->a[113][ts_external_token_LT_LT] = true;
+	v->a[113][ts_external_token_LT_LT_DASH] = true;
+	v->a[114][ts_external_token_RBRACE] = true;
+	external_scanner_states_30(v);
+}
+
+/* EOF external_scanner_states_5.c */

shcat_c/parser/src/external_scanner_states/external_scanner_states_6.c

@@ -0,0 +1,55 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_states_6.c                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./external_scanner_states.h"
+
+void	external_scanner_states_30(t_external_scanner_states_array *v)
+{
+	v->a[115][ts_external_token__concat] = true;
+	v->a[116][ts_external_token_heredoc_content] = true;
+	v->a[116][ts_external_token_heredoc_end] = true;
+	v->a[117][ts_external_token__regex_no_slash] = true;
+	v->a[117][ts_external_token_RBRACE] = true;
+	v->a[118][ts_external_token__concat] = true;
+	v->a[118][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[119][ts_external_token_regex] = true;
+	v->a[119][ts_external_token_RBRACE] = true;
+	v->a[120][ts_external_token_heredoc_redirect_token1] = true;
+	v->a[121][ts_external_token__concat] = true;
+	v->a[121][ts_external_token__expansion_word] = true;
+	v->a[121][ts_external_token_RBRACE] = true;
+	v->a[122][ts_external_token_simple_heredoc_body] = true;
+	v->a[122][ts_external_token__heredoc_body_beginning] = true;
+	v->a[123][ts_external_token__concat] = true;
+	v->a[123][ts_external_token__external_expansion_sym_hash] = true;
+	v->a[123][ts_external_token__external_expansion_sym_bang] = true;
+	v->a[123][ts_external_token__external_expansion_sym_equal] = true;
+	v->a[123][ts_external_token_RBRACE] = true;
+	external_scanner_states_31(v);
+}
+
+void	external_scanner_states_31(t_external_scanner_states_array *v)
+{
+	v->a[124][ts_external_token__concat] = true;
+	v->a[124][ts_external_token_RBRACE] = true;
+	v->a[125][ts_external_token__external_expansion_sym_hash] = true;
+	v->a[125][ts_external_token__external_expansion_sym_bang] = true;
+	v->a[125][ts_external_token__external_expansion_sym_equal] = true;
+	v->a[125][ts_external_token_RBRACE] = true;
+	v->a[126][ts_external_token_esac] = true;
+	v->a[127][ts_external_token_extglob_pattern] = true;
+	v->a[128][ts_external_token_heredoc_end] = true;
+	v->a[129][ts_external_token_RBRACK] = true;
+	v->a[130][ts_external_token_heredoc_start] = true;
+}
+
+/* EOF external_scanner_states_6.c */

shcat_c/parser/src/external_scanner_symbol_map/external_scanner_symbol_map.h

@@ -0,0 +1,26 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_symbol_map.h                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef EXTERNAL_SCANNER_SYMBOL_MAP_H
+# define EXTERNAL_SCANNER_SYMBOL_MAP_H
+
+# include "../types/type_external_scanner_symbol_map.h"
+# include "../headers/symbols.h"
+# include "../headers/external_scanner_symbol_identifiers.h"
+# include "../headers/field_identifiers.h"
+
+# include "../headers/constants.h"
+
+void	external_scanner_symbol_map_0(t_external_scanner_symbol_map_array *v);
+void	external_scanner_symbol_map_1(t_external_scanner_symbol_map_array *v);
+
+#endif // EXTERNAL_SCANNER_SYMBOL_MAP_H

shcat_c/parser/src/external_scanner_symbol_map/external_scanner_symbol_map_0.c

@@ -0,0 +1,59 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_symbol_map_0.c                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./external_scanner_symbol_map.h"
+
+void	external_scanner_symbol_map_0(t_external_scanner_symbol_map_array *v)
+{
+	v->a[ts_external_token_heredoc_start] = sym_heredoc_start;
+	v->a[ts_external_token_simple_heredoc_body] = sym_simple_heredoc_body;
+	v->a[ts_external_token__heredoc_body_beginning] \
+	= sym__heredoc_body_beginning;
+	v->a[ts_external_token_heredoc_content] = sym_heredoc_content;
+	v->a[ts_external_token_heredoc_end] = sym_heredoc_end;
+	v->a[ts_external_token_file_descriptor] = sym_file_descriptor;
+	v->a[ts_external_token__empty_value] = sym__empty_value;
+	v->a[ts_external_token__concat] = sym__concat;
+	v->a[ts_external_token_variable_name] = sym_variable_name;
+	v->a[ts_external_token_test_operator] = sym_test_operator;
+	v->a[ts_external_token_regex] = sym_regex;
+	v->a[ts_external_token__regex_no_slash] = sym__regex_no_slash;
+	v->a[ts_external_token__regex_no_space] = sym__regex_no_space;
+	v->a[ts_external_token__expansion_word] = sym__expansion_word;
+	v->a[ts_external_token_extglob_pattern] = sym_extglob_pattern;
+	v->a[ts_external_token__bare_dollar] = sym__bare_dollar;
+	v->a[ts_external_token__brace_start] = sym__brace_start;
+	v->a[ts_external_token__immediate_double_hash] \
+	= sym__immediate_double_hash;
+	v->a[ts_external_token__external_expansion_sym_hash] \
+	= sym__external_expansion_sym_hash;
+	v->a[ts_external_token__external_expansion_sym_bang] \
+	= sym__external_expansion_sym_bang;
+	external_scanner_symbol_map_1(v);
+}
+
+void	external_scanner_symbol_map_1(t_external_scanner_symbol_map_array *v)
+{
+	v->a[ts_external_token__external_expansion_sym_equal] \
+	= sym__external_expansion_sym_equal;
+	v->a[ts_external_token_RBRACE] = anon_sym_RBRACE3;
+	v->a[ts_external_token_RBRACK] = anon_sym_RBRACK;
+	v->a[ts_external_token_LT_LT] = anon_sym_LT_LT;
+	v->a[ts_external_token_LT_LT_DASH] = anon_sym_LT_LT_DASH;
+	v->a[ts_external_token_heredoc_redirect_token1] \
+	= aux_sym_heredoc_redirect_token1;
+	v->a[ts_external_token_LPAREN] = anon_sym_LPAREN;
+	v->a[ts_external_token_esac] = anon_sym_esac;
+	v->a[ts_external_token___error_recovery] = sym___error_recovery;
+}
+
+/* EOF external_scanner_symbol_map_0.c */

shcat_c/parser/src/field_map_entries/field_map_entries.h

@@ -0,0 +1,39 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_map_entries.h                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef FIELD_MAP_ENTRIES_H
+# define FIELD_MAP_ENTRIES_H
+
+# include "../types/type_field_map_entries.h"
+# include "../headers/symbols.h"
+# include "../headers/external_scanner_symbol_identifiers.h"
+# include "../headers/field_identifiers.h"
+
+# include "../headers/constants.h"
+
+void	field_map_entries_0(t_field_map_entries_array *v);
+void	field_map_entries_1(t_field_map_entries_array *v);
+void	field_map_entries_2(t_field_map_entries_array *v);
+void	field_map_entries_3(t_field_map_entries_array *v);
+void	field_map_entries_4(t_field_map_entries_array *v);
+void	field_map_entries_5(t_field_map_entries_array *v);
+void	field_map_entries_6(t_field_map_entries_array *v);
+void	field_map_entries_7(t_field_map_entries_array *v);
+void	field_map_entries_8(t_field_map_entries_array *v);
+void	field_map_entries_9(t_field_map_entries_array *v);
+void	field_map_entries_10(t_field_map_entries_array *v);
+void	field_map_entries_11(t_field_map_entries_array *v);
+void	field_map_entries_12(t_field_map_entries_array *v);
+void	field_map_entries_13(t_field_map_entries_array *v);
+void	field_map_entries_14(t_field_map_entries_array *v);
+
+#endif // FIELD_MAP_ENTRIES_H

shcat_c/parser/src/field_map_entries/field_map_entries_0.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_map_entries_0.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./field_map_entries.h"
+
+void	field_map_entries_0(t_field_map_entries_array *v)
+{
+	v->a[0] = fmap_entry(field_name, 0, false);
+	v->a[1] = fmap_entry(field_redirect, 0, false);
+	v->a[2] = fmap_entry(field_descriptor, 0, false);
+	v->a[3] = fmap_entry(field_left, 0, true);
+	v->a[4] = fmap_entry(field_operator, 0, true);
+	v->a[5] = fmap_entry(field_right, 0, true);
+	v->a[6] = fmap_entry(field_alternative, 0, true);
+	v->a[7] = fmap_entry(field_condition, 0, true);
+	v->a[8] = fmap_entry(field_consequence, 0, true);
+	v->a[9] = fmap_entry(field_operator, 0, true);
+	v->a[10] = fmap_entry(field_destination, 1, false);
+	v->a[11] = fmap_entry(field_operator, 0, false);
+	v->a[12] = fmap_entry(field_body, 0, false);
+	v->a[13] = fmap_entry(field_redirect, 1, false);
+	v->a[14] = fmap_entry(field_body, 0, false);
+	v->a[15] = fmap_entry(field_argument, 0, false);
+	v->a[16] = fmap_entry(field_argument, 1, true);
+	v->a[17] = fmap_entry(field_name, 0, false);
+	v->a[18] = fmap_entry(field_redirect, 1, true);
+	v->a[19] = fmap_entry(field_name, 1, false);
+	field_map_entries_1(v);
+}
+
+void	field_map_entries_1(t_field_map_entries_array *v)
+{
+	v->a[20] = fmap_entry(field_redirect, 0, true);
+	v->a[21] = fmap_entry(field_redirect, 0, true);
+	v->a[22] = fmap_entry(field_redirect, 1, true);
+	v->a[23] = fmap_entry(field_descriptor, 0, false);
+	v->a[24] = fmap_entry(field_destination, 2, false);
+	v->a[25] = fmap_entry(field_name, 0, false);
+	v->a[26] = fmap_entry(field_value, 2, false);
+	v->a[27] = fmap_entry(field_name, 0, true);
+	v->a[28] = fmap_entry(field_value, 0, true);
+	v->a[29] = fmap_entry(field_operator, 1, false);
+	v->a[30] = fmap_entry(field_body, 2, false);
+	v->a[31] = fmap_entry(field_condition, 1, false);
+	v->a[32] = fmap_entry(field_body, 2, false);
+	v->a[33] = fmap_entry(field_name, 1, false);
+	v->a[34] = fmap_entry(field_left, 1, true);
+	v->a[35] = fmap_entry(field_operator, 1, true);
+	v->a[36] = fmap_entry(field_right, 1, true);
+	v->a[37] = fmap_entry(field_operator, 1, true);
+	v->a[38] = fmap_entry(field_operator, 0, true);
+	v->a[39] = fmap_entry(field_operator, 1, true);
+	field_map_entries_2(v);
+}
+
+void	field_map_entries_2(t_field_map_entries_array *v)
+{
+	v->a[40] = fmap_entry(field_redirect, 1, false);
+	v->a[41] = fmap_entry(field_argument, 0, false);
+	v->a[42] = fmap_entry(field_argument, 1, false);
+	v->a[43] = fmap_entry(field_argument, 0, true);
+	v->a[44] = fmap_entry(field_argument, 1, true);
+	v->a[45] = fmap_entry(field_redirect, 0, true);
+	v->a[46] = fmap_entry(field_redirect, 1, true);
+	v->a[47] = fmap_entry(field_argument, 2, true);
+	v->a[48] = fmap_entry(field_name, 1, false);
+	v->a[49] = fmap_entry(field_redirect, 0, true);
+	v->a[50] = fmap_entry(field_redirect, 2, true);
+	v->a[51] = fmap_entry(field_index, 2, false);
+	v->a[52] = fmap_entry(field_name, 0, false);
+	v->a[53] = fmap_entry(field_body, 3, false);
+	v->a[54] = fmap_entry(field_variable, 1, false);
+	v->a[55] = fmap_entry(field_left, 0, false);
+	v->a[56] = fmap_entry(field_operator, 1, false);
+	v->a[57] = fmap_entry(field_right, 2, false);
+	v->a[58] = fmap_entry(field_condition, 1, false);
+	v->a[59] = fmap_entry(field_value, 1, false);
+	field_map_entries_3(v);
+}
+
+void	field_map_entries_3(t_field_map_entries_array *v)
+{
+	v->a[60] = fmap_entry(field_body, 2, false);
+	v->a[61] = fmap_entry(field_name, 1, false);
+	v->a[62] = fmap_entry(field_redirect, 3, false);
+	v->a[63] = fmap_entry(field_operator, 0, false);
+	v->a[64] = fmap_entry(field_operator, 1, false);
+	v->a[65] = fmap_entry(field_operator, 0, false);
+	v->a[66] = fmap_entry(field_operator, 1, true);
+	v->a[67] = fmap_entry(field_operator, 0, false);
+	v->a[68] = fmap_entry(field_operator, 2, false);
+	v->a[69] = fmap_entry(field_operator, 0, false);
+	v->a[70] = fmap_entry(field_operator, 2, true);
+	v->a[71] = fmap_entry(field_body, 3, false);
+	v->a[72] = fmap_entry(field_name, 0, false);
+	v->a[73] = fmap_entry(field_body, 4, false);
+	v->a[74] = fmap_entry(field_condition, 2, true);
+	v->a[75] = fmap_entry(field_initializer, 2, true);
+	v->a[76] = fmap_entry(field_update, 2, true);
+	v->a[77] = fmap_entry(field_initializer, 0, false);
+	v->a[78] = fmap_entry(field_update, 2, false);
+	v->a[79] = fmap_entry(field_value, 0, false);
+	field_map_entries_4(v);
+}
+
+void	field_map_entries_4(t_field_map_entries_array *v)
+{
+	v->a[80] = fmap_entry(field_body, 4, false);
+	v->a[81] = fmap_entry(field_name, 1, false);
+	v->a[82] = fmap_entry(field_operator, 0, false);
+	v->a[83] = fmap_entry(field_operator, 1, false);
+	v->a[84] = fmap_entry(field_operator, 2, true);
+	v->a[85] = fmap_entry(field_operator, 0, false);
+	v->a[86] = fmap_entry(field_operator, 1, true);
+	v->a[87] = fmap_entry(field_operator, 2, false);
+	v->a[88] = fmap_entry(field_body, 3, false);
+	v->a[89] = fmap_entry(field_name, 0, false);
+	v->a[90] = fmap_entry(field_redirect, 4, false);
+	v->a[91] = fmap_entry(field_operator, 0, false);
+	v->a[92] = fmap_entry(field_right, 1, false);
+	v->a[93] = fmap_entry(field_argument, 0, true);
+	v->a[94] = fmap_entry(field_argument, 1, true);
+	v->a[95] = fmap_entry(field_body, 5, false);
+	v->a[96] = fmap_entry(field_condition, 2, true);
+	v->a[97] = fmap_entry(field_initializer, 2, true);
+	v->a[98] = fmap_entry(field_update, 2, true);
+	v->a[99] = fmap_entry(field_condition, 2, false);
+	field_map_entries_5(v);
+}
+
+/* EOF field_map_entries_0.c */

shcat_c/parser/src/field_map_entries/field_map_entries_1.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_map_entries_1.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./field_map_entries.h"
+
+void	field_map_entries_5(t_field_map_entries_array *v)
+{
+	v->a[100] = fmap_entry(field_initializer, 0, false);
+	v->a[101] = fmap_entry(field_initializer, 0, false);
+	v->a[102] = fmap_entry(field_update, 3, false);
+	v->a[103] = fmap_entry(field_initializer, 0, false);
+	v->a[104] = fmap_entry(field_initializer, 1, false);
+	v->a[105] = fmap_entry(field_condition, 1, false);
+	v->a[106] = fmap_entry(field_update, 3, false);
+	v->a[107] = fmap_entry(field_condition, 1, false);
+	v->a[108] = fmap_entry(field_condition, 2, false);
+	v->a[109] = fmap_entry(field_update, 2, false);
+	v->a[110] = fmap_entry(field_update, 3, false);
+	v->a[111] = fmap_entry(field_body, 5, false);
+	v->a[112] = fmap_entry(field_value, 3, false);
+	v->a[113] = fmap_entry(field_variable, 1, false);
+	v->a[114] = fmap_entry(field_alternative, 4, false);
+	v->a[115] = fmap_entry(field_condition, 0, false);
+	v->a[116] = fmap_entry(field_consequence, 2, false);
+	v->a[117] = fmap_entry(field_termination, 2, false);
+	v->a[118] = fmap_entry(field_value, 0, false);
+	v->a[119] = fmap_entry(field_fallthrough, 2, false);
+	field_map_entries_6(v);
+}
+
+void	field_map_entries_6(t_field_map_entries_array *v)
+{
+	v->a[120] = fmap_entry(field_value, 0, false);
+	v->a[121] = fmap_entry(field_value, 0, false);
+	v->a[122] = fmap_entry(field_value, 1, true);
+	v->a[123] = fmap_entry(field_value, 0, true);
+	v->a[124] = fmap_entry(field_value, 1, true);
+	v->a[125] = fmap_entry(field_body, 4, false);
+	v->a[126] = fmap_entry(field_name, 1, false);
+	v->a[127] = fmap_entry(field_redirect, 5, false);
+	v->a[128] = fmap_entry(field_operator, 0, false);
+	v->a[129] = fmap_entry(field_operator, 1, false);
+	v->a[130] = fmap_entry(field_operator, 3, false);
+	v->a[131] = fmap_entry(field_operator, 0, false);
+	v->a[132] = fmap_entry(field_operator, 3, false);
+	v->a[133] = fmap_entry(field_operator, 0, false);
+	v->a[134] = fmap_entry(field_operator, 2, false);
+	v->a[135] = fmap_entry(field_operator, 3, true);
+	v->a[136] = fmap_entry(field_operator, 0, false);
+	v->a[137] = fmap_entry(field_operator, 1, false);
+	v->a[138] = fmap_entry(field_operator, 3, true);
+	v->a[139] = fmap_entry(field_operator, 0, false);
+	field_map_entries_7(v);
+}
+
+void	field_map_entries_7(t_field_map_entries_array *v)
+{
+	v->a[140] = fmap_entry(field_operator, 1, true);
+	v->a[141] = fmap_entry(field_operator, 2, false);
+	v->a[142] = fmap_entry(field_operator, 3, true);
+	v->a[143] = fmap_entry(field_operator, 2, true);
+	v->a[144] = fmap_entry(field_right, 2, true);
+	v->a[145] = fmap_entry(field_argument, 2, true);
+	v->a[146] = fmap_entry(field_redirect, 2, false);
+	v->a[147] = fmap_entry(field_condition, 2, false);
+	v->a[148] = fmap_entry(field_initializer, 0, false);
+	v->a[149] = fmap_entry(field_update, 4, false);
+	v->a[150] = fmap_entry(field_condition, 2, false);
+	v->a[151] = fmap_entry(field_condition, 3, false);
+	v->a[152] = fmap_entry(field_initializer, 0, false);
+	v->a[153] = fmap_entry(field_initializer, 0, false);
+	v->a[154] = fmap_entry(field_update, 3, false);
+	v->a[155] = fmap_entry(field_update, 4, false);
+	v->a[156] = fmap_entry(field_condition, 3, false);
+	v->a[157] = fmap_entry(field_initializer, 0, false);
+	v->a[158] = fmap_entry(field_initializer, 1, false);
+	v->a[159] = fmap_entry(field_initializer, 0, false);
+	field_map_entries_8(v);
+}
+
+void	field_map_entries_8(t_field_map_entries_array *v)
+{
+	v->a[160] = fmap_entry(field_initializer, 1, false);
+	v->a[161] = fmap_entry(field_update, 4, false);
+	v->a[162] = fmap_entry(field_condition, 1, false);
+	v->a[163] = fmap_entry(field_update, 3, false);
+	v->a[164] = fmap_entry(field_update, 4, false);
+	v->a[165] = fmap_entry(field_condition, 1, false);
+	v->a[166] = fmap_entry(field_condition, 2, false);
+	v->a[167] = fmap_entry(field_update, 4, false);
+	v->a[168] = fmap_entry(field_termination, 3, false);
+	v->a[169] = fmap_entry(field_value, 0, false);
+	v->a[170] = fmap_entry(field_fallthrough, 3, false);
+	v->a[171] = fmap_entry(field_value, 0, false);
+	v->a[172] = fmap_entry(field_termination, 3, false);
+	v->a[173] = fmap_entry(field_value, 0, false);
+	v->a[174] = fmap_entry(field_value, 1, true);
+	v->a[175] = fmap_entry(field_fallthrough, 3, false);
+	v->a[176] = fmap_entry(field_value, 0, false);
+	v->a[177] = fmap_entry(field_value, 1, true);
+	v->a[178] = fmap_entry(field_termination, 3, false);
+	v->a[179] = fmap_entry(field_value, 1, false);
+	field_map_entries_9(v);
+}
+
+void	field_map_entries_9(t_field_map_entries_array *v)
+{
+	v->a[180] = fmap_entry(field_fallthrough, 3, false);
+	v->a[181] = fmap_entry(field_value, 1, false);
+	v->a[182] = fmap_entry(field_value, 1, false);
+	v->a[183] = fmap_entry(field_value, 2, true);
+	v->a[184] = fmap_entry(field_operator, 0, false);
+	v->a[185] = fmap_entry(field_operator, 2, false);
+	v->a[186] = fmap_entry(field_operator, 4, false);
+	v->a[187] = fmap_entry(field_operator, 0, false);
+	v->a[188] = fmap_entry(field_operator, 1, false);
+	v->a[189] = fmap_entry(field_operator, 4, false);
+	v->a[190] = fmap_entry(field_operator, 0, false);
+	v->a[191] = fmap_entry(field_operator, 2, false);
+	v->a[192] = fmap_entry(field_operator, 4, true);
+	v->a[193] = fmap_entry(field_operator, 0, false);
+	v->a[194] = fmap_entry(field_operator, 1, true);
+	v->a[195] = fmap_entry(field_operator, 2, false);
+	v->a[196] = fmap_entry(field_operator, 4, true);
+	v->a[197] = fmap_entry(field_descriptor, 0, false);
+	v->a[198] = fmap_entry(field_operator, 3, true);
+	v->a[199] = fmap_entry(field_right, 3, true);
+	field_map_entries_10(v);
+}
+
+/* EOF field_map_entries_1.c */

shcat_c/parser/src/field_map_entries/field_map_entries_2.c

@@ -0,0 +1,126 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_map_entries_2.c                              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./field_map_entries.h"
+
+void	field_map_entries_10(t_field_map_entries_array *v)
+{
+	v->a[200] = fmap_entry(field_argument, 3, true);
+	v->a[201] = fmap_entry(field_descriptor, 0, false);
+	v->a[202] = fmap_entry(field_descriptor, 0, false);
+	v->a[203] = fmap_entry(field_redirect, 3, false);
+	v->a[204] = fmap_entry(field_operator, 3, true);
+	v->a[205] = fmap_entry(field_redirect, 2, false);
+	v->a[206] = fmap_entry(field_right, 3, true);
+	v->a[207] = fmap_entry(field_condition, 2, false);
+	v->a[208] = fmap_entry(field_initializer, 0, false);
+	v->a[209] = fmap_entry(field_update, 4, false);
+	v->a[210] = fmap_entry(field_update, 5, false);
+	v->a[211] = fmap_entry(field_condition, 2, false);
+	v->a[212] = fmap_entry(field_condition, 3, false);
+	v->a[213] = fmap_entry(field_initializer, 0, false);
+	v->a[214] = fmap_entry(field_update, 5, false);
+	v->a[215] = fmap_entry(field_condition, 3, false);
+	v->a[216] = fmap_entry(field_initializer, 0, false);
+	v->a[217] = fmap_entry(field_initializer, 1, false);
+	v->a[218] = fmap_entry(field_update, 5, false);
+	v->a[219] = fmap_entry(field_condition, 3, false);
+	field_map_entries_11(v);
+}
+
+void	field_map_entries_11(t_field_map_entries_array *v)
+{
+	v->a[220] = fmap_entry(field_condition, 4, false);
+	v->a[221] = fmap_entry(field_initializer, 0, false);
+	v->a[222] = fmap_entry(field_initializer, 1, false);
+	v->a[223] = fmap_entry(field_initializer, 0, false);
+	v->a[224] = fmap_entry(field_initializer, 1, false);
+	v->a[225] = fmap_entry(field_update, 4, false);
+	v->a[226] = fmap_entry(field_update, 5, false);
+	v->a[227] = fmap_entry(field_condition, 1, false);
+	v->a[228] = fmap_entry(field_condition, 2, false);
+	v->a[229] = fmap_entry(field_update, 4, false);
+	v->a[230] = fmap_entry(field_update, 5, false);
+	v->a[231] = fmap_entry(field_termination, 4, false);
+	v->a[232] = fmap_entry(field_value, 0, false);
+	v->a[233] = fmap_entry(field_value, 1, true);
+	v->a[234] = fmap_entry(field_fallthrough, 4, false);
+	v->a[235] = fmap_entry(field_value, 0, false);
+	v->a[236] = fmap_entry(field_value, 1, true);
+	v->a[237] = fmap_entry(field_termination, 4, false);
+	v->a[238] = fmap_entry(field_value, 1, false);
+	v->a[239] = fmap_entry(field_fallthrough, 4, false);
+	field_map_entries_12(v);
+}
+
+void	field_map_entries_12(t_field_map_entries_array *v)
+{
+	v->a[240] = fmap_entry(field_value, 1, false);
+	v->a[241] = fmap_entry(field_termination, 4, false);
+	v->a[242] = fmap_entry(field_value, 1, false);
+	v->a[243] = fmap_entry(field_value, 2, true);
+	v->a[244] = fmap_entry(field_fallthrough, 4, false);
+	v->a[245] = fmap_entry(field_value, 1, false);
+	v->a[246] = fmap_entry(field_value, 2, true);
+	v->a[247] = fmap_entry(field_operator, 0, false);
+	v->a[248] = fmap_entry(field_operator, 2, false);
+	v->a[249] = fmap_entry(field_operator, 5, false);
+	v->a[250] = fmap_entry(field_operator, 0, false);
+	v->a[251] = fmap_entry(field_operator, 3, false);
+	v->a[252] = fmap_entry(field_operator, 5, false);
+	v->a[253] = fmap_entry(field_descriptor, 0, false);
+	v->a[254] = fmap_entry(field_operator, 4, true);
+	v->a[255] = fmap_entry(field_redirect, 3, false);
+	v->a[256] = fmap_entry(field_right, 4, true);
+	v->a[257] = fmap_entry(field_condition, 2, false);
+	v->a[258] = fmap_entry(field_condition, 3, false);
+	v->a[259] = fmap_entry(field_initializer, 0, false);
+	field_map_entries_13(v);
+}
+
+void	field_map_entries_13(t_field_map_entries_array *v)
+{
+	v->a[260] = fmap_entry(field_update, 5, false);
+	v->a[261] = fmap_entry(field_update, 6, false);
+	v->a[262] = fmap_entry(field_condition, 3, false);
+	v->a[263] = fmap_entry(field_initializer, 0, false);
+	v->a[264] = fmap_entry(field_initializer, 1, false);
+	v->a[265] = fmap_entry(field_update, 5, false);
+	v->a[266] = fmap_entry(field_update, 6, false);
+	v->a[267] = fmap_entry(field_condition, 3, false);
+	v->a[268] = fmap_entry(field_condition, 4, false);
+	v->a[269] = fmap_entry(field_initializer, 0, false);
+	v->a[270] = fmap_entry(field_initializer, 1, false);
+	v->a[271] = fmap_entry(field_update, 6, false);
+	v->a[272] = fmap_entry(field_termination, 5, false);
+	v->a[273] = fmap_entry(field_value, 1, false);
+	v->a[274] = fmap_entry(field_value, 2, true);
+	v->a[275] = fmap_entry(field_fallthrough, 5, false);
+	v->a[276] = fmap_entry(field_value, 1, false);
+	v->a[277] = fmap_entry(field_value, 2, true);
+	v->a[278] = fmap_entry(field_operator, 0, false);
+	v->a[279] = fmap_entry(field_operator, 3, false);
+	field_map_entries_14(v);
+}
+
+void	field_map_entries_14(t_field_map_entries_array *v)
+{
+	v->a[280] = fmap_entry(field_operator, 6, false);
+	v->a[281] = fmap_entry(field_condition, 3, false);
+	v->a[282] = fmap_entry(field_condition, 4, false);
+	v->a[283] = fmap_entry(field_initializer, 0, false);
+	v->a[284] = fmap_entry(field_initializer, 1, false);
+	v->a[285] = fmap_entry(field_update, 6, false);
+	v->a[286] = fmap_entry(field_update, 7, false);
+}
+
+/* EOF field_map_entries_2.c */

shcat_c/parser/src/field_map_slices/field_map_slices.h

@@ -0,0 +1,32 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_map_slices.h                                 :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef FIELD_MAP_SLICES_H
+# define FIELD_MAP_SLICES_H
+
+# include "../types/type_field_map_slices.h"
+# include "../headers/symbols.h"
+# include "../headers/external_scanner_symbol_identifiers.h"
+# include "../headers/field_identifiers.h"
+
+# include "../headers/constants.h"
+
+void	field_map_slices_0(t_field_map_slices_array *v);
+void	field_map_slices_1(t_field_map_slices_array *v);
+void	field_map_slices_2(t_field_map_slices_array *v);
+void	field_map_slices_3(t_field_map_slices_array *v);
+void	field_map_slices_4(t_field_map_slices_array *v);
+void	field_map_slices_5(t_field_map_slices_array *v);
+void	field_map_slices_6(t_field_map_slices_array *v);
+void	field_map_slices_7(t_field_map_slices_array *v);
+
+#endif // FIELD_MAP_SLICES_H

shcat_c/parser/src/field_map_slices/field_map_slices_0.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_map_slices_0.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./field_map_slices.h"
+
+void	field_map_slices_0(t_field_map_slices_array *v)
+{
+	v->a[2] = fmap_slice(0, 1);
+	v->a[3] = fmap_slice(1, 1);
+	v->a[4] = fmap_slice(2, 1);
+	v->a[5] = fmap_slice(3, 3);
+	v->a[6] = fmap_slice(6, 3);
+	v->a[7] = fmap_slice(9, 1);
+	v->a[8] = fmap_slice(10, 1);
+	v->a[9] = fmap_slice(10, 1);
+	v->a[12] = fmap_slice(11, 1);
+	v->a[14] = fmap_slice(12, 2);
+	v->a[15] = fmap_slice(14, 1);
+	v->a[16] = fmap_slice(15, 1);
+	v->a[17] = fmap_slice(15, 1);
+	v->a[18] = fmap_slice(16, 3);
+	v->a[19] = fmap_slice(19, 2);
+	v->a[20] = fmap_slice(21, 2);
+	v->a[21] = fmap_slice(23, 2);
+	v->a[22] = fmap_slice(23, 2);
+	v->a[23] = fmap_slice(2, 1);
+	v->a[24] = fmap_slice(25, 2);
+	field_map_slices_1(v);
+}
+
+void	field_map_slices_1(t_field_map_slices_array *v)
+{
+	v->a[25] = fmap_slice(25, 2);
+	v->a[26] = fmap_slice(27, 2);
+	v->a[27] = fmap_slice(29, 1);
+	v->a[28] = fmap_slice(30, 2);
+	v->a[29] = fmap_slice(32, 2);
+	v->a[30] = fmap_slice(34, 3);
+	v->a[31] = fmap_slice(37, 1);
+	v->a[32] = fmap_slice(37, 1);
+	v->a[33] = fmap_slice(11, 1);
+	v->a[34] = fmap_slice(38, 2);
+	v->a[35] = fmap_slice(40, 1);
+	v->a[36] = fmap_slice(41, 2);
+	v->a[37] = fmap_slice(41, 2);
+	v->a[38] = fmap_slice(43, 4);
+	v->a[39] = fmap_slice(47, 4);
+	v->a[40] = fmap_slice(51, 2);
+	v->a[41] = fmap_slice(51, 2);
+	v->a[42] = fmap_slice(53, 2);
+	v->a[43] = fmap_slice(55, 3);
+	v->a[44] = fmap_slice(58, 1);
+	field_map_slices_2(v);
+}
+
+void	field_map_slices_2(t_field_map_slices_array *v)
+{
+	v->a[45] = fmap_slice(59, 1);
+	v->a[46] = fmap_slice(59, 1);
+	v->a[47] = fmap_slice(60, 3);
+	v->a[49] = fmap_slice(63, 2);
+	v->a[50] = fmap_slice(65, 2);
+	v->a[51] = fmap_slice(67, 2);
+	v->a[52] = fmap_slice(69, 2);
+	v->a[53] = fmap_slice(69, 2);
+	v->a[54] = fmap_slice(71, 2);
+	v->a[55] = fmap_slice(25, 2);
+	v->a[56] = fmap_slice(73, 4);
+	v->a[57] = fmap_slice(77, 1);
+	v->a[58] = fmap_slice(78, 1);
+	v->a[59] = fmap_slice(79, 1);
+	v->a[60] = fmap_slice(79, 1);
+	v->a[61] = fmap_slice(80, 2);
+	v->a[62] = fmap_slice(63, 2);
+	v->a[63] = fmap_slice(82, 3);
+	v->a[64] = fmap_slice(85, 3);
+	v->a[65] = fmap_slice(88, 3);
+	field_map_slices_3(v);
+}
+
+void	field_map_slices_3(t_field_map_slices_array *v)
+{
+	v->a[66] = fmap_slice(91, 2);
+	v->a[67] = fmap_slice(93, 2);
+	v->a[68] = fmap_slice(95, 4);
+	v->a[69] = fmap_slice(99, 2);
+	v->a[70] = fmap_slice(101, 2);
+	v->a[71] = fmap_slice(103, 2);
+	v->a[72] = fmap_slice(105, 2);
+	v->a[73] = fmap_slice(107, 2);
+	v->a[74] = fmap_slice(109, 2);
+	v->a[75] = fmap_slice(111, 3);
+	v->a[76] = fmap_slice(114, 3);
+	v->a[77] = fmap_slice(117, 2);
+	v->a[78] = fmap_slice(119, 2);
+	v->a[79] = fmap_slice(121, 2);
+	v->a[80] = fmap_slice(123, 2);
+	v->a[81] = fmap_slice(117, 2);
+	v->a[82] = fmap_slice(119, 2);
+	v->a[83] = fmap_slice(121, 2);
+	v->a[84] = fmap_slice(125, 3);
+	v->a[85] = fmap_slice(67, 2);
+	field_map_slices_4(v);
+}
+
+void	field_map_slices_4(t_field_map_slices_array *v)
+{
+	v->a[86] = fmap_slice(128, 3);
+	v->a[87] = fmap_slice(128, 3);
+	v->a[88] = fmap_slice(63, 2);
+	v->a[89] = fmap_slice(131, 2);
+	v->a[90] = fmap_slice(133, 3);
+	v->a[91] = fmap_slice(136, 3);
+	v->a[92] = fmap_slice(139, 4);
+	v->a[93] = fmap_slice(143, 2);
+	v->a[94] = fmap_slice(145, 1);
+	v->a[95] = fmap_slice(146, 1);
+	v->a[96] = fmap_slice(147, 3);
+	v->a[97] = fmap_slice(150, 3);
+	v->a[98] = fmap_slice(153, 3);
+	v->a[99] = fmap_slice(156, 3);
+	v->a[100] = fmap_slice(159, 3);
+	v->a[101] = fmap_slice(162, 3);
+	v->a[102] = fmap_slice(165, 3);
+	v->a[103] = fmap_slice(168, 2);
+	v->a[104] = fmap_slice(170, 2);
+	v->a[105] = fmap_slice(172, 3);
+	field_map_slices_5(v);
+}
+
+/* EOF field_map_slices_0.c */

shcat_c/parser/src/field_map_slices/field_map_slices_1.c

@@ -0,0 +1,82 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_map_slices_1.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./field_map_slices.h"
+
+void	field_map_slices_5(t_field_map_slices_array *v)
+{
+	v->a[106] = fmap_slice(175, 3);
+	v->a[107] = fmap_slice(178, 2);
+	v->a[108] = fmap_slice(180, 2);
+	v->a[109] = fmap_slice(182, 2);
+	v->a[110] = fmap_slice(178, 2);
+	v->a[111] = fmap_slice(180, 2);
+	v->a[112] = fmap_slice(182, 2);
+	v->a[113] = fmap_slice(168, 2);
+	v->a[114] = fmap_slice(170, 2);
+	v->a[115] = fmap_slice(172, 3);
+	v->a[116] = fmap_slice(175, 3);
+	v->a[117] = fmap_slice(184, 3);
+	v->a[118] = fmap_slice(184, 3);
+	v->a[119] = fmap_slice(67, 2);
+	v->a[120] = fmap_slice(187, 3);
+	v->a[121] = fmap_slice(131, 2);
+	v->a[122] = fmap_slice(190, 3);
+	v->a[123] = fmap_slice(193, 4);
+	v->a[124] = fmap_slice(197, 3);
+	v->a[125] = fmap_slice(200, 2);
+	field_map_slices_6(v);
+}
+
+void	field_map_slices_6(t_field_map_slices_array *v)
+{
+	v->a[126] = fmap_slice(202, 2);
+	v->a[127] = fmap_slice(204, 3);
+	v->a[128] = fmap_slice(207, 4);
+	v->a[129] = fmap_slice(211, 4);
+	v->a[130] = fmap_slice(215, 4);
+	v->a[131] = fmap_slice(219, 4);
+	v->a[132] = fmap_slice(223, 4);
+	v->a[133] = fmap_slice(227, 4);
+	v->a[134] = fmap_slice(231, 3);
+	v->a[135] = fmap_slice(234, 3);
+	v->a[136] = fmap_slice(237, 2);
+	v->a[137] = fmap_slice(239, 2);
+	v->a[138] = fmap_slice(241, 3);
+	v->a[139] = fmap_slice(244, 3);
+	v->a[140] = fmap_slice(237, 2);
+	v->a[141] = fmap_slice(239, 2);
+	v->a[142] = fmap_slice(241, 3);
+	v->a[143] = fmap_slice(244, 3);
+	v->a[144] = fmap_slice(231, 3);
+	v->a[145] = fmap_slice(234, 3);
+	field_map_slices_7(v);
+}
+
+void	field_map_slices_7(t_field_map_slices_array *v)
+{
+	v->a[146] = fmap_slice(247, 3);
+	v->a[147] = fmap_slice(250, 3);
+	v->a[148] = fmap_slice(250, 3);
+	v->a[149] = fmap_slice(253, 4);
+	v->a[150] = fmap_slice(257, 5);
+	v->a[151] = fmap_slice(262, 5);
+	v->a[152] = fmap_slice(267, 5);
+	v->a[153] = fmap_slice(272, 3);
+	v->a[154] = fmap_slice(275, 3);
+	v->a[155] = fmap_slice(272, 3);
+	v->a[156] = fmap_slice(275, 3);
+	v->a[157] = fmap_slice(278, 3);
+	v->a[158] = fmap_slice(281, 6);
+}
+
+/* EOF field_map_slices_1.c */

shcat_c/parser/src/field_names/field_names.h

@@ -0,0 +1,25 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_names.h                                      :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef FIELD_NAMES_H
+# define FIELD_NAMES_H
+
+# include "../types/type_field_names.h"
+# include "../headers/symbols.h"
+# include "../headers/external_scanner_symbol_identifiers.h"
+# include "../headers/field_identifiers.h"
+
+# include "../headers/constants.h"
+
+void	field_names_0(t_field_names_array *v);
+
+#endif // FIELD_NAMES_H

shcat_c/parser/src/field_names/field_names_0.c

@@ -0,0 +1,38 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_names_0.c                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./field_names.h"
+
+void	field_names_0(t_field_names_array *v)
+{
+	v->a[field_alternative] = "alternative";
+	v->a[field_argument] = "argument";
+	v->a[field_body] = "body";
+	v->a[field_condition] = "condition";
+	v->a[field_consequence] = "consequence";
+	v->a[field_descriptor] = "descriptor";
+	v->a[field_destination] = "destination";
+	v->a[field_fallthrough] = "fallthrough";
+	v->a[field_index] = "index";
+	v->a[field_initializer] = "initializer";
+	v->a[field_left] = "left";
+	v->a[field_name] = "name";
+	v->a[field_operator] = "operator";
+	v->a[field_redirect] = "redirect";
+	v->a[field_right] = "right";
+	v->a[field_termination] = "termination";
+	v->a[field_update] = "update";
+	v->a[field_value] = "value";
+	v->a[field_variable] = "variable";
+}
+
+/* EOF field_names_0.c */

shcat_c/parser/src/headers/constants.h

@@ -0,0 +1,27 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   constants.h                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef CONSTANTS_H
+# define CONSTANTS_H
+
+# define LANGUAGE_VERSION 14
+# define STATE_COUNT 7671
+# define LARGE_STATE_COUNT 528
+# define SYMBOL_COUNT 280
+# define ALIAS_COUNT 0
+# define TOKEN_COUNT 175
+# define EXTERNAL_TOKEN_COUNT 29
+# define FIELD_COUNT 19
+# define MAX_ALIAS_SEQUENCE_LENGTH 8
+# define PRODUCTION_ID_COUNT 159
+
+#endif // CONSTANTS_H

shcat_c/parser/src/headers/external_scanner_symbol_identifiers.h

@@ -0,0 +1,48 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   external_scanner_symbol_identifiers.h              :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef EXTERNAL_SCANNER_SYMBOL_IDENTIFIERS_H
+# define EXTERNAL_SCANNER_SYMBOL_IDENTIFIERS_H
+
+enum e_external_scanner_symbol_identifiers {
+	ts_external_token_heredoc_start = 0,
+	ts_external_token_simple_heredoc_body = 1,
+	ts_external_token__heredoc_body_beginning = 2,
+	ts_external_token_heredoc_content = 3,
+	ts_external_token_heredoc_end = 4,
+	ts_external_token_file_descriptor = 5,
+	ts_external_token__empty_value = 6,
+	ts_external_token__concat = 7,
+	ts_external_token_variable_name = 8,
+	ts_external_token_test_operator = 9,
+	ts_external_token_regex = 10,
+	ts_external_token__regex_no_slash = 11,
+	ts_external_token__regex_no_space = 12,
+	ts_external_token__expansion_word = 13,
+	ts_external_token_extglob_pattern = 14,
+	ts_external_token__bare_dollar = 15,
+	ts_external_token__brace_start = 16,
+	ts_external_token__immediate_double_hash = 17,
+	ts_external_token__external_expansion_sym_hash = 18,
+	ts_external_token__external_expansion_sym_bang = 19,
+	ts_external_token__external_expansion_sym_equal = 20,
+	ts_external_token_RBRACE = 21,
+	ts_external_token_RBRACK = 22,
+	ts_external_token_LT_LT = 23,
+	ts_external_token_LT_LT_DASH = 24,
+	ts_external_token_heredoc_redirect_token1 = 25,
+	ts_external_token_LPAREN = 26,
+	ts_external_token_esac = 27,
+	ts_external_token___error_recovery = 28,
+};
+
+#endif // EXTERNAL_SCANNER_SYMBOL_IDENTIFIERS_H

shcat_c/parser/src/headers/field_identifiers.h

@@ -0,0 +1,38 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   field_identifiers.h                                :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef FIELD_IDENTIFIERS_H
+# define FIELD_IDENTIFIERS_H
+
+enum e_field_identifiers {
+	field_alternative = 1,
+	field_argument = 2,
+	field_body = 3,
+	field_condition = 4,
+	field_consequence = 5,
+	field_descriptor = 6,
+	field_destination = 7,
+	field_fallthrough = 8,
+	field_index = 9,
+	field_initializer = 10,
+	field_left = 11,
+	field_name = 12,
+	field_operator = 13,
+	field_redirect = 14,
+	field_right = 15,
+	field_termination = 16,
+	field_update = 17,
+	field_value = 18,
+	field_variable = 19,
+};
+
+#endif // FIELD_IDENTIFIERS_H

shcat_c/parser/src/headers/symbols.h

@@ -0,0 +1,298 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   symbols.h                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef SYMBOLS_H
+# define SYMBOLS_H
+
+enum e_symbols {
+	sym_word = 1,
+	anon_sym_for = 2,
+	anon_sym_select = 3,
+	anon_sym_in = 4,
+	anon_sym_LPAREN_LPAREN = 5,
+	anon_sym_RPAREN_RPAREN = 6,
+	anon_sym_SEMI = 7,
+	anon_sym_COMMA = 8,
+	anon_sym_EQ = 9,
+	anon_sym_PLUS_PLUS = 10,
+	anon_sym_DASH_DASH = 11,
+	anon_sym_PLUS_EQ = 12,
+	anon_sym_DASH_EQ = 13,
+	anon_sym_STAR_EQ = 14,
+	anon_sym_SLASH_EQ = 15,
+	anon_sym_PERCENT_EQ = 16,
+	anon_sym_STAR_STAR_EQ = 17,
+	anon_sym_LT_LT_EQ = 18,
+	anon_sym_GT_GT_EQ = 19,
+	anon_sym_AMP_EQ = 20,
+	anon_sym_CARET_EQ = 21,
+	anon_sym_PIPE_EQ = 22,
+	anon_sym_PIPE_PIPE = 23,
+	anon_sym_DASHo = 24,
+	anon_sym_AMP_AMP = 25,
+	anon_sym_DASHa = 26,
+	anon_sym_PIPE = 27,
+	anon_sym_CARET = 28,
+	anon_sym_AMP = 29,
+	anon_sym_EQ_EQ = 30,
+	anon_sym_BANG_EQ = 31,
+	anon_sym_LT = 32,
+	anon_sym_GT = 33,
+	anon_sym_LT_EQ = 34,
+	anon_sym_GT_EQ = 35,
+	anon_sym_LT_LT = 36,
+	anon_sym_GT_GT = 37,
+	anon_sym_PLUS = 38,
+	anon_sym_DASH = 39,
+	anon_sym_STAR = 40,
+	anon_sym_SLASH = 41,
+	anon_sym_PERCENT = 42,
+	anon_sym_STAR_STAR = 43,
+	anon_sym_LPAREN = 44,
+	anon_sym_RPAREN = 45,
+	aux_sym__c_word_token1 = 46,
+	anon_sym_while = 47,
+	anon_sym_until = 48,
+	anon_sym_do = 49,
+	anon_sym_done = 50,
+	anon_sym_if = 51,
+	anon_sym_then = 52,
+	anon_sym_fi = 53,
+	anon_sym_elif = 54,
+	anon_sym_else = 55,
+	anon_sym_case = 56,
+	anon_sym_esac = 57,
+	anon_sym_SEMI_SEMI = 58,
+	anon_sym_SEMI_AMP = 59,
+	anon_sym_SEMI_SEMI_AMP = 60,
+	anon_sym_function = 61,
+	anon_sym_LBRACE = 62,
+	anon_sym_RBRACE = 63,
+	anon_sym_PIPE_AMP = 64,
+	anon_sym_BANG = 65,
+	anon_sym_LBRACK = 66,
+	anon_sym_RBRACK = 67,
+	anon_sym_LBRACK_LBRACK = 68,
+	anon_sym_RBRACK_RBRACK = 69,
+	anon_sym_declare = 70,
+	anon_sym_typeset = 71,
+	anon_sym_export = 72,
+	anon_sym_readonly = 73,
+	anon_sym_local = 74,
+	anon_sym_unset = 75,
+	anon_sym_unsetenv = 76,
+	anon_sym_EQ_TILDE = 77,
+	anon_sym_AMP_GT = 78,
+	anon_sym_AMP_GT_GT = 79,
+	anon_sym_LT_AMP = 80,
+	anon_sym_GT_AMP = 81,
+	anon_sym_GT_PIPE = 82,
+	anon_sym_LT_AMP_DASH = 83,
+	anon_sym_GT_AMP_DASH = 84,
+	anon_sym_LT_LT_DASH = 85,
+	aux_sym_heredoc_redirect_token1 = 86,
+	anon_sym_LT_LT_LT = 87,
+	anon_sym_QMARK = 88,
+	anon_sym_COLON = 89,
+	anon_sym_PLUS_PLUS2 = 90,
+	anon_sym_DASH_DASH2 = 91,
+	anon_sym_DASH2 = 92,
+	anon_sym_PLUS2 = 93,
+	anon_sym_TILDE = 94,
+	anon_sym_DOLLAR_LPAREN_LPAREN = 95,
+	anon_sym_DOLLAR_LBRACK = 96,
+	aux_sym_brace_expression_token1 = 97,
+	anon_sym_DOT_DOT = 98,
+	anon_sym_RBRACE2 = 99,
+	aux_sym_concatenation_token1 = 100,
+	anon_sym_DOLLAR = 101,
+	sym__special_character = 102,
+	anon_sym_DQUOTE = 103,
+	sym_string_content = 104,
+	sym_raw_string = 105,
+	sym_ansi_c_string = 106,
+	aux_sym_number_token1 = 107,
+	aux_sym_number_token2 = 108,
+	anon_sym_POUND = 109,
+	anon_sym_DOLLAR_LBRACE = 110,
+	anon_sym_RBRACE3 = 111,
+	anon_sym_BANG2 = 112,
+	anon_sym_AT = 113,
+	anon_sym_STAR2 = 114,
+	anon_sym_POUND2 = 115,
+	anon_sym_EQ2 = 116,
+	anon_sym_COLON_EQ = 117,
+	anon_sym_DASH3 = 118,
+	anon_sym_COLON_DASH = 119,
+	anon_sym_PLUS3 = 120,
+	anon_sym_COLON_PLUS = 121,
+	anon_sym_QMARK2 = 122,
+	anon_sym_COLON_QMARK = 123,
+	anon_sym_PERCENT_PERCENT = 124,
+	aux_sym__expansion_regex_token1 = 125,
+	anon_sym_SLASH_SLASH = 126,
+	anon_sym_SLASH_POUND = 127,
+	anon_sym_SLASH_PERCENT = 128,
+	anon_sym_COMMA_COMMA = 129,
+	anon_sym_CARET_CARET = 130,
+	anon_sym_U = 131,
+	anon_sym_u = 132,
+	anon_sym_L = 133,
+	anon_sym_Q = 134,
+	anon_sym_E = 135,
+	anon_sym_P = 136,
+	anon_sym_A = 137,
+	anon_sym_K = 138,
+	anon_sym_a = 139,
+	anon_sym_k = 140,
+	anon_sym_DOLLAR_LPAREN = 141,
+	anon_sym_BQUOTE = 142,
+	anon_sym_DOLLAR_BQUOTE = 143,
+	anon_sym_LT_LPAREN = 144,
+	anon_sym_GT_LPAREN = 145,
+	sym_comment = 146,
+	sym__comment_word = 147,
+	aux_sym__simple_variable_name_token1 = 148,
+	aux_sym__multiline_variable_name_token1 = 149,
+	anon_sym_AT2 = 150,
+	anon_sym_0 = 151,
+	anon_sym__ = 152,
+	sym_heredoc_start = 153,
+	sym_simple_heredoc_body = 154,
+	sym__heredoc_body_beginning = 155,
+	sym_heredoc_content = 156,
+	sym_heredoc_end = 157,
+	sym_file_descriptor = 158,
+	sym__empty_value = 159,
+	sym__concat = 160,
+	sym_variable_name = 161,
+	sym_test_operator = 162,
+	sym_regex = 163,
+	sym__regex_no_slash = 164,
+	sym__regex_no_space = 165,
+	sym__expansion_word = 166,
+	sym_extglob_pattern = 167,
+	sym__bare_dollar = 168,
+	sym__brace_start = 169,
+	sym__immediate_double_hash = 170,
+	sym__external_expansion_sym_hash = 171,
+	sym__external_expansion_sym_bang = 172,
+	sym__external_expansion_sym_equal = 173,
+	sym___error_recovery = 174,
+	sym_program = 175,
+	sym__statements = 176,
+	aux_sym__terminated_statement = 177,
+	sym__statement_not_pipeline = 178,
+	sym_redirected_statement = 179,
+	sym_for_statement = 180,
+	sym_c_style_for_statement = 181,
+	sym__for_body = 182,
+	sym__c_expression = 183,
+	sym__c_expression_not_assignment = 184,
+	sym__c_variable_assignment = 185,
+	sym__c_unary_expression = 186,
+	sym__c_binary_expression = 187,
+	sym__c_postfix_expression = 188,
+	sym__c_parenthesized_expression = 189,
+	sym_while_statement = 190,
+	sym_do_group = 191,
+	sym_if_statement = 192,
+	sym_elif_clause = 193,
+	sym_else_clause = 194,
+	sym_case_statement = 195,
+	sym_case_item = 196,
+	sym_last_case_item = 197,
+	sym_function_definition = 198,
+	sym_compound_statement = 199,
+	sym_subshell = 200,
+	sym_pipeline = 201,
+	sym_list = 202,
+	sym_negated_command = 203,
+	sym_test_command = 204,
+	sym__test_command_binary_expression = 205,
+	sym_declaration_command = 206,
+	sym_unset_command = 207,
+	sym_command = 208,
+	sym_command_name = 209,
+	sym_variable_assignment = 210,
+	sym_variable_assignments = 211,
+	sym_subscript = 212,
+	sym_file_redirect = 213,
+	sym_heredoc_redirect = 214,
+	sym__heredoc_pipeline = 215,
+	sym__heredoc_expression = 216,
+	aux_sym__heredoc_command = 217,
+	sym__heredoc_body = 218,
+	sym_heredoc_body = 219,
+	sym__simple_heredoc_body = 220,
+	sym_herestring_redirect = 221,
+	sym__expression = 222,
+	sym_binary_expression = 223,
+	sym_ternary_expression = 224,
+	sym_unary_expression = 225,
+	sym_postfix_expression = 226,
+	sym_parenthesized_expression = 227,
+	sym_arithmetic_expansion = 228,
+	sym_brace_expression = 229,
+	sym__arithmetic_expression = 230,
+	sym__arithmetic_literal = 231,
+	sym__arithmetic_binary_expression = 232,
+	sym__arithmetic_ternary_expression = 233,
+	sym__arithmetic_unary_expression = 234,
+	sym__arithmetic_postfix_expression = 235,
+	sym__arithmetic_parenthesized_expression = 236,
+	sym_concatenation = 237,
+	sym_string = 238,
+	sym_translated_string = 239,
+	sym_array = 240,
+	sym_number = 241,
+	sym_simple_expansion = 242,
+	sym_expansion = 243,
+	sym__expansion_body = 244,
+	sym__expansion_expression = 245,
+	sym__expansion_regex = 246,
+	sym__expansion_regex_replacement = 247,
+	sym__expansion_regex_removal = 248,
+	sym__expansion_max_length = 249,
+	sym__expansion_max_length_expression = 250,
+	sym__expansion_max_length_binary_expression = 251,
+	sym__expansion_operator = 252,
+	sym__concatenation_in_expansion = 253,
+	sym_command_substitution = 254,
+	sym_process_substitution = 255,
+	sym__extglob_blob = 256,
+	sym__c_terminator = 257,
+	aux_sym__statements_repeat1 = 258,
+	aux_sym_redirected_statement_repeat1 = 259,
+	aux_sym_redirected_statement_repeat2 = 260,
+	aux_sym_for_statement_repeat1 = 261,
+	aux_sym__for_body_repeat1 = 262,
+	aux_sym_if_statement_repeat1 = 263,
+	aux_sym_case_statement_repeat1 = 264,
+	aux_sym_case_item_repeat1 = 265,
+	aux_sym_pipeline_repeat1 = 266,
+	aux_sym_declaration_command_repeat1 = 267,
+	aux_sym_unset_command_repeat1 = 268,
+	aux_sym_command_repeat1 = 269,
+	aux_sym_command_repeat2 = 270,
+	aux_sym_variable_assignments_repeat1 = 271,
+	aux_sym_heredoc_body_repeat1 = 272,
+	aux_sym__literal_repeat1 = 273,
+	aux_sym_arithmetic_expansion_repeat1 = 274,
+	aux_sym_concatenation_repeat1 = 275,
+	aux_sym_string_repeat1 = 276,
+	aux_sym__expansion_body_repeat1 = 277,
+	aux_sym__expansion_regex_repeat1 = 278,
+	aux_sym__concatenation_in_expansion_repeat1 = 279,
+};
+
+#endif // SYMBOLS_H

shcat_c/parser/src/lex_funcs/lex_keywords/create_table/lex_keywords_array.h

@@ -0,0 +1,30 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_keywords_array.h                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef LEX_KEYWORDS_ARRAY_H
+# define LEX_KEYWORDS_ARRAY_H
+
+# include "../../../types/type_lex_keywords.h"
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../char_set/charset_inline.h"
+# include "../lex_keywords_funcs.h"
+
+void	lex_keywords_array_0(t_lex_keywords_array *v);
+void	lex_keywords_array_1(t_lex_keywords_array *v);
+void	lex_keywords_array_2(t_lex_keywords_array *v);
+void	lex_keywords_array_3(t_lex_keywords_array *v);
+void	lex_keywords_array_4(t_lex_keywords_array *v);
+
+#endif // LEX_KEYWORDS_ARRAY_H

shcat_c/parser/src/lex_funcs/lex_keywords/create_table/lex_keywords_array_0.c

@@ -0,0 +1,140 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_keywords_array_0.c                             :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_keywords_funcs.h"
+#include "./lex_keywords_array.h"
+
+void	lex_keywords_array_0(t_lex_keywords_array *v)
+{
+	v->a[0] = lex_keywords_s0;
+	v->a[1] = lex_keywords_s1;
+	v->a[2] = lex_keywords_s2;
+	v->a[3] = lex_keywords_s3;
+	v->a[4] = lex_keywords_s4;
+	v->a[5] = lex_keywords_s5;
+	v->a[6] = lex_keywords_s6;
+	v->a[7] = lex_keywords_s7;
+	v->a[8] = lex_keywords_s8;
+	v->a[9] = lex_keywords_s9;
+	v->a[10] = lex_keywords_s10;
+	v->a[11] = lex_keywords_s11;
+	v->a[12] = lex_keywords_s12;
+	v->a[13] = lex_keywords_s13;
+	v->a[14] = lex_keywords_s14;
+	v->a[15] = lex_keywords_s15;
+	v->a[16] = lex_keywords_s16;
+	v->a[17] = lex_keywords_s17;
+	v->a[18] = lex_keywords_s18;
+	v->a[19] = lex_keywords_s19;
+	lex_keywords_array_1(v);
+}
+
+void	lex_keywords_array_1(t_lex_keywords_array *v)
+{
+	v->a[20] = lex_keywords_s20;
+	v->a[21] = lex_keywords_s21;
+	v->a[22] = lex_keywords_s22;
+	v->a[23] = lex_keywords_s23;
+	v->a[24] = lex_keywords_s24;
+	v->a[25] = lex_keywords_s25;
+	v->a[26] = lex_keywords_s26;
+	v->a[27] = lex_keywords_s27;
+	v->a[28] = lex_keywords_s28;
+	v->a[29] = lex_keywords_s29;
+	v->a[30] = lex_keywords_s30;
+	v->a[31] = lex_keywords_s31;
+	v->a[32] = lex_keywords_s32;
+	v->a[33] = lex_keywords_s33;
+	v->a[34] = lex_keywords_s34;
+	v->a[35] = lex_keywords_s35;
+	v->a[36] = lex_keywords_s36;
+	v->a[37] = lex_keywords_s37;
+	v->a[38] = lex_keywords_s38;
+	v->a[39] = lex_keywords_s39;
+	lex_keywords_array_2(v);
+}
+
+void	lex_keywords_array_2(t_lex_keywords_array *v)
+{
+	v->a[40] = lex_keywords_s40;
+	v->a[41] = lex_keywords_s41;
+	v->a[42] = lex_keywords_s42;
+	v->a[43] = lex_keywords_s43;
+	v->a[44] = lex_keywords_s44;
+	v->a[45] = lex_keywords_s45;
+	v->a[46] = lex_keywords_s46;
+	v->a[47] = lex_keywords_s47;
+	v->a[48] = lex_keywords_s48;
+	v->a[49] = lex_keywords_s49;
+	v->a[50] = lex_keywords_s50;
+	v->a[51] = lex_keywords_s51;
+	v->a[52] = lex_keywords_s52;
+	v->a[53] = lex_keywords_s53;
+	v->a[54] = lex_keywords_s54;
+	v->a[55] = lex_keywords_s55;
+	v->a[56] = lex_keywords_s56;
+	v->a[57] = lex_keywords_s57;
+	v->a[58] = lex_keywords_s58;
+	v->a[59] = lex_keywords_s59;
+	lex_keywords_array_3(v);
+}
+
+void	lex_keywords_array_3(t_lex_keywords_array *v)
+{
+	v->a[60] = lex_keywords_s60;
+	v->a[61] = lex_keywords_s61;
+	v->a[62] = lex_keywords_s62;
+	v->a[63] = lex_keywords_s63;
+	v->a[64] = lex_keywords_s64;
+	v->a[65] = lex_keywords_s65;
+	v->a[66] = lex_keywords_s66;
+	v->a[67] = lex_keywords_s67;
+	v->a[68] = lex_keywords_s68;
+	v->a[69] = lex_keywords_s69;
+	v->a[70] = lex_keywords_s70;
+	v->a[71] = lex_keywords_s71;
+	v->a[72] = lex_keywords_s72;
+	v->a[73] = lex_keywords_s73;
+	v->a[74] = lex_keywords_s74;
+	v->a[75] = lex_keywords_s75;
+	v->a[76] = lex_keywords_s76;
+	v->a[77] = lex_keywords_s77;
+	v->a[78] = lex_keywords_s78;
+	v->a[79] = lex_keywords_s79;
+	lex_keywords_array_4(v);
+}
+
+void	lex_keywords_array_4(t_lex_keywords_array *v)
+{
+	v->a[80] = lex_keywords_s80;
+	v->a[81] = lex_keywords_s81;
+	v->a[82] = lex_keywords_s82;
+	v->a[83] = lex_keywords_s83;
+	v->a[84] = lex_keywords_s84;
+	v->a[85] = lex_keywords_s85;
+	v->a[86] = lex_keywords_s86;
+	v->a[87] = lex_keywords_s87;
+	v->a[88] = lex_keywords_s88;
+	v->a[89] = lex_keywords_s89;
+	v->a[90] = lex_keywords_s90;
+	v->a[91] = lex_keywords_s91;
+	v->a[92] = lex_keywords_s92;
+	v->a[93] = lex_keywords_s93;
+	v->a[94] = lex_keywords_s94;
+	v->a[95] = lex_keywords_s95;
+	v->a[96] = lex_keywords_s96;
+}
+/* EOF lex_keywords_array_0.c */

shcat_c/parser/src/lex_funcs/lex_keywords/inline.h

@@ -0,0 +1,22 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline.h                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_H
+# define INLINE_H
+
+# include "../../headers/symbols.h"
+# include "../../headers/external_scanner_symbol_identifiers.h"
+# include "../../headers/field_identifiers.h"
+# include "../../headers/constants.h"
+# include "../../../parse_types.h"
+
+#endif // INLINE_H

shcat_c/parser/src/lex_funcs/lex_keywords/lex_keywords_funcs.h

@@ -0,0 +1,124 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_keywords_funcs.h                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef LEX_KEYWORDS_FUNCS_H
+# define LEX_KEYWORDS_FUNCS_H
+
+# include "../../types/type_lex_keywords.h"
+# include "../../headers/symbols.h"
+# include "../../headers/external_scanner_symbol_identifiers.h"
+# include "../../headers/field_identifiers.h"
+# include "../../headers/constants.h"
+# include "../../char_set/charset_inline.h"
+# include "./inline.h"
+# include "../../../parse_types.h"
+
+bool	lex_keywords_s0(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s1(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s2(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s3(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s4(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s5(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s6(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s7(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s8(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s9(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s10(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s11(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s12(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s13(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s14(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s15(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s16(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s17(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s18(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s19(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s20(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s21(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s22(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s23(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s24(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s25(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s26(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s27(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s28(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s29(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s30(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s31(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s32(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s33(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s34(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s35(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s36(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s37(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s38(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s39(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s40(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s41(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s42(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s43(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s44(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s45(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s46(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s47(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s48(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s49(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s50(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s51(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s52(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s53(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s54(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s55(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s56(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s57(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s58(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s59(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s60(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s61(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s62(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s63(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s64(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s65(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s66(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s67(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s68(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s69(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s70(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s71(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s72(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s73(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s74(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s75(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s76(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s77(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s78(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s79(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s80(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s81(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s82(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s83(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s84(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s85(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s86(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s87(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s88(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s89(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s90(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s91(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s92(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s93(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s94(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s95(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_s96(t_lexer *lexer, t_lexer_state *s);
+bool	lex_keywords_default(t_lexer *lexer, t_lexer_state *s);
+
+#endif // LEX_KEYWORDS_FUNCS_H

shcat_c/parser/src/lex_funcs/lex_keywords/main_func.c

@@ -0,0 +1,49 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   main_func.c                                        :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+t_lex_keywords_array	*create_lex_keywords(void);
+
+bool	lex_keywords_call(t_lexer *lexer, t_lexer_state *s)
+{
+	t_lex_keywords_array	*t;
+
+	t = create_lex_keywords();
+	if (s->state < 97)
+	{
+		return (((bool (*)(t_lexer *, t_lexer_state \
+	*))(t->a[s->state]))(lexer, s));
+	}
+	return (lex_keywords_default(lexer, s));
+}
+
+bool	lex_keywords_main(t_lexer *lexer, t_state_id state)
+{
+	t_lexer_state	s;
+
+	s = (t_lexer_state){.result = false, .skip = false, .eof = \
+	false};
+	s.state = state;
+	s.skip = false;
+	s.lookahead = lexer->lookahead;
+	s.eof = lexer->eof(lexer);
+	while (lex_keywords_call(lexer, &s))
+	{
+		lexer->advance(lexer, s.skip);
+		s.skip = false;
+		s.lookahead = lexer->lookahead;
+		s.eof = lexer->eof(lexer);
+	}
+	return (s.result);
+}
+/* main_func.c */

shcat_c/parser/src/lex_funcs/lex_keywords/state_0.c

@@ -0,0 +1,87 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_0.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s0(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'A')
+		return (lex_advance(1, lexer, s));
+	if (s->lookahead == 'E')
+		return (lex_advance(2, lexer, s));
+	if (s->lookahead == 'K')
+		return (lex_advance(3, lexer, s));
+	if (s->lookahead == 'L')
+		return (lex_advance(4, lexer, s));
+	if (s->lookahead == 'P')
+		return (lex_advance(5, lexer, s));
+	if (s->lookahead == 'Q')
+		return (lex_advance(6, lexer, s));
+	if (s->lookahead == 'U')
+		return (lex_advance(7, lexer, s));
+	if (s->lookahead == '\\')
+		return (lex_skip(8, lexer, s));
+	if (s->lookahead == 'a')
+		return (lex_advance(9, lexer, s));
+	if (s->lookahead == 'c')
+		return (lex_advance(10, lexer, s));
+	if (s->lookahead == 'd')
+		return (lex_advance(11, lexer, s));
+	if (s->lookahead == 'e')
+		return (lex_advance(12, lexer, s));
+	if (s->lookahead == 'f')
+		return (lex_advance(13, lexer, s));
+	if (s->lookahead == 'i')
+		return (lex_advance(14, lexer, s));
+	if (s->lookahead == 'k')
+		return (lex_advance(15, lexer, s));
+	if (s->lookahead == 'l')
+		return (lex_advance(16, lexer, s));
+	if (s->lookahead == 'r')
+		return (lex_advance(17, lexer, s));
+	if (s->lookahead == 's')
+		return (lex_advance(18, lexer, s));
+	if (s->lookahead == 't')
+		return (lex_advance(19, lexer, s));
+	if (s->lookahead == 'u')
+		return (lex_advance(20, lexer, s));
+	if (s->lookahead == 'w')
+		return (lex_advance(21, lexer, s));
+	if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
+	s->lookahead == ' '))
+		return (lex_skip(22, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s1(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_A, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s2(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_E, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s3(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_K, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s4(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_L, lexer, s);
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_1.c

@@ -0,0 +1,47 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_1.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s5(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_P, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s6(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_Q, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s7(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_U, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s8(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == '\r')
+		return (lex_skip(23, lexer, s));
+	if (((s->lookahead >= '\t' && s->lookahead <= '\f') || \
+	s->lookahead == ' '))
+		return (lex_skip(22, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s9(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_a, lexer, s);
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_10.c

@@ -0,0 +1,48 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_10.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s50(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'd')
+		return (lex_advance(65, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s51(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(66, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s52(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'n')
+		return (lex_advance(67, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s53(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(68, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s54(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(69, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_11.c

@@ -0,0 +1,46 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_11.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s55(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'i')
+		return (lex_advance(70, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s56(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'l')
+		return (lex_advance(71, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s57(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_case, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s58(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'a')
+		return (lex_advance(72, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s59(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_done, lexer, s);
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_12.c

@@ -0,0 +1,46 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_12.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s60(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_elif, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s61(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_else, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s62(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'r')
+		return (lex_advance(73, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s63(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 't')
+		return (lex_advance(74, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s64(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'l')
+		return (lex_advance(75, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_13.c

@@ -0,0 +1,47 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_13.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s65(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'o')
+		return (lex_advance(76, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s66(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'c')
+		return (lex_advance(77, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s67(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_then, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s68(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 's')
+		return (lex_advance(78, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s69(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 't')
+		return (lex_advance(79, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_14.c

@@ -0,0 +1,48 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_14.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s70(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'l')
+		return (lex_advance(80, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s71(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(81, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s72(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'r')
+		return (lex_advance(82, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s73(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 't')
+		return (lex_advance(83, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s74(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'i')
+		return (lex_advance(84, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_15.c

@@ -0,0 +1,48 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_15.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s75(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_local, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s76(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'n')
+		return (lex_advance(85, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s77(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 't')
+		return (lex_advance(86, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s78(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(87, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s79(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_unset, lexer, s);
+	if (s->lookahead == 'e')
+		return (lex_advance(88, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_16.c

@@ -0,0 +1,45 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_16.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s80(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_until, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s81(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_while, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s82(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(89, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s83(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_export, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s84(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'o')
+		return (lex_advance(90, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_17.c

@@ -0,0 +1,46 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_17.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s85(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'l')
+		return (lex_advance(91, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s86(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_select, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s87(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 't')
+		return (lex_advance(92, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s88(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'n')
+		return (lex_advance(93, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s89(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_declare, lexer, s);
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_18.c

@@ -0,0 +1,46 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_18.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s90(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'n')
+		return (lex_advance(94, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s91(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'y')
+		return (lex_advance(95, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s92(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_typeset, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s93(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'v')
+		return (lex_advance(96, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s94(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_function, lexer, s);
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_19.c

@@ -0,0 +1,33 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_19.c                                         :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s95(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_readonly, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s96(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_unsetenv, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_default(t_lexer *lexer, t_lexer_state *s)
+{
+	(void)(lexer);
+	(void)(s);
+	s->result = false;
+	return (false);
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_2.c

@@ -0,0 +1,56 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_2.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s10(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'a')
+		return (lex_advance(24, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s11(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(25, lexer, s));
+	if (s->lookahead == 'o')
+		return (lex_advance(26, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s12(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'l')
+		return (lex_advance(27, lexer, s));
+	if (s->lookahead == 'x')
+		return (lex_advance(28, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s13(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'i')
+		return (lex_advance(29, lexer, s));
+	if (s->lookahead == 'o')
+		return (lex_advance(30, lexer, s));
+	if (s->lookahead == 'u')
+		return (lex_advance(31, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s14(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'f')
+		return (lex_advance(32, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_3.c

@@ -0,0 +1,49 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_3.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s15(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_k, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s16(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'o')
+		return (lex_advance(33, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s17(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(34, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s18(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(35, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s19(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'h')
+		return (lex_advance(36, lexer, s));
+	if (s->lookahead == 'y')
+		return (lex_advance(37, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_4.c

@@ -0,0 +1,74 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_4.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s20(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_u, lexer, s);
+	if (s->lookahead == 'n')
+		return (lex_advance(38, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s21(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'h')
+		return (lex_advance(39, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s22(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == '\\')
+		return (lex_skip(8, lexer, s));
+	if (s->lookahead == 'c')
+		return (lex_advance(10, lexer, s));
+	if (s->lookahead == 'd')
+		return (lex_advance(11, lexer, s));
+	if (s->lookahead == 'e')
+		return (lex_advance(12, lexer, s));
+	if (s->lookahead == 'f')
+		return (lex_advance(13, lexer, s));
+	if (s->lookahead == 'i')
+		return (lex_advance(14, lexer, s));
+	if (s->lookahead == 'l')
+		return (lex_advance(16, lexer, s));
+	if (s->lookahead == 'r')
+		return (lex_advance(17, lexer, s));
+	if (s->lookahead == 's')
+		return (lex_advance(18, lexer, s));
+	if (s->lookahead == 't')
+		return (lex_advance(19, lexer, s));
+	if (s->lookahead == 'u')
+		return (lex_advance(40, lexer, s));
+	if (s->lookahead == 'w')
+		return (lex_advance(21, lexer, s));
+	if (((s->lookahead >= '\t' && s->lookahead <= '\r') || \
+	s->lookahead == ' '))
+		return (lex_skip(22, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s23(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == '\n')
+		return (lex_skip(22, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s24(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 's')
+		return (lex_advance(41, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_5.c

@@ -0,0 +1,50 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_5.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s25(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'c')
+		return (lex_advance(42, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s26(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_do, lexer, s);
+	if (s->lookahead == 'n')
+		return (lex_advance(43, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s27(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'i')
+		return (lex_advance(44, lexer, s));
+	if (s->lookahead == 's')
+		return (lex_advance(45, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s28(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'p')
+		return (lex_advance(46, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s29(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_fi, lexer, s);
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_6.c

@@ -0,0 +1,47 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_6.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s30(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'r')
+		return (lex_advance(47, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s31(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'n')
+		return (lex_advance(48, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s32(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_if, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s33(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'c')
+		return (lex_advance(49, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s34(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'a')
+		return (lex_advance(50, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_7.c

@@ -0,0 +1,50 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_7.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s35(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'l')
+		return (lex_advance(51, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s36(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(52, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s37(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'p')
+		return (lex_advance(53, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s38(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 's')
+		return (lex_advance(54, lexer, s));
+	if (s->lookahead == 't')
+		return (lex_advance(55, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s39(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'i')
+		return (lex_advance(56, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_8.c

@@ -0,0 +1,48 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_8.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s40(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'n')
+		return (lex_advance(38, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s41(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(57, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s42(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'l')
+		return (lex_advance(58, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s43(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(59, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s44(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'f')
+		return (lex_advance(60, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_keywords/state_9.c

@@ -0,0 +1,47 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   state_9.c                                          :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "./lex_keywords_funcs.h"
+
+bool	lex_keywords_s45(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'e')
+		return (lex_advance(61, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s46(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'o')
+		return (lex_advance(62, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s47(t_lexer *lexer, t_lexer_state *s)
+{
+	lex_accept_token(anon_sym_for, lexer, s);
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s48(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'c')
+		return (lex_advance(63, lexer, s));
+	return (lex_end_state(lexer, s));
+}
+
+bool	lex_keywords_s49(t_lexer *lexer, t_lexer_state *s)
+{
+	if (s->lookahead == 'a')
+		return (lex_advance(64, lexer, s));
+	return (lex_end_state(lexer, s));
+}

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array.h

@@ -0,0 +1,73 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array.h                                 :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef LEX_NORMAL_ARRAY_H
+# define LEX_NORMAL_ARRAY_H
+
+# include "../../../types/type_lex_normal.h"
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../char_set/charset_inline.h"
+# include "../lex_normal_funcs.h"
+
+void	lex_normal_array_0(t_lex_normal_array *v);
+void	lex_normal_array_1(t_lex_normal_array *v);
+void	lex_normal_array_2(t_lex_normal_array *v);
+void	lex_normal_array_3(t_lex_normal_array *v);
+void	lex_normal_array_4(t_lex_normal_array *v);
+void	lex_normal_array_5(t_lex_normal_array *v);
+void	lex_normal_array_6(t_lex_normal_array *v);
+void	lex_normal_array_7(t_lex_normal_array *v);
+void	lex_normal_array_8(t_lex_normal_array *v);
+void	lex_normal_array_9(t_lex_normal_array *v);
+void	lex_normal_array_10(t_lex_normal_array *v);
+void	lex_normal_array_11(t_lex_normal_array *v);
+void	lex_normal_array_12(t_lex_normal_array *v);
+void	lex_normal_array_13(t_lex_normal_array *v);
+void	lex_normal_array_14(t_lex_normal_array *v);
+void	lex_normal_array_15(t_lex_normal_array *v);
+void	lex_normal_array_16(t_lex_normal_array *v);
+void	lex_normal_array_17(t_lex_normal_array *v);
+void	lex_normal_array_18(t_lex_normal_array *v);
+void	lex_normal_array_19(t_lex_normal_array *v);
+void	lex_normal_array_20(t_lex_normal_array *v);
+void	lex_normal_array_21(t_lex_normal_array *v);
+void	lex_normal_array_22(t_lex_normal_array *v);
+void	lex_normal_array_23(t_lex_normal_array *v);
+void	lex_normal_array_24(t_lex_normal_array *v);
+void	lex_normal_array_25(t_lex_normal_array *v);
+void	lex_normal_array_26(t_lex_normal_array *v);
+void	lex_normal_array_27(t_lex_normal_array *v);
+void	lex_normal_array_28(t_lex_normal_array *v);
+void	lex_normal_array_29(t_lex_normal_array *v);
+void	lex_normal_array_30(t_lex_normal_array *v);
+void	lex_normal_array_31(t_lex_normal_array *v);
+void	lex_normal_array_32(t_lex_normal_array *v);
+void	lex_normal_array_33(t_lex_normal_array *v);
+void	lex_normal_array_34(t_lex_normal_array *v);
+void	lex_normal_array_35(t_lex_normal_array *v);
+void	lex_normal_array_36(t_lex_normal_array *v);
+void	lex_normal_array_37(t_lex_normal_array *v);
+void	lex_normal_array_38(t_lex_normal_array *v);
+void	lex_normal_array_39(t_lex_normal_array *v);
+void	lex_normal_array_40(t_lex_normal_array *v);
+void	lex_normal_array_41(t_lex_normal_array *v);
+void	lex_normal_array_42(t_lex_normal_array *v);
+void	lex_normal_array_43(t_lex_normal_array *v);
+void	lex_normal_array_44(t_lex_normal_array *v);
+void	lex_normal_array_45(t_lex_normal_array *v);
+void	lex_normal_array_46(t_lex_normal_array *v);
+void	lex_normal_array_47(t_lex_normal_array *v);
+
+#endif // LEX_NORMAL_ARRAY_H

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_0.c

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_0.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_0(t_lex_normal_array *v)
+{
+	v->a[0] = lex_normal_s0;
+	v->a[1] = lex_normal_s1;
+	v->a[2] = lex_normal_s2;
+	v->a[3] = lex_normal_s3;
+	v->a[4] = lex_normal_s4;
+	v->a[5] = lex_normal_s5;
+	v->a[6] = lex_normal_s6;
+	v->a[7] = lex_normal_s7;
+	v->a[8] = lex_normal_s8;
+	v->a[9] = lex_normal_s9;
+	v->a[10] = lex_normal_s10;
+	v->a[11] = lex_normal_s11;
+	v->a[12] = lex_normal_s12;
+	v->a[13] = lex_normal_s13;
+	v->a[14] = lex_normal_s14;
+	v->a[15] = lex_normal_s15;
+	v->a[16] = lex_normal_s16;
+	v->a[17] = lex_normal_s17;
+	v->a[18] = lex_normal_s18;
+	v->a[19] = lex_normal_s19;
+	lex_normal_array_1(v);
+}
+
+void	lex_normal_array_1(t_lex_normal_array *v)
+{
+	v->a[20] = lex_normal_s20;
+	v->a[21] = lex_normal_s21;
+	v->a[22] = lex_normal_s22;
+	v->a[23] = lex_normal_s23;
+	v->a[24] = lex_normal_s24;
+	v->a[25] = lex_normal_s25;
+	v->a[26] = lex_normal_s26;
+	v->a[27] = lex_normal_s27;
+	v->a[28] = lex_normal_s28;
+	v->a[29] = lex_normal_s29;
+	v->a[30] = lex_normal_s30;
+	v->a[31] = lex_normal_s31;
+	v->a[32] = lex_normal_s32;
+	v->a[33] = lex_normal_s33;
+	v->a[34] = lex_normal_s34;
+	v->a[35] = lex_normal_s35;
+	v->a[36] = lex_normal_s36;
+	v->a[37] = lex_normal_s37;
+	v->a[38] = lex_normal_s38;
+	v->a[39] = lex_normal_s39;
+	lex_normal_array_2(v);
+}
+
+void	lex_normal_array_2(t_lex_normal_array *v)
+{
+	v->a[40] = lex_normal_s40;
+	v->a[41] = lex_normal_s41;
+	v->a[42] = lex_normal_s42;
+	v->a[43] = lex_normal_s43;
+	v->a[44] = lex_normal_s44;
+	v->a[45] = lex_normal_s45;
+	v->a[46] = lex_normal_s46;
+	v->a[47] = lex_normal_s47;
+	v->a[48] = lex_normal_s48;
+	v->a[49] = lex_normal_s49;
+	v->a[50] = lex_normal_s50;
+	v->a[51] = lex_normal_s51;
+	v->a[52] = lex_normal_s52;
+	v->a[53] = lex_normal_s53;
+	v->a[54] = lex_normal_s54;
+	v->a[55] = lex_normal_s55;
+	v->a[56] = lex_normal_s56;
+	v->a[57] = lex_normal_s57;
+	v->a[58] = lex_normal_s58;
+	v->a[59] = lex_normal_s59;
+	lex_normal_array_3(v);
+}
+
+void	lex_normal_array_3(t_lex_normal_array *v)
+{
+	v->a[60] = lex_normal_s60;
+	v->a[61] = lex_normal_s61;
+	v->a[62] = lex_normal_s62;
+	v->a[63] = lex_normal_s63;
+	v->a[64] = lex_normal_s64;
+	v->a[65] = lex_normal_s65;
+	v->a[66] = lex_normal_s66;
+	v->a[67] = lex_normal_s67;
+	v->a[68] = lex_normal_s68;
+	v->a[69] = lex_normal_s69;
+	v->a[70] = lex_normal_s70;
+	v->a[71] = lex_normal_s71;
+	v->a[72] = lex_normal_s72;
+	v->a[73] = lex_normal_s73;
+	v->a[74] = lex_normal_s74;
+	v->a[75] = lex_normal_s75;
+	v->a[76] = lex_normal_s76;
+	v->a[77] = lex_normal_s77;
+	v->a[78] = lex_normal_s78;
+	v->a[79] = lex_normal_s79;
+	lex_normal_array_4(v);
+}
+
+void	lex_normal_array_4(t_lex_normal_array *v)
+{
+	v->a[80] = lex_normal_s80;
+	v->a[81] = lex_normal_s81;
+	v->a[82] = lex_normal_s82;
+	v->a[83] = lex_normal_s83;
+	v->a[84] = lex_normal_s84;
+	v->a[85] = lex_normal_s85;
+	v->a[86] = lex_normal_s86;
+	v->a[87] = lex_normal_s87;
+	v->a[88] = lex_normal_s88;
+	v->a[89] = lex_normal_s89;
+	v->a[90] = lex_normal_s90;
+	v->a[91] = lex_normal_s91;
+	v->a[92] = lex_normal_s92;
+	v->a[93] = lex_normal_s93;
+	v->a[94] = lex_normal_s94;
+	v->a[95] = lex_normal_s95;
+	v->a[96] = lex_normal_s96;
+	v->a[97] = lex_normal_s97;
+	v->a[98] = lex_normal_s98;
+	v->a[99] = lex_normal_s99;
+	lex_normal_array_5(v);
+}
+
+/* EOF lex_normal_array_0.c */

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_1.c

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_1.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_5(t_lex_normal_array *v)
+{
+	v->a[100] = lex_normal_s100;
+	v->a[101] = lex_normal_s101;
+	v->a[102] = lex_normal_s102;
+	v->a[103] = lex_normal_s103;
+	v->a[104] = lex_normal_s104;
+	v->a[105] = lex_normal_s105;
+	v->a[106] = lex_normal_s106;
+	v->a[107] = lex_normal_s107;
+	v->a[108] = lex_normal_s108;
+	v->a[109] = lex_normal_s109;
+	v->a[110] = lex_normal_s110;
+	v->a[111] = lex_normal_s111;
+	v->a[112] = lex_normal_s112;
+	v->a[113] = lex_normal_s113;
+	v->a[114] = lex_normal_s114;
+	v->a[115] = lex_normal_s115;
+	v->a[116] = lex_normal_s116;
+	v->a[117] = lex_normal_s117;
+	v->a[118] = lex_normal_s118;
+	v->a[119] = lex_normal_s119;
+	lex_normal_array_6(v);
+}
+
+void	lex_normal_array_6(t_lex_normal_array *v)
+{
+	v->a[120] = lex_normal_s120;
+	v->a[121] = lex_normal_s121;
+	v->a[122] = lex_normal_s122;
+	v->a[123] = lex_normal_s123;
+	v->a[124] = lex_normal_s124;
+	v->a[125] = lex_normal_s125;
+	v->a[126] = lex_normal_s126;
+	v->a[127] = lex_normal_s127;
+	v->a[128] = lex_normal_s128;
+	v->a[129] = lex_normal_s129;
+	v->a[130] = lex_normal_s130;
+	v->a[131] = lex_normal_s131;
+	v->a[132] = lex_normal_s132;
+	v->a[133] = lex_normal_s133;
+	v->a[134] = lex_normal_s134;
+	v->a[135] = lex_normal_s135;
+	v->a[136] = lex_normal_s136;
+	v->a[137] = lex_normal_s137;
+	v->a[138] = lex_normal_s138;
+	v->a[139] = lex_normal_s139;
+	lex_normal_array_7(v);
+}
+
+void	lex_normal_array_7(t_lex_normal_array *v)
+{
+	v->a[140] = lex_normal_s140;
+	v->a[141] = lex_normal_s141;
+	v->a[142] = lex_normal_s142;
+	v->a[143] = lex_normal_s143;
+	v->a[144] = lex_normal_s144;
+	v->a[145] = lex_normal_s145;
+	v->a[146] = lex_normal_s146;
+	v->a[147] = lex_normal_s147;
+	v->a[148] = lex_normal_s148;
+	v->a[149] = lex_normal_s149;
+	v->a[150] = lex_normal_s150;
+	v->a[151] = lex_normal_s151;
+	v->a[152] = lex_normal_s152;
+	v->a[153] = lex_normal_s153;
+	v->a[154] = lex_normal_s154;
+	v->a[155] = lex_normal_s155;
+	v->a[156] = lex_normal_s156;
+	v->a[157] = lex_normal_s157;
+	v->a[158] = lex_normal_s158;
+	v->a[159] = lex_normal_s159;
+	lex_normal_array_8(v);
+}
+
+void	lex_normal_array_8(t_lex_normal_array *v)
+{
+	v->a[160] = lex_normal_s160;
+	v->a[161] = lex_normal_s161;
+	v->a[162] = lex_normal_s162;
+	v->a[163] = lex_normal_s163;
+	v->a[164] = lex_normal_s164;
+	v->a[165] = lex_normal_s165;
+	v->a[166] = lex_normal_s166;
+	v->a[167] = lex_normal_s167;
+	v->a[168] = lex_normal_s168;
+	v->a[169] = lex_normal_s169;
+	v->a[170] = lex_normal_s170;
+	v->a[171] = lex_normal_s171;
+	v->a[172] = lex_normal_s172;
+	v->a[173] = lex_normal_s173;
+	v->a[174] = lex_normal_s174;
+	v->a[175] = lex_normal_s175;
+	v->a[176] = lex_normal_s176;
+	v->a[177] = lex_normal_s177;
+	v->a[178] = lex_normal_s178;
+	v->a[179] = lex_normal_s179;
+	lex_normal_array_9(v);
+}
+
+void	lex_normal_array_9(t_lex_normal_array *v)
+{
+	v->a[180] = lex_normal_s180;
+	v->a[181] = lex_normal_s181;
+	v->a[182] = lex_normal_s182;
+	v->a[183] = lex_normal_s183;
+	v->a[184] = lex_normal_s184;
+	v->a[185] = lex_normal_s185;
+	v->a[186] = lex_normal_s186;
+	v->a[187] = lex_normal_s187;
+	v->a[188] = lex_normal_s188;
+	v->a[189] = lex_normal_s189;
+	v->a[190] = lex_normal_s190;
+	v->a[191] = lex_normal_s191;
+	v->a[192] = lex_normal_s192;
+	v->a[193] = lex_normal_s193;
+	v->a[194] = lex_normal_s194;
+	v->a[195] = lex_normal_s195;
+	v->a[196] = lex_normal_s196;
+	v->a[197] = lex_normal_s197;
+	v->a[198] = lex_normal_s198;
+	v->a[199] = lex_normal_s199;
+	lex_normal_array_10(v);
+}
+
+/* EOF lex_normal_array_1.c */

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_2.c

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_2.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_10(t_lex_normal_array *v)
+{
+	v->a[200] = lex_normal_s200;
+	v->a[201] = lex_normal_s201;
+	v->a[202] = lex_normal_s202;
+	v->a[203] = lex_normal_s203;
+	v->a[204] = lex_normal_s204;
+	v->a[205] = lex_normal_s205;
+	v->a[206] = lex_normal_s206;
+	v->a[207] = lex_normal_s207;
+	v->a[208] = lex_normal_s208;
+	v->a[209] = lex_normal_s209;
+	v->a[210] = lex_normal_s210;
+	v->a[211] = lex_normal_s211;
+	v->a[212] = lex_normal_s212;
+	v->a[213] = lex_normal_s213;
+	v->a[214] = lex_normal_s214;
+	v->a[215] = lex_normal_s215;
+	v->a[216] = lex_normal_s216;
+	v->a[217] = lex_normal_s217;
+	v->a[218] = lex_normal_s218;
+	v->a[219] = lex_normal_s219;
+	lex_normal_array_11(v);
+}
+
+void	lex_normal_array_11(t_lex_normal_array *v)
+{
+	v->a[220] = lex_normal_s220;
+	v->a[221] = lex_normal_s221;
+	v->a[222] = lex_normal_s222;
+	v->a[223] = lex_normal_s223;
+	v->a[224] = lex_normal_s224;
+	v->a[225] = lex_normal_s225;
+	v->a[226] = lex_normal_s226;
+	v->a[227] = lex_normal_s227;
+	v->a[228] = lex_normal_s228;
+	v->a[229] = lex_normal_s229;
+	v->a[230] = lex_normal_s230;
+	v->a[231] = lex_normal_s231;
+	v->a[232] = lex_normal_s232;
+	v->a[233] = lex_normal_s233;
+	v->a[234] = lex_normal_s234;
+	v->a[235] = lex_normal_s235;
+	v->a[236] = lex_normal_s236;
+	v->a[237] = lex_normal_s237;
+	v->a[238] = lex_normal_s238;
+	v->a[239] = lex_normal_s239;
+	lex_normal_array_12(v);
+}
+
+void	lex_normal_array_12(t_lex_normal_array *v)
+{
+	v->a[240] = lex_normal_s240;
+	v->a[241] = lex_normal_s241;
+	v->a[242] = lex_normal_s242;
+	v->a[243] = lex_normal_s243;
+	v->a[244] = lex_normal_s244;
+	v->a[245] = lex_normal_s245;
+	v->a[246] = lex_normal_s246;
+	v->a[247] = lex_normal_s247;
+	v->a[248] = lex_normal_s248;
+	v->a[249] = lex_normal_s249;
+	v->a[250] = lex_normal_s250;
+	v->a[251] = lex_normal_s251;
+	v->a[252] = lex_normal_s252;
+	v->a[253] = lex_normal_s253;
+	v->a[254] = lex_normal_s254;
+	v->a[255] = lex_normal_s255;
+	v->a[256] = lex_normal_s256;
+	v->a[257] = lex_normal_s257;
+	v->a[258] = lex_normal_s258;
+	v->a[259] = lex_normal_s259;
+	lex_normal_array_13(v);
+}
+
+void	lex_normal_array_13(t_lex_normal_array *v)
+{
+	v->a[260] = lex_normal_s260;
+	v->a[261] = lex_normal_s261;
+	v->a[262] = lex_normal_s262;
+	v->a[263] = lex_normal_s263;
+	v->a[264] = lex_normal_s264;
+	v->a[265] = lex_normal_s265;
+	v->a[266] = lex_normal_s266;
+	v->a[267] = lex_normal_s267;
+	v->a[268] = lex_normal_s268;
+	v->a[269] = lex_normal_s269;
+	v->a[270] = lex_normal_s270;
+	v->a[271] = lex_normal_s271;
+	v->a[272] = lex_normal_s272;
+	v->a[273] = lex_normal_s273;
+	v->a[274] = lex_normal_s274;
+	v->a[275] = lex_normal_s275;
+	v->a[276] = lex_normal_s276;
+	v->a[277] = lex_normal_s277;
+	v->a[278] = lex_normal_s278;
+	v->a[279] = lex_normal_s279;
+	lex_normal_array_14(v);
+}
+
+void	lex_normal_array_14(t_lex_normal_array *v)
+{
+	v->a[280] = lex_normal_s280;
+	v->a[281] = lex_normal_s281;
+	v->a[282] = lex_normal_s282;
+	v->a[283] = lex_normal_s283;
+	v->a[284] = lex_normal_s284;
+	v->a[285] = lex_normal_s285;
+	v->a[286] = lex_normal_s286;
+	v->a[287] = lex_normal_s287;
+	v->a[288] = lex_normal_s288;
+	v->a[289] = lex_normal_s289;
+	v->a[290] = lex_normal_s290;
+	v->a[291] = lex_normal_s291;
+	v->a[292] = lex_normal_s292;
+	v->a[293] = lex_normal_s293;
+	v->a[294] = lex_normal_s294;
+	v->a[295] = lex_normal_s295;
+	v->a[296] = lex_normal_s296;
+	v->a[297] = lex_normal_s297;
+	v->a[298] = lex_normal_s298;
+	v->a[299] = lex_normal_s299;
+	lex_normal_array_15(v);
+}
+
+/* EOF lex_normal_array_2.c */

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_3.c

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_3.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_15(t_lex_normal_array *v)
+{
+	v->a[300] = lex_normal_s300;
+	v->a[301] = lex_normal_s301;
+	v->a[302] = lex_normal_s302;
+	v->a[303] = lex_normal_s303;
+	v->a[304] = lex_normal_s304;
+	v->a[305] = lex_normal_s305;
+	v->a[306] = lex_normal_s306;
+	v->a[307] = lex_normal_s307;
+	v->a[308] = lex_normal_s308;
+	v->a[309] = lex_normal_s309;
+	v->a[310] = lex_normal_s310;
+	v->a[311] = lex_normal_s311;
+	v->a[312] = lex_normal_s312;
+	v->a[313] = lex_normal_s313;
+	v->a[314] = lex_normal_s314;
+	v->a[315] = lex_normal_s315;
+	v->a[316] = lex_normal_s316;
+	v->a[317] = lex_normal_s317;
+	v->a[318] = lex_normal_s318;
+	v->a[319] = lex_normal_s319;
+	lex_normal_array_16(v);
+}
+
+void	lex_normal_array_16(t_lex_normal_array *v)
+{
+	v->a[320] = lex_normal_s320;
+	v->a[321] = lex_normal_s321;
+	v->a[322] = lex_normal_s322;
+	v->a[323] = lex_normal_s323;
+	v->a[324] = lex_normal_s324;
+	v->a[325] = lex_normal_s325;
+	v->a[326] = lex_normal_s326;
+	v->a[327] = lex_normal_s327;
+	v->a[328] = lex_normal_s328;
+	v->a[329] = lex_normal_s329;
+	v->a[330] = lex_normal_s330;
+	v->a[331] = lex_normal_s331;
+	v->a[332] = lex_normal_s332;
+	v->a[333] = lex_normal_s333;
+	v->a[334] = lex_normal_s334;
+	v->a[335] = lex_normal_s335;
+	v->a[336] = lex_normal_s336;
+	v->a[337] = lex_normal_s337;
+	v->a[338] = lex_normal_s338;
+	v->a[339] = lex_normal_s339;
+	lex_normal_array_17(v);
+}
+
+void	lex_normal_array_17(t_lex_normal_array *v)
+{
+	v->a[340] = lex_normal_s340;
+	v->a[341] = lex_normal_s341;
+	v->a[342] = lex_normal_s342;
+	v->a[343] = lex_normal_s343;
+	v->a[344] = lex_normal_s344;
+	v->a[345] = lex_normal_s345;
+	v->a[346] = lex_normal_s346;
+	v->a[347] = lex_normal_s347;
+	v->a[348] = lex_normal_s348;
+	v->a[349] = lex_normal_s349;
+	v->a[350] = lex_normal_s350;
+	v->a[351] = lex_normal_s351;
+	v->a[352] = lex_normal_s352;
+	v->a[353] = lex_normal_s353;
+	v->a[354] = lex_normal_s354;
+	v->a[355] = lex_normal_s355;
+	v->a[356] = lex_normal_s356;
+	v->a[357] = lex_normal_s357;
+	v->a[358] = lex_normal_s358;
+	v->a[359] = lex_normal_s359;
+	lex_normal_array_18(v);
+}
+
+void	lex_normal_array_18(t_lex_normal_array *v)
+{
+	v->a[360] = lex_normal_s360;
+	v->a[361] = lex_normal_s361;
+	v->a[362] = lex_normal_s362;
+	v->a[363] = lex_normal_s363;
+	v->a[364] = lex_normal_s364;
+	v->a[365] = lex_normal_s365;
+	v->a[366] = lex_normal_s366;
+	v->a[367] = lex_normal_s367;
+	v->a[368] = lex_normal_s368;
+	v->a[369] = lex_normal_s369;
+	v->a[370] = lex_normal_s370;
+	v->a[371] = lex_normal_s371;
+	v->a[372] = lex_normal_s372;
+	v->a[373] = lex_normal_s373;
+	v->a[374] = lex_normal_s374;
+	v->a[375] = lex_normal_s375;
+	v->a[376] = lex_normal_s376;
+	v->a[377] = lex_normal_s377;
+	v->a[378] = lex_normal_s378;
+	v->a[379] = lex_normal_s379;
+	lex_normal_array_19(v);
+}
+
+void	lex_normal_array_19(t_lex_normal_array *v)
+{
+	v->a[380] = lex_normal_s380;
+	v->a[381] = lex_normal_s381;
+	v->a[382] = lex_normal_s382;
+	v->a[383] = lex_normal_s383;
+	v->a[384] = lex_normal_s384;
+	v->a[385] = lex_normal_s385;
+	v->a[386] = lex_normal_s386;
+	v->a[387] = lex_normal_s387;
+	v->a[388] = lex_normal_s388;
+	v->a[389] = lex_normal_s389;
+	v->a[390] = lex_normal_s390;
+	v->a[391] = lex_normal_s391;
+	v->a[392] = lex_normal_s392;
+	v->a[393] = lex_normal_s393;
+	v->a[394] = lex_normal_s394;
+	v->a[395] = lex_normal_s395;
+	v->a[396] = lex_normal_s396;
+	v->a[397] = lex_normal_s397;
+	v->a[398] = lex_normal_s398;
+	v->a[399] = lex_normal_s399;
+	lex_normal_array_20(v);
+}
+
+/* EOF lex_normal_array_3.c */

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_4.c

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_4.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_20(t_lex_normal_array *v)
+{
+	v->a[400] = lex_normal_s400;
+	v->a[401] = lex_normal_s401;
+	v->a[402] = lex_normal_s402;
+	v->a[403] = lex_normal_s403;
+	v->a[404] = lex_normal_s404;
+	v->a[405] = lex_normal_s405;
+	v->a[406] = lex_normal_s406;
+	v->a[407] = lex_normal_s407;
+	v->a[408] = lex_normal_s408;
+	v->a[409] = lex_normal_s409;
+	v->a[410] = lex_normal_s410;
+	v->a[411] = lex_normal_s411;
+	v->a[412] = lex_normal_s412;
+	v->a[413] = lex_normal_s413;
+	v->a[414] = lex_normal_s414;
+	v->a[415] = lex_normal_s415;
+	v->a[416] = lex_normal_s416;
+	v->a[417] = lex_normal_s417;
+	v->a[418] = lex_normal_s418;
+	v->a[419] = lex_normal_s419;
+	lex_normal_array_21(v);
+}
+
+void	lex_normal_array_21(t_lex_normal_array *v)
+{
+	v->a[420] = lex_normal_s420;
+	v->a[421] = lex_normal_s421;
+	v->a[422] = lex_normal_s422;
+	v->a[423] = lex_normal_s423;
+	v->a[424] = lex_normal_s424;
+	v->a[425] = lex_normal_s425;
+	v->a[426] = lex_normal_s426;
+	v->a[427] = lex_normal_s427;
+	v->a[428] = lex_normal_s428;
+	v->a[429] = lex_normal_s429;
+	v->a[430] = lex_normal_s430;
+	v->a[431] = lex_normal_s431;
+	v->a[432] = lex_normal_s432;
+	v->a[433] = lex_normal_s433;
+	v->a[434] = lex_normal_s434;
+	v->a[435] = lex_normal_s435;
+	v->a[436] = lex_normal_s436;
+	v->a[437] = lex_normal_s437;
+	v->a[438] = lex_normal_s438;
+	v->a[439] = lex_normal_s439;
+	lex_normal_array_22(v);
+}
+
+void	lex_normal_array_22(t_lex_normal_array *v)
+{
+	v->a[440] = lex_normal_s440;
+	v->a[441] = lex_normal_s441;
+	v->a[442] = lex_normal_s442;
+	v->a[443] = lex_normal_s443;
+	v->a[444] = lex_normal_s444;
+	v->a[445] = lex_normal_s445;
+	v->a[446] = lex_normal_s446;
+	v->a[447] = lex_normal_s447;
+	v->a[448] = lex_normal_s448;
+	v->a[449] = lex_normal_s449;
+	v->a[450] = lex_normal_s450;
+	v->a[451] = lex_normal_s451;
+	v->a[452] = lex_normal_s452;
+	v->a[453] = lex_normal_s453;
+	v->a[454] = lex_normal_s454;
+	v->a[455] = lex_normal_s455;
+	v->a[456] = lex_normal_s456;
+	v->a[457] = lex_normal_s457;
+	v->a[458] = lex_normal_s458;
+	v->a[459] = lex_normal_s459;
+	lex_normal_array_23(v);
+}
+
+void	lex_normal_array_23(t_lex_normal_array *v)
+{
+	v->a[460] = lex_normal_s460;
+	v->a[461] = lex_normal_s461;
+	v->a[462] = lex_normal_s462;
+	v->a[463] = lex_normal_s463;
+	v->a[464] = lex_normal_s464;
+	v->a[465] = lex_normal_s465;
+	v->a[466] = lex_normal_s466;
+	v->a[467] = lex_normal_s467;
+	v->a[468] = lex_normal_s468;
+	v->a[469] = lex_normal_s469;
+	v->a[470] = lex_normal_s470;
+	v->a[471] = lex_normal_s471;
+	v->a[472] = lex_normal_s472;
+	v->a[473] = lex_normal_s473;
+	v->a[474] = lex_normal_s474;
+	v->a[475] = lex_normal_s475;
+	v->a[476] = lex_normal_s476;
+	v->a[477] = lex_normal_s477;
+	v->a[478] = lex_normal_s478;
+	v->a[479] = lex_normal_s479;
+	lex_normal_array_24(v);
+}
+
+void	lex_normal_array_24(t_lex_normal_array *v)
+{
+	v->a[480] = lex_normal_s480;
+	v->a[481] = lex_normal_s481;
+	v->a[482] = lex_normal_s482;
+	v->a[483] = lex_normal_s483;
+	v->a[484] = lex_normal_s484;
+	v->a[485] = lex_normal_s485;
+	v->a[486] = lex_normal_s486;
+	v->a[487] = lex_normal_s487;
+	v->a[488] = lex_normal_s488;
+	v->a[489] = lex_normal_s489;
+	v->a[490] = lex_normal_s490;
+	v->a[491] = lex_normal_s491;
+	v->a[492] = lex_normal_s492;
+	v->a[493] = lex_normal_s493;
+	v->a[494] = lex_normal_s494;
+	v->a[495] = lex_normal_s495;
+	v->a[496] = lex_normal_s496;
+	v->a[497] = lex_normal_s497;
+	v->a[498] = lex_normal_s498;
+	v->a[499] = lex_normal_s499;
+	lex_normal_array_25(v);
+}
+
+/* EOF lex_normal_array_4.c */

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_5.c

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_5.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_25(t_lex_normal_array *v)
+{
+	v->a[500] = lex_normal_s500;
+	v->a[501] = lex_normal_s501;
+	v->a[502] = lex_normal_s502;
+	v->a[503] = lex_normal_s503;
+	v->a[504] = lex_normal_s504;
+	v->a[505] = lex_normal_s505;
+	v->a[506] = lex_normal_s506;
+	v->a[507] = lex_normal_s507;
+	v->a[508] = lex_normal_s508;
+	v->a[509] = lex_normal_s509;
+	v->a[510] = lex_normal_s510;
+	v->a[511] = lex_normal_s511;
+	v->a[512] = lex_normal_s512;
+	v->a[513] = lex_normal_s513;
+	v->a[514] = lex_normal_s514;
+	v->a[515] = lex_normal_s515;
+	v->a[516] = lex_normal_s516;
+	v->a[517] = lex_normal_s517;
+	v->a[518] = lex_normal_s518;
+	v->a[519] = lex_normal_s519;
+	lex_normal_array_26(v);
+}
+
+void	lex_normal_array_26(t_lex_normal_array *v)
+{
+	v->a[520] = lex_normal_s520;
+	v->a[521] = lex_normal_s521;
+	v->a[522] = lex_normal_s522;
+	v->a[523] = lex_normal_s523;
+	v->a[524] = lex_normal_s524;
+	v->a[525] = lex_normal_s525;
+	v->a[526] = lex_normal_s526;
+	v->a[527] = lex_normal_s527;
+	v->a[528] = lex_normal_s528;
+	v->a[529] = lex_normal_s529;
+	v->a[530] = lex_normal_s530;
+	v->a[531] = lex_normal_s531;
+	v->a[532] = lex_normal_s532;
+	v->a[533] = lex_normal_s533;
+	v->a[534] = lex_normal_s534;
+	v->a[535] = lex_normal_s535;
+	v->a[536] = lex_normal_s536;
+	v->a[537] = lex_normal_s537;
+	v->a[538] = lex_normal_s538;
+	v->a[539] = lex_normal_s539;
+	lex_normal_array_27(v);
+}
+
+void	lex_normal_array_27(t_lex_normal_array *v)
+{
+	v->a[540] = lex_normal_s540;
+	v->a[541] = lex_normal_s541;
+	v->a[542] = lex_normal_s542;
+	v->a[543] = lex_normal_s543;
+	v->a[544] = lex_normal_s544;
+	v->a[545] = lex_normal_s545;
+	v->a[546] = lex_normal_s546;
+	v->a[547] = lex_normal_s547;
+	v->a[548] = lex_normal_s548;
+	v->a[549] = lex_normal_s549;
+	v->a[550] = lex_normal_s550;
+	v->a[551] = lex_normal_s551;
+	v->a[552] = lex_normal_s552;
+	v->a[553] = lex_normal_s553;
+	v->a[554] = lex_normal_s554;
+	v->a[555] = lex_normal_s555;
+	v->a[556] = lex_normal_s556;
+	v->a[557] = lex_normal_s557;
+	v->a[558] = lex_normal_s558;
+	v->a[559] = lex_normal_s559;
+	lex_normal_array_28(v);
+}
+
+void	lex_normal_array_28(t_lex_normal_array *v)
+{
+	v->a[560] = lex_normal_s560;
+	v->a[561] = lex_normal_s561;
+	v->a[562] = lex_normal_s562;
+	v->a[563] = lex_normal_s563;
+	v->a[564] = lex_normal_s564;
+	v->a[565] = lex_normal_s565;
+	v->a[566] = lex_normal_s566;
+	v->a[567] = lex_normal_s567;
+	v->a[568] = lex_normal_s568;
+	v->a[569] = lex_normal_s569;
+	v->a[570] = lex_normal_s570;
+	v->a[571] = lex_normal_s571;
+	v->a[572] = lex_normal_s572;
+	v->a[573] = lex_normal_s573;
+	v->a[574] = lex_normal_s574;
+	v->a[575] = lex_normal_s575;
+	v->a[576] = lex_normal_s576;
+	v->a[577] = lex_normal_s577;
+	v->a[578] = lex_normal_s578;
+	v->a[579] = lex_normal_s579;
+	lex_normal_array_29(v);
+}
+
+void	lex_normal_array_29(t_lex_normal_array *v)
+{
+	v->a[580] = lex_normal_s580;
+	v->a[581] = lex_normal_s581;
+	v->a[582] = lex_normal_s582;
+	v->a[583] = lex_normal_s583;
+	v->a[584] = lex_normal_s584;
+	v->a[585] = lex_normal_s585;
+	v->a[586] = lex_normal_s586;
+	v->a[587] = lex_normal_s587;
+	v->a[588] = lex_normal_s588;
+	v->a[589] = lex_normal_s589;
+	v->a[590] = lex_normal_s590;
+	v->a[591] = lex_normal_s591;
+	v->a[592] = lex_normal_s592;
+	v->a[593] = lex_normal_s593;
+	v->a[594] = lex_normal_s594;
+	v->a[595] = lex_normal_s595;
+	v->a[596] = lex_normal_s596;
+	v->a[597] = lex_normal_s597;
+	v->a[598] = lex_normal_s598;
+	v->a[599] = lex_normal_s599;
+	lex_normal_array_30(v);
+}
+
+/* EOF lex_normal_array_5.c */

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_6.c

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_6.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_30(t_lex_normal_array *v)
+{
+	v->a[600] = lex_normal_s600;
+	v->a[601] = lex_normal_s601;
+	v->a[602] = lex_normal_s602;
+	v->a[603] = lex_normal_s603;
+	v->a[604] = lex_normal_s604;
+	v->a[605] = lex_normal_s605;
+	v->a[606] = lex_normal_s606;
+	v->a[607] = lex_normal_s607;
+	v->a[608] = lex_normal_s608;
+	v->a[609] = lex_normal_s609;
+	v->a[610] = lex_normal_s610;
+	v->a[611] = lex_normal_s611;
+	v->a[612] = lex_normal_s612;
+	v->a[613] = lex_normal_s613;
+	v->a[614] = lex_normal_s614;
+	v->a[615] = lex_normal_s615;
+	v->a[616] = lex_normal_s616;
+	v->a[617] = lex_normal_s617;
+	v->a[618] = lex_normal_s618;
+	v->a[619] = lex_normal_s619;
+	lex_normal_array_31(v);
+}
+
+void	lex_normal_array_31(t_lex_normal_array *v)
+{
+	v->a[620] = lex_normal_s620;
+	v->a[621] = lex_normal_s621;
+	v->a[622] = lex_normal_s622;
+	v->a[623] = lex_normal_s623;
+	v->a[624] = lex_normal_s624;
+	v->a[625] = lex_normal_s625;
+	v->a[626] = lex_normal_s626;
+	v->a[627] = lex_normal_s627;
+	v->a[628] = lex_normal_s628;
+	v->a[629] = lex_normal_s629;
+	v->a[630] = lex_normal_s630;
+	v->a[631] = lex_normal_s631;
+	v->a[632] = lex_normal_s632;
+	v->a[633] = lex_normal_s633;
+	v->a[634] = lex_normal_s634;
+	v->a[635] = lex_normal_s635;
+	v->a[636] = lex_normal_s636;
+	v->a[637] = lex_normal_s637;
+	v->a[638] = lex_normal_s638;
+	v->a[639] = lex_normal_s639;
+	lex_normal_array_32(v);
+}
+
+void	lex_normal_array_32(t_lex_normal_array *v)
+{
+	v->a[640] = lex_normal_s640;
+	v->a[641] = lex_normal_s641;
+	v->a[642] = lex_normal_s642;
+	v->a[643] = lex_normal_s643;
+	v->a[644] = lex_normal_s644;
+	v->a[645] = lex_normal_s645;
+	v->a[646] = lex_normal_s646;
+	v->a[647] = lex_normal_s647;
+	v->a[648] = lex_normal_s648;
+	v->a[649] = lex_normal_s649;
+	v->a[650] = lex_normal_s650;
+	v->a[651] = lex_normal_s651;
+	v->a[652] = lex_normal_s652;
+	v->a[653] = lex_normal_s653;
+	v->a[654] = lex_normal_s654;
+	v->a[655] = lex_normal_s655;
+	v->a[656] = lex_normal_s656;
+	v->a[657] = lex_normal_s657;
+	v->a[658] = lex_normal_s658;
+	v->a[659] = lex_normal_s659;
+	lex_normal_array_33(v);
+}
+
+void	lex_normal_array_33(t_lex_normal_array *v)
+{
+	v->a[660] = lex_normal_s660;
+	v->a[661] = lex_normal_s661;
+	v->a[662] = lex_normal_s662;
+	v->a[663] = lex_normal_s663;
+	v->a[664] = lex_normal_s664;
+	v->a[665] = lex_normal_s665;
+	v->a[666] = lex_normal_s666;
+	v->a[667] = lex_normal_s667;
+	v->a[668] = lex_normal_s668;
+	v->a[669] = lex_normal_s669;
+	v->a[670] = lex_normal_s670;
+	v->a[671] = lex_normal_s671;
+	v->a[672] = lex_normal_s672;
+	v->a[673] = lex_normal_s673;
+	v->a[674] = lex_normal_s674;
+	v->a[675] = lex_normal_s675;
+	v->a[676] = lex_normal_s676;
+	v->a[677] = lex_normal_s677;
+	v->a[678] = lex_normal_s678;
+	v->a[679] = lex_normal_s679;
+	lex_normal_array_34(v);
+}
+
+void	lex_normal_array_34(t_lex_normal_array *v)
+{
+	v->a[680] = lex_normal_s680;
+	v->a[681] = lex_normal_s681;
+	v->a[682] = lex_normal_s682;
+	v->a[683] = lex_normal_s683;
+	v->a[684] = lex_normal_s684;
+	v->a[685] = lex_normal_s685;
+	v->a[686] = lex_normal_s686;
+	v->a[687] = lex_normal_s687;
+	v->a[688] = lex_normal_s688;
+	v->a[689] = lex_normal_s689;
+	v->a[690] = lex_normal_s690;
+	v->a[691] = lex_normal_s691;
+	v->a[692] = lex_normal_s692;
+	v->a[693] = lex_normal_s693;
+	v->a[694] = lex_normal_s694;
+	v->a[695] = lex_normal_s695;
+	v->a[696] = lex_normal_s696;
+	v->a[697] = lex_normal_s697;
+	v->a[698] = lex_normal_s698;
+	v->a[699] = lex_normal_s699;
+	lex_normal_array_35(v);
+}
+
+/* EOF lex_normal_array_6.c */

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_7.c

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_7.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_35(t_lex_normal_array *v)
+{
+	v->a[700] = lex_normal_s700;
+	v->a[701] = lex_normal_s701;
+	v->a[702] = lex_normal_s702;
+	v->a[703] = lex_normal_s703;
+	v->a[704] = lex_normal_s704;
+	v->a[705] = lex_normal_s705;
+	v->a[706] = lex_normal_s706;
+	v->a[707] = lex_normal_s707;
+	v->a[708] = lex_normal_s708;
+	v->a[709] = lex_normal_s709;
+	v->a[710] = lex_normal_s710;
+	v->a[711] = lex_normal_s711;
+	v->a[712] = lex_normal_s712;
+	v->a[713] = lex_normal_s713;
+	v->a[714] = lex_normal_s714;
+	v->a[715] = lex_normal_s715;
+	v->a[716] = lex_normal_s716;
+	v->a[717] = lex_normal_s717;
+	v->a[718] = lex_normal_s718;
+	v->a[719] = lex_normal_s719;
+	lex_normal_array_36(v);
+}
+
+void	lex_normal_array_36(t_lex_normal_array *v)
+{
+	v->a[720] = lex_normal_s720;
+	v->a[721] = lex_normal_s721;
+	v->a[722] = lex_normal_s722;
+	v->a[723] = lex_normal_s723;
+	v->a[724] = lex_normal_s724;
+	v->a[725] = lex_normal_s725;
+	v->a[726] = lex_normal_s726;
+	v->a[727] = lex_normal_s727;
+	v->a[728] = lex_normal_s728;
+	v->a[729] = lex_normal_s729;
+	v->a[730] = lex_normal_s730;
+	v->a[731] = lex_normal_s731;
+	v->a[732] = lex_normal_s732;
+	v->a[733] = lex_normal_s733;
+	v->a[734] = lex_normal_s734;
+	v->a[735] = lex_normal_s735;
+	v->a[736] = lex_normal_s736;
+	v->a[737] = lex_normal_s737;
+	v->a[738] = lex_normal_s738;
+	v->a[739] = lex_normal_s739;
+	lex_normal_array_37(v);
+}
+
+void	lex_normal_array_37(t_lex_normal_array *v)
+{
+	v->a[740] = lex_normal_s740;
+	v->a[741] = lex_normal_s741;
+	v->a[742] = lex_normal_s742;
+	v->a[743] = lex_normal_s743;
+	v->a[744] = lex_normal_s744;
+	v->a[745] = lex_normal_s745;
+	v->a[746] = lex_normal_s746;
+	v->a[747] = lex_normal_s747;
+	v->a[748] = lex_normal_s748;
+	v->a[749] = lex_normal_s749;
+	v->a[750] = lex_normal_s750;
+	v->a[751] = lex_normal_s751;
+	v->a[752] = lex_normal_s752;
+	v->a[753] = lex_normal_s753;
+	v->a[754] = lex_normal_s754;
+	v->a[755] = lex_normal_s755;
+	v->a[756] = lex_normal_s756;
+	v->a[757] = lex_normal_s757;
+	v->a[758] = lex_normal_s758;
+	v->a[759] = lex_normal_s759;
+	lex_normal_array_38(v);
+}
+
+void	lex_normal_array_38(t_lex_normal_array *v)
+{
+	v->a[760] = lex_normal_s760;
+	v->a[761] = lex_normal_s761;
+	v->a[762] = lex_normal_s762;
+	v->a[763] = lex_normal_s763;
+	v->a[764] = lex_normal_s764;
+	v->a[765] = lex_normal_s765;
+	v->a[766] = lex_normal_s766;
+	v->a[767] = lex_normal_s767;
+	v->a[768] = lex_normal_s768;
+	v->a[769] = lex_normal_s769;
+	v->a[770] = lex_normal_s770;
+	v->a[771] = lex_normal_s771;
+	v->a[772] = lex_normal_s772;
+	v->a[773] = lex_normal_s773;
+	v->a[774] = lex_normal_s774;
+	v->a[775] = lex_normal_s775;
+	v->a[776] = lex_normal_s776;
+	v->a[777] = lex_normal_s777;
+	v->a[778] = lex_normal_s778;
+	v->a[779] = lex_normal_s779;
+	lex_normal_array_39(v);
+}
+
+void	lex_normal_array_39(t_lex_normal_array *v)
+{
+	v->a[780] = lex_normal_s780;
+	v->a[781] = lex_normal_s781;
+	v->a[782] = lex_normal_s782;
+	v->a[783] = lex_normal_s783;
+	v->a[784] = lex_normal_s784;
+	v->a[785] = lex_normal_s785;
+	v->a[786] = lex_normal_s786;
+	v->a[787] = lex_normal_s787;
+	v->a[788] = lex_normal_s788;
+	v->a[789] = lex_normal_s789;
+	v->a[790] = lex_normal_s790;
+	v->a[791] = lex_normal_s791;
+	v->a[792] = lex_normal_s792;
+	v->a[793] = lex_normal_s793;
+	v->a[794] = lex_normal_s794;
+	v->a[795] = lex_normal_s795;
+	v->a[796] = lex_normal_s796;
+	v->a[797] = lex_normal_s797;
+	v->a[798] = lex_normal_s798;
+	v->a[799] = lex_normal_s799;
+	lex_normal_array_40(v);
+}
+
+/* EOF lex_normal_array_7.c */

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_8.c

@@ -0,0 +1,145 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_8.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_40(t_lex_normal_array *v)
+{
+	v->a[800] = lex_normal_s800;
+	v->a[801] = lex_normal_s801;
+	v->a[802] = lex_normal_s802;
+	v->a[803] = lex_normal_s803;
+	v->a[804] = lex_normal_s804;
+	v->a[805] = lex_normal_s805;
+	v->a[806] = lex_normal_s806;
+	v->a[807] = lex_normal_s807;
+	v->a[808] = lex_normal_s808;
+	v->a[809] = lex_normal_s809;
+	v->a[810] = lex_normal_s810;
+	v->a[811] = lex_normal_s811;
+	v->a[812] = lex_normal_s812;
+	v->a[813] = lex_normal_s813;
+	v->a[814] = lex_normal_s814;
+	v->a[815] = lex_normal_s815;
+	v->a[816] = lex_normal_s816;
+	v->a[817] = lex_normal_s817;
+	v->a[818] = lex_normal_s818;
+	v->a[819] = lex_normal_s819;
+	lex_normal_array_41(v);
+}
+
+void	lex_normal_array_41(t_lex_normal_array *v)
+{
+	v->a[820] = lex_normal_s820;
+	v->a[821] = lex_normal_s821;
+	v->a[822] = lex_normal_s822;
+	v->a[823] = lex_normal_s823;
+	v->a[824] = lex_normal_s824;
+	v->a[825] = lex_normal_s825;
+	v->a[826] = lex_normal_s826;
+	v->a[827] = lex_normal_s827;
+	v->a[828] = lex_normal_s828;
+	v->a[829] = lex_normal_s829;
+	v->a[830] = lex_normal_s830;
+	v->a[831] = lex_normal_s831;
+	v->a[832] = lex_normal_s832;
+	v->a[833] = lex_normal_s833;
+	v->a[834] = lex_normal_s834;
+	v->a[835] = lex_normal_s835;
+	v->a[836] = lex_normal_s836;
+	v->a[837] = lex_normal_s837;
+	v->a[838] = lex_normal_s838;
+	v->a[839] = lex_normal_s839;
+	lex_normal_array_42(v);
+}
+
+void	lex_normal_array_42(t_lex_normal_array *v)
+{
+	v->a[840] = lex_normal_s840;
+	v->a[841] = lex_normal_s841;
+	v->a[842] = lex_normal_s842;
+	v->a[843] = lex_normal_s843;
+	v->a[844] = lex_normal_s844;
+	v->a[845] = lex_normal_s845;
+	v->a[846] = lex_normal_s846;
+	v->a[847] = lex_normal_s847;
+	v->a[848] = lex_normal_s848;
+	v->a[849] = lex_normal_s849;
+	v->a[850] = lex_normal_s850;
+	v->a[851] = lex_normal_s851;
+	v->a[852] = lex_normal_s852;
+	v->a[853] = lex_normal_s853;
+	v->a[854] = lex_normal_s854;
+	v->a[855] = lex_normal_s855;
+	v->a[856] = lex_normal_s856;
+	v->a[857] = lex_normal_s857;
+	v->a[858] = lex_normal_s858;
+	v->a[859] = lex_normal_s859;
+	lex_normal_array_43(v);
+}
+
+void	lex_normal_array_43(t_lex_normal_array *v)
+{
+	v->a[860] = lex_normal_s860;
+	v->a[861] = lex_normal_s861;
+	v->a[862] = lex_normal_s862;
+	v->a[863] = lex_normal_s863;
+	v->a[864] = lex_normal_s864;
+	v->a[865] = lex_normal_s865;
+	v->a[866] = lex_normal_s866;
+	v->a[867] = lex_normal_s867;
+	v->a[868] = lex_normal_s868;
+	v->a[869] = lex_normal_s869;
+	v->a[870] = lex_normal_s870;
+	v->a[871] = lex_normal_s871;
+	v->a[872] = lex_normal_s872;
+	v->a[873] = lex_normal_s873;
+	v->a[874] = lex_normal_s874;
+	v->a[875] = lex_normal_s875;
+	v->a[876] = lex_normal_s876;
+	v->a[877] = lex_normal_s877;
+	v->a[878] = lex_normal_s878;
+	v->a[879] = lex_normal_s879;
+	lex_normal_array_44(v);
+}
+
+void	lex_normal_array_44(t_lex_normal_array *v)
+{
+	v->a[880] = lex_normal_s880;
+	v->a[881] = lex_normal_s881;
+	v->a[882] = lex_normal_s882;
+	v->a[883] = lex_normal_s883;
+	v->a[884] = lex_normal_s884;
+	v->a[885] = lex_normal_s885;
+	v->a[886] = lex_normal_s886;
+	v->a[887] = lex_normal_s887;
+	v->a[888] = lex_normal_s888;
+	v->a[889] = lex_normal_s889;
+	v->a[890] = lex_normal_s890;
+	v->a[891] = lex_normal_s891;
+	v->a[892] = lex_normal_s892;
+	v->a[893] = lex_normal_s893;
+	v->a[894] = lex_normal_s894;
+	v->a[895] = lex_normal_s895;
+	v->a[896] = lex_normal_s896;
+	v->a[897] = lex_normal_s897;
+	v->a[898] = lex_normal_s898;
+	v->a[899] = lex_normal_s899;
+	lex_normal_array_45(v);
+}
+
+/* EOF lex_normal_array_8.c */

shcat_c/parser/src/lex_funcs/lex_normal/create_table/lex_normal_array_9.c

@@ -0,0 +1,92 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   lex_normal_array_9.c                               :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#include "../../../headers/symbols.h"
+#include "../../../headers/external_scanner_symbol_identifiers.h"
+#include "../../../headers/field_identifiers.h"
+#include "../../../headers/constants.h"
+#include "../lex_normal_funcs.h"
+#include "./lex_normal_array.h"
+
+void	lex_normal_array_45(t_lex_normal_array *v)
+{
+	v->a[900] = lex_normal_s900;
+	v->a[901] = lex_normal_s901;
+	v->a[902] = lex_normal_s902;
+	v->a[903] = lex_normal_s903;
+	v->a[904] = lex_normal_s904;
+	v->a[905] = lex_normal_s905;
+	v->a[906] = lex_normal_s906;
+	v->a[907] = lex_normal_s907;
+	v->a[908] = lex_normal_s908;
+	v->a[909] = lex_normal_s909;
+	v->a[910] = lex_normal_s910;
+	v->a[911] = lex_normal_s911;
+	v->a[912] = lex_normal_s912;
+	v->a[913] = lex_normal_s913;
+	v->a[914] = lex_normal_s914;
+	v->a[915] = lex_normal_s915;
+	v->a[916] = lex_normal_s916;
+	v->a[917] = lex_normal_s917;
+	v->a[918] = lex_normal_s918;
+	v->a[919] = lex_normal_s919;
+	lex_normal_array_46(v);
+}
+
+void	lex_normal_array_46(t_lex_normal_array *v)
+{
+	v->a[920] = lex_normal_s920;
+	v->a[921] = lex_normal_s921;
+	v->a[922] = lex_normal_s922;
+	v->a[923] = lex_normal_s923;
+	v->a[924] = lex_normal_s924;
+	v->a[925] = lex_normal_s925;
+	v->a[926] = lex_normal_s926;
+	v->a[927] = lex_normal_s927;
+	v->a[928] = lex_normal_s928;
+	v->a[929] = lex_normal_s929;
+	v->a[930] = lex_normal_s930;
+	v->a[931] = lex_normal_s931;
+	v->a[932] = lex_normal_s932;
+	v->a[933] = lex_normal_s933;
+	v->a[934] = lex_normal_s934;
+	v->a[935] = lex_normal_s935;
+	v->a[936] = lex_normal_s936;
+	v->a[937] = lex_normal_s937;
+	v->a[938] = lex_normal_s938;
+	v->a[939] = lex_normal_s939;
+	lex_normal_array_47(v);
+}
+
+void	lex_normal_array_47(t_lex_normal_array *v)
+{
+	v->a[940] = lex_normal_s940;
+	v->a[941] = lex_normal_s941;
+	v->a[942] = lex_normal_s942;
+	v->a[943] = lex_normal_s943;
+	v->a[944] = lex_normal_s944;
+	v->a[945] = lex_normal_s945;
+	v->a[946] = lex_normal_s946;
+	v->a[947] = lex_normal_s947;
+	v->a[948] = lex_normal_s948;
+	v->a[949] = lex_normal_s949;
+	v->a[950] = lex_normal_s950;
+	v->a[951] = lex_normal_s951;
+	v->a[952] = lex_normal_s952;
+	v->a[953] = lex_normal_s953;
+	v->a[954] = lex_normal_s954;
+	v->a[955] = lex_normal_s955;
+	v->a[956] = lex_normal_s956;
+	v->a[957] = lex_normal_s957;
+	v->a[958] = lex_normal_s958;
+}
+/* EOF lex_normal_array_9.c */

shcat_c/parser/src/lex_funcs/lex_normal/inline.h

@@ -0,0 +1,69 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline.h                                           :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_H
+# define INLINE_H
+
+# include "../../headers/symbols.h"
+# include "../../headers/external_scanner_symbol_identifiers.h"
+# include "../../headers/field_identifiers.h"
+# include "../../headers/constants.h"
+# include "../../../parse_types.h"
+# include "./inline/inline_impl0.h"
+# include "./inline/inline_impl1.h"
+# include "./inline/inline_impl2.h"
+# include "./inline/inline_impl3.h"
+# include "./inline/inline_impl4.h"
+# include "./inline/inline_impl5.h"
+# include "./inline/inline_impl6.h"
+# include "./inline/inline_impl7.h"
+# include "./inline/inline_impl8.h"
+# include "./inline/inline_impl9.h"
+# include "./inline/inline_impl10.h"
+# include "./inline/inline_impl11.h"
+# include "./inline/inline_impl12.h"
+# include "./inline/inline_impl13.h"
+# include "./inline/inline_impl14.h"
+# include "./inline/inline_impl15.h"
+# include "./inline/inline_impl16.h"
+# include "./inline/inline_impl17.h"
+# include "./inline/inline_impl18.h"
+# include "./inline/inline_impl19.h"
+# include "./inline/inline_impl20.h"
+# include "./inline/inline_impl21.h"
+# include "./inline/inline_impl22.h"
+# include "./inline/inline_impl23.h"
+# include "./inline/inline_impl24.h"
+# include "./inline/inline_impl25.h"
+# include "./inline/inline_impl26.h"
+# include "./inline/inline_impl27.h"
+# include "./inline/inline_impl28.h"
+# include "./inline/inline_impl29.h"
+# include "./inline/inline_impl30.h"
+# include "./inline/inline_impl31.h"
+# include "./inline/inline_impl32.h"
+# include "./inline/inline_impl33.h"
+# include "./inline/inline_impl34.h"
+# include "./inline/inline_impl35.h"
+# include "./inline/inline_impl36.h"
+# include "./inline/inline_impl37.h"
+# include "./inline/inline_impl38.h"
+# include "./inline/inline_impl39.h"
+# include "./inline/inline_impl40.h"
+# include "./inline/inline_impl41.h"
+# include "./inline/inline_impl42.h"
+# include "./inline/inline_impl43.h"
+# include "./inline/inline_impl44.h"
+# include "./inline/inline_impl45.h"
+# include "./inline/inline_impl46.h"
+
+#endif // INLINE_H

shcat_c/parser/src/lex_funcs/lex_normal/inline/inline_impl0.h

@@ -0,0 +1,86 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline_impl0.h                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_IMPL0_H
+# define INLINE_IMPL0_H
+
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../../parse_types.h"
+
+static inline bool	lex_normal_map0(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 820, '"', 788, '#', 825, \
+	'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
+	655, '*', 824, '+', 770, ',', 557, '-', 768, '.', 949, \
+	'/', 642, '0', 944, ':', 763, ';', 554, '<', 607, '=', \
+	827, '>', 616, '?', 837, '@', 822, '[', 674, '\\', 301, \
+	']', 675, '^', 595, '_', 946, '`', 856, 'e', 956, 'i', \
+	955, '{', 666, '|', 592, '}', 778, '~', 772};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map6(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 688, '!', 670, '"', 788, \
+	'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
+	654, ')', 655, '*', 638, '+', 771, '-', 769, '/', 644, \
+	'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
+	761, '\\', 307, '^', 596, '`', 856, '|', 592, '~', 772, \
+	'[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map12(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 689, '!', 670, '"', 788, \
+	'#', 816, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
+	654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
+	'0', 943, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
+	761, '@', 942, '\\', 14, '^', 596, '_', 947, '`', 855, \
+	'|', 592, '[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map83(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 690, '!', 506, '#', 862, \
+	'%', 650, '&', 600, '*', 639, '+', 631, ',', 556, '-', \
+	635, '/', 645, ';', 553, '<', 615, '=', 561, '>', 620};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map84(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 690, '"', 788, '#', 862, \
+	'$', 785, '&', 599, '(', 653, '+', 500, ',', 556, '-', \
+	502, '0', 809, ';', 553};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+#endif // INLINE_IMPL0_H

shcat_c/parser/src/lex_funcs/lex_normal/inline/inline_impl1.h

@@ -0,0 +1,86 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline_impl1.h                                     :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_IMPL1_H
+# define INLINE_IMPL1_H
+
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../../parse_types.h"
+
+static inline bool	lex_normal_map85(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 690, '#', 862, '$', 783, \
+	'&', 489, '(', 654, '-', 504, '0', 808, ':', 762, '<', \
+	611, '>', 618};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map146(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 691, '!', 951, '"', 788, \
+	'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
+	654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
+	'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
+	761, '\\', 316, '^', 596, '`', 856, '|', 592, '[', 786, \
+	']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map200(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 692, '!', 669, '"', 788, \
+	'#', 816, '$', 780, '&', 602, '*', 637, '-', 632, '0', \
+	945, ';', 554, '<', 612, '>', 618, '?', 760, '@', 941, \
+	'\\', 81, '_', 948, 'e', 877, '|', 593};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map219(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 693, '!', 672, '"', 788, \
+	'#', 816, '$', 781, '&', 602, '\'', 491, '(', 654, '*', \
+	640, '-', 636, '0', 943, ';', 554, '<', 609, '=', 952, \
+	'>', 617, '?', 761, '@', 942, '\\', 27, '_', 947, '`', \
+	855, 'e', 871, '|', 593, '[', 786, ']', 786, '{', 786, \
+	'}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map236(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 694, '!', 951, '"', 788, \
+	'#', 862, '$', 781, '%', 649, '&', 601, '\'', 491, '(', \
+	654, ')', 655, '*', 638, '+', 630, '-', 633, '/', 644, \
+	'0', 803, ';', 555, '<', 607, '=', 560, '>', 616, '?', \
+	761, '\\', 317, '^', 596, '`', 855, '|', 592, '[', 786, \
+	']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+#endif // INLINE_IMPL1_H

shcat_c/parser/src/lex_funcs/lex_normal/inline/inline_impl10.h

@@ -0,0 +1,86 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline_impl10.h                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_IMPL10_H
+# define INLINE_IMPL10_H
+
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../../parse_types.h"
+
+static inline bool	lex_normal_map277(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 735, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
+	803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 335, \
+	'`', 856, 'e', 956, '|', 593, '[', 786, ']', 786, '{', \
+	786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map278(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 736, '!', 672, '"', 788, \
+	'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, ')', \
+	655, '*', 640, '-', 636, '0', 943, ';', 555, '<', 610, \
+	'>', 617, '?', 761, '@', 942, '\\', 228, '_', 947, '`', \
+	855, '|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map279(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 737, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 654, '-', 950, '0', \
+	803, ';', 554, '<', 609, '=', 952, '>', 617, '\\', 337, \
+	'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
+	786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map280(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 738, '!', 672, '"', 788, \
+	'#', 816, '$', 781, '&', 602, '\'', 491, '(', 494, '*', \
+	640, '-', 636, '0', 943, ';', 555, '<', 610, '>', 617, \
+	'?', 761, '@', 942, '\\', 207, '_', 947, '`', 855, '|', \
+	593, '[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map281(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 739, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 654, ')', 655, '-', \
+	950, '0', 803, ';', 555, '<', 609, '=', 952, '>', 617, \
+	'\\', 339, '`', 856, '|', 593, '[', 786, ']', 786, '{', \
+	786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+#endif // INLINE_IMPL10_H

shcat_c/parser/src/lex_funcs/lex_normal/inline/inline_impl11.h

@@ -0,0 +1,86 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline_impl11.h                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_IMPL11_H
+# define INLINE_IMPL11_H
+
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../../parse_types.h"
+
+static inline bool	lex_normal_map282(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 740, '!', 672, '"', 788, \
+	'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
+	640, '-', 636, '0', 943, '<', 609, '=', 952, '>', 617, \
+	'?', 761, '@', 942, '\\', 168, '_', 947, '`', 855, '|', \
+	593, '[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map283(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 741, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
+	804, ';', 554, '<', 610, '>', 617, '\\', 341, '`', 856, \
+	'e', 866, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
+	786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map284(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 742, '!', 672, '"', 788, \
+	'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
+	640, '-', 636, '0', 943, '<', 609, '>', 617, '?', 761, \
+	'@', 942, '\\', 58, '_', 947, '`', 855, '|', 593, '[', \
+	786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map285(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 743, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
+	803, ';', 554, '<', 609, '>', 617, '\\', 343, '`', 856, \
+	'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
+	786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map286(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 744, '!', 672, '"', 788, \
+	'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
+	640, '-', 636, '0', 943, '<', 610, '>', 617, '?', 761, \
+	'@', 942, '\\', 233, '_', 947, '`', 855, '|', 593, '[', \
+	786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+#endif // INLINE_IMPL11_H

shcat_c/parser/src/lex_funcs/lex_normal/inline/inline_impl12.h

@@ -0,0 +1,84 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline_impl12.h                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_IMPL12_H
+# define INLINE_IMPL12_H
+
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../../parse_types.h"
+
+static inline bool	lex_normal_map287(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 745, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
+	804, ';', 554, '<', 610, '>', 617, '\\', 344, '`', 856, \
+	'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map288(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 746, '!', 672, '"', 788, \
+	'#', 816, '$', 781, '&', 489, '\'', 491, '(', 494, '*', \
+	640, '-', 636, '0', 943, '<', 608, '>', 617, '?', 761, \
+	'@', 942, '\\', 176, '_', 947, '`', 855, '|', 516, '[', \
+	786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map289(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 747, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
+	803, ';', 554, '<', 609, '>', 617, '\\', 346, '`', 856, \
+	'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map290(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 748, '!', 672, '"', 788, \
+	'#', 816, '$', 781, '&', 599, '\'', 491, '(', 494, '*', \
+	640, '-', 636, '0', 943, ';', 555, '<', 495, '>', 496, \
+	'?', 761, '@', 942, '\\', 100, '_', 947, '`', 855, '[', \
+	786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map291(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 749, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
+	803, ';', 554, '<', 610, '>', 617, '\\', 347, '`', 856, \
+	'e', 956, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
+	786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+#endif // INLINE_IMPL12_H

shcat_c/parser/src/lex_funcs/lex_normal/inline/inline_impl13.h

@@ -0,0 +1,85 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline_impl13.h                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_IMPL13_H
+# define INLINE_IMPL13_H
+
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../../parse_types.h"
+
+static inline bool	lex_normal_map292(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 750, '!', 672, '"', 788, \
+	'#', 816, '$', 781, '\'', 491, '(', 494, '*', 640, '-', \
+	636, '0', 943, '<', 495, '>', 496, '?', 761, '@', 942, \
+	'\\', 112, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
+	786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map293(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 751, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
+	950, '0', 804, ';', 555, '<', 610, '>', 617, '\\', 349, \
+	'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
+	786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map294(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 752, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
+	950, '0', 803, ';', 555, '<', 609, '>', 617, '\\', 350, \
+	'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
+	786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map295(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 753, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 494, '-', 950, '0', \
+	803, ';', 554, '<', 610, '>', 617, '\\', 351, '`', 856, \
+	'|', 593, '[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map296(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 754, '"', 788, '#', 862, \
+	'$', 781, '&', 602, '\'', 491, '(', 494, ')', 655, '-', \
+	950, '0', 803, ';', 555, '<', 610, '>', 617, '\\', 354, \
+	'`', 856, '|', 593, '[', 786, ']', 786, '{', 786, '}', \
+	786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+#endif // INLINE_IMPL13_H

shcat_c/parser/src/lex_funcs/lex_normal/inline/inline_impl14.h

@@ -0,0 +1,84 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline_impl14.h                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_IMPL14_H
+# define INLINE_IMPL14_H
+
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../../parse_types.h"
+
+static inline bool	lex_normal_map297(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 755, '"', 788, '#', 862, \
+	'$', 781, '&', 599, '\'', 491, '(', 654, '-', 950, '0', \
+	803, ';', 555, '<', 495, '>', 496, '\\', 357, '`', 855, \
+	'e', 956, '[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map298(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 756, '"', 788, '#', 862, \
+	'$', 781, '&', 489, '\'', 491, '(', 494, '-', 950, '0', \
+	803, '<', 608, '>', 617, '\\', 370, '`', 856, '|', 516, \
+	'[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map299(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 757, '"', 788, '#', 862, \
+	'$', 781, '&', 599, '\'', 491, '(', 494, '-', 950, '0', \
+	803, ';', 555, '<', 495, '>', 496, '\\', 372, '`', 855, \
+	'[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map300(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'\n', 758, '"', 788, '#', 862, \
+	'$', 781, '&', 599, '\'', 491, '(', 494, '-', 950, '0', \
+	803, ';', 555, '<', 495, '>', 496, '\\', 381, '`', 856, \
+	'[', 786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map401(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 670, '"', 788, '#', 816, \
+	'$', 781, '%', 647, '&', 601, '\'', 491, '(', 654, ')', \
+	655, '*', 638, '+', 770, ',', 557, '-', 768, '/', 642, \
+	'0', 944, ':', 765, ';', 554, '<', 607, '=', 563, '>', \
+	616, '?', 761, '@', 942, '[', 674, '\\', 301, ']', 675, \
+	'^', 595, '_', 946, '`', 856, 'e', 956, 'i', 955, '{', \
+	666, '|', 592, '}', 818, '~', 772};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+#endif // INLINE_IMPL14_H

shcat_c/parser/src/lex_funcs/lex_normal/inline/inline_impl15.h

@@ -0,0 +1,91 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline_impl15.h                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_IMPL15_H
+# define INLINE_IMPL15_H
+
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../../parse_types.h"
+
+static inline bool	lex_normal_map402(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 670, '"', 788, '#', 816, \
+	'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
+	638, '+', 630, '-', 633, '/', 644, '0', 943, '<', 607, \
+	'=', 560, '>', 616, '?', 761, '@', 942, '\\', 19, ']', \
+	675, '^', 596, '_', 947, '`', 855, '|', 592, '[', 786, \
+	'{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map403(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 670, '"', 788, '#', 862, \
+	'$', 781, '%', 649, '&', 601, '\'', 491, '(', 654, '*', \
+	638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 607, \
+	'=', 560, '>', 616, '?', 761, '\\', 308, ']', 675, '^', \
+	596, '`', 856, '|', 592, '~', 772, '[', 786, '{', 786, \
+	'}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map404(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 670, '"', 788, '#', 862, \
+	'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, ')', \
+	655, '*', 638, '+', 771, '-', 769, '/', 644, '0', 803, \
+	'<', 614, '=', 560, '>', 619, '?', 761, '\\', 311, '^', \
+	596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
+	'{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map405(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 670, '"', 788, '#', 862, \
+	'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, ')', \
+	499, '*', 638, '+', 771, '-', 769, '/', 644, '0', 803, \
+	'<', 614, '=', 560, '>', 619, '?', 761, '\\', 314, '^', \
+	596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
+	'{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map406(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 670, '"', 788, '#', 862, \
+	'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
+	638, '+', 771, '-', 769, '/', 644, '0', 803, ':', 765, \
+	'<', 614, '=', 560, '>', 619, '?', 761, '\\', 313, '^', \
+	596, '`', 856, '|', 594, '~', 772, '[', 786, ']', 786, \
+	'{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+#endif // INLINE_IMPL15_H

shcat_c/parser/src/lex_funcs/lex_normal/inline/inline_impl16.h

@@ -0,0 +1,88 @@
+/* ************************************************************************** */
+/*                                                                            */
+/*                                                        :::      ::::::::   */
+/*   inline_impl16.h                                    :+:      :+:    :+:   */
+/*                                                    +:+ +:+         +:+     */
+/*   By: maiboyer <maiboyer@student.42.fr>          +#+  +:+       +#+        */
+/*                                                +#+#+#+#+#+   +#+           */
+/*   Created: 2024/04/14 19:17:54 by maiboyer          #+#    #+#             */
+/*   Updated: 2024/04/14 19:18:20 by maiboyer         ###   ########.fr       */
+/*                                                                            */
+/* ************************************************************************** */
+
+#ifndef INLINE_IMPL16_H
+# define INLINE_IMPL16_H
+
+# include "../../../headers/symbols.h"
+# include "../../../headers/external_scanner_symbol_identifiers.h"
+# include "../../../headers/field_identifiers.h"
+# include "../../../headers/constants.h"
+# include "../../../../parse_types.h"
+
+static inline bool	lex_normal_map407(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 670, '"', 788, '#', 862, \
+	'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
+	638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 614, \
+	'=', 560, '>', 619, '?', 761, '\\', 312, ']', 675, '^', \
+	596, '`', 856, '|', 594, '~', 772, '[', 786, '{', 786, \
+	'}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map408(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 670, '"', 788, '#', 862, \
+	'$', 781, '%', 649, '&', 600, '\'', 491, '(', 654, '*', \
+	638, '+', 771, '-', 769, '/', 644, '0', 803, '<', 614, \
+	'=', 560, '>', 619, '?', 761, '\\', 315, ']', 787, '^', \
+	596, '`', 856, '|', 594, '~', 772, '[', 786, '{', 786, \
+	'}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map409(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 672, '"', 788, '#', 816, \
+	'$', 781, '&', 508, '\'', 491, '(', 494, '*', 640, '-', \
+	636, '0', 943, '<', 608, '>', 617, '?', 761, '@', 942, \
+	'\\', 74, '_', 947, '`', 855, '[', 786, ']', 786, '{', \
+	786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map410(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 672, '"', 788, '#', 816, \
+	'$', 781, '&', 489, '\'', 491, '(', 654, '*', 640, '-', \
+	636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
+	'@', 942, '\\', 51, '_', 947, '`', 855, '|', 593, '[', \
+	786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+
+static inline bool	lex_normal_map411(t_lexer *lexer, \
+	t_lexer_state *s)
+{
+	static uint32_t	map[] = {'!', 672, '"', 788, '#', 816, \
+	'$', 781, '&', 489, '\'', 491, '(', 494, '*', 640, '-', \
+	636, '0', 943, '<', 609, '=', 952, '>', 617, '?', 761, \
+	'@', 942, '\\', 171, '_', 947, '`', 855, '|', 593, '[', \
+	786, ']', 786, '{', 786, '}', 786};
+
+	return (advance_map_inner(map, sizeof(map) / sizeof(*map), \
+	lexer, s));
+}
+#endif // INLINE_IMPL16_H