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