char *ft_path(char *cmd, t_env *var)
{
char **tmp;
char *der;
int i;
char *scm;
i = 0;
scm = ft_strjoin("/", cmd);
tmp = ft_strsplit(ft_search_content(var, "PATH"), ':');
if (!tmp)
return (NULL);
while (tmp[i])
{
der = ft_strjoin(tmp[i], scm);
if (ft_isfile(der))
{
free(scm);
ft_free_tab(tmp);
return (der);
}
free(der);
i++;
}
free(scm);
ft_free_tab(tmp);
return (NULL);
}
static int check_if_arg_is_dir(t_prompt *prompt)
{
char **arg;
DIR *str;
int i;
i = 0;
arg = ft_strsplit_ws(prompt->cmd);
while (arg[i])
i++;
if ((str = opendir(arg[i - 1])) != NULL &&
arg[i - 1][ft_strlen(arg[i - 1]) - 1] != '/')
{
arg_is_dir(prompt, arg, i);
closedir(str);
if (arg)
ft_free_tab(arg);
return (1);
}
if (str)
closedir(str);
if (arg)
ft_free_tab(arg);
return (0);
}
static void ft_realloc_alias(char *value, char ***tab)
{
char **cmd;
char **tmp;
int len;
int i;
int j;
tmp = ft_tabdup(*tab);
ft_free_tab(tab);
cmd = ft_strsplit_space(value);
i = ft_tablen(tmp) - 1;
j = ft_tablen(cmd);
len = i + j;
*tab = (char **)malloc(sizeof(char *) * (len + 1));
(*tab)[len] = NULL;
while (--len >= 0)
{
if (i > 0)
(*tab)[len] = ft_strdup(tmp[i--]);
else
(*tab)[len] = ft_strdup(cmd[--j]);
}
ft_free_tab(&cmd);
ft_free_tab(&tmp);
}
int ft_function_cmd(t_env *env, int cs, char *rcv)
{
int i;
static t_cmd cmds[NB_CMDS];
char **split;
split = NULL;
split = ft_super_split(rcv);
st_assign(cmds, env);
i = 0;
while (i < NB_CMDS)
{
if (0 == ft_strcmp(cmds[i].name, split[0]))
{
if (i == 9)
ft_action_incantation(cs, 0, cmds[i].fn, rcv);
else
ft_action_add(cs, cmds[i].t, cmds[i].fn, rcv);
if (i == 10)
ft_graphic_reply(env, cs, ft_graphic_pfk);
ft_free_tab((void ***)&split);
return (OK);
}
++i;
}
ft_free_tab((void ***)&split);
return (ERR);
}
static int parse_polygon_components(
const char **tokens,
t_polygon *new_polygon)
{
int i;
int nt;
char **ctokens;
i = 0;
if (!tokens_are_enough(tokens, 3))
parser_die("A face must declare at least three vertices.");
while (tokens[i])
{
nt = 0;
if (strstr(tokens[i], "//"))
nt = 1;
ctokens = ft_split(tokens[i], "/\n");
if (!add_vertex((const char **)ctokens, nt, new_polygon->vertices))
{
ft_free_tab(ctokens);
return (0);
}
++i;
ft_free_tab(ctokens);
}
return (1);
}
void free_parse(t_parse **head)
{
t_parse *parse;
parse = *head;
if (parse->argv)
ft_free_tab(parse->argv);
if (parse->env)
ft_free_tab(parse->env);
if (parse->right_path)
free(parse->right_path);
parse->pid = 0;
free(parse);
parse = NULL;
}
int builtin_unsetenv(char **av)
{
int i;
int j;
int index;
char **tab;
i = 0;
j = 0;
if (!av[1])
return (-1);
if ((index = find_env(av[1])) == -1)
return (0);
tab = (char **)ft_memalloc(sizeof(char *) * ft_tablen(g_handler.env));
if (!tab)
return (-42);
while (g_handler.env[i])
{
if (index != i)
tab[j++] = ft_strdup(g_handler.env[i]);
i++;
}
ft_free_tab(&g_handler.env);
g_handler.env = tab;
return (0);
}
void ft_init_source(t_data *d)
{
int fd;
char **tab;
char *tmp;
char *ptr;
tmp = ft_getenv_list(d->my_env, "HOME");
if (!tmp)
return ;
ptr = ft_strjoin(tmp + 5, "/.42shrc");
fd = open(ptr, O_RDONLY);
if (fd != -1)
{
tab = (char **)malloc(sizeof(char *) * 3);
tab[0] = ft_strdup("source");
tab[1] = ft_strdup(ptr);
tab[2] = NULL;
ft_source(d, tab);
ft_free_tab(&tab);
}
ft_strdel(&tmp);
ft_strdel(&ptr);
close(fd);
}
void ft_free_all(t_fdf *fdf)
{
ft_free_tab(fdf->tabsize, fdf->dot);
free(fdf->win1);
free(fdf->mlx);
ft_free_struct(fdf);
}
static int minishell(t_sh *sh)
{
char **cmds;
char *cmd;
int res;
res = 0;
ft_putstr("$>");
while (get_next_line(0, &cmd))
{
sh->last_res = res;
cmd = ft_strfjoin(cmd, " ");
cmds = ft_str_to_tab(cmd);
res = minishell_boot(sh, sh->env_list, cmds);
if (cmd)
free(cmd);
if (cmds)
ft_free_tab(cmds);
cmds = NULL;
ft_putstr("$>");
}
if (sh->env_list)
{
ft_lstdel(&sh->env_list, &minishell_builtins_unsetenv_free);
free(sh->env_list);
}
return (res);
}
void ft_exec(char *cmd, char **opt, t_env *var)
{
char *tmp;
char **conv;
pid_t proc;
if (ft_isfile(cmd))
tmp = ft_strdup(cmd);
else
tmp = ft_path(cmd, var);
if (!tmp)
{
ft_error_cmd(cmd);
return ;
}
proc = fork();
if (proc == 0)
{
conv = ft_conv_env(var);
execve(tmp, opt, conv);
ft_free_tab(conv);
}
wait(NULL);
free(tmp);
}
void make_my_unsetenv(char *line)
{
char *str;
char **tab;
int i;
int j;
j = 1;
tab = ft_strsplit(line, ' ');
while (tab[j] != NULL)
{
if (make_verify_setenv(tab[j]) == 0)
error_unset(tab[j]);
else
{
str = ft_strjoin(tab[j], "=");
i = get_line_env(str);
if (i != -1)
g_my_env = ft_realloc_tab_m(g_my_env, i);
else
error_unset_isnt(tab[j]);
free(str);
}
j++;
}
ft_free_tab(tab);
}
void get_map(t_env *env)
{
char **tab;
t_map *map;
char *line;
tab = NULL;
while (get_next_line(0, &line) == 1)
{
if (ft_strncmp(line, "Plateau", 7) == 0)
{
tab = ft_strsplit(line, ' ');
if (!(map = (t_map*)malloc(sizeof(t_map))))
error("Error : creation de map");
map->line = ft_atoi(tab[1]);
map->col = ft_atoi(tab[2]);
map->tab = get_board(map);
env->map = map;
ft_strdel(&line);
ft_free_tab(tab);
break ;
}
ft_strdel(&line);
line = NULL;
}
if (tab == NULL)
error("pas de tab");
}
int ft_ttaux(int argc, char **argv, char **env)
{
char **path;
char *name;
t_s s;
s.j = 0;
name = argv[0];
s.i = 0;
if (!ft_found(env, "PATH=", 1))
(SB(name, argv, env) == -1) ? ft_printff(P1, NULL, 0) : 0;
else
{
path = ft_strsplit(ft_found(env, "PATH=", 1), ':');
while ((s.ind = ft_sub_syscall(name, argv, env) == -1) && path[s.i])
{
s.j = access(name, F_OK) && s.ind == -1 ? s.j++ : s.j;
name = ft_fr(ft_strjoin(path[s.i], "/"), name, s.i);
name = ft_fr(ft_strjoin(name, argv[0]), name, 1);
s.i++;
}
if (!path[s.i] && ft_printff("sh1:", GG(argv[0], s.j), 0))
ft_putendl(argv[0]);
ft_free_tab(path);
s.i ? free(name) : (void)s.i;
}
return (argc - argc);
}
void ft_tab_split(char **tab, t_bol bol)
{
char **dir;
char **files;
int i;
int ret;
ret = 0;
i = 0;
dir = (char **)ft_memalloc(sizeof(char *) * 1);
files = (char **)ft_memalloc(sizeof(char *) * 1);
dir[0] = NULL;
files[0] = NULL;
while (tab[i])
{
ret = ft_sort_dir_files(tab[i], bol);
if (ret == 1)
files = ft_realloc_tab(files, tab[i]);
else if (ret == 0)
dir = ft_realloc_tab(dir, tab[i]);
i++;
}
ft_free_tab(tab, bol.tmp);
ft_sort_tab(files, dir, bol);
}
char *minishell_complete(const char *buff, const char *path)
{
char *complete;
char **split;
char *pattern;
size_t blen;
size_t plen;
(void)&minishell_complete_maxlen;
if ((!buff) || (!path) || (!(pattern = ft_strmjoin(2, buff, "*"))))
return (NULL);
plen = ft_strlen(pattern);
if ((!(split = minishell_completion(pattern, path))) &&
(ft_mfree(1, pattern)))
return (NULL);
blen = (split[0]) ? ft_strlen(split[0]) : 0;
if (blen > plen)
complete = ft_strdup(split[0] + plen - 1);
else
complete = NULL;
ft_free_tab(split, (unsigned int)ft_tabcount((void**)split));
free(pattern);
free(split);
return (complete);
}
static int deal_with_arg(t_shell *sh, char **arg, char **env_cpy)
{
char **res;
char *cmd;
res = NULL;
if (cmp_line(arg, env_cpy) == 0)
{
if (check_caract(*arg, '=') < 0)
return (print_wrong_identifier_env(*arg));
else if (check_caract(*arg, '=') != 1)
{
cmd = join_tab(arg);
exec_env(sh, cmd, env_cpy);
free(cmd);
return (sh->return_val);
}
else if (check_caract(*arg, '=') == 1)
{
res = add_elem(env_cpy, *arg);
ft_print_tab(res);
ft_free_tab(res);
return (0);
}
}
ft_print_tab(env_cpy);
return (0);
}
void ft_print_map(t_tetr *ptr, int size)
{
int i;
int j;
char **tab;
tab = ft_tabnew(size);
ft_dot_filler(tab, size);
while (ptr != NULL)
{
i = 0;
while (i < 4)
{
j = 0;
while (j < 4)
{
if (ptr->tetr[i][j] == '#')
{
tab[ptr->x + i][ptr->y + j] = ptr->nbr;
}
j++;
}
i++;
}
ptr = ptr->next;
}
ft_free_tab(tab, size);
}
void byte_reception(char **new_av, char *buf, int ret)
{
ft_putstr("received ");
ft_putnbr(ret);
ft_putstr(" bytes: ");
ft_putendl(buf);
ft_free_tab(new_av);
}
int parse_line(char *line)
{
char **tokens;
int (*parse_function)(const char **);
if (!(tokens = ft_split(line, " \t\n")))
return (0);
parse_function = get_parse_func(tokens[0]);
if (!parse_function)
{
puts(tokens[0]);
ft_free_tab(tokens);
parser_die("Unknown data type.");
}
(*parse_function)((const char **)(tokens + 1));
ft_free_tab(tokens);
return (1);
}
static int ft_get_nb(char *line)
{
char **split;
int res;
split = ft_strsplit(line, ' ');
res = ft_atoi(split[1]);
ft_free_tab((void ***)&split);
return (res);
}
int exec_free_root(t_tree *root)
{
if (root == NULL)
return (0);
if (root->left != NULL)
exec_free_root(root->left);
if (root->right != NULL)
exec_free_root(root->right);
if (root->cmd != NULL)
ft_free_tab(root->cmd);
free(root);
return (0);
}
void make_my_setenv(char *line)
{
char **tab;
tab = ft_strsplit(line, ' ');
if (tab[2] == NULL || tab[3] == NULL)
{
if (tab[1] && ((make_verify_setenv(tab[1])) == -1))
make_my_setenv2(tab);
}
else if (tab[3] != NULL)
ft_putendl_fd("setenv: too many arguments", 2);
ft_free_tab(tab);
}
static int main_minishell(void)
{
sh_reset_term();
ft_putstr_fd("TERM not found or unknown\n", STDOUT_FILENO);
ft_putstr_fd("shell: limited commands available\n", STDOUT_FILENO);
ft_putstr_fd("shell: no termcaps activated\n", STDOUT_FILENO);
ft_putstr_fd("WARNING: undetermined behaviors may occur\n", STDOUT_FILENO);
while (42)
{
if (sh_minishell() < 0)
{
ft_free_tab(g_env);
sh_reset_term();
return (0);
}
}
return (0);
}
void history(char *line)
{
char **argv;
int argc;
int begin;
t_cmds *first_cmds;
first_cmds = save_history_sig(NULL, 0);
first_cmds = find_first_cmds(first_cmds);
argv = ft_strsplit(line, ' ');
argc = count_arg(argv);
begin = adjust_history(first_cmds);
if (argc == 1)
make_simple_history(begin, TRUE, first_cmds);
else
valid_hist_arg(argv, argc, begin, first_cmds);
ft_free_tab(argv);
}
int main(int argc, char **argv)
{
int fd;
t_list **begin_list;
if (argc != 2)
{
ft_putendl("usage : ./fillit source_file");
return (0);
}
if ((fd = open(argv[1], O_RDONLY)) == -1)
return (0);
begin_list = ft_open_and_check(fd);
if (!(begin_list))
return (0);
ft_free_tab(begin_list);
return (0);
}
static int check_i_opt(t_shell *sh, char **arg, char **env_cpy)
{
char *cmd;
char **tab_cpy;
if (arg[0][0] == '-' && arg[0][1] == 'i' && !arg[0][2] && arg[1])
{
arg++;
cmd = join_tab(arg);
tab_cpy = ft_tabdup(env_cpy);
ft_free_tab(tab_cpy);
tab_cpy = NULL;
exec_env(sh, cmd, tab_cpy);
free(cmd);
return (0);
}
else
return (1);
}
int *convert_t(char *t, char c, t_tabi *tabi)
{
int *tab;
char **c_b;
int i;
i = 0;
c_b = ft_strsplit(t, c);
if (!(tab = (int *)malloc((sizeof(int) * len_num(t, c) + 1))))
return (NULL);
while (c_b[i])
{
tab[i] = ft_atoi(c_b[i]);
i++;
}
ft_free_tab(&c_b);
tabi->x = i;
return (tab);
}
void make_my_shell(char *line, char **av)
{
pid_t father;
char **path;
int child_status;
path = find_my_path("PATH=");
father = fork();
if (father > 0)
{
wait(&child_status);
if (child_status != 0)
g_son = -1;
else
g_son = 1;
}
if (father == 0)
make_my_shell1_2(line, av, path);
ft_free_tab(path);
}
int deal_with_env(t_shell *sh, char **arg)
{
char **env_cpy;
int i;
env_cpy = get_env(sh->env);
arg++;
i = 0;
if (*arg)
{
if (*arg[0] == '-')
i = deal_with_opt(sh, arg, env_cpy);
else
i = deal_with_arg(sh, arg, env_cpy);
}
else
print_env(sh->env);
ft_free_tab(env_cpy);
return (i);
}
