raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
minishell/exec/src/run_ast.c
Maieul BOYER 993efe4287
Updated WIP
2024-09-02 16:28:13 +02:00

1205 lines
38 KiB
C
Raw Blame History

/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* run_ast.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/11 17:22:29 by maiboyer #+# #+# */
/* Updated: 2024/09/02 13:44:31 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "app/env.h"
#include "app/state.h"
#include "ast/ast.h"
#include "exec/_run_ast.h"
#include "exec/builtins.h"
#include "exec/run.h"
#include "me/convert/numbers_to_str.h"
#include "me/fs/fs.h"
#include "me/hashmap/hashmap_env.h"
#include "me/mem/mem.h"
#include "me/os/os.h"
#include "me/str/str.h"
#include "me/string/string.h"
#include "me/types.h"
#include "me/vec/vec_ast.h"
#include "me/vec/vec_estr.h"
#include "me/vec/vec_pid.h"
#include "me/vec/vec_str.h"
#include "unistd.h"
#include <signal.h>
#include <sys/wait.h>
#include <stdio.h>
#define NOT_DONE \
{ \
printf("function `%s` isn't done !\n", __func__); \
return (ERROR); \
}
#pragma GCC diagnostic ignored "-Wunused-parameter"
#pragma GCC diagnostic ignored "-Wunused-variable"
#pragma GCC diagnostic ignored "-Wunknown-pragmas"
#pragma GCC diagnostic ignored "-Wempty-body"
#pragma clang diagnostic ignored "-Wunknown-pragmas"
#pragma clang diagnostic ignored "-Wunused-parameter"
#pragma clang diagnostic ignored "-Wunused-variable"
bool _is_special_var(t_ast_expansion *self)
{
char name;
if (self == NULL)
return (true);
if (self->var_name == NULL)
return (true);
if (str_len(self->var_name) != 1)
return (false);
name = self->var_name[0];
if (name == '*' || name == '@' || name == '?' || name == '!' || name == '#' || name == '-' || name == '$' || name == '0')
return (true);
return (false);
}
t_error _run_expansion_special_var(t_ast_expansion *self, t_state *state, t_expansion_result *out)
{
char name;
if (self == NULL || state == NULL || out == NULL)
return (ERROR);
name = self->var_name[0];
*out = (t_expansion_result){.exists = false, .value = NULL};
if (name == '*')
; // return all args with argv[0]
if (name == '@')
; // return all args without argv[0]
if (name == '?')
; // return exit code of last run program
if (name == '!')
; // return pid of last run program
if (name == '#')
; // return `argc - 1` bc we don't care about argv[0]
if (name == '$')
; // return pid of self (the shell)
if (name == '-')
; // return the option string <ask maiboyer>
printf("PLEASE MAKE SURE TO FINISH THE SPECIAL VAR HANDLING !");
return (ERROR);
}
t_error _get_expansion_value(t_ast_expansion *self, t_state *state, t_expansion_result *out)
{
t_str *hmap_ret;
t_expansion_result ret;
if (self == NULL || state == NULL || out == NULL)
return (ERROR);
hmap_ret = hmap_env_get(state->tmp_var, &self->var_name);
if (hmap_ret == NULL)
hmap_ret = hmap_env_get(state->env, &self->var_name);
ret = (t_expansion_result){.exists = (hmap_ret != NULL), .value = NULL};
if (ret.exists)
ret.value = *hmap_ret;
return (*out = ret, NO_ERROR);
}
t_error _handle_len_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value)
{
t_str len_str;
t_usize len;
if (value->exists && value->value != NULL)
len = str_len(value->value);
else
len = 0;
if (u64_to_str(len, &len_str))
return (ERROR);
mem_free(value->value);
value->exists = true;
value->value = len_str;
return (NO_ERROR);
};
t_error _handle_no_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value)
{
t_str *val;
if (self == NULL || state == NULL || value == NULL)
return (ERROR);
val = hmap_env_get(state->tmp_var, &self->var_name);
if (val == NULL)
val = hmap_env_get(state->env, &self->var_name);
if (val == NULL)
return (value->exists = false, NO_ERROR);
value->exists = true;
value->value = str_clone(*val);
return (NO_ERROR);
};
t_error _exp_assign_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_assign_colon_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_alternate_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_alternate_colon_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_default_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_default_colon_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_error_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_error_colon_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_suffix_pattern_smallest_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_suffix_pattern_largest_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_prefix_pattern_smallest_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _exp_prefix_pattern_largest_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value) NOT_DONE;
t_error _get_op_func(t_ast_expansion *self, t_error (**op_func)(t_ast_expansion *self, t_state *state, t_expansion_result *value))
{
if (self == NULL || op_func == NULL)
return (ERROR);
if (self->kind == E_OP_NONE)
return (*op_func = _handle_no_operator, NO_ERROR);
if (self->kind == E_OP_ERROR)
return (*op_func = _exp_error_operator, NO_ERROR);
if (self->kind == E_OP_ERROR_COLON)
return (*op_func = _exp_error_colon_operator, NO_ERROR);
if (self->kind == E_OP_ASSIGN_DEFAULT)
return (*op_func = _exp_assign_operator, NO_ERROR);
if (self->kind == E_OP_ASSIGN_DEFAULT_COLON)
return (*op_func = _exp_assign_colon_operator, NO_ERROR);
if (self->kind == E_OP_DEFAULT)
return (*op_func = _exp_default_operator, NO_ERROR);
if (self->kind == E_OP_DEFAULT_COLON)
return (*op_func = _exp_default_colon_operator, NO_ERROR);
if (self->kind == E_OP_ALTERNATE)
return (*op_func = _exp_alternate_operator, NO_ERROR);
if (self->kind == E_OP_ALTERNATE_COLON)
return (*op_func = _exp_alternate_colon_operator, NO_ERROR);
if (self->kind == E_OP_LARGEST_PREFIX)
return (*op_func = _exp_prefix_pattern_largest_operator, NO_ERROR);
if (self->kind == E_OP_SMALLEST_PREFIX)
return (*op_func = _exp_prefix_pattern_smallest_operator, NO_ERROR);
if (self->kind == E_OP_LARGEST_SUFFIX)
return (*op_func = _exp_suffix_pattern_largest_operator, NO_ERROR);
if (self->kind == E_OP_SMALLEST_SUFFIX)
return (*op_func = _exp_suffix_pattern_smallest_operator, NO_ERROR);
return (ERROR);
}
t_error _handle_expansion_operator(t_ast_expansion *self, t_state *state, t_expansion_result *value)
{
t_error (*op_func)(t_ast_expansion *self, t_state *state, t_expansion_result *value);
if (self == NULL || state == NULL || value == NULL)
return (ERROR);
if (_get_op_func(self, &op_func))
return (ERROR);
if (op_func(self, state, value))
return (ERROR);
return (NO_ERROR);
}
t_error _ast_get_str__raw__no_quote(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
{
bool last_backslash;
t_string ret;
t_usize i;
if (elem == NULL || state == NULL || out == NULL || elem->kind != AST_RAW_STRING || elem->data.raw_string.kind != AST_WORD_NO_QUOTE)
return (ERROR);
i = 0;
ret = string_new(elem->data.raw_string.len);
last_backslash = false;
while (elem->data.raw_string.str[i])
{
if (elem->data.raw_string.str[i] != '\\' || last_backslash)
string_push_char(&ret, elem->data.raw_string.str[i]);
last_backslash = false;
if (elem->data.raw_string.str[i] == '\\' && !last_backslash)
last_backslash = true;
i++;
}
return (vec_estr_push(out, (t_expandable_str){.do_expand = false, .value = ret.buf}), NO_ERROR);
}
t_error _ast_get_str__raw__single_quote(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
{
t_string ret;
t_usize i;
if (elem == NULL || state == NULL || out == NULL || elem->kind != AST_RAW_STRING || elem->data.raw_string.kind != AST_WORD_SINGLE_QUOTE)
return (ERROR);
i = 1;
ret = string_new(elem->data.raw_string.len);
while (elem->data.raw_string.str[i])
string_push_char(&ret, elem->data.raw_string.str[i++]);
string_pop(&ret);
return (vec_estr_push(out, (t_expandable_str){.do_expand = false, .value = ret.buf}), NO_ERROR);
}
t_error _ast_get_str__raw__double_quote(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
{
bool last_backslash;
t_string ret;
t_usize i;
if (elem == NULL || state == NULL || out == NULL || elem->kind != AST_RAW_STRING || elem->data.raw_string.kind != AST_WORD_DOUBLE_QUOTE)
return (ERROR);
i = 0;
ret = string_new(elem->data.raw_string.len);
last_backslash = false;
while (elem->data.raw_string.str[i])
{
if (elem->data.raw_string.str[i] != '\\' || last_backslash)
string_push_char(&ret, elem->data.raw_string.str[i]);
last_backslash = false;
if (elem->data.raw_string.str[i] == '\\' && !last_backslash)
last_backslash = true;
i++;
}
return (vec_estr_push(out, (t_expandable_str){.do_expand = false, .value = ret.buf}), NO_ERROR);
}
t_error _ast_get_str__raw(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
{
if (elem == NULL || state == NULL || out == NULL || elem->kind != AST_RAW_STRING)
return (ERROR);
if (elem->data.raw_string.kind == AST_WORD_NO_QUOTE)
return (_ast_get_str__raw__no_quote(elem, state, out));
if (elem->data.raw_string.kind == AST_WORD_SINGLE_QUOTE)
return (_ast_get_str__raw__single_quote(elem, state, out));
if (elem->data.raw_string.kind == AST_WORD_DOUBLE_QUOTE)
return (_ast_get_str__raw__double_quote(elem, state, out));
return (ERROR);
}
t_str _get_ifs_value(t_state *state)
{
t_str ifs;
t_str *ifs_entry;
t_str ifs_key;
ifs_key = "IFS";
ifs = NULL;
ifs_entry = hmap_env_get(state->tmp_var, (t_str *)&ifs_key);
if (ifs_entry != NULL)
ifs_entry = hmap_env_get(state->env, (t_str *)&ifs_key);
if (ifs_entry != NULL)
ifs = *ifs_entry;
if (ifs == NULL)
ifs = " \t\n";
return (ifs);
}
t_error _ast_get_str__expansion(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
{
t_expansion_result exp_ret;
t_vec_str words;
if (elem == NULL || state == NULL || out == NULL || elem->kind != AST_EXPANSION)
return (ERROR);
if (run_expansion(&elem->data.expansion, state->state, &exp_ret))
return (ERROR);
return (vec_estr_push(out, (t_expandable_str){.do_expand = state->res.kind == AST_WORD_NO_QUOTE, .value = exp_ret.value}), NO_ERROR);
}
t_error _ast_get_str__arimethic_expansion(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
{
t_str out_str;
t_i64 out_num;
if (elem == NULL || state == NULL || out == NULL || elem->kind != AST_ARITHMETIC_EXPANSION)
return (ERROR);
if (run_arithmetic_expansion(&elem->data.arithmetic_expansion, state->state, &out_num))
return (ERROR);
if (i64_to_str(out_num, &out_str))
return (ERROR);
vec_estr_push(out, (t_expandable_str){.do_expand = state->res.kind == AST_WORD_NO_QUOTE, .value = out_str});
return (NO_ERROR);
}
t_error _ast_get_str__command_substitution(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
{
if (elem == NULL || state == NULL || out == NULL || elem->kind != AST_COMMAND_SUBSTITUTION)
return (ERROR);
// vec_estr_push(out, (t_expandable_str){.do_expand = state->res.kind == AST_WORD_NO_QUOTE, .value = str_clone(exp_out.value)});
return (ERROR);
}
t_error _ast_get_str(t_ast_node elem, t_word_iterator *state, t_vec_estr *out);
t_error _ast_into_str(t_ast_node self, t_state *state, t_vec_str *append);
t_error _ast_get_str__word(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
{
t_usize i;
t_vec_str res;
t_str tmp;
if (elem == NULL || state == NULL || out == NULL || elem->kind != AST_WORD)
return (ERROR);
res = vec_str_new(16, str_free);
if (_ast_into_str(elem, state->state, &res))
return (vec_str_free(res), ERROR);
while (!vec_str_pop_front(&res, &tmp))
vec_estr_push(out, (t_expandable_str){.do_expand = false, .value = tmp});
vec_str_free(res);
return (NO_ERROR);
}
t_error _ast_get_str(t_ast_node elem, t_word_iterator *state, t_vec_estr *out)
{
if (elem == NULL || state == NULL || out == NULL)
return (ERROR);
if (elem->kind == AST_RAW_STRING)
return (_ast_get_str__raw(elem, state, out));
if (elem->kind == AST_EXPANSION)
return (_ast_get_str__expansion(elem, state, out));
if (elem->kind == AST_ARITHMETIC_EXPANSION)
return (_ast_get_str__arimethic_expansion(elem, state, out));
if (elem->kind == AST_COMMAND_SUBSTITUTION)
return (_ast_get_str__command_substitution(elem, state, out));
if (elem->kind == AST_WORD)
return (_ast_get_str__word(elem, state, out));
return (ERROR);
}
void _run_word_into_str(t_usize idx, t_ast_node *elem, t_word_iterator *state)
{
t_vec_str val;
(void)(idx);
if (elem == NULL || *elem == NULL || state == NULL)
return;
if (_ast_get_str(*elem, state, &state->res.value))
return;
}
t_error _exp_into_str(t_ast_node self, t_state *state, t_vec_str *append)
{
t_expansion_result res;
t_vec_str splitted;
t_str tmp;
if (self == NULL || state == NULL || append == NULL || self->kind != AST_EXPANSION)
return (ERROR);
if (run_expansion(&self->data.expansion, state, &res))
return (ERROR);
if (res.value == NULL)
return (NO_ERROR);
if (str_split(res.value, _get_ifs_value(state), &splitted))
return (ERROR);
while (!vec_str_pop_front(&splitted, &tmp))
vec_str_push(append, tmp);
vec_str_free(splitted);
return (NO_ERROR);
}
t_error _arith_into_str(t_ast_node self, t_state *state, t_vec_str *append)
{
if (self == NULL || state == NULL || append == NULL || self->kind != AST_ARITHMETIC_EXPANSION)
return (ERROR);
return (NO_ERROR);
}
t_error _cmd_into_str(t_ast_node self, t_state *state, t_vec_str *append)
{
if (self == NULL || state == NULL || append == NULL || self->kind != AST_COMMAND_SUBSTITUTION)
return (ERROR);
/*
if (str_split(res.value, _get_ifs_value(state), &splitted))
return (ERROR);
while (!vec_str_pop_front(&splitted, &tmp))
vec_str_push(append, tmp);
vec_str_free(splitted);
*/
return (ERROR);
}
t_error _word_into_str(t_ast_node self, t_state *state, t_vec_str *append)
{
t_word_result res;
t_vec_str splitted;
t_string tmp;
t_usize i;
t_usize j;
t_usize len;
t_str ifs;
t_str tmp_str;
if (self == NULL || state == NULL || append == NULL || self->kind != AST_WORD)
return (ERROR);
if (run_word(&self->data.word, state, &res))
return (ERROR);
if (res.kind == AST_WORD_NO_QUOTE)
{
tmp = string_new(64);
i = 0;
while (i < res.value.len)
{
if (!res.value.buffer[i].do_expand)
string_push(&tmp, res.value.buffer[i].value);
else
{
ifs = _get_ifs_value(state);
while (ifs != NULL && *ifs != '\0' && str_find_chr(res.value.buffer[i].value, *ifs) == NULL)
ifs++;
if (ifs == NULL || *ifs == '\0')
string_push(&tmp, res.value.buffer[i].value);
else
{
ifs = _get_ifs_value(state);
if (str_split(res.value.buffer[i].value, ifs, &splitted))
return (vec_estr_free(res.value), ERROR);
if (!vec_str_pop_front(&splitted, &tmp_str))
{
if (str_find_chr(ifs, res.value.buffer[i].value[0]) == NULL)
{
string_push(&tmp, tmp_str), str_free(tmp_str);
}
else
{
vec_str_push(append, tmp.buf);
tmp = string_new(64);
string_push(&tmp, tmp_str);
str_free(tmp_str);
}
j = 0;
while (j + 1 < splitted.len)
{
if (vec_str_pop_front(&splitted, &tmp_str))
return (vec_estr_free(res.value), ERROR);
vec_str_push(append, tmp_str);
j++;
}
len = str_len(res.value.buffer[i].value);
if (len != 0 && str_find_chr(ifs, res.value.buffer[i].value[len - 1]) == NULL)
string_push(&tmp, tmp_str), str_free(tmp_str);
else
vec_str_push(append, tmp_str);
}
}
}
i++;
}
vec_str_push(append, tmp.buf);
}
else
{
tmp = string_new(64);
i = 0;
while (i < res.value.len)
{
string_push(&tmp, res.value.buffer[i++].value);
}
vec_str_push(append, tmp.buf);
}
vec_estr_free(res.value);
return (NO_ERROR);
}
t_error _raw_str_into_str(t_ast_node self, t_state *state, t_vec_str *append)
{
if (self == NULL || state == NULL || append == NULL || self->kind != AST_RAW_STRING)
return (ERROR);
vec_str_push(append, str_clone(self->data.raw_string.str));
return (NO_ERROR);
}
t_error _ast_into_str(t_ast_node self, t_state *state, t_vec_str *append)
{
if (self == NULL || state == NULL || append == NULL)
return (ERROR);
if (self->kind == AST_EXPANSION)
return (_exp_into_str(self, state, append));
if (self->kind == AST_ARITHMETIC_EXPANSION)
return (_arith_into_str(self, state, append));
if (self->kind == AST_COMMAND_SUBSTITUTION)
return (_cmd_into_str(self, state, append));
if (self->kind == AST_WORD)
return (_word_into_str(self, state, append));
if (self->kind == AST_RAW_STRING)
return (_raw_str_into_str(self, state, append));
printf("unknown Kind = %#04x\n", self->kind);
return (ERROR);
}
// End Internals funcs
// These are done externally
// t_error run_file_redirection(t_ast_file_redirection *file_redirection, t_state *state, void *out) NOT_DONE;
// t_error run_heredoc_redirection(t_ast_heredoc_redirection *heredoc_redirection, t_state *state, void *out) NOT_DONE;
// t_error run_raw_string(t_ast_raw_string *raw_string, t_state *state, void *out) NOT_DONE;
t_error run_case_(t_ast_case *case_, t_state *state, void *out) NOT_DONE;
t_error run_case_item(t_ast_case_item *case_item, t_state *state, void *out) NOT_DONE;
t_error run_command_substitution(t_ast_command_substitution *command_substitution, t_state *state, void *out) NOT_DONE;
t_error run_compound_statement(t_ast_compound_statement *compound_statement, t_state *state, void *out) NOT_DONE;
t_error run_elif(t_ast_elif *elif, t_state *state, void *out) NOT_DONE;
t_error run_else_(t_ast_else *else_, t_state *state, void *out) NOT_DONE;
t_error run_empty(t_ast_empty *empty, t_state *state, void *out) NOT_DONE;
t_error run_extglob(t_ast_extglob *extglob, t_state *state, void *out) NOT_DONE;
t_error run_for_(t_ast_for *for_, t_state *state, void *out) NOT_DONE;
t_error run_function_definition(t_ast_function_definition *function_definition, t_state *state, void *out) NOT_DONE;
t_error run_if_(t_ast_if *if_, t_state *state, void *out) NOT_DONE;
t_error run_regex(t_ast_regex *regex, t_state *state, void *out) NOT_DONE;
t_error run_until(t_ast_until *until, t_state *state, void *out) NOT_DONE;
t_error run_variable_assignment(t_ast_variable_assignment *variable_assignment, t_state *state, bool is_temporary, void *out) NOT_DONE;
t_error run_while_(t_ast_while *while_, t_state *state, void *out) NOT_DONE;
void mem_free(void *free);
struct s_subshell_info
{
t_fd *stdin;
t_fd *stderr;
t_fd *stdout;
t_fd *ret_stdout;
};
t_error _run_get_exit_code(t_ast_node self, t_state *state, int *out)
{
t_command_result cmd_res;
t_pipeline_result pipe_res;
t_list_result list_res;
t_subshell_result subshell_res;
if (self->kind == AST_COMMAND)
{
if (run_command(&self->data.command, state, (t_cmd_pipe){NULL, false}, &cmd_res))
return (ERROR);
if (cmd_res.process.stdin != NULL)
close_fd(cmd_res.process.stdin);
if (cmd_res.process.stdout != NULL)
close_fd(cmd_res.process.stdout);
if (cmd_res.process.stderr != NULL)
close_fd(cmd_res.process.stderr);
*out = cmd_res.exit;
}
if (self->kind == AST_PIPELINE)
{
if (run_pipeline(&self->data.pipeline, state, &pipe_res))
return (ERROR);
*out = pipe_res.exit;
}
if (self->kind == AST_LIST)
{
if (run_list(&self->data.list, state, &list_res))
return (ERROR);
*out = list_res.exit;
}
if (self->kind == AST_SUBSHELL)
{
if (run_subshell(&self->data.subshell, state, (t_cmd_pipe){NULL, false}, &subshell_res))
return (ERROR);
*out = subshell_res.exit;
}
return (NO_ERROR);
}
t_error run_subshell(t_ast_subshell *subshell, t_state *state, t_cmd_pipe cmd_pipe, t_subshell_result *out)
{
struct s_subshell_info info;
t_pipe spipe;
t_usize i;
t_vec_str filename_args;
t_ast_node red;
t_vec_ast redirection;
t_fd *red_fd;
if (subshell == NULL || state == NULL || out == NULL)
return (ERROR);
mem_set_zero(&info, sizeof(info));
info.stdin = cmd_pipe.input;
if (cmd_pipe.create_output)
{
if (create_pipe(&spipe))
return (ERROR);
info.stdout = spipe.write;
info.ret_stdout = spipe.read;
}
i = 0;
filename_args = vec_str_new(16, str_free);
redirection = subshell->suffixes_redirections;
while (i < redirection.len)
{
red = redirection.buffer[i];
if (red == NULL)
continue;
vec_str_free(filename_args);
filename_args = vec_str_new(16, str_free);
if (red->kind == AST_FILE_REDIRECTION)
{
if (red->data.file_redirection.op == AST_REDIR_INPUT)
{
if (info.stdin != NULL)
close_fd(info.stdin);
info.stdin = NULL;
if (_ast_into_str(red->data.file_redirection.output, state, &filename_args))
return (ERROR);
if (filename_args.len != 1)
return (vec_str_free(filename_args), ERROR);
red_fd = open_fd(filename_args.buffer[i], FD_READ, O_CLOEXEC, 0);
if (red_fd == NULL)
return (vec_str_free(filename_args), ERROR);
info.stdin = red_fd;
};
if (red->data.file_redirection.op == AST_REDIR_OUTPUT)
{
if (info.stdout != NULL)
close_fd(info.stdout);
info.stdout = NULL;
if (_ast_into_str(red->data.file_redirection.output, state, &filename_args))
return (ERROR);
if (filename_args.len != 1)
return (vec_str_free(filename_args), ERROR);
red_fd = open_fd(filename_args.buffer[i], FD_WRITE, O_TRUNC | O_CREAT | O_CLOEXEC, FP_ALL_READ | FP_ALL_WRITE);
if (red_fd == NULL)
return (vec_str_free(filename_args), ERROR);
info.stdout = red_fd;
};
if (red->data.file_redirection.op == AST_REDIR_APPEND)
{
if (info.stdout != NULL)
close_fd(info.stdout);
info.stdout = NULL;
if (_ast_into_str(red->data.file_redirection.output, state, &filename_args))
return (ERROR);
if (filename_args.len != 1)
return (vec_str_free(filename_args), ERROR);
red_fd = open_fd(filename_args.buffer[i], FD_WRITE, O_TRUNC | O_CREAT | O_CLOEXEC, FP_ALL_READ | FP_ALL_WRITE);
if (red_fd == NULL)
return (vec_str_free(filename_args), ERROR);
info.stdout = red_fd;
};
if (red->data.file_redirection.op == AST_REDIR_DUP_INPUT || red->data.file_redirection.op == AST_REDIR_DUP_OUTPUT ||
red->data.file_redirection.op == AST_REDIR_CLOSE_INPUT || red->data.file_redirection.op == AST_REDIR_CLOSE_OUTPUT ||
red->data.file_redirection.op == AST_REDIR_INPUT_OUTPUT || red->data.file_redirection.op == AST_REDIR_OUTPUT_CLOBBER)
return (ERROR);
}
if (red->kind == AST_HEREDOC_REDIRECTION)
{
if (red->data.heredoc_redirection.op == AST_REDIR_HEREDOC)
{
t_pipe heredoc_pipe;
if (info.stdout != NULL)
close_fd(info.stdout);
info.stdout = NULL;
if (create_pipe(&heredoc_pipe))
return (ERROR);
put_string_fd(heredoc_pipe.write, red->data.heredoc_redirection.content);
close_fd(heredoc_pipe.write);
info.stdin = heredoc_pipe.read;
}
if (red->data.heredoc_redirection.op == AST_REDIR_HEREDOC_INDENT)
return (ERROR);
}
i++;
}
vec_str_free(filename_args);
t_pid forked;
forked = fork();
if (forked == 0)
{
int code;
if (info.ret_stdout != NULL)
close_fd(info.ret_stdout);
if (info.stdin != NULL)
(dup2(info.stdin->fd, 0), close_fd(info.stdin));
if (info.stdout != NULL)
(dup2(info.stdout->fd, 1), close_fd(info.stdout));
if (info.stderr != NULL)
(dup2(info.stderr->fd, 2), close_fd(info.stderr));
i = 0;
code = 0;
while (i < subshell->body.len)
{
if (_run_get_exit_code(subshell->body.buffer[i], state, &code))
me_exit(127);
i++;
}
me_exit(code);
}
if (forked == -1)
return (ERROR);
out->exit = -1;
out->pid = forked;
if (info.stdin != NULL)
(dup2(info.stdin->fd, 0), close_fd(info.stdin));
if (info.stdout != NULL)
(dup2(info.stdout->fd, 1), close_fd(info.stdout));
if (info.stderr != NULL)
(dup2(info.stderr->fd, 2), close_fd(info.stderr));
if (cmd_pipe.create_output || cmd_pipe.input != NULL)
return (out->stdout = info.ret_stdout, NO_ERROR);
int status;
if (waitpid(forked, &status, 0) == -1)
return (ERROR);
if (WIFEXITED(status))
out->exit = WEXITSTATUS(status);
if (WIFSIGNALED(status))
out->exit = WTERMSIG(status);
return (NO_ERROR);
}
t_error run_list(t_ast_list *list, t_state *state, t_list_result *out)
{
t_ast_node tmp;
t_vec_ast *append;
int left;
int right;
if (list == NULL || state == NULL || out == NULL)
return (ERROR);
append = NULL;
if (list->right->kind == AST_COMMAND)
append = &list->right->data.command.suffixes_redirections;
if (list->right->kind == AST_PIPELINE)
append = &list->right->data.pipeline.suffixes_redirections;
if (list->right->kind == AST_LIST)
append = &list->right->data.list.suffixes_redirections;
if (list->right->kind == AST_SUBSHELL)
append = &list->right->data.subshell.suffixes_redirections;
if (append != NULL)
{
while (!vec_ast_pop_front(&list->suffixes_redirections, &tmp))
vec_ast_push(append, tmp);
}
left = -1;
right = -1;
if (_run_get_exit_code(list->left, state, &left))
return (ERROR);
if ((list->op == AST_LIST_OR && left != 0) || (list->op == AST_LIST_AND && left == 0))
{
if (_run_get_exit_code(list->right, state, &right))
return (ERROR);
out->exit = right;
}
else
out->exit = left;
return (NO_ERROR);
};
t_error run_pipeline(t_ast_pipeline *pipeline, t_state *state, t_pipeline_result *out)
{
t_usize i;
t_cmd_pipe cmd_pipe;
t_ast_node child;
t_error ret;
t_command_result cmd_result;
t_ast_node tmp_ast;
t_vec_pid pids;
int waitpid_status;
if (pipeline == NULL || state == NULL || out == NULL)
return (ERROR);
i = 0;
ret = NO_ERROR;
cmd_pipe.input = NULL;
cmd_pipe.create_output = true;
out->exit = 127;
pids = vec_pid_new(32, NULL);
while (i < pipeline->statements.len - 1)
{
child = pipeline->statements.buffer[i];
if (child->kind == AST_COMMAND)
{
if (run_command(&child->data.command, state, cmd_pipe, &cmd_result))
{
cmd_pipe.input = NULL;
ret = ERROR;
}
else
{
vec_pid_push(&pids, cmd_result.process.pid);
close_fd(cmd_pipe.input);
if (cmd_result.process.stdout != NULL)
cmd_pipe.input = cmd_result.process.stdout;
if (cmd_result.process.stdin != NULL)
close_fd(cmd_result.process.stdin);
if (cmd_result.process.stderr != NULL)
close_fd(cmd_result.process.stderr);
}
}
i++;
}
{
cmd_pipe.create_output = false;
child = pipeline->statements.buffer[i];
if (child->kind == AST_COMMAND)
{
while (!vec_ast_pop_front(&pipeline->suffixes_redirections, &tmp_ast))
vec_ast_push(&child->data.command.suffixes_redirections, tmp_ast);
if (run_command(&child->data.command, state, cmd_pipe, &cmd_result))
{
ret = ERROR;
}
else
{
vec_pid_push(&pids, cmd_result.process.pid);
close_fd(cmd_pipe.input);
if (cmd_result.process.stdout != NULL)
close_fd(cmd_result.process.stdout);
if (cmd_result.process.stdin != NULL)
close_fd(cmd_result.process.stdin);
if (cmd_result.process.stderr != NULL)
close_fd(cmd_result.process.stderr);
}
}
}
if (pids.len != 0)
{
while (waitpid(pids.buffer[pids.len - 1], &waitpid_status, 0) < 0)
;
while (waitpid(-1, NULL, 0) != -1)
;
if (WIFEXITED(waitpid_status))
out->exit = WEXITSTATUS(waitpid_status);
if (WIFSIGNALED(waitpid_status))
out->exit = WTERMSIG(waitpid_status);
}
else
out->exit = 127;
vec_pid_free(pids);
return (ret);
}
t_error run_program(t_ast_program *self, t_state *state, t_program_result *out)
{
t_usize i;
if (self == NULL || state == NULL || out == NULL)
return (ERROR);
i = 0;
while (i < self->body.len)
{
if (_run_get_exit_code(self->body.buffer[i], state, &out->exit))
return (ERROR);
i++;
}
return (NO_ERROR);
}
/// this functons returns different things depending on the operator and/or the state of the shell
/// NULL != empty string for example
t_error run_expansion(t_ast_expansion *self, t_state *state, t_expansion_result *out)
{
t_expansion_result ret;
bool is_special_var;
is_special_var = _is_special_var(self);
if (is_special_var && _run_expansion_special_var(self, state, &ret))
return (ERROR);
if (!is_special_var && _get_expansion_value(self, state, &ret))
return (ERROR);
if (_handle_expansion_operator(self, state, &ret))
return (ERROR);
if (self->len_operator && _handle_len_operator(self, state, &ret))
return (ERROR);
return (*out = ret, NO_ERROR);
}
struct s_ffree_state
{
t_state *state;
t_cmd_pipe cmd_pipe;
};
void _ffree_func(struct s_ffree_state *state)
{
if (state == NULL)
return;
hmap_env_free(state->state->env);
hmap_env_free(state->state->tmp_var);
close_fd(state->cmd_pipe.input);
}
bool _is_builtin(t_const_str argv0)
{
t_usize i;
const t_str value[] = {"cd", "echo", "env", "exit", "export", "pwd", "unset", "_debug", NULL};
i = 0;
if (argv0 == NULL)
return (false);
while (value[i] != NULL)
if (str_compare(argv0, value[i++]))
return (true);
return (false);
}
t_error _handle_builtin(t_spawn_info info, t_state *state, t_cmd_pipe cmd_pipe, t_command_result *out)
{
t_usize i;
const t_const_str argv0 = info.binary_path;
const t_str value[] = {"cd", "echo", "env", "exit", "export", "pwd", "unset", "_debug", NULL};
const t_builtin_func funcs[] = {builtin_cd____, builtin_echo__, builtin_env___,
builtin_exit__, builtin_export, builtin_pwd___,
builtin_unset_, builtin_debug_, NULL};
t_builtin_func actual_func;
i = 0;
if (argv0 == NULL)
return (ERROR);
actual_func = NULL;
while (value[i] != NULL)
{
if (str_compare(argv0, value[i]))
{
actual_func = funcs[i];
break;
}
i++;
}
if (actual_func == NULL)
return (me_abort("Builtin found but no function found..."), ERROR);
t_builtin_spawn_info binfo;
mem_set_zero(out, sizeof(*out));
if (info.stdin.tag == R_FD)
binfo.stdin = info.stdin.fd.fd;
if (info.stdin.tag == R_INHERITED)
binfo.stdin = dup_fd(get_stdin());
if (info.stderr.tag == R_FD)
binfo.stderr = info.stderr.fd.fd;
if (info.stderr.tag == R_INHERITED)
binfo.stderr = dup_fd(get_stderr());
if (info.stdout.tag == R_FD)
binfo.stdout = info.stdout.fd.fd;
if (info.stdout.tag == R_INHERITED)
binfo.stdout = dup_fd(get_stdout());
if (info.stdout.tag == R_PIPED)
{
t_pipe pipe_fd;
if (create_pipe(&pipe_fd))
return (ERROR);
out->process.stdout = pipe_fd.read;
binfo.stdout = pipe_fd.write;
}
binfo.args = info.arguments;
bool do_fork = cmd_pipe.input != NULL || cmd_pipe.create_output;
t_i32 exit_code;
if (do_fork)
{
out->process.pid = fork();
if (out->process.pid == 0)
{
if (actual_func(state, binfo, &exit_code))
me_exit(127);
me_exit(exit_code);
}
if (out->process.pid == -1)
out->exit = 126;
else
out->exit = -1;
}
else
{
if (actual_func(state, binfo, &exit_code))
out->exit = 126;
else
out->exit = exit_code;
}
if (binfo.stdin)
close_fd(binfo.stdin);
if (binfo.stdout)
close_fd(binfo.stdout);
if (binfo.stderr)
close_fd(binfo.stderr);
vec_str_free(info.arguments);
str_free(info.binary_path);
return (NO_ERROR);
}
t_error _spawn_cmd_and_run(t_vec_str args, t_vec_ast redirection, t_state *state, t_cmd_pipe cmd_pipe, t_command_result *out)
{
t_spawn_info info;
t_usize i;
t_ast_node red;
t_vec_str filename_args;
t_fd *red_fd;
struct s_ffree_state ffree;
info = (t_spawn_info){};
if (cmd_pipe.input != NULL)
info.stdin = fd(cmd_pipe.input);
if (cmd_pipe.create_output)
info.stdout = piped();
i = 0;
filename_args = vec_str_new(16, str_free);
while (i < redirection.len)
{
red = redirection.buffer[i];
if (red == NULL)
continue;
vec_str_free(filename_args);
filename_args = vec_str_new(16, str_free);
if (red->kind == AST_FILE_REDIRECTION)
{
if (red->data.file_redirection.op == AST_REDIR_INPUT)
{
if (info.stdin.tag == R_FD)
close_fd(info.stdin.fd.fd);
info.stdin.tag = R_INHERITED;
if (_ast_into_str(red->data.file_redirection.output, state, &filename_args))
return (ERROR);
if (filename_args.len != 1)
return (vec_str_free(filename_args), ERROR);
red_fd = open_fd(filename_args.buffer[i], FD_READ, O_CLOEXEC, 0);
if (red_fd == NULL)
return (vec_str_free(filename_args), ERROR);
info.stdin = fd(red_fd);
};
if (red->data.file_redirection.op == AST_REDIR_OUTPUT)
{
if (info.stdout.tag == R_FD)
close_fd(info.stdout.fd.fd);
info.stdout.tag = R_INHERITED;
if (_ast_into_str(red->data.file_redirection.output, state, &filename_args))
return (ERROR);
if (filename_args.len != 1)
return (vec_str_free(filename_args), ERROR);
red_fd = open_fd(filename_args.buffer[i], FD_WRITE, O_TRUNC | O_CREAT | O_CLOEXEC, FP_ALL_READ | FP_ALL_WRITE);
if (red_fd == NULL)
return (vec_str_free(filename_args), ERROR);
info.stdout = fd(red_fd);
};
if (red->data.file_redirection.op == AST_REDIR_APPEND)
{
if (info.stdout.tag == R_FD)
close_fd(info.stdout.fd.fd);
info.stdout.tag = R_INHERITED;
if (_ast_into_str(red->data.file_redirection.output, state, &filename_args))
return (ERROR);
if (filename_args.len != 1)
return (vec_str_free(filename_args), ERROR);
red_fd = open_fd(filename_args.buffer[i], FD_WRITE, O_TRUNC | O_CREAT | O_CLOEXEC, FP_ALL_READ | FP_ALL_WRITE);
if (red_fd == NULL)
return (vec_str_free(filename_args), ERROR);
info.stdout = fd(red_fd);
};
if (red->data.file_redirection.op == AST_REDIR_DUP_INPUT || red->data.file_redirection.op == AST_REDIR_DUP_OUTPUT ||
red->data.file_redirection.op == AST_REDIR_CLOSE_INPUT || red->data.file_redirection.op == AST_REDIR_CLOSE_OUTPUT ||
red->data.file_redirection.op == AST_REDIR_INPUT_OUTPUT || red->data.file_redirection.op == AST_REDIR_OUTPUT_CLOBBER)
return (ERROR);
}
if (red->kind == AST_HEREDOC_REDIRECTION)
{
if (red->data.heredoc_redirection.op == AST_REDIR_HEREDOC)
{
t_pipe heredoc_pipe;
if (info.stdout.tag == R_FD)
close_fd(info.stdout.fd.fd);
info.stdout.tag = R_INHERITED;
if (create_pipe(&heredoc_pipe))
return (ERROR);
put_string_fd(heredoc_pipe.write, red->data.heredoc_redirection.content);
close_fd(heredoc_pipe.write);
info.stdin = fd(heredoc_pipe.read);
}
if (red->data.heredoc_redirection.op == AST_REDIR_HEREDOC_INDENT)
return (ERROR);
}
i++;
}
ffree = (struct s_ffree_state){.state = state, .cmd_pipe = cmd_pipe};
redirection.len = 0;
vec_ast_free(redirection);
vec_str_free(filename_args);
info.arguments = args;
if (args.len == 0)
return (vec_str_free(args), ERROR);
info.binary_path = str_clone(info.arguments.buffer[0]);
if (_is_builtin(info.binary_path))
return (_handle_builtin(info, state, cmd_pipe, out));
if (build_envp(state->env, state->tmp_var, &info.environement))
return (str_free(info.binary_path), ERROR);
info.forked_free_args = &ffree;
info.forked_free = (void (*)(void *))_ffree_func;
signal(SIGINT, SIG_IGN);
signal(SIGQUIT, SIG_IGN);
if (spawn_process(info, &out->process))
return (close_fd(cmd_pipe.input), out->exit = 127, ERROR);
if (cmd_pipe.create_output || cmd_pipe.input != NULL)
return (out->exit = -1, NO_ERROR);
int status;
if (waitpid(out->process.pid, &status, 0) == -1)
return (ERROR);
if (WIFEXITED(status))
out->exit = WEXITSTATUS(status);
if (WIFSIGNALED(status))
out->exit = WTERMSIG(status);
return (NO_ERROR);
}
t_error run_command(t_ast_command *command, t_state *state, t_cmd_pipe cmd_pipe, t_command_result *out)
{
t_vec_str args;
t_vec_str split;
t_vec_ast redirection;
t_usize i;
t_hashmap_env *env_bck;
t_ast_node tmp;
t_str tmp_str;
if (command == NULL || state == NULL || out == NULL)
return (ERROR);
hmap_env_clear(state->tmp_var);
args = vec_str_new(command->cmd_word.len, str_free);
redirection = vec_ast_new(command->suffixes_redirections.len, ast_free);
i = 0;
while (i < command->prefixes.len)
{
tmp = command->prefixes.buffer[i];
if (tmp->kind == AST_FILE_REDIRECTION || tmp->kind == AST_HEREDOC_REDIRECTION)
vec_ast_push(&redirection, tmp);
if (tmp->kind == AST_VARIABLE_ASSIGNMENT)
{
if (run_variable_assignment(&tmp->data.variable_assignment, state, true, NULL))
return (vec_str_free(args), vec_ast_free(redirection), ERROR);
}
i++;
}
i = 0;
while (i < command->cmd_word.len)
{
if (_ast_into_str(command->cmd_word.buffer[i], state, &args))
return (vec_str_free(args), vec_ast_free(redirection), ERROR);
i++;
}
i = 0;
while (i < command->suffixes_redirections.len)
{
tmp = command->suffixes_redirections.buffer[i];
if (tmp->kind == AST_FILE_REDIRECTION || tmp->kind == AST_HEREDOC_REDIRECTION)
vec_ast_push(&redirection, tmp);
i++;
}
if (_spawn_cmd_and_run(args, redirection, state, cmd_pipe, out))
return (ERROR);
return (NO_ERROR);
}
t_error run_word(t_ast_word *word, t_state *state, t_word_result *out)
{
t_word_iterator iter_state;
t_vec_str tmp;
t_str tmp_str;
t_expandable_str s;
if (word == NULL || state == NULL || out == NULL)
return (ERROR);
iter_state.res.value = vec_estr_new(64, free_expandable_str);
iter_state.res.has_error = false;
iter_state.res.kind = word->kind;
iter_state.state = state;
vec_ast_iter(&word->inner, (void (*)())_run_word_into_str, &iter_state);
if (iter_state.res.has_error)
return (vec_estr_free(iter_state.res.value), ERROR);
return (*out = iter_state.res, NO_ERROR);
}
Reference in a new issue View git blame Copy permalink