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); }