victorvobis/minishell
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
minishell/minishell.h
Victor Vobis 814bac23a7 first commit
2025-06-04 14:58:04 +02:00

582 lines
16 KiB
C
Raw Blame History

/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* minishell.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: anarama <anarama@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/05 12:16:38 by victor #+# #+# */
/* Updated: 2024/08/27 17:28:49 by vvobis ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef MINISHELL_H
# define MINISHELL_H
# include <stdbool.h>
# include "libft/libft.h"
# include <unistd.h>
# include <fcntl.h>
# include <sys/types.h>
# include <stdio.h>
# include <dirent.h>
# include <string.h>
# include <stdlib.h>
# include <sys/wait.h>
# include <termios.h>
# include <errno.h>
# include <signal.h>
# include <sys/ioctl.h>
# include <stddef.h>
# include <sys/stat.h>
# define PWD 0
# define CUSTOM 1
# define PROMPT_COMMAND_STACK_SIZE 16
# define PROMPT_INPUT_BUFFER_SIZE 4096
# define CURSOR_MOVE_HOME "\033[H"
# define GREEN "\033[0;32m"
# define RESET "\033[0m"
# define RED "\033[0;31m"
# define CURSOR_MOVE_UP "\033[A"
# define CURSOR_MOVE_DOWN "\033[B"
# define CURSOR_MOVE_RIGHT "\033[C"
# define CURSOR_MOVE_LEFT "\033[D"
# define CURSOR_POSITION_GET "\033[6n"
# define CURSOR_POSITION_SET "\033[%d;%dH"
# define CURSOR_POSITION_SAVE "\033[s"
# define CURSOR_POSITION_RESTORE "\033[u"
# define MAXIMUM_COLUMN 9999
# define MAXIMUM_ROW 9999
# define SCREEN_MAX "\033[9999;9999H"
# define DEL 127
# define EOT 4
# define ESC 27
# define VARIABLE_TOKEN_SIZE 1024
# define SCREEN_DISBLE_WRAPPING "\033[?7l"
# define SCREEN_ENABLE_WRAPPING "\033[?7h"
# define SCREEN_CLEAR_TO_EOL "\033[K"
# define SCREEN_CLEAR "\033[2J"
# define SCREEN_CLEAR_TO_EOF "\033[J"
# define ENVIRONMENT_SIZE 512
# define INITIAL_TOKEN_CAPACITY 16
# define BUFFER_CAPACITY 64
typedef struct s_history_buffer
{
uint write;
uint read;
uint buffer_capacity;
char *buffer[BUFFER_CAPACITY];
} t_history_buffer;
typedef struct s_prompt
{
bool exists;
char *prompt;
t_history_buffer history;
uint32_t cursor_position[2];
void (*prompt_display_func)(char *);
uint32_t prompt_length;
char *command;
} t_prompt;
typedef enum e_token_type
{
TOKEN_WORD = 1,
TOKEN_REDIRECT_OUT,
TOKEN_REDIRECT_IN,
TOKEN_REDIRECT_APPEND,
TOKEN_HEREDOC,
TOKEN_PIPE,
TOKEN_AND,
TOKEN_OR,
TOKEN_NEWLINE,
TOKEN_SEMICOLON,
TOKEN_EOL,
TOKEN_DONE,
} t_token_type;
typedef struct s_token
{
t_token_type token_type;
char *token_value;
} t_token;
typedef struct s_ring_buffer
{
uint write;
uint read;
uint buffer_capacity;
t_token *buffer[BUFFER_CAPACITY];
} t_ring_buffer;
typedef enum t_node_type
{
NODE_NONE,
NODE_END = TOKEN_EOL,
NODE_PIPE = 6,
NODE_LOGICAL_AND,
NODE_LOGICAL_OR,
NODE_NEWLINE,
NODE_INVALID,
} t_node_type;
typedef struct s_ast
{
t_node_type type;
t_token_type token_type;
char **args;
bool is_heredoc;
char *path_file_in;
char *path_file_out;
bool has_redir_in;
bool has_redir_out;
bool was_pipe;
int32_t pipefd[2];
int fd_in;
int fd_out;
pid_t cpid;
} t_ast;
enum e_alloc
{
ADD,
CLEAN,
END,
FREE,
};
typedef struct s_clean
{
void *content;
void (*clean)(void *del);
struct s_clean *next;
} t_clean;
extern int32_t volatile g_signal_flag;
/* Builtins */
int32_t ft_echo(char **args, int32_t *exit_status);
void ft_cd( const char **environment, \
const char **args, \
int32_t *exit_status);
void ft_pwd(const char **env, int32_t *exit_status);
void ft_env(const char **env, int32_t *exit_status);
void ft_unset( char **environment, \
const char **args, \
int32_t *exit_status);
void ft_export(const char **args, int32_t *exit_status);
void ft_exit(t_ast *tree, int *exit_status);
void *ft_realloc(void *ptr, int old_size, int new_size);
/* Commands */
bool is_buildin( t_ast *node);
bool buildin_execute( t_ast *node, \
const char **environment, \
int *exit_status);
void command_execute( char const *command_path, \
char const *argv[], \
char const **env);
void m_tokenizer( const char *input, \
char **env, \
int *exit_status, \
int32_t std[2]);
/* non_interactive */
int32_t minishell_single_command( char *command, \
char **environment, \
int32_t std[2]);
void *ft_realloc_string( char **string, uint32_t *new_size);
char *check_redir_input(void);
void setup_environment( const char **environment);
int setup( uint32_t argc, \
const char **argv, \
char **environment, \
int32_t std[2]);
/* Handle signal */
void handle_sigint(int sig);
void setup_signal_handlers(void);
/* Input */
void free_split(void *back);
uint32_t get_split_size(const char **split);
uint32_t get_split_length(char **split);
int get_amount_tokens(t_token *tokens);
/* List Memory */
void lst_memory(void *mem, void (*del)(void *c), int mode);
int p_stderr(int stderr_fd, const char *error, const char *specifier);
/* List */
t_clean *lst_node_new(void *content, void (*del)(void *));
void lst_node_del(t_clean **lst);
void lst_node_del_clean(t_clean **lst, void *mem);
void lst_list_clean(t_clean **head);
int lst_add_back(t_clean **node, t_clean *node_new);
/* Path Utils */
char *find_absolute_path( const char *path_variable, \
char *input, \
int *exit_status);
/* Prompt */
void prompt_destroy(void *prompt);
t_prompt prompt_create(uint8_t mode);
char *prompt_get(const char *prompt);
uint32_t prompt_display_string_set( t_prompt *prompt, \
const char **environment, \
const char *prompt_string);
void handle_arrow_key_up( t_history_buffer *history, \
char **input, \
uint32_t cursor_position_current[2]);
/* Prompt_print.c */
void prompt_print_custom_string(char *string);
void prompt_print_pwd(char *prompt);
/* Lexer */
void evaluate_input( char **input[], \
int32_t *exit_status, \
bool *error_caught);
uint32_t get_spaces(char *input);
uint32_t determine_variables(char **input);
void split_string_by_space(char *to_split, char **input_new);
void adjust_input(char **input, char *new_string);
uint32_t determine_full_length(char *string, char **environment);
uint32_t evaluate_variable( char ***input, \
int32_t *exit_status);
/* input skip pattern */
bool is_delimiter_variable(char c);
char skip_to_delimiter(char *input_new);
bool skip_single_quotes( char *input, \
uint32_t *i, \
bool *in_double_quotes);
bool evaluate_double_quotes(char *input, uint32_t *i);
bool evaluate_single_quotes(char *input, uint32_t *i);
/* Cursor Manipulation */
void cursor_position_get(uint32_t cursor_position[2]);
void cursor_position_save(void);
void cursor_position_restore(void);
bool handle_escape_sequence( t_prompt *prompt, \
char buffer[], \
char **input, \
uint32_t cursor_position[2]);
char *prompt_get_input( t_prompt *prompt, \
uint32_t prompt_initial_size, \
const char *delimiter);
bool handle_multiple_character( char **input, \
char buffer[], \
uint32_t cursor_position[2], \
uint32_t prompt_length);
/* Prompt Buffer Management */
void prompt_refresh_line( char *input, \
uint32_t cursor_position_base, \
uint32_t cursor_position[2]);
char *prompt_buffer_size_manage( char **input, \
uint32_t old_size, \
uint32_t size_to_add, \
uint32_t scalar);
void prompt_string_insert( char *string_to_insert, \
char **current_input, \
char *position_to_insert, \
uint32_t current_word_length);
bool handle_new_character_to_input( char **input, \
char character, \
uint32_t *cursor_position, \
uint32_t prompt_length);
uint8_t handle_single_char_input( char **input, char buffer[], \
uint32_t cursor_position[2], \
bool *do_refresh);
uint8_t handle_single_char_input( char **input, char buffer[], \
uint32_t cursor_position[2], \
bool *do_refresh);
bool handle_new_character_to_input( char **input, \
char character, \
uint32_t *cursor_position, \
uint32_t prompt_length);
/* Non Blocking mode */
void blocking_mode_toggle(int flag);
/* Tab Completion */
void handle_tab( char **input, t_prompt *prompt);
void handle_tab_no_match( const char *input_path, \
char **env, \
uint32_t cursor_position_current[2], \
t_prompt *prompt);
void handle_tab_yes_match( t_prompt *prompt, \
const char *next_word_match, \
char **input, \
uint32_t current_word_length);
char *determine_word( char *input, \
char **input_path, \
uint32_t cursor_position_current);
void get_next_word_match( char **input, \
t_prompt *prompt, \
char *input_path, \
bool *is_directory);
void handle_rapid_input( char buffer[], \
uint32_t cursor_position[2], \
char **input, \
uint32_t cursor_position_base);
void handle_backspace( char *input, \
uint32_t *cursor_position_current, \
uint32_t input_length_current);
/* Termios */
void terminal_raw_mode_enable(int flag);
void terminal_raw_mode_disable(int flag);
/* Utils */
int ft_close(int fd, const char *specifier);
void ft_pipe(int pipefd[2], const char *specifier);
void ft_dup2(int fd_old, int fd_new, const char *specifier);
void ft_fork(pid_t *pid, const char *specifier);
void ft_open(int *fd, const char *path, int flag, int mode);
int64_t ft_read(int fd, char *character, uint32_t size_read);
void ft_opendir(DIR **directory, const char *directory_path);
void close_fds(void *std_ptr);
/* Wildcards */
void check_and_expand_wildcards(char ***input);
int check_wildcard(char *str);
int get_tokens_count(char **tokens);
/* Wildcards Helper */
int compare_suffix( const char *current_position_in_str, \
const char *current_position_in_pattern);
int handle_prefix( const char *pattern, \
const char *str, \
char *adr_next_wild);
int handle_middle( const char *pattern, const char *str);
char **expand_wildcard( const char *pattern);
/* Environment_variable */
void environment_variable_print( const char *variable, \
const char **environment);
void environment_print( const char **environment);
char **environment_create( const char **env);
void environment_variable_remove( char **environment, \
const char *variable);
void environment_variable_add( char ***environment, \
const char *variable_name, \
const char *variable_value);
char **environment_variable_get( const char *variable, \
const char **environment);
char *environment_variable_value_get( const char *variable, \
const char **environment);
void environment_variable_value_change( const char **environment, \
const char *variable_name, \
const char *variable_value);
char **env_static(char **environment);
/*check_special_symbol.c*/
int is_special_char(char c);
int ft_isspace(char c);
bool is_in_alphabet(char c);
bool unrecognized_input(char c);
/*create_token_double_special_symbol.c*/
int is_double_special(const char *input);
t_token create_token_double_special_symbol(char **input);
bool is_mutliple_lines(char *c);
void remove_qoutes_delimiter(char *delimiter, uint32_t *length);
void token_heredoc_get( t_token *token, const char *delimiter);
/* token_heredoc.c */
char *heredoc_while_tokenizing(char *input);
char *handle_delimiter(char *input, char **temp_move);
char *heredoc_loop( char *input, \
char *temp_move, \
const char *delimiter, \
uint32_t delimiter_length);
/* handle_heredoc.c */
void handle_heredoc(t_token tokens, int32_t fd);
bool heredoc_has_been_done(t_token *token, char *value, int fd);
void print_value(char *value, int fd);
void remove_quotes(char *s);
/*create_token_single_special_symbol.c*/
int is_single_special(const char input);
t_token create_token_single_special_symbol(const char **input);
/*create_token_word.c*/
t_token create_token_word(const char **input);
/*create_token.c*/
t_token create_token(t_token_type token_type, const char *value);
/*env_utils.c*/
void print_tokens(t_token *tokens);
/* subshell.c */
char *execute_subshell(char *input, const char **environement);
/*tokenizer.c*/
t_token *lexical_analysis(char *input);
/* tokenizer_heredoc_helper.c */
void ring_buffer_put( t_ring_buffer *buffer, t_token *entry);
t_token *ring_buffer_get( t_ring_buffer *buffer);
t_token mark_tokens_till_heredoc( char *value, char **input);
void tokenizing_loop( char **input, \
t_token *tokens, \
uint32_t *i, \
t_ring_buffer *heredoc_buffer);
/*ats_print.c*/
void print_ast(t_ast *head);
/*handle_command.c*/
void handle_command( t_ast *current, \
const char **env, \
int *exit_status, \
int std[2]);
void execute_commands( t_ast *tree, \
const char **env, \
int *exit_status, \
int32_t std[2]);
void wait_pids( t_ast *tree, \
uint pid_count, \
pid_t pid_final, \
int32_t *exit_status);
/*handle_fds.c*/
bool handle_fds_child_proccess(t_ast *command, int32_t *exit_status);
void handle_fds_parent_proccess(t_ast *command, int32_t *exit_status);
void handle_pipe_in_child(t_ast *command);
void handle_pipe_in_parent(t_ast *command);
bool buildin_apply_pipe(t_ast *node, int32_t *exit_status);
/*handle_logical_operator.c*/
void handle_logical_operator(t_ast **logical_node, int exit_status);
/* handle_pipes.c */
void handle_pipe(t_ast *pipe_node, int *error_catched);
/*handle_redirs.c*/
void handle_redir_in( t_ast *branch, \
t_token *token, \
t_token *token_next);
void handle_redir_out( t_ast *branch, \
t_token *token, \
t_token *token_next);
void handle_redir_append( t_ast *branch, \
t_token *token, \
t_token *token_next);
void handle_redir_heredoc( t_ast *branch, \
t_token *token, \
uint8_t token_id);
/*parse_tokens.c*/
t_ast *parse_tokens( t_token *tokens, \
int32_t *exit_status);
uint32_t determine_trees(t_token *tokens);
void tree_destroy(void *tree_ptr);
/* Syntac_check.c */
void check_valid_logical_operator( t_token *token, \
int index, \
int *error_catched);
void check_valid_pipe( t_token *token, \
int index, \
int *error_catched);
void check_valid_redir( t_token *token, \
int index, \
int *error_catched);
void print_error_redir( t_token_type token_type);
void print_error_logical_operator( t_token_type token_type);
void restore_fd(int std[2]);
/*parser.c*/
void fill_args( char ***args, \
int count, \
char *token_value, \
int *capacity);
bool is_delimiter_token(t_token *token);
/*syntax_check.c*/
void check_valid_redir( t_token *token, \
int index, \
int *error_catched);
void check_valid_pipe( t_token *token, \
int index, \
int *error_catched);
void check_valid_logical_operator( t_token *token, \
int index, \
int *error_catched);
void check_valid_heredoc(t_token *token, int index, int *error_catched);
/* syntax_check_helper.c */
void print_error_logical_operator(t_token_type token_type);
void print_error_pipe(void);
void print_error_redir(t_token_type token_type);
void free_tokens(void *token_ptr);
#endif
Reference in New Issue View Git Blame Copy Permalink