minishell.h

Go to the documentation of this file.

/* ************************************************************************** */
/*                                                                            */
/*                                                        :::      ::::::::   */
/*   minishell.h                                        :+:      :+:    :+:   */
/*                                                    +:+ +:+         +:+     */
/*   By: phnowak <phnowak@student.42vienna.com>     +#+  +:+       +#+        */
/*   By: dzauner <dzauner@student.42vienna.com>   +#+#+#+#+#+   +#+           */
/*   Created: 2023/09/20 20:55:19 by phnowak           #+#    #+#             */
/*   Updated: 2023/10/02 13:28:57 by dzauner          ###   ########.fr       */
/*                                                                            */
/* ************************************************************************** */
 
#ifndef MINISHELL_H
# define MINISHELL_H
 
# include <stdio.h>
# include <errno.h>
# include <fcntl.h>
# include <readline/readline.h>
# include <readline/history.h>
# include <signal.h>
# include <stdbool.h>
# include <stdlib.h>
# include <sys/types.h>
# include <sys/wait.h>
# include <sysexits.h>
# include <unistd.h>
# include "../libft/libft.h"
 
//                              Macros
 
//  General
# define PARENT 1
# define CHILD  2
# define IGNORE 3
# define ERR_SYN_QUOTES "Syntax error: quotes unclosed\n"
# define ERR_SYN_RD "Syntax error: redirections\n"
# define ERR_SYN_PIPE   "Syntax error: pipes\n"
# define EXIT_SYN_QUOTES    2
# define EXIT_SYN_RD    2
# define EXIT_SYN_PIPE  2
 
//  fill_executor_list()
# define OK         100
# define NOT_FOUND  101
# define FAILED     102
 
//  handle_multi()
# define FAIL_SYSCALL       -1
# define OKAY               0
# define FAIL_SYSCALL_PARENT    1
# define FAIL_SYSCALL_CHILD  2
 
//                              Structs
 
typedef struct s_shell
{
    char                    *rl_input;
    char                    *rl_copy;
    struct s_environ_list   *environ;
    struct s_lexer_list     *lex_head;
    struct s_executor       *executor;
}               t_shell;
 
typedef struct s_environ_list
{
    struct s_environ_node       *head;
    int                         size;
}               t_environ_list;
 
typedef struct s_environ_node
{
    char                    *key;
    char                    *value;
    struct s_environ_node   *next;
}               t_environ_node;
 
typedef enum s_token
{
    NONE = 0,
    PIPE = 1,
    TRUNCATE = 2,
    APPEND = 3,
    REDIRECT_INPUT = 4,
    HEREDOC = 5,
}           t_token;
 
typedef struct s_lexer_list
{
    char                *str;
    t_token             type;
    int                 index;
    struct s_lexer_list *prev;
    struct s_lexer_list *next;
}   t_lexer_list;
 
typedef struct s_executor
{
    int                 id;
    int                 size;
    int                 fd_in;
    int                 fd_out;
    bool                truncate;
    bool                append;
    bool                redirect_input;
    bool                heredoc;
    char                **path;
    char                **execs;
    struct s_executor   *prev;
    struct s_executor   *next;
}               t_executor;
 
typedef struct s_expander
{
    char        *beginning;
    char        *res;
    char        *invalid;
    char        *env_val;
    char        *var;
    char        *str;
    char        *conv;
    int         pos;
    int         len;
    int         recently_invalid;
    int         expanded;
    int         flag;
}               t_expander;
 
typedef struct s_info
{
    int                     wstatus;
    t_shell                 *shell;
    int                     stdin_copy;
    pid_t                   *pids;
}   t_info;
 
//                              Global Variables
 
extern int      g_exit_code;
 
//                              Debug Functions
 
//  debug_prints.c
 
// void         print_env(t_environ_list *environ);
// void         printlexerlist(t_lexer_list *head);
// void         print_executor_list(t_executor *list);
 
//                              Function Prototypes
 
//  ft_getpid.c
 
pid_t           ft_getpid(void);
 
//  signal_setup.c
 
void            signal_setup(int process);
 
//  check_exitcode.c
 
void            check_exitcode(int wstatus, bool *is_print);
 
//  init_shell.c
 
t_shell         *init_shell(char **envp);
t_environ_list  *init_environ(char **envp);
t_environ_list  *empty_environ(t_environ_list *environ);
void            lvl_up(t_shell *shell);
 
//  environ_list_utils.c
 
t_environ_node  *create_environ_node(char *var);
t_environ_node  *add_back_environ_node(t_environ_list *environ,
                    t_environ_node *node);
t_environ_node  *get_node(t_environ_list *environ, char *key);
 
//  free_heap.c
 
char            **free_str_arr(char **arr);
void            free_environ(t_environ_list *environ);
t_lexer_list    *free_lex(t_lexer_list *lex_head);
t_executor      *free_executor_list(t_executor *list);
void            free_heap(t_shell *shell);
 
//  parser.c
 
bool            check_pipe_syntax(t_lexer_list *lexer);
t_lexer_list    *lexer(t_shell *shell);
bool            parser(t_shell *shell);
 
//  check_quote_syntax.c
 
int             get_end_quote(const char *input, char c);
bool            check_quote_syntax(const char *input);
 
//  clean_rl_copy.c
 
int             ft_isspace(int c);
char            *replace_with_clean(char *rl_copy, size_t start, size_t end);
char            *clean_rl_copy(char *rl_copy);
 
//  tokenize.c
 
t_token         assign_type(char tok);
t_token         which_type(char *s);
t_lexer_list    *create_lexer_list(char **input_array);
t_lexer_list    *fill_lexer_list(char **input_array);
t_lexer_list    *tokenize(t_shell *shell);
 
//  create_input_array.c
 
int             len_substr(char *str);
int             count_elements(char *rl_copy);
int             find_token(char **input_array, char **input, int index);
char            **fill_input_array(char **input_array, char *input);
char            **create_input_array(t_shell *shell);
 
//  input_array_utils.c
 
int             skip_quotes(char *str);
void            no_delim_found(char *str, int *len);
bool            is_token(char to_check);
bool            is_token2(char to_check);
 
//  prep_executor.c
 
int             get_size_executor(t_lexer_list *head);
t_executor      *create_executor_list(int size);
void            set_executor_defaults(t_executor *node);
t_executor      *init_executor_list(int size);
t_executor      *prepare_executor(t_shell *shell);
 
//  check_execs_after_expand.c
 
char            **combine_execs(char **resplit, char **new_execs, char **execs);
int             after_expand(t_executor *current);
bool            check_execs_after_expand(t_shell *shell);
 
//  set_path_executor.c
 
void            set_path_executor(t_executor *list, t_environ_list *environ);
 
//  fill_executor_list.c
 
int             process_out_append(t_executor *current, t_lexer_list *lexer);
int             process_in_heredoc(t_executor *current, t_lexer_list *lexer);
int             process_command(t_executor *current, t_lexer_list *lexer);
t_executor      *process_lexemes(t_executor *list, t_executor *current,
                    t_lexer_list **lexer);
t_executor      *fill_executor_list(t_shell *shell, t_executor *list);
 
//  process_out_append.c
 
bool            close_outputfile(int fd);
bool            open_outputfile(t_executor *current, t_lexer_list *lexer);
 
//  process_in_heredoc.c
 
bool            get_input(int fd, char *delimiter);
int             create_heredoc(char *delimiter);
bool            open_inputfile(t_executor *current, t_lexer_list *lexer);
 
//  process_command.c
 
int             get_size_execs(t_lexer_list *lexer);
char            **get_execs_array(t_lexer_list *lexer, int size);
 
//  cd_builtin.c
 
void            update_old(t_shell *shell, char *old);
int             env_var_update(t_shell *shell, char *old, char *new);
int             cd_no_args(t_shell *shell);
int             cd(t_shell *shell, char **args);
 
//  pwd_builtin.c
 
int             get_sizeof_args(char **args);
int             pwd(void);
 
//  export_builtin.c
 
int             export_no_args(t_shell *shell);
void            exporting(t_shell *shell, char *str);
int             export_args(t_shell *shell, char **args);
int             export(t_shell *shell, char **args);
 
// env_builtin.c
 
int             env(t_shell *shell, char **args);
 
//  exit_builtin_utils.c
 
void            child(t_shell *shell, char **args, int number);
void            handle_child(t_shell *shell, char **args, int number);
void            parent(t_shell *shell, char **args, int number);
int             handle_parent(t_shell *shell, char **args, int number);
 
//  exit_builtin.c
 
bool            is_arg_number(char *arg);
int             exit_builtin(t_shell *shell, char **args, bool in_child);
 
//  unset_builtin.c
 
void            delete_variable(t_shell *shell, char *arg);
void            unset_arg(t_shell *shell, char *arg, int *fails);
int             unset(t_shell *shell, char **args);
 
//  echo_builtin.c
 
int             echo(char **args);
 
//  expander.c
 
bool            expander(t_shell *shell);
int             expand_var(t_shell *shell, char **str, t_expander *exp,
                    int pos);
 
//  handle_quotes.c
 
char            *handle_quotes(t_shell *shell, char **str, char end_quote,
                    t_expander *inter);
 
//  interpolate.c
 
char            *interpolate(t_shell *shell, char *str);
 
//  expander_utils.c
 
t_expander      *init_expander(char *str);
char            *realloc_str(char *res, int pos);
void            free_exp(t_expander *exp);
char            *ft_strjoin_expander(char const *s1, char const *s2);
char            *ft_charjoin_expander(char const *s, char const c);
 
//  executor.c
 
void            close_fds(t_executor *current);
void            handle_single(t_shell *shell);
void            executor(t_shell *shell);
 
//  handle_single_builtin.c
 
bool            is_builtin(char *exec);
void            execute_builtin(t_shell *shell);
int             handle_single_builtin(t_shell *shell);
 
//  single_builtin_utils.c
 
bool            handle_redirections_single_builtin(t_shell *shell);
void            saving_stds(int *stdin_cpy, int *stdout_cpy);
bool            restore_stds(int stdin_cpy, int stdout_cpy);
 
//  handle_single_child.c
 
void            handle_single_child(t_shell *shell);
 
//  single_child_utils.c
 
bool            handle_redirections_single_child(t_shell *shell);
char            *get_absolute_path(t_shell *shell);
void            check_errno(t_shell *shell, char *path);
void            get_path_error(char *str);
char            *get_path(t_shell *shell, bool printerror);
 
//  single_child_utils_2.c
 
int             get_size_environ(t_environ_node *current);
char            **create_environ_array(t_environ_list *environ);
void            transform_error(char **environ_array);
void            transform_helper(t_environ_node *current, char **environ_array);
char            **transform_environ_array(t_shell *shell);
 
//  handle_multi.c
 
t_info          *init_info(t_shell *shell);
void            wait_pipeline(t_info *info, int number);
void            ft_error(t_executor *current, t_info *info);
void            handle_multi(t_shell *shell, t_executor *current);
 
//  child_handler_multi.c
 
int             handle_redirections_pipeline(int *fildes, t_executor *current,
                    t_info *info);
void            execute_builtin_child(t_executor *current, t_info *info);
char            *execute_other_helper(t_executor *current);
int             execute_other(t_executor *current, t_info *info);
int             child_handler_multi(int *fildes, t_executor *current,
                    t_info *info);
 
//  handle_pipeline.c
 
int             handle_pipes(int fildes[2]);
pid_t           handle_forks(void);
int             parent_handler_multi(int *fildes, t_executor *current);
int             handle_pipeline(int *fildes, t_executor *current,
                    t_info *info, int i);
 
#endif