void test_strncpy(void)
{
char *s1 = "Je suis la copie";
char *s1_true;
char *s2_true;
char *true_ret;
char *s1_test;
char *s2_test;
char *test_ret;
printf("\nTesting ft_strncpy\n");
s1_true = malloc(20);
s2_true = malloc(20);
s1_test = malloc(20);
s2_test = malloc(20);
s1_true[19] = 'a';
s1_test[19] = 'a';
true_ret = strncpy(s1_true, s1, 20);
test_ret = ft_strncpy(s1_test, s1, 20);
strncpy(s2_true, s1, 0);
ft_strncpy(s2_test, s1, 0);
printf("%-20s %-20s %-20s %-20s\n%-20s %-20s %-20s %-20s\n",
"Expected result:", s1_true, true_ret, s2_true,
"Actual result:", s1_test, test_ret, s2_test);
free(s1_true);
free(s2_true);
free(s1_test);
free(s2_test);
}
static int check_cond(char *buff, char **line, int count, int *first_go)
{
char *cpy_buff;
char *cpy;
if ((ft_strchr(buff, (int)'\n')) == NULL && *first_go)
{
*line = ft_strncpy(*line, buff, count);
first_go = 0;
}
else if ((ft_strchr(buff, (int)'\n')) == NULL)
{
cpy_buff = (char *)ft_memalloc(sizeof(cpy_buff) * (count + 1));
cpy_buff = ft_strncpy(cpy_buff, buff, count);
cpy = ft_strjoin(*line, cpy_buff);
free(*line);
free(cpy_buff);
*line = cpy;
}
else if ((ft_strchr(buff, (int)'\n')) != NULL)
{
end_line(buff, line, (-1), *first_go);
return (1);
}
return (0);
}
static char *ft_joinstr(char *name, char *env, int *len)
{
char *str;
size_t len_2;
int i;
size_t j;
i = *len;
if (!env[*len])
return (NULL);
while (env[*len] != ':' && env[*len])
(*len)++;
j = *len - i;
(*len)++;
len_2 = ft_strlen(name);
str = (char *)malloc(j + len_2 + 2);
if (str)
{
(void)ft_strncpy(str, &env[i], j);
str[j] = '/';
(void)ft_strncpy(&str[j + 1], name, len_2);
str[j + len_2 + 1] = 0;
return (str);
}
return (NULL);
}
int get_next_line(int const fd, char **line)
{
static char *str;
int res;
char *buf;
char *tmp;
if (fd < 0 || !line || BUFF_SIZE < 1 || BUFF_SIZE > 10000000)
return (-1);
buf = (char*)malloc(sizeof(char) * (BUFF_SIZE + 1));
if (str == NULL)
str = ft_strnew(BUFF_SIZE);
tmp = ft_strncpy(ft_memalloc(BUFF_SIZE), str, BUFF_SIZE);
while (!(ft_strchr(tmp, '\n')))
{
if ((res = read(fd, buf, BUFF_SIZE)) < 1)
return (line_verif(line, &tmp, res, &str));
buf[res] = '\0';
tmp = cpycat(tmp, buf);
}
*line = read_line(tmp);
if (ft_strchr(tmp, '\n'))
str = ft_strncpy(str, ft_strchr(tmp, '\n') + 1, BUFF_SIZE);
free(tmp);
free(buf);
return (1);
}
char *get_exec_path(t_env env, char *cmd)
{
char path[6000];
char *bin;
char *colon;
if (!cmd)
shell_perror("get_exec_path recieved NULL command string");
if (!*cmd)
return (shell_pwarning("not a valid command: ", "(Empty)"));
if (isdir(cmd))
return (shell_pwarning("is a directory: ", cmd));
if (!access(cmd, X_OK))
return (ft_strdup(cmd));
if (!(bin = fetch_key_val(env, "PATH")))
return (NULL);
while ((colon = ft_strchr(bin, ':')))
{
ft_strncpy(path, bin, (colon - bin) + 1);
ft_strncpy(ft_strchr(path, ':'), "/", 2);
ft_strcat(path, cmd);
if (!access(path, X_OK))
return (ft_strdup(path));
bin = colon + 1;
}
return (parse_exec_string(path, bin, cmd));
}
static char get_mem(char **tab, char **mem)
{
char *find;
if (!*tab)
{
if (!(*tab = ft_strnew(BUFF_S)))
return (-1);
if (!(*mem = ft_strnew(BUFF_S)))
return (-1);
return (0);
}
if (!(*mem = ft_strnew(BUFF_S)))
{
ft_memdel((void **)tab);
return (-1);
}
if (!(find = ft_strchr(*tab, '\n')))
{
ft_strncpy(*mem, *tab, BUFF_S);
ft_bzero(*tab, BUFF_S);
return (0);
}
*find = '\0';
ft_strncpy(*mem, *tab, BUFF_S);
ft_strncpy(*tab, &(find[1]), BUFF_S);
return (1);
}
void *ft_memmove(void *dst, void const *src, size_t n)
{
char *tmp;
tmp = (char *)malloc(sizeof(char *) * n);
tmp = ft_strncpy(tmp, src, n);
dst = (void *)ft_strncpy(dst, tmp, n);
free(tmp);
return (dst);
}
void *ft_memmove(void *dest, const void *src, size_t len)
{
char *str;
str = (char *)malloc(sizeof(char *) * len);
str = ft_strncpy(str, src, len);
dest = (void *)ft_strncpy(dest, str, len);
free(str);
return (dest);
}
char *ft_strjoin(char *str1, char *str2)
{
char *res;
int len1;
int len2;
len1 = (str1) ? ft_strlen(str1) : 0;
len2 = (str2) ? ft_strlen(str2) : 0;
res = ft_strnew(len1 + len2);
ft_strncpy(res, str1, len1);
ft_strncpy(res + len1, str2, len2);
return (res);
}
void *ft_memmove(void *dst, const void *src, size_t len)
{
char *tmp;
if (dst == NULL || src == NULL)
return (NULL);
if (!(tmp = (char*)malloc(sizeof(char*) * len)))
return (NULL);
tmp = ft_strncpy(tmp, src, len);
dst = (void*)ft_strncpy(dst, tmp, len);
free(tmp);
return (dst);
}
int ft_strncmp(const char *s1, const char *s2, size_t n)
{
char *new_s1;
char *new_s2;
int cmp;
if (!s1 || !s2)
return (0);
new_s1 = ft_strncpy(ft_strnew(n), s1, n);
new_s2 = ft_strncpy(ft_strnew(n), s2, n);
cmp = ft_strcmp(new_s1, new_s2);
ft_strdel(&new_s1);
ft_strdel(&new_s2);
return (cmp);
}
char *ft_strjoin(char const *s1, char const *s2)
{
size_t len1;
size_t len2;
char *str;
len1 = ft_strlen(s1);
len2 = ft_strlen(s2);
str = ft_strnew(len1 + len2);
if (!str)
return (NULL);
ft_strncpy(str, s1, len1);
ft_strncpy(str + len1, s2, len2);
return (str);
}
char *ft_strncpy(char *dest, char *src, unsigned int n)
{
if (n == 0)
return (dest);
else if (*src == '\0')
{
*dest = '\0';
return (ft_strncpy(dest + 1, src, n - 1));
}
else
{
*dest = *src;
return (ft_strncpy(dest + 1, src + 1, n - 1));
}
}
char *ft_strjoin_char(const char *s1, char c, const char *s2)
{
char *str;
size_t lens1;
size_t lens2;
lens1 = ft_strlen(s1);
lens2 = ft_strlen(s2);
str = ft_strnew(lens1 + lens2 + 3);
if (!str)
return (NULL);
ft_strncpy(str, s1, lens1);
str[lens1] = c;
ft_strncpy(str + lens1 + 1, s2, lens2);
return (str);
}
char *ft_strtrim(char const *s)
{
int len;
int i;
char *s1;
i = 0;
if (!s)
return (NULL);
while (ft_isspace(*s) && *s)
s++;
len = ft_strlen(s);
while (s[i])
i++;
i--;
while (ft_isspace(s[i]) && i >= 0 && *s)
{
len--;
i--;
}
if (!(s1 = ft_strnew(len + 1)))
return (NULL);
ft_strncpy(s1, s, (len));
s1[len + i] = '\0';
return (s1);
}
static int check_end_line(t_gnl *token, char **line)
{
int i;
i = 0;
if (token->rest && token->rest[i] != '\0')
{
while (token->rest[i] && token->rest[i] != '\n')
i++;
if ((token->rest[i] == '\n') || token->flag_read == 1)
{
*line = (char *)malloc(sizeof(char) * i + 1);
ft_bzero(*line, i + 1);
if (i > 0)
ft_strncpy(*line, token->rest, i);
if (token->rest[i] == '\n')
token->rest = token->rest + i + 1;
else
token->rest = token->rest + i;
return (1);
}
}
else if ((!token->rest || token->rest[i] == '\0') && token->flag_read == 1)
return (0);
return (-1);
}
char *ft_strreplace(char *s, char *find, char *replace)
{
char *v_new;
char *v_find;
size_t occ;
if (!s)
return (0);
if (!find || !replace)
return (s);
v_find = ft_strstr(s, find);
occ = 0;
while (v_find && occ++)
v_find = ft_strstr(v_find + ft_strlen(find), find);
occ = (ft_strlen(replace) - ft_strlen(find)) * occ + ft_strlen(s);
v_new = ft_strcpy(ft_strnew(occ), "");
v_find = ft_strstr(s, find);
while (v_find)
{
ft_strncpy((v_new + ft_strlen(v_new)), s, (v_find - s));
ft_strcpy((v_new + ft_strlen(v_new)), replace);
s = v_find + ft_strlen(find);
v_find = ft_strstr((v_find + ft_strlen(find)), find);
}
ft_strcpy((v_new + ft_strlen(v_new)), s);
return (v_new);
}
char *ft_strtrim(char const *s)
{
size_t i;
size_t start;
size_t end;
char *dest;
if (s == NULL)
return (NULL);
i = 0;
while (ft_iswhite(s[i]) && s[i])
i++;
start = i;
end = ft_end((char *)s, start);
dest = (char *)malloc(sizeof(char));
if (start != end || (start == end && start != (size_t)ft_strlen(s)))
{
if (!(dest == (char *)malloc((end - start + 2) * sizeof(char))))
return (NULL);
ft_strncpy(dest, s + start, end - start + 1);
dest[end - start + 1] = 0;
}
else if (start == end && start == (size_t)ft_strlen(s))
*dest = '\0';
return (dest);
}
char *ft_strtrim(char const *s)
{
char *result;
unsigned int i;
unsigned int len;
if (s)
{
len = ft_len_nospace(s);
if (len > 0)
{
i = 0;
result = ft_strnew(len);
if (result)
{
while (s[i] && ft_isspace(s[i]))
i++;
if (!s[i])
return (ft_strdup(""));
ft_strncpy(result, &s[i], len);
result[len] = '\0';
return (result);
}
}
}
return (NULL);
}
static int ft_cd_double(t_env *shell)
{
char *ptr;
char *pwd;
char *tmp;
int v;
if (!(pwd = ft_get_env_value(shell, "PWD")))
if (!(pwd = ft_strdup(shell->pwd)))
return (0);
if (!(ptr = ft_strstr(pwd, shell->av[1])))
{
write(1, "cd: string not in pwd: ", 23);
ft_putendl(shell->av[1]);
free(pwd);
return (0);
}
if (!(tmp = (char *)ft_memalloc(sizeof(char) * (ft_strlen(pwd) +
ft_strlen(shell->av[2]) - ft_strlen(shell->av[1])))))
return (0);
ft_strncpy(tmp, pwd, ptr - pwd);
ft_strcpy(tmp + (ptr - pwd), shell->av[2]);
ft_strcpy(tmp + ft_strlen(tmp), ptr + ft_strlen(shell->av[1]));
v = ft_cd_normal(shell, tmp);
free(tmp);
free(pwd);
return (v);
}
static int ft_comm(int fd, t_header *header)
{
t_token tok;
char *str;
int state;
state = 0;
while ((tok = next_token(fd, &str)) != END)
{
if (state == 0 && tok == STRING)
{
if (ft_strlen(str) > COMMENT_LENGTH + 2)
ft_head_error(COMMENT_LENGTH, header, COMMENT_CMD_STRING + 1);
ft_strncpy(header->comment, str + 1, ft_strlen(str) - 2);
state++;
}
else if (state == 1 && tok == ENDLINE)
state++;
else
ft_tok_error(tok, str, NULL, 0);
free(str);
if (state == 2)
return (1);
}
return (0);
}
t_file *create_fake_list(char **av, int start, int ac)
{
char *dup;
char *name;
t_file *list2;
list2 = NULL;
while (start < ac)
{
dup = ft_strdup(av[start]);
name = find_name(dup, av, start);
if (!list2)
{
list2 = malloc(sizeof(t_file));
ft_strncpy(list2->name, name, PATH_MAX);
list2->path = ft_strsub(dup, 0, name - dup);
list2->av_name = ft_strdup(av[start]);
list2->next = NULL;
}
else
add_list_with_name(list2, name, av[start], name - dup);
start++;
free(dup);
}
return (list2);
}
t_hex *initiaizelinks(char *tab, t_hex *lst)
{
int i;
i = 0;
if ((lst->links->next = (t_links*)malloc(sizeof(t_links))) == NULL)
error("ERROR : Malloc NULL.");
while (tab[i] != '-')
i++;
if ((lst->links->room1 = malloc(sizeof(char) * i + 1)) == NULL)
error("ERROR : Malloc NULL.");
lst->links->room1 = ft_strncpy(lst->links->room1, tab, i);
i = 0;
while (tab[i] != '-')
i++;
i++;
if ((lst->links->room2 = malloc(sizeof(char) * ft_strlen(&tab[i]) + 1)) ==
NULL)
error("ERROR : Malloc NULL.");
lst->links->room2 = ft_strcpy(lst->links->room2, &tab[i]);
i = 0;
if (ft_strcmp(lst->links->room1, lst->links->room2) == 0)
error("\nERROR : You just link a room with itself, no no no -_-.");
lst->links = lst->links->next;
return (analizestartend(lst));
}
int get_next_line(int const fd, char **line)
{
static char buff[BUFF_SIZE + 1];
int ret;
char *cue;
*line = ft_strnew(1);
ft_bzero(*line, 1);
if (buff[0] != '\0')
{
if (!ft_strchr(buff, '\n'))
return (0);
cue = (ft_strchr(buff, '\n') + 1);
if (ft_buff_read(cue, line) == 1)
{
ft_strncpy(buff, cue, BUFF_SIZE + 1);
return (1);
}
}
ft_bzero(buff, BUFF_SIZE + 1);
while ((ret = read(fd, buff, BUFF_SIZE)) > 0)
{
buff[ret] = '\0';
if (ft_buff_read(buff, line) == 1)
return (1);
}
return (ret);
}
t_chlst *ft_strsplit_nbr(char *str, int i)
{
int i2;
t_chlst *lst;
t_chlst *first;
if (!(lst = new_chlst()))
return (NULL);
first = lst;
while (str[i] != '\0')
{
if (i != 0)
{
lst->next = new_chlst();
lst = lst->next;
}
while (is_delim(str[i]) == 1 && str[i] != '\0')
i++;
i2 = i;
while (is_delim(str[i]) == 0)
i++;
if (!(lst->str = ft_strnew(i - i2)))
return (NULL);
ft_strncpy(lst->str, &str[i2], i - i2);
}
return (first);
}
char *ft_strnapp(char const *origin, char const *str, size_t n)
{
char *result;
size_t org_len;
char *it;
org_len = ft_strlen(origin);
result = (char *)malloc(sizeof(*result) * (org_len + n + 1));
if (result)
{
it = result;
if (origin)
{
ft_strcpy(it, origin);
it += org_len;
}
if (str)
{
ft_strncpy(it, str, n);
if (n > ft_strlen(str))
it += n;
else
it += ft_strlen(str);
}
}
return (result);
}
int exec_shell(char **env)
{
int ret;
char buf[BUF_SIZE];
char *cmd;
char **list_cmd;
int i;
i = 0;
prompt(env);
ret = read(0, buf, BUF_SIZE);
if (ret == 0 || buf[0] == '\n')
return (0);
cmd = (char*)malloc(sizeof(cmd) * (ret + 1));
if (cmd)
ft_strncpy(cmd, buf, ret - 1);
while (ft_syntaxchecked(cmd) && !verif_cmd(cmd))
cmd = get_new_cmd(cmd);
list_cmd = ft_strsplit(ft_replacetab(cmd), ';');
while (list_cmd[i] != NULL && ft_checksymbolcmd(cmd))
{
choose_cmd(list_cmd[i]);
i++;
}
free(cmd);
ft_freetable(list_cmd);
return (1);
}
static char *parse_prompt_tokens(t_list *tokens)
{
size_t size;
char *str;
size_t i;
size_t len;
t_token *token;
size = total_size(tokens);
str = (char *)malloc(sizeof(char) * (size + 1));
i = 0;
while (tokens)
{
token = get_token(&tokens);
len = ft_strlen(token->lexeme);
if (token->type == CHARS)
ft_strncpy(str + i, token->lexeme, len);
else
{
add_color(token, str + i, len);
i += COLOR_STR_SIZE;
}
i += len;
tokens = tokens->next;
}
str[i] = '\0';
return (str);
}
void ft_putstr_width(const char *str, int n)
{
int len;
char *buf;
len = ft_strlen(str);
buf = NULL;
if (len < n)
{
if (!(buf = (char *)ft_memallocset(sizeof(char) * (n + 1), ' ')))
{
OUT_OF_MEMORY;
return ;
}
ft_strncpy(buf, str, len);
}
else
{
if (!(buf = ft_strdup(str)))
{
OUT_OF_MEMORY;
return ;
}
ft_strcpy(buf + n - 2, "..");
}
write(1, buf, n);
free(buf);
}
char *ft_strtrim(char const *s)
{
char *scpy;
int i;
int j;
i = 0;
j = 0;
while (s[i] == ' ' || s[i] == '\n' || s[i] == '\t')
i++;
while (s[i] != '\0')
{
i++;
j++;
}
i--;
while ((s[i] == ' ' || s[i] == '\n' || s[i] == '\t') && i != 0)
{
i--;
j--;
}
i = 0;
while (s[i] == ' ' || s[i] == '\n' || s[i] == '\t')
i++;
if ((scpy = ft_strnew(j)))
ft_strncpy(scpy, (char *)(s + i), j);
return (ft_ret(scpy));
}
