tokens.h File Reference

#include "../lib/libft/inc/libft.h"
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <readline/readline.h>
#include <readline/history.h>
#include <pwd.h>
#include "shell.h"
#include "env.h"

Include dependency graph for tokens.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	s_token
struct	s_ast
struct	s_loop_data

Macros
#define	HISTORY_PATH   "./src/utils/.maxishell_history"

Typedefs
typedef enum e_token_type	t_token_type
typedef struct s_token	t_token
typedef struct s_ast	t_ast
typedef struct s_loop_data	t_loop_data

Enumerations
enum	e_token_type {   PHRASE , PIPE , ENV_VAR , REDIR_IN ,   REDIR_OUT , REDIR_APPEND , REDIR_HEREDOC , NONE }

Functions
void	final_quote_removal (int arg_count, t_ast *command_node)
char *	expand_env_var (char *arg, t_ms_data *data)
void	post_process_command_args (t_ast *command_node, int arg_count, t_ms_data *data)
void	add_node (t_token **head, char *str)
void	print_stack (t_token **stack)
void	free_stack (t_token **stack)
int	calc_stack_size (t_token *stack)
char **	list_to_array (t_token *head)
void	build_linked_list (t_token **tokens, char **argv)
void	handle_quotes (char **tokens, int *pos, char **input)
char *	handle_special_chars (char *str, t_token **tokens)
void	skip_delimiters (char **input, char *delim)
void	reallocate_tokens (char ***tokens, int *bufsize)
void	parse_loop (char **input, char **tokens, int *pos, int *bufsize)
char **	parse_input (char *input)
char *	generate_prompt (t_ms_data *data)
void	make_history (char *line)
void	loop_cleanup (t_loop_data *loop_data, t_token *tokens_head)
void	free_ms_data (t_ms_data *data)
char *	check_heredoc (char *line)
char *	heredoc (char *eof)
void	init_ms_data (t_ms_data *data, char **argv, char **envp)
void	initialise (int argc, char **argv)
void	execute_command (char **parsed_text, t_token **tokens)
void	print_maxishell (void)
int	input_error_checks (t_loop_data *loop_data)
t_token *	tokenise (char *str)
void	print_tokens (t_token *tokens, char *name)
t_ast *	parse_tokens (t_token **tokens, t_ms_data *data)
void	visualize_ast (t_ast *root)
void	free_ast (t_ast *node)
void	free_all_tokens (t_token *tokens)
t_token *	new_token (char *value, t_token_type type)
void	append_token (t_token **tokens, t_token *new_token)
int	valid_operator (const char **str)
t_ast *	new_ast_node (void)
t_ast *	create_redir (t_token **tokens, t_token *tmp, t_ms_data *data)
int	arg_len (t_token *current)
void	set_command_args (t_ast *command_node, t_token **tokens, int arg_count)
t_ast *	manage_commands (t_token **tokens, t_ms_data *data)
void	handle_local_vars (t_ms_data *data, char *arg)
t_ast *	create_redir_node (t_token *token)
int	is_redir_node (t_token *tokens)
t_ast *	manage_redirs (t_token **tokens, t_ms_data *data)
t_ast *	manage_pipe (t_token **tokens, t_ms_data *data)
char *	trim_input (char *str)
void	print_ast_root (t_ast *root)
void	execute_tree (t_ast *node, t_ms_data *data)
char *	expand_env_and_loc_var (char *arg, t_ms_data *data)
char *	append_literal (char **start, char *processed_arg)
char *	process_argument (char *arg, t_ms_data *data)
char *	expand_variable (char **start, t_ms_data *data)
void	clear_history_file (void)
int	is_in_single_quotes (char *arg)
void	print_ast_args (t_ast *node)
void	append_word_if_valid (char *start, char *str, t_token **tokens)
char *	exit_status_adj (char *arg)
char *	str_start_adj (char *arg)
char *	tmp_adj (char *arg)
int	cmd_arg_len (t_token *current)
char **	ft_split_preserve_quotes (char *str, char delimiter)
char **	ft_add_segment (char **result, char *start, size_t length, int *count)
char **	initialize_result_array (int *count)
int	toggle_quotes (int in_quotes, char current_char)
char **	add_segment_on_delimiter (char **result, char **start, char *str, int *count)
char **	finalize_result_array (char **result, int count)

Macro Definition Documentation

HISTORY_PATH

#define HISTORY_PATH   "./src/utils/.maxishell_history"

Definition at line 27 of file tokens.h.

Typedef Documentation

t_ast

typedef struct s_ast t_ast

t_loop_data

typedef struct s_loop_data t_loop_data

t_token

typedef struct s_token t_token

t_token_type

typedef enum e_token_type t_token_type

Enumeration Type Documentation

e_token_type

enum e_token_type

Enumerator
PHRASE
PIPE
ENV_VAR
REDIR_IN
REDIR_OUT
REDIR_APPEND
REDIR_HEREDOC
NONE

Definition at line 29 of file tokens.h.

{
    PHRASE,
    PIPE,
    ENV_VAR,
    REDIR_IN,
    REDIR_OUT,
    REDIR_APPEND,
    REDIR_HEREDOC,
    NONE
}   t_token_type;

Function Documentation

add_node()

void add_node	(	t_token **	head,
		char *	str
	)

Definition at line 15 of file stack_control.c.

{
    t_token *new_node;  
    t_token *curr_node;
 
    new_node = (t_token *)malloc(sizeof(t_token));
    if (!new_node)
        return ;
    new_node->data = str;
    new_node->next = NULL;
    if (*head == NULL)
    {
        *head = new_node;
        return ;
    }
    curr_node = *head;
    while (curr_node->next != NULL)
        curr_node = curr_node->next;
    curr_node->next = new_node;
}

References s_token::data, and s_token::next.

Referenced by build_linked_list().

Here is the caller graph for this function:

add_segment_on_delimiter()

char ** add_segment_on_delimiter	(	char **	result,
		char **	start,
		char *	str,
		int *	count
	)

Definition at line 33 of file loc_env_var_handler_utils_utils_utils_utils.c.

{
    result = ft_add_segment(result, *start, str - *start, count);
    *start = str + 1;
    return (result);
}

References ft_add_segment().

Referenced by ft_split_preserve_quotes().

Here is the call graph for this function:

Here is the caller graph for this function:

append_literal()

char * append_literal	(	char **	start,
		char *	processed_arg
	)

Definition at line 74 of file loc_env_var_handler_utils_utils_utils.c.

{
    char    *literal_part;
    char    *literal_start;
    char    *tmp;
 
    literal_start = *start;
    while (**start != '\0' && **start != '$')
        (*start)++;
    literal_part = ft_substr(literal_start, 0, *start - literal_start);
    tmp = ft_strjoin(processed_arg, literal_part);
    free(literal_part);
    free(processed_arg);
    return (tmp);
}

References ft_strjoin(), and ft_substr().

Referenced by process_argument().

Here is the call graph for this function:

Here is the caller graph for this function:

append_token()

void append_token	(	t_token **	tokens,
		t_token *	new_token
	)

Definition at line 85 of file tokeniser.c.

{
    t_token *curr;
 
    if (!*tokens)
        *tokens = new_token;
    else
    {
        curr = *tokens;
        while (curr->next)
            curr = curr->next;
        curr->next = new_token;
    }
}

References new_token(), and s_token::next.

Referenced by append_word_if_valid(), and handle_special_chars().

Here is the call graph for this function:

Here is the caller graph for this function:

append_word_if_valid()

void append_word_if_valid	(	char *	start,
		char *	str,
		t_token **	tokens
	)

Definition at line 49 of file tokeniser_helpers.c.

{
    char    *word;
 
    if (str > start)
    {
        word = ft_strndup(start, str - start);
        if (word)
        {
            append_token(tokens, new_token(word, PHRASE));
            free(word);
        }
        else
            ft_printf("Error: unable to allocate memory for token\n");
    }
}

References append_token(), ft_printf(), ft_strndup(), new_token(), and PHRASE.

Referenced by handle_phrase().

Here is the call graph for this function:

Here is the caller graph for this function:

arg_len()

int arg_len

(

t_token *

current

)

build_linked_list()

void build_linked_list	(	t_token **	tokens,
		char **	argv
	)

Definition at line 15 of file stack_control_2.c.

{
    int i;
 
    i = 0;
    while (argv[i])
    {
        add_node(tokens, argv[i]);
        i++;
    }
}

References add_node().

Here is the call graph for this function:

calc_stack_size()

int calc_stack_size

(

t_token *

stack

)

Definition at line 65 of file stack_control.c.

{
    int         size;
    t_token     *current;
 
    size = 0;
    current = stack;
    while (current != NULL)
    {
        size++;
        current = current->next;
    }
    return (size);
}

References s_token::next.

Referenced by list_to_array().

Here is the caller graph for this function:

check_heredoc()

char * check_heredoc

(

char *

line

)

clear_history_file()

void clear_history_file

(

void

)

Definition at line 31 of file builtins_utils.c.

{
    remove(HISTORY_PATH);
}

References HISTORY_PATH.

Referenced by cleanup_exit_resources(), main(), and main_loop().

Here is the caller graph for this function:

cmd_arg_len()

int cmd_arg_len

(

t_token *

current

)

Definition at line 88 of file AST_utils.c.

{
    int i;
 
    i = 0;
    while (current && current->type == PHRASE)
    {
        i++;
        current = current->next;
    }
    return (i);
}

References s_token::next, PHRASE, and s_token::type.

Referenced by manage_commands().

Here is the caller graph for this function:

create_redir()

t_ast * create_redir	(	t_token **	tokens,
		t_token *	tmp,
		t_ms_data *	data
	)

create_redir_node()

t_ast * create_redir_node

(

t_token *

token

)

Definition at line 62 of file AST.c.

{
    t_ast           *node;
 
    node = new_ast_node();
    node->type = token->type;
    node->args = malloc(sizeof(char *) * 2);
    if (!node->args)
    {
        free(node);
        return (NULL);
    }
    node->args[0] = ft_strdup(token->data);
    node->args[1] = NULL;
    return (node);
}

References s_ast::args, s_token::data, ft_strdup(), new_ast_node(), s_token::type, and s_ast::type.

Referenced by manage_redirs().

Here is the call graph for this function:

Here is the caller graph for this function:

execute_command()

void execute_command	(	char **	parsed_text,
		t_token **	tokens
	)

execute_tree()

void execute_tree	(	t_ast *	node,
		t_ms_data *	data
	)

exit_status_adj()

char * exit_status_adj

(

char *

arg

)

Definition at line 21 of file loc_env_var_handler_utils_utils_utils.c.

{
    if (ft_strcmp(arg, "$") == 0)
        return ("$?");
    return (arg);
}

References ft_strcmp().

Referenced by expand_env_and_loc_var().

Here is the call graph for this function:

Here is the caller graph for this function:

expand_env_and_loc_var()

char * expand_env_and_loc_var	(	char *	arg,
		t_ms_data *	data
	)

Definition at line 45 of file loc_env_var_handler_utils_utils.c.

{
    char    *env_value_dup;
 
    arg = exit_status_adj(arg);
    if (ft_strcmp(arg, "$?") == 0)
        return (get_exit_status(data));
    else if (arg[0] == '$')
    {
        handle_trailing_quote(arg);
        env_value_dup = get_env_variable(arg, data);
        return (env_value_dup);
    }
    return (ft_strdup(""));
}

References exit_status_adj(), ft_strcmp(), ft_strdup(), get_env_variable(), get_exit_status(), and handle_trailing_quote().

Referenced by ev_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

expand_env_var()

char * expand_env_var	(	char *	arg,
		t_ms_data *	data
	)

expand_variable()

char * expand_variable	(	char **	start,
		t_ms_data *	data
	)

Definition at line 40 of file loc_env_var_handler_utils.c.

{
    char    *expanded_str;
    char    *str_start;
    char    *result;
 
    result = NULL;
    str_start = *start;
    expanded_str = ft_strdup("");
    while (**start && **start != '\0')
    {
        if (**start == '$')
        {
            expanded_str = ev_loop(start, data, str_start, expanded_str);
            str_start = *start;
            str_start = str_start_adj(str_start);
        }
        else
            (*start)++;
    }
    if (str_start != *start)
    {
        result = ft_substr(str_start, 0, *start - str_start);
        expanded_str = ft_strjoin_free(expanded_str, result);
        free(result);
    }
    return (expanded_str);
}

References ev_loop(), ft_strdup(), ft_strjoin_free(), ft_substr(), and str_start_adj().

Referenced by process_argument(), and process_single_token().

Here is the call graph for this function:

Here is the caller graph for this function:

final_quote_removal()

void final_quote_removal	(	int	arg_count,
		t_ast *	command_node
	)

Definition at line 21 of file loc_env_var_handler_utils_utils.c.

{
    int     i;
    size_t  len;
    char    *arg;
    char    *trimmed_arg;
 
    i = 0;
    ft_print_2d_arr(command_node->args, "final-quote_removal");
    while (i < arg_count)
    {
        arg = command_node->args[i];
        len = ft_strlen(arg);
        if ((arg[0] == '"' && arg[len - 1] == '"') || (arg[0] == '\''
                && arg[len - 1] == '\''))
        {
            trimmed_arg = ft_strndup(arg + 1, len - 2);
            free(command_node->args[i]);
            command_node->args[i] = trimmed_arg;
        }
        i++;
    }
}

References s_ast::args, ft_print_2d_arr(), ft_strlen(), and ft_strndup().

Here is the call graph for this function:

finalize_result_array()

char ** finalize_result_array	(	char **	result,
		int	count
	)

Definition at line 41 of file loc_env_var_handler_utils_utils_utils_utils.c.

{
    char    **temp;
 
    temp = realloc(result, sizeof(char *) * (count + 1));
    if (!temp)
    {
        free(result);
        return (NULL);
    }
    result = temp;
    result[count] = NULL;
    return (result);
}

Referenced by ft_split_preserve_quotes().

Here is the caller graph for this function:

free_all_tokens()

void free_all_tokens

(

t_token *

tokens

)

Definition at line 17 of file clean_utils.c.

{
    t_token *temp;
 
    while (tokens)
    {
        temp = tokens;
        tokens = tokens->next;
        if (temp)
        {
            if (temp->data)
            {
                free(temp->data);
                temp->data = NULL;
            }
        }
        free(temp);
        temp = NULL;
    }
}

References s_token::data, and s_token::next.

free_ast()

void free_ast

(

t_ast *

node

)

Definition at line 74 of file clean.c.

{
    int             i;
 
    i = 0;
    if (!node)
        return ;
    if (node->args)
    {
        while (node->args && node->args[i])
        {
            free(node->args[i]);
            i++;
        }
        free(node->args);
    }
    free_ast(node->left);
    free_ast(node->right);
    free(node);
}

References s_ast::args, free_ast(), s_ast::left, and s_ast::right.

Referenced by free_ast(), and loop_cleanup().

Here is the call graph for this function:

Here is the caller graph for this function:

free_ms_data()

void free_ms_data

(

t_ms_data *

data

)

Definition at line 51 of file clean.c.

{
    if (data)
    {
        free_shell_var_list(data->envp);
        free_shell_var_list(data->shell_variables);
        free(data->current_dir);
        if (data->std_in >= 0)
            close(data->std_in);
        if (data->std_out >= 0)
            close(data->std_out);
        if (data->std_err >= 0)
            close(data->std_err);
    }
}

References s_ms_data::current_dir, s_ms_data::envp, free_shell_var_list(), s_ms_data::shell_variables, s_ms_data::std_err, s_ms_data::std_in, and s_ms_data::std_out.

Referenced by cleanup_exit_resources(), and main().

Here is the call graph for this function:

Here is the caller graph for this function:

free_stack()

void free_stack

(

t_token **

stack

)

Definition at line 51 of file stack_control.c.

{
    t_token *current;
    t_token *next;
 
    current = *stack;
    while (current != NULL)
    {
        next = current->next;
        free(current);
        current = next;
    }
}

References s_token::next.

ft_add_segment()

char ** ft_add_segment	(	char **	result,
		char *	start,
		size_t	length,
		int *	count
	)

Definition at line 91 of file loc_env_var_handler_utils.c.

{
    result = realloc(result, (*count + 1) * sizeof(char *));
    result[*count] = ft_strndup(start, length);
    (*count)++;
    return (result);
}

References ft_strndup().

Referenced by add_segment_on_delimiter(), and ft_split_preserve_quotes().

Here is the call graph for this function:

Here is the caller graph for this function:

ft_split_preserve_quotes()

char ** ft_split_preserve_quotes	(	char *	str,
		char	delimiter
	)

Definition at line 99 of file loc_env_var_handler_utils.c.

{
    int     count;
    int     in_quotes;
    char    *start;
    char    **result;
 
    in_quotes = 0;
    start = str;
    result = initialize_result_array(&count);
    if (!result)
        return (NULL);
    while (*str)
    {
        in_quotes = toggle_quotes(in_quotes, *str);
        if (*str == delimiter && !in_quotes)
            result = add_segment_on_delimiter(result, &start, str, &count);
        str++;
    }
    if (str != start)
        result = ft_add_segment(result, start, str - start, &count);
    return (finalize_result_array(result, count));
}

References add_segment_on_delimiter(), finalize_result_array(), ft_add_segment(), initialize_result_array(), and toggle_quotes().

Referenced by split_loc_vars().

Here is the call graph for this function:

Here is the caller graph for this function:

generate_prompt()

char * generate_prompt

(

t_ms_data *

data

)

Definition at line 20 of file prompt.c.

{
    char    *prompt;
    size_t  prompt_len;
 
    prompt_len = ft_strlen("🌴 @maxishell$ ") + \
            ft_strlen(getenv("LOGNAME"));
    prompt = (char *)malloc(prompt_len + 1);
    if (!prompt)
        exit(EXIT_FAILURE);
    ft_strcpy(prompt, "🌴 ");
    ft_strcat(prompt, getenv("LOGNAME"));
    ft_strcat(prompt, "@maxishell$ ");
    (void)data;
    return (prompt);
}

References EXIT_FAILURE, ft_strcat(), ft_strcpy(), and ft_strlen().

Here is the call graph for this function:

handle_local_vars()

void handle_local_vars	(	t_ms_data *	data,
		char *	arg
	)

Definition at line 69 of file loc_env_var_handler_utils.c.

{
    char    *p;
    int     valid_var;
 
    p = arg;
    valid_var = 1;
    if (arg[0] != '=' && ft_strchr(arg, '='))
    {
        while (p < ft_strchr(arg, '='))
        {
            if (!ft_isalnum(*p++))
            {
                valid_var = 0;
                break ;
            }
        }
        if (valid_var)
            handle_add_set_shell_variable(&data->shell_variables, arg);
    }
}

References ft_isalnum(), ft_strchr(), handle_add_set_shell_variable(), and s_ms_data::shell_variables.

Here is the call graph for this function:

handle_quotes()

void handle_quotes	(	char **	tokens,
		int *	pos,
		char **	input
	)

handle_special_chars()

char * handle_special_chars	(	char *	str,
		t_token **	tokens
	)

Definition at line 39 of file tokeniser.c.

{
    if (*str == '<')
    {
        if (*(str + 1) == '<')
        {
            append_token(tokens, new_token("<<", REDIR_HEREDOC));
            (str)++;
        }
        else
            append_token(tokens, new_token("<", REDIR_IN));
    }
    else if (*str == '>')
    {
        if (*(str + 1) == '>')
        {
            append_token(tokens, new_token(">>", REDIR_APPEND));
            (str)++;
        }
        else
            append_token(tokens, new_token(">", REDIR_OUT));
    }
    else if (*str == '|')
        append_token(tokens, new_token("|", PIPE));
    (str)++;
    return (str);
}

References append_token(), new_token(), PIPE, REDIR_APPEND, REDIR_HEREDOC, REDIR_IN, and REDIR_OUT.

Referenced by tokenise().

Here is the call graph for this function:

Here is the caller graph for this function:

heredoc()

char * heredoc

(

char *

eof

)

init_ms_data()

void init_ms_data	(	t_ms_data *	data,
		char **	argv,
		char **	envp
	)

Definition at line 20 of file initialise.c.

{
    (void)argv;
    data->args = NULL;
    data->envp = NULL;
    init_env(&data->envp, envp);
    data->shell_variables = NULL;
    handle_add_set_shell_variable(&data->shell_variables, "_=/usr/bin/env");
    set_shell_var(&data->shell_variables, "?", "0");
    data->current_dir = getcwd(NULL, 0);
    data->exit_status = 0;
    data->std_in = -1;
    data->std_out = -1;
    data->std_err = 2;
}

References s_ms_data::args, s_ms_data::current_dir, s_ms_data::envp, s_ms_data::exit_status, handle_add_set_shell_variable(), init_env(), set_shell_var(), s_ms_data::shell_variables, s_ms_data::std_err, s_ms_data::std_in, and s_ms_data::std_out.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

initialise()

void initialise	(	int	argc,
		char **	argv
	)

Definition at line 36 of file initialise.c.

{
    if (argc > 1)
    {
        ft_printf("Usage: %s\n", argv[0]);
        exit(EXIT_FAILURE);
    }
    read_history(HISTORY_PATH);
}

References EXIT_FAILURE, ft_printf(), and HISTORY_PATH.

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

initialize_result_array()

char ** initialize_result_array

(

int *

count

)

Definition at line 15 of file loc_env_var_handler_utils_utils_utils_utils.c.

{
    char    **result;
 
    *count = 0;
    result = malloc(sizeof(char *));
    if (!result)
        return (NULL);
    return (result);
}

Referenced by ft_split_preserve_quotes().

Here is the caller graph for this function:

input_error_checks()

int input_error_checks

(

t_loop_data *

loop_data

)

Definition at line 96 of file input_checker.c.

{
    const char  *str = loop_data->trimmed_input;
 
    if (check_redirections(str))
        ft_printf("Input error: invalid redirection.\n");
    else if (check_operators(loop_data))
        ft_printf("Input error: invalid operator.\n");
    else if (check_open_quotes(str))
        ft_printf("Input error: open quote.\n");
    else
        return (0);
    return (1);
}

References check_open_quotes(), check_operators(), check_redirections(), ft_printf(), and s_loop_data::trimmed_input.

Referenced by main_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

is_in_single_quotes()

int is_in_single_quotes

(

char *

arg

)

Definition at line 28 of file loc_env_var_handler_utils_utils_utils.c.

{
    int len;
 
    if (!arg || arg[0] != '\'')
        return (0);
    len = 0;
    while (arg[len] != '\0')
        len++;
    if (arg[len - 1] == '\'')
        return (1);
    return (0);
}

Referenced by post_process_command_args().

Here is the caller graph for this function:

is_redir_node()

int is_redir_node

(

t_token *

tokens

)

Definition at line 79 of file AST.c.

{
    if (tokens->type == REDIR_IN
        || tokens->type == REDIR_OUT
        || tokens->type == REDIR_APPEND
        || tokens->type == REDIR_HEREDOC)
        return (1);
    return (0);
}

References REDIR_APPEND, REDIR_HEREDOC, REDIR_IN, REDIR_OUT, and s_token::type.

Referenced by manage_redirs().

Here is the caller graph for this function:

list_to_array()

char ** list_to_array

(

t_token *

head

)

Definition at line 80 of file stack_control.c.

{
    int         count;
    int         i;
    char        **arr;
    t_token     *current;
 
    current = head;
    count = calc_stack_size(current);
    arr = (char **)malloc((count + 1) * sizeof(char *));
    if (!arr)
        return (NULL);
    current = head;
    i = 0;
    while (i < count)
    {
        arr[i] = ft_strdup(current->data);
        current = current->next;
        i++;
    }
    arr[count] = NULL;
    return (arr);
}

References calc_stack_size(), s_token::data, ft_strdup(), and s_token::next.

Here is the call graph for this function:

loop_cleanup()

void loop_cleanup	(	t_loop_data *	loop_data,
		t_token *	tokens_head
	)

Definition at line 67 of file clean.c.

{
    free(loop_data->trimmed_input);
    free_all_tokens(tokens_head);
    free_ast(loop_data->tree);
}

References free_all_tokens(), free_ast(), s_loop_data::tree, and s_loop_data::trimmed_input.

Referenced by process_command().

Here is the call graph for this function:

Here is the caller graph for this function:

make_history()

void make_history

(

char *

line

)

Definition at line 15 of file aux.c.

{
    if (*line)
        add_history(line);
    write_history(HISTORY_PATH);
}

References HISTORY_PATH.

Referenced by main_loop().

Here is the caller graph for this function:

manage_commands()

t_ast * manage_commands	(	t_token **	tokens,
		t_ms_data *	data
	)

Definition at line 72 of file AST_utils.c.

{
    t_ast       *command_node;
    int         cmd_arg_count;
 
    command_node = new_ast_node();
    command_node->type = PHRASE;
    cmd_arg_count = cmd_arg_len(*tokens);
    command_node->args = malloc(sizeof(char *) * (cmd_arg_count + 1));
    if (!command_node->args)
        return (NULL);
    set_command_args(command_node, tokens, cmd_arg_count);
    post_process_command_args(command_node, cmd_arg_count, data);
    return (command_node);
}

References s_ast::args, cmd_arg_len(), new_ast_node(), PHRASE, post_process_command_args(), set_command_args(), and s_ast::type.

Referenced by manage_redirs().

Here is the call graph for this function:

Here is the caller graph for this function:

manage_pipe()

t_ast * manage_pipe	(	t_token **	tokens,
		t_ms_data *	data
	)

Definition at line 56 of file AST_utils.c.

{
    t_token *tmp;
    t_token *next_token;
 
    tmp = *tokens;
    while (*tokens && (*tokens)->next)
    {
        next_token = (*tokens)->next;
        if (next_token->type == PIPE)
            return (create_pipe_node(next_token, tokens, data, tmp));
        *tokens = next_token;
    }
    return (manage_redirs(&tmp, data));
}

References create_pipe_node(), manage_redirs(), s_token::next, PIPE, and s_token::type.

Referenced by create_pipe_node(), and parse_tokens().

Here is the call graph for this function:

Here is the caller graph for this function:

manage_redirs()

t_ast * manage_redirs	(	t_token **	tokens,
		t_ms_data *	data
	)

Definition at line 20 of file AST.c.

{
    t_ast       *command_node;
    t_ast       *redirect_node;
    t_token     *current_token;
 
    if (!tokens || !*tokens)
        return (NULL);
    command_node = manage_commands(tokens, data);
    current_token = *tokens;
    while (current_token && is_redir_node(current_token))
    {
        redirect_node = create_redir_node(current_token);
        redirect_node->left = command_node;
        *tokens = current_token->next;
        if (*tokens)
        {
            redirect_node->right = create_redir_node(*tokens);
            *tokens = (*tokens)->next;
        }
        else
            redirect_node->right = NULL;
        command_node = redirect_node;
        current_token = *tokens;
    }
    return (command_node);
}

References create_redir_node(), is_redir_node(), s_ast::left, manage_commands(), s_token::next, and s_ast::right.

Referenced by create_pipe_node(), and manage_pipe().

Here is the call graph for this function:

Here is the caller graph for this function:

new_ast_node()

t_ast * new_ast_node

(

void

)

Definition at line 89 of file AST.c.

{
    t_ast       *node;
 
    node = malloc(sizeof(t_ast));
    if (!node)
        return (NULL);
    node->type = NONE;
    node->args = NULL;
    node->left = NULL;
    node->right = NULL;
    return (node);
}

References s_ast::args, s_ast::left, NONE, s_ast::right, and s_ast::type.

Referenced by create_pipe_node(), create_redir_node(), and manage_commands().

Here is the caller graph for this function:

new_token()

t_token * new_token	(	char *	value,
		t_token_type	type
	)

Definition at line 67 of file tokeniser.c.

{
    t_token *token;
 
    token = malloc(sizeof(t_token));
    if (!token)
        return (NULL);
    token->data = ft_strdup(value);
    if (!token->data)
    {
        free(token);
        return (NULL);
    }
    token->type = type;
    token->next = NULL;
    return (token);
}

References s_token::data, ft_strdup(), s_token::next, and s_token::type.

Referenced by append_token(), append_word_if_valid(), finalize_token(), handle_special_chars(), and process_single_token().

Here is the call graph for this function:

Here is the caller graph for this function:

parse_input()

char ** parse_input

(

char *

input

)

parse_loop()

void parse_loop	(	char **	input,
		char **	tokens,
		int *	pos,
		int *	bufsize
	)

parse_tokens()

t_ast * parse_tokens	(	t_token **	tokens,
		t_ms_data *	data
	)

Definition at line 23 of file AST_utils.c.

{
    if (!tokens || !*tokens)
        return (NULL);
    return (manage_pipe(tokens, data));
}

References manage_pipe().

Referenced by main_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

post_process_command_args()

void post_process_command_args	(	t_ast *	command_node,
		int	arg_count,
		t_ms_data *	data
	)

Definition at line 60 of file loc_env_var_handler.c.

{
    int     i;
    char    *processed_arg;
    int     current_size;
    char    *tmp_proc_arg;
 
    i = 0;
    tmp_proc_arg = NULL;
    current_size = arg_count;
    while (i < current_size)
    {
        if (!is_in_single_quotes(command_node->args[i]))
        {
            handle_local_vars(data, command_node->args[i]);
            tmp_proc_arg = process_argument(command_node->args[i], data);
        }
        else
            tmp_proc_arg = ft_substr(command_node->args[i], 1, \
                                        ft_strlen(command_node->args[i]) - 2);
        free(command_node->args[i]);
        processed_arg = ft_remove_quotes(tmp_proc_arg, '\"');
        free(tmp_proc_arg);
        split_loc_vars(command_node, processed_arg, &current_size, &i);
        free(processed_arg);
    }
    command_node->args[current_size] = NULL;
}

References s_ast::args, ft_remove_quotes(), ft_strlen(), ft_substr(), handle_local_vars(), is_in_single_quotes(), process_argument(), and split_loc_vars().

Referenced by manage_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

print_ast_args()

void print_ast_args

(

t_ast *

node

)

Definition at line 37 of file tokeniser_helpers.c.

{
    int     i;              
 
    i = 0;
    while (node->args[i] != NULL)
    {
        ft_printf("ast arg[%d] ->  %s \n", i, node->args[i]);
        i++;
    }
}

References s_ast::args, and ft_printf().

Here is the call graph for this function:

print_ast_root()

void print_ast_root

(

t_ast *

root

)

Definition at line 103 of file visualiser.c.

{
    if (!root)
        return ;
    print_ast_graphical(root, 0, "", 0);
}

References print_ast_graphical().

Here is the call graph for this function:

print_maxishell()

void print_maxishell

(

void

)

Definition at line 56 of file prompt.c.

{
    ft_printf("\033[1;33m\n\n\n\n\n");
    ft_printf("███╗░░░███╗░█████╗░██╗░░██╗██╗░██████╗██╗░"
        "░██╗███████╗██╗░░░░░██╗░░░░░\n");
    ft_printf("████╗░████║██╔══██╗╚██╗██╔╝██║██╔════╝██║░"
        "░██║██╔════╝██║░░░░░██║░░░░░\n");
    ft_printf("██╔████╔██║███████║░╚███╔╝░██║╚█████╗░█████"
        "██║█████╗░░██║░░░░░██║░░░░░\n");
    ft_printf("██║╚██╔╝██║██╔══██║░██╔██╗░██║░╚═══██╗██╔══"
        "██║██╔══╝░░██║░░░░░██║░░░░░\n");
    ft_printf("██║░╚═╝░██║██║░░██║██╔╝╚██╗██║██████╔╝██║░░"
        "██║███████╗███████╗███████╗\n");
    ft_printf("╚═╝░░░░░╚═╝╚═╝░░╚═╝╚═╝░░╚═╝╚═╝╚═════╝░╚═╝░░"
        "╚═╝╚══════╝╚══════╝╚══════╝\n");
    ft_printf("\n");
    ft_printf("            \033[1;34m"
        "Version 1.0.0\033[0m\n");
    ft_printf("           \033[1;36m"
        "By Димас и Ромас\033[0m\n");
    ft_printf("\n");
}

References ft_printf().

Referenced by main().

Here is the call graph for this function:

Here is the caller graph for this function:

print_stack()

void print_stack

(

t_token **

stack

)

Definition at line 36 of file stack_control.c.

{
    t_token *current_node;
    int     i;
 
    i = 0;
    current_node = *stack;
    while (current_node != NULL)
    {
        ft_printf("input[%d] ->  %s \n", i, current_node->data);
        current_node = current_node->next;
        i++;
    }
}

References s_token::data, ft_printf(), and s_token::next.

Here is the call graph for this function:

print_tokens()

void print_tokens	(	t_token *	tokens,
		char *	name
	)

Definition at line 19 of file tokeniser_helpers.c.

{
    t_token *token;
    int     i;              
 
    i = 0;
    token = tokens;
    if (ft_strlen(name) > 0)
        ft_printf(GRN"-----         %s[]        -----\n"RESET, name);
    while (token != NULL)
    {
        ft_printf(GRN"input[%d] ->      %s      at add:         %p\n"RESET, \
            i, token->data, &token->data);
        token = token->next;
        i++;
    }
}

References s_token::data, ft_printf(), ft_strlen(), GRN, s_token::next, and RESET.

Here is the call graph for this function:

process_argument()

char * process_argument	(	char *	arg,
		t_ms_data *	data
	)

Definition at line 104 of file loc_env_var_handler.c.

{
    char    *start;
    char    *processed_arg;
    char    *tmp_ad;
    char    *expanded_var;
 
    tmp_ad = NULL;
    processed_arg = ft_strdup("");
    start = arg;
    while (*start != '\0')
    {
        if (*start == '$')
        {
            expanded_var = expand_variable(&start, data);
            if (expanded_var != NULL)
            {
                processed_arg = append_expanded_var(processed_arg, \
                                    tmp_ad, expanded_var);
                free(tmp_ad);
            }
        }
        else
            processed_arg = append_literal(&start, processed_arg);
    }
    return (processed_arg);
}

References append_expanded_var(), append_literal(), expand_variable(), and ft_strdup().

Referenced by post_process_command_args().

Here is the call graph for this function:

Here is the caller graph for this function:

reallocate_tokens()

void reallocate_tokens	(	char ***	tokens,
		int *	bufsize
	)

set_command_args()

void set_command_args	(	t_ast *	command_node,
		t_token **	tokens,
		int	arg_count
	)

Definition at line 48 of file AST.c.

{
    int i;
 
    i = 0;
    while (i < arg_count)
    {
        command_node->args[i] = ft_strdup((*tokens)->data);
        *tokens = (*tokens)->next;
        i++;
    }
    command_node->args[arg_count] = NULL;
}

References s_ast::args, ft_strdup(), and s_token::next.

Referenced by manage_commands().

Here is the call graph for this function:

Here is the caller graph for this function:

skip_delimiters()

void skip_delimiters	(	char **	input,
		char *	delim
	)

str_start_adj()

char * str_start_adj

(

char *

arg

)

Definition at line 42 of file loc_env_var_handler_utils_utils_utils.c.

{
    if (!ft_strcmp(arg, "?") || !ft_strcmp(arg, "?\""))
        return ("");
    else if (!ft_strcmp(arg, "?\'"))
        return ("\'");
    return (arg);
}

References ft_strcmp().

Referenced by expand_variable().

Here is the call graph for this function:

Here is the caller graph for this function:

tmp_adj()

char * tmp_adj

(

char *

arg

)

Definition at line 51 of file loc_env_var_handler_utils_utils_utils.c.

{
    char    *ptr;
    char    *tmp_adj_dup;
 
    if (*arg == '\"')
    {
        ptr = arg + 1;
        while (*ptr)
        {
            if (!ft_isdigit(*ptr))
                return (arg);
            ptr++;
        }
        tmp_adj_dup = ft_strdup(arg + 1);
        free(arg);
        return (tmp_adj_dup);
    }
    tmp_adj_dup = ft_strdup(arg);
    free(arg);
    return (tmp_adj_dup);
}

References ft_isdigit(), and ft_strdup().

Referenced by append_expanded_var().

Here is the call graph for this function:

Here is the caller graph for this function:

toggle_quotes()

int toggle_quotes	(	int	in_quotes,
		char	current_char
	)

Definition at line 26 of file loc_env_var_handler_utils_utils_utils_utils.c.

{
    if (current_char == '"' || current_char == '\'')
        return (!in_quotes);
    return (in_quotes);
}

Referenced by ft_split_preserve_quotes().

Here is the caller graph for this function:

tokenise()

t_token * tokenise

(

char *

str

)

Definition at line 22 of file tokeniser.c.

{
    t_token *tokens;
 
    tokens = NULL;
    while (*str)
    {
        while (*str && ft_strchr(" \t\n\r\v\f", *str) != NULL)
            str++;
        if (ft_strchr("<|>", *str) != NULL)
            str = handle_special_chars(str, &tokens);
        else
            str = handle_phrase(str, &tokens);
    }
    return (tokens);
}

References ft_strchr(), handle_phrase(), and handle_special_chars().

Referenced by main_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

trim_input()

char * trim_input

(

char *

str

)

Definition at line 15 of file input_checker_helpers.c.

{
    char    *trimmed_str;
 
    trimmed_str = ft_strtrim(str, " \t\n\r\v\f");
    if (!trimmed_str)
        return (0);
    return (trimmed_str);
}

References ft_strtrim().

Referenced by main_loop().

Here is the call graph for this function:

Here is the caller graph for this function:

valid_operator()

int valid_operator

(

const char **

str

)

Definition at line 25 of file input_checker_helpers.c.

{
    const char  *start;
 
    start = (*str)++;
    if (*start == **str)
        (*str)++;
    *str = ft_exclude_delimiters(*str, " \t\n\r\v\f");
    if (**str == '<' || **str == '>' || **str == '|' || **str == '\0')
        return (0);
    return (1);
}

References ft_exclude_delimiters().

Referenced by check_redirections().

Here is the call graph for this function:

Here is the caller graph for this function:

visualize_ast()

void visualize_ast

(

t_ast *

root

)