int create_var(t_cmd *tmp, t_env *var)
{
int i;
i = 0;
while (tmp->word[i] && tmp->word[i] != '=')
++i;
if (tmp->word[i])
{
tmp->word[i] = '\0';
++i;
}
if (put_in_list(var, tmp->word) == NULL
|| (var->prev->content = ft_strdup(tmp->word + i)) == NULL)
return (-1);
return (0);
}
static void test_2(void)
{
char *str;
printf("\ttest 2: ft_strdup(\"42\"): ");
str = ft_strdup("Alexandre");
if (str == NULL)
{
puts(MEM_ERROR);
return ;
}
if (strcmp(str, "Alexandre") == 0)
puts(SUCCESS);
else
puts(ERROR);
free(str);
}
t_map *ft_get_map_info(int fd)
{
char *charset;
t_map *map;
int i;
if ((map = (t_map *)malloc(sizeof(t_map))) == NULL)
return (NULL);
if ((charset = ft_get_first_line(fd, NULL)) == NULL)
return (NULL);
i = ft_strlen(charset) - 4;
map->charset = ft_strdup(charset + i);
map->charset[3] = '\0';
charset[i] = '\0';
map->height = ft_atoi(charset);
return (map);
}
int print_with_precision(t_formater *fmt, t_printf *pf)
{
int is_nega;
int ret;
ret = 0;
is_nega = pf->fmt_str[0] == '-' ? 1 : 0;
if (is_nega)
pf->prefix = ft_strdup("-");
if (is_signed(fmt) && fmt->flag & F_BLANK && !is_neg(pf->fmt_str))
{
ret += ft_putchar(' ');
fmt->width -= 1;
}
ret += print_w_pres3(fmt, pf);
return (ret);
}
t_ls *filla(int *state, t_ls *a, char *path, struct dirent *dir)
{
t_osef *osef;
if (((state[A] == 0 && dir->d_name[0] != '.' &&\
dir->d_name[0] != 0 &&
state[F] == 0)) || (((state[A] == 1) ||
(state[F] == 1)) && dir->d_name[0] != 0))
{
if (!(osef = malloc(sizeof(*osef))))
return (NULL);
osef->name = ft_strdup(dir->d_name);
lstat(ft_strjoinslash(path, dir->d_name), &osef->my_stat);
a = addelem(&a, osef);
}
return (a);
}
static int cmp_line(char **arg, char **env_cpy)
{
int i;
i = 0;
while (env_cpy[i])
{
if (ft_strccmp(env_cpy[i], *arg, '=') == 0)
{
free(env_cpy[i]);
env_cpy[i] = ft_strdup(*arg);
return (1);
}
i++;
}
return (0);
}
void print_lnkabout(char *fpath)
{
int path_size;
char *path_save;
if (!(path_save = ft_strdup(fpath)))
return ;
path_size = readlink(fpath, fpath, 1024);
if (path_size > 0)
{
fpath[path_size] = '\0';
ft_putstr(" -> ");
ft_putstr(fpath);
}
ft_strcpy(fpath, path_save);
free(path_save);
}
char *append_path(char *environ, char *av)
{
char **path_env;
char *ret;
if (!environ)
return (av);
ret = NULL;
path_env = ft_strsplit(environ, ':');
path_env = append_slash(path_env, &environ);
ret = check_path(path_env, av);
if (ret)
av = ft_strdup(ret);
free_double_array(path_env);
ft_memdel((void**)&ret);
return (av);
}
t_select *ft_listnew(char *str, int pos)
{
t_select *list;
if ((list = (t_select *)malloc(sizeof(t_select))))
{
list->str = ft_strdup(str);
list->curseur = 'n';
list->select = 'n';
list->row = 0;
list->col = 0;
list->pos = pos;
list->next = list;
list->prev = list;
}
return (list);
}
void increment_shlvl(char ***env)
{
int n;
char **str;
if (get_in_env(*env, "SHLVL"))
{
n = ft_atoi(get_in_env(*env, "SHLVL"));
str = ft_memalloc(sizeof(char*) * 3);
str[0] = ft_strdup("setenv");
str[1] = ft_strnew(20);
str[1] = ft_strcat(str[1], "SHLVL=");
str[1] = ft_strcat(str[1], ft_itoa(++n));
builtin_setenv(str, env);
ft_tabfree(str);
}
}
size_t *ls_read_stat(t_lltree **tree, char *pathname, char *choice)
{
struct dirent *file;
DIR *rep;
struct stat *stats_struct;
t_llstat statsfile;
int stats;
static size_t keep_infos[6] = {0};
char *filepathname;
if((rep = opendir(pathname)))
{
if ((stats_struct = (struct stat*)malloc(sizeof(struct stat))))
{
if (!(check_slash(pathname)))
pathname = ft_strjoin(pathname, "/");
while ((file = readdir(rep)))
{
statsfile.filename = ft_strdup(file->d_name);
filepathname = ft_strjoin(pathname, file->d_name);
if (((stats = lstat(filepathname, stats_struct))) != -1)
{
// printf("Filepathname : %s; Device number (st_rdev): %d major=%u; minor=%d\n",filepathname, stats_struct->st_rdev, major_ex(stats_struct->st_rdev), (int) minor_ex(stats_struct->st_rdev));
takestats(stats_struct, &statsfile);
test_sizeinfos(&statsfile, keep_infos, stats_struct->st_blocks, choice);
if (!(choice[1]))
ltree_insert_data(tree, statsfile);
else if (choice[1])
ltree_insert_data_time(tree, statsfile);
}
free(filepathname);
filepathname = NULL;
}
closedir(rep);
free(stats_struct);
stats_struct = NULL;
}
}
else
{
if ((!(choice[5])) || ((choice[5]) && errno != EACCES))
print_error(pathname);
}
return (keep_infos);
}
char *ft_strmap(char const *s, char (*f)(char))
{
char *dest;
int i;
i = 0;
dest = (char *)malloc(sizeof(char) * (ft_strlen(s) + 1));
while (s[i] != '\0' && f != NULL)
{
dest[i] = f(s[i]);
i++;
}
dest[i] = '\0';
if (i != 0)
return (dest);
else
return (ft_strdup(s));
}
t_list *ft_lstnew(void const *content, size_t content_size)
{
t_list *list;
list = (t_list *)malloc(sizeof(t_list));
if (list == NULL)
return (NULL);
list->next = NULL;
if (content == NULL)
{
list->content_size = 0;
list->content = NULL;
return (list);
}
list->content = ft_strdup(content);
list->content_size = content_size;
return (list);
}
static void make_line(char **line, char **str, char *tmp)
{
size_t i;
i = ft_count_char_befor(*str, '\n');
*line = (char *)malloc(sizeof(char) * (i + 1));
*line = ft_strncpy(*line, *str, i);
if (tmp[0] != '\0' && tmp[1] != '\0')
{
free(*str);
*str = ft_strdup(tmp + 1);
}
else
{
free(*str);
*str = NULL;
}
}
void ft_do_padding_switch_3_2(t_conv *conv, char **ret,
char **padding, int i)
{
if (ft_strchr(conv->flag, '-') == NULL)
{
(*padding)[i - 2] = '0';
(*padding)[i - 1] = 'x';
*ret = ft_strjoin_free(
*padding, *ret);
}
else
{
if ((int)(ft_strlen(*padding) - 2) >= 0)
(*padding)[ft_strlen(*padding) - 2] = '\0';
*ret = ft_strjoin_free(ft_strdup("0x"), ft_strjoin_free(
*ret, *padding));
}
}
char *ft_uitoa(unsigned int n)
{
char *nstr;
char *tmp;
unsigned int nbr;
if (n == 0)
return (ft_strdup("0"));
nstr = ft_strnew(1000);
tmp = nstr;
nbr = n;
while (nbr)
{
*nstr++ = (char)(nbr % 10 + (int)'0');
nbr /= 10;
}
return (ft_strrev(tmp));
}
char *get_command_string(t_lsys *self, int it)
{
char *result;
char *tmp;
int i;
int nsize;
i = 1;
result = ft_strdup(self->axiom);
while (i++ < it)
{
nsize = expanded_size(self, result);
tmp = result;
result = expand_into(self, result, ft_memalloc(nsize + 1));
free(tmp);
}
return (result);
}
char *search_key(char *key, t_node *root)
{
int i;
t_node *tmp;
tmp = root;
i = 0;
while (key[i])
{
if (tmp->kids[key[i] % 95] == NULL)
return (not_found(key));
tmp = tmp->kids[key[i] % 95];
i++;
}
if (tmp->isleaf)
return (ft_strdup(tmp->v));
return (not_found(key));
}
static t_history *return_last_elem(t_it *it, t_history *list)
{
int i;
i = 0;
if (it->tmp_line)
{
it->line = ft_strdup(it->tmp_line);
ft_putstr(it->line);
i = ft_strlen(it->line);
while (i--)
it->i++;
}
else
it->line = NULL;
it->first = 1;
return (list);
}
char *ft_strmapi(char const *str, char (*f)(unsigned int, char))
{
char *ret;
size_t id;
size_t len;
len = ft_strlen(str);
id = 0;
ret = ft_strdup(str);
if (!ret)
return (NULL);
while (id < len)
{
ret[id] = f(id, ret[id]);
id++;
}
return (ret);
}
static char *search_argument(char **tab, char *str, int *v)
{
int i;
char *result;
result = NULL;
i = 0;
while (tab[i])
{
if (!ft_strncmp(tab[i], str, ft_strlen(str)))
{
++*v;
result = ft_strdup(tab[i]);
}
++i;
}
return (result);
}
static int check_arg(char **env_cpy, char *arg)
{
int i;
i = 0;
while (env_cpy[i])
{
if (ft_strncmp(env_cpy[i], arg, ft_strlen(arg)) == 0)
{
free(env_cpy[i]);
env_cpy[i] = ft_strdup("");
ft_strclr(env_cpy[i]);
return (1);
}
i++;
}
return (0);
}
int ft_cmd_cd_oldpwd(void)
{
char *cwd;
char *oldpwd;
if (ft_cmd_env_srch("OLDPWD") == -1)
return (ft_sh_error("42sh: cd: No OLDPWD to move to."));
cwd = getcwd(NULL, PATH_MAX + 1);
oldpwd = ft_strdup(ft_cmd_env_get("OLDPWD"));
if (chdir(oldpwd) == -1)
return (ft_sh_perror("42sh: cd"));
ft_cmd_env_set("OLDPWD", cwd);
ft_cmd_env_set("PWD", oldpwd);
ft_putendl(oldpwd);
free(cwd);
free(oldpwd);
return (1);
}
static char *verify_path(t_env *tenv, char **args)
{
char *path;
if ((path = get_prog_path(tenv, args[0])) != NULL)
{
return (path);
}
else if ((access(args[0], F_OK) == 0) && (access(args[0], X_OK) == 0))
{
path = ft_strdup(args[0]);
return (path);
}
else
{
return (NULL);
}
}
char *ft_strmapi(char const *s, char (*f)(unsigned int, char))
{
char *map;
int i;
if (s == NULL || f == NULL)
return (NULL);
i = 0;
map = ft_strdup(s);
if (map == NULL)
return (NULL);
while (map[i] != '\0')
{
map[i] = f(i, map[i]);
i++;
}
return (map);
}
void *ft_memmove(void *dst, void const *src, size_t len)
{
char *psrc;
char *pdst;
char *ptemp;
size_t i;
i = 0;
pdst = (char *)dst;
psrc = (char *)src;
ptemp = (char *)ft_memcpy((void *)ft_strdup((const char *)dst), src, len);
while (i < len)
{
pdst[i] = ptemp[i];
i++;
}
return (dst);
}
static char *join_refresh(char **s1, char const *s2)
{
char *stand_in;
if (*s1 == NULL)
{
stand_in = ft_strdup(s2);
return (stand_in);
}
stand_in = ft_strnew(ft_strlen(*s1) + ft_strlen(s2));
if (stand_in != NULL)
{
stand_in = ft_strcpy(stand_in, *s1);
*s1 = 0;
return (ft_strcat(stand_in, s2));
}
return (NULL);
}
ssize_t ft_asprintf_conv_str(char **string, va_list arg, t_printer *p)
{
char *input;
if ((p->length & 4) != 0)
return (ft_asprintf_conv_str_long(string, arg, p));
input = va_arg(arg, char*);
if (input == NULL)
input = "(null)";
if (p->prec >= 0)
*string = ft_strndup(input, p->prec);
else
*string = ft_strdup(input);
if (*string == NULL)
return (-1);
else
return (ft_strlen(*string));
}
char *ft_strtrim(char const *s)
{
size_t len;
size_t start;
if (s)
{
len = count_spaces_return(s, ft_strlen(s));
start = count_spaces(s);
if (!len && !start)
return (ft_strdup(s));
else if (start == ft_strlen(s))
return (ft_strsub(s, 0, 0));
else
return (ft_strsub(s, start, len - start + 1));
}
return (NULL);
}
void shell_env_to_list(t_list **list, char **environ)
{
int i;
t_env *env;
i = 0;
while (environ[i])
{
env = malloc(sizeof(t_env));
env->var = ft_strnew(ft_strlen(environ[i]) -
ft_strlen(ft_strchr(environ[i], '=') + 1));
ft_strncpy(env->var, environ[i], ft_strlen(environ[i]) -
ft_strlen(ft_strchr(environ[i], '=')));
env->value = ft_strdup(ft_strchr(environ[i], '=') + 1);
ft_lstadd(list, ft_lstnew(env, sizeof(t_env)));
i++;
}
}
