int get_next_line(char **line, int fd)
{
static char *buf = NULL;
int ret;
if (!line)
return (-1);
if (buf)
{
if (*line)
ft_strclr(*line);
if (create_line(&buf, line))
return (1);
else
ft_strclr(buf);
}
else if ((*line = ft_strnew(0)))
buf = (char *)malloc(sizeof(char) * (100));
while ((ret = read(fd, buf, 1)))
{
buf[ret] = '\0';
if (create_line(&buf, line))
return (1);
}
ft_memdel((void **)(&buf));
return ((ret = **line ? 1 : 0));
}
int get_next_line(const int fd, char **line)
{
static char *rest;
int i;
char *tmp;
int r;
char *c;
i = 0;
if (!rest)
if (!(rest = (char *)realloc(rest, sizeof(char) * BUFF_SIZE)))
return (-1);
if (!(tmp = (char *)malloc(sizeof(char) * BUFF_SIZE)))
return (-1);
if (!(c = (char *)malloc(sizeof(char) * BUFF_SIZE)))
return (-1);
if (!(*line = (char *)malloc(sizeof(char) * BUFF_SIZE)))
return (-1);
while (rest[i])
{
tmp[i] = rest[i];
if (rest[i] == '\n' || rest[i] == 'EOF')
{
*line = (char *)ft_strjoin((*line), tmp);
rest = rest + i;
return (1);
}
i++;
}
printf("rest : ~%s~ -- tmp : ~%s~\n", rest, tmp);
i = 0;
ft_strclr(tmp);
*line = ft_strjoin((*line), rest);
printf("line : ~%s~\n", *line);
while ((r = read(fd, c, BUFF_SIZE)) > 0)
{
printf("--- read : ~%s~ | line : ~%s~\n", c, *line);
while (c[i])
{
tmp[i] = c[i];
printf("------ tmp : ~%s~ / c : ~%s~ / c[i] : ~%c~\n", tmp, c, c[i]);
if (c[i] == '\n')
{
*line = ft_strjoin((*line), tmp);
printf("XXXX line finale : ~%s~ XXXX\n", *line);
rest = &c[i + 1];
return (1);
}
i++;
}
i = 0;
ft_strclr(tmp);
*line = ft_strjoin((*line), c);
ft_strclr(c);
}
if (r == 0)
return (0);
return (-1);
}
static inline int ft_get_single_line(int fd, char **memory)
{
register char *tmp;
register char *buff;
register int re;
if (!(buff = (char *)ft_memalloc(sizeof(char) * (BUFF_SIZE + 1))))
return (-1);
while (!ft_strchr(*memory, '\n'))
{
ft_strclr(buff);
if ((re = read(fd, buff, BUFF_SIZE)) == -1)
return (re);
if (re == 0)
{
free(buff);
return (0);
}
tmp = ft_strjoin(*memory, buff);
free(*memory);
*memory = tmp;
}
free(buff);
return (1);
}
int get_next_line(int const fd, char **line)
{
static t_files *saved_files = NULL;
char *file_line;
char buff[BUFF_SIZE + 1];
int ret;
ret = BUFF_SIZE;
ft_strclr(buff);
if ((file_line = find_file(fd, &saved_files)) == NULL)
return (-1);
if (!parse_line(buff, &file_line))
{
while ((ret = read(fd, buff, BUFF_SIZE)) != 0)
{
buff[ret] = '\0';
if (parse_line(buff, &file_line))
break ;
}
}
if ((*line = get_line(&file_line)) == NULL || ret != BUFF_SIZE)
delete_file(fd, &saved_files);
if (line == NULL)
return (-1);
return (ret == BUFF_SIZE ? 1 : 0);
}
static int store_read(t_file *file, char **line, char *buf)
{
int e;
if (!find_next(file->buf))
{
while (!find_next(file->buf) &&
(e = read(file->fd, buf, BUFF_SIZE)) >= 1)
{
file->buf = ft_strjoin_free(file->buf, buf);
ft_bzero(buf, BUFF_SIZE);
}
if (e < 0)
return (-1);
if (e == 0 && !find_next(file->buf) && ft_strlen(file->buf))
{
*line = ft_strdup(file->buf);
ft_strclr(file->buf);
return (1);
}
if (!ft_strlen(file->buf) && e == 0)
return (0);
}
*line = strchrsubdup(&file->buf);
return (1);
}
static void simple_test(t_test *test)
{
char str[] = "tttttt";
ft_strclr(str);
mt_assert(memcmp(str, "\0\0\0\0\0\0", 7) == 0);
}
static int ft_join_keep(char **line, char *buf)
{
char *p;
char *tmp;
char *tmp2;
if ((p = ft_strchr(buf, '\n')))
{
tmp = ft_strndup(buf, (p - buf));
tmp2 = ft_strjoin(*line, tmp);
free(*line);
*line = ft_strsub(tmp2, 0, ft_strlen(tmp2));
free(tmp2);
p++;
ft_strcpy(buf, p);
free(tmp);
return (1);
}
else
{
tmp = ft_strjoin(*line, buf);
free(*line);
*line = ft_strsub(tmp, 0, ft_strlen(tmp));
free(tmp);
ft_strclr(buf);
return (0);
}
}
int ft_hexa_char(char const *fl, va_list ap, t_print *gl)
{
gl->f = 2;
gl->i = 0;
if (fl[gl->l - gl->f] == 'h')
gl->f++;
if (fl[gl->l - gl->f] == 'h')
gl->f++;
if (ft_isdigit(fl[gl->l - gl->f]) || fl[gl->l - gl->f] == '*')
gl->p = ft_precision_str(fl, ap, gl);
if (fl[gl->l - gl->f] == '.')
{
gl->p = 0;
gl->f++;
}
if (ft_isdigit(fl[gl->l - gl->f]) || fl[gl->l - gl->f] == '*')
gl->larg = ft_width_str(fl, ap, gl);
if (gl->inv == 2)
ft_swap(&gl->p, &gl->larg);
if (fl[gl->l - gl->f] == ' ' || fl[gl->l - gl->f] == '#' ||
fl[gl->l - gl->f] == '-' || fl[gl->l - gl->f] == '+' ||
fl[gl->l - gl->f] == '%')
gl->flag = ft_hexa_flag(fl, ap, gl, 'c');
ft_strclr(gl->s);
return (gl->flag);
}
int get_next_line(int const fd, char **line)
{
static char *save;
if (!save)
{
save = ft_strnew(BUFF_SIZE);
if (ft_loop(fd, line, &save) == 1)
return (1);
else if (ft_loop(fd, line, &save) == -1)
return (-1);
else
return (0);
}
if (save && ft_return_next_line(line, &save) == 1)
return (1);
else if (ft_loop(fd, line, &save) == 1)
return (1);
else if (ft_loop(fd, line, &save) == -1)
return (-1);
else
{
ft_strclr(*line);
*line = ft_strncat(*line, save, ft_cut_line(save));
}
return (0);
}
static int ft_fill_line(char **line, char **buf, int ret)
{
int n;
if (ret == -1)
*buf = NULL;
if (ret == -1)
return (-1);
if (ret == 0 && *buf[0] == '\0')
{
*buf = NULL;
*line = ft_strdup("\0");
return (0);
}
n = ft_strcchr(*buf, '\n');
if (n > -1)
{
*line = ft_strndup(*buf, n);
*buf += n + 1;
return (1);
}
else
{
*line = ft_strndup(*buf, ft_strlen(*buf));
ft_strclr(*buf);
return (1);
}
}
int ft_uns_long(char const *fl, va_list ap, t_print *gl)
{
gl->f = 2;
gl->i = 0;
if (fl[gl->l - gl->f] == 'l' || fl[gl->l - gl->f] == 'h')
gl->f++;
if (fl[gl->l - gl->f] == 'h' || fl[gl->l - gl->f] == 'j' ||
fl[gl->l - gl->f] == 'z')
gl->f++;
if (fl[gl->l - gl->f] == 'l')
return (ft_uns_long_long(fl, ap, gl));
if (ft_isdigit(fl[gl->l - gl->f]) || fl[gl->l - gl->f] == '*')
gl->p = ft_precision_str(fl, ap, gl);
if (fl[gl->l - gl->f] == '.')
gl->f++;
if (ft_isdigit(fl[gl->l - gl->f]) || fl[gl->l - gl->f] == '*')
gl->larg = ft_width_str(fl, ap, gl);
if (gl->inv == 2)
ft_swap(&gl->p, &gl->larg);
if (fl[gl->l - gl->f] == ' ' || fl[gl->l - gl->f] == '#' ||
fl[gl->l - gl->f] == '-' || fl[gl->l - gl->f] == '+' ||
fl[gl->l - gl->f] == '%')
gl->flag = ft_flag_unsl(fl, ap, gl);
ft_strclr(gl->s);
return (gl->flag);
}
int read_user(t_list *head)
{
char read_char[4] = {0};
while (42)
{
tputs(tgetstr("cl", NULL), 1, ft_putschar);
so_printed(head);
print_cursor(head);
ft_strclr(read_char);
read(0, read_char, 3);
head = is_key(head, read_char);
head = is_spc(head, read_char);
if (read_char[0] == 10 && read_char[1] == 0)
return (0);
else if ((KEYDEL) || (KEYSUP))
{
head->slc = -1;
head = head->next;
if (head->next == head && head->slc == -1)
return (-1);
}
else if (read_char[0] == 27 && read_char[1] == 0)
return (-1);
}
return (0);
}
t_piece *ft_read(char *file, int *s, int caca)
{
int ret;
int fd;
char buff[BUFF_SIZE + 1];
int z;
t_piece *tetriminos;
z = 0;
tetriminos = malloc(sizeof(tetriminos) * 25);
ft_bzero(buff, sizeof(buff));
fd = ft_open_file(file);
while ((ret = read(fd, buff, BUFF_SIZE)))
{
z >= 26 ? ft_error() : 0;
ft_put_piece(buff, &tetriminos[z]);
caca = ret;
tetriminos[z].name = 'A' + z;
ft_strclr(buff);
z++;
}
caca == 21 ? ft_error() : 0;
!tetriminos[0].piece[0][0] ? ft_error() : 0;
*s = z;
close(fd);
ft_check_struct(tetriminos, z);
return (tetriminos);
}
int process_copypaste(char *key, int *pos, char **line)
{
static char *clip;
int x;
if (key[0] == 11)
{
if (clip)
free(clip);
clip = ft_strdup(*line + term_line_index(pos, line));
ft_strclr(*line + term_line_index(pos, line));
tputs(tgetstr("sc", NULL), 0, ft_outc);
x = ft_strlen(clip);
while (x--)
ft_putstr(" ");
tputs(tgetstr("rc", NULL), 0, ft_outc);
}
else if (key[0] == 25)
{
x = -1;
while (++x < (int)ft_strlen(clip))
insert_key(clip + x, line, pos);
}
return (0);
}
char *ft_strnew(size_t size)
{
char *ret;
if (!(ret = (char *)ft_memalloc(size)))
return (NULL);
ft_strclr(ret);
return (ret);
}
char *ft_strnew(size_t size)
{
char *s;
if (!(s = ft_memalloc(size + 1)))
return (NULL);
ft_strclr(s);
return (s);
}
char *ft_strnew(size_t size)
{
char *newstr;
if ((newstr = (char*)malloc(sizeof(char) * size + 1)) == NULL)
return (NULL);
ft_strclr(newstr);
return (newstr);
}
static int ft_no_new_line(char **line, char *buf, int j)
{
char *tmp;
if (!(tmp = (char *)gmalloc(sizeof(*tmp) * BUFF_SIZE * j + 1)))
return (-1);
ft_strclr(tmp);
ft_strcpy(tmp, *line);
gfree((void *)*line);
j++;
if (!(*line = (char *)gmalloc(sizeof(**line) * BUFF_SIZE * j + 1)))
return (-1);
ft_strclr(*line);
ft_strcpy(*line, tmp);
gfree((void *)tmp);
ft_strcat(*line, buf);
buf[0] = '\0';
return (j);
}
static void lst_next_noexist(t_lst **lst, char **key)
{
t_lst *tmp;
tmp = *lst;
tmp->select = 0;
tmp->next = NULL;
tmp->previous = NULL;
ft_strclr(tmp->str);
ft_strclr(tmp->strr);
free(tmp->str);
free(tmp->strr);
free(*lst);
tmp = NULL;
*lst = NULL;
(*key)[0] = 27;
(*key)[1] = 0;
(*key)[2] = 0;
}
void ft_top(int sock)
{
char buff[4096];
int ret;
write(sock, "avance\n", ft_strlen("avance\n"));
ret = read(sock, buff, 4096);
buff[ret] = '\0';
ft_strclr(buff);
}
void ft_right(int sock)
{
char buff[4096];
int ret;
write(sock, "droite\n", ft_strlen("droite\n"));
ret = read(sock, buff, 4096);
buff[ret] = '\0';
ft_strclr(buff);
}
void ft_left(int sock)
{
char buff[4096];
int ret;
write(sock, "gauche\n", ft_strlen("gauche\n"));
ret = read(sock, buff, 4096);
buff[ret] = '\0';
ft_strclr(buff);
}
void ft_expels(int sock)
{
char buff[4096];
int ret;
write(sock, "expulse\n", ft_strlen("expulse\n"));
ret = read(sock, buff, 4096);
buff[ret] = '\0';
ft_strclr(buff);
}
char *ft_strnew(size_t size)
{
char *ptr;
ptr = (char*)ft_memalloc(sizeof(char) * (size + 1));
if (!ptr)
return (NULL);
ptr[size] = '\0';
ft_strclr(ptr);
return (ptr);
}
char *ft_strnew(size_t size)
{
char *str;
str = NULL;
str = (char *)malloc(size + 1);
if (str == NULL)
return (NULL);
ft_strclr(str);
return (str);
}
char *ft_strnew(size_t size)
{
char *str;
size_t i;
i = 0;
str = (char *)malloc(sizeof(*str) * size + 1);
if (str)
ft_strclr(str);
return (str);
}
void test_strclr()
{
char ptr[20] = "bonjour";
ft_strclr(ptr);
ft_putstr("TEST STRCLR : ");
if (ptr[6] == '\0' && ptr[3] == '\0')
ft_putendl("ok :)");
else
ft_putendl("not ok :(");
}
void ft_reput_prompt(int a)
{
ft_reset();
tputs(tgetstr("do", NULL), 1, ft_putonterm);
tputs(tgetstr("cr", NULL), 1, ft_putonterm);
tputs(tgetstr("cd", NULL), 1, ft_putonterm);
ft_prompt(ft_stock(NULL, 1));
ft_strclr(g_e.buff);
g_e.i = 0;
(void)a;
}
static int ft_end(char **line, char **save)
{
if (ft_strlen(*save) != 0)
{
*line = ft_strdup(*save);
ft_strclr(*save);
return (1);
}
*line = ft_strdup(*save);
ft_strdel(save);
return (0);
}
int ft_return_next_line(char **line, char **save)
{
if (ft_strchr(*save, '\n') != NULL)
{
*line = ft_strnew(ft_strlen(*save));
ft_strclr(*line);
*line = ft_strncat(*line, *save, ft_cut_line(*save));
*save = ft_strchr(*save, '\n') + 1;
return (1);
}
return (0);
}
