[FDF] ft_make_layer

type.h

typedef	struct s_layer_len
{
  int   x;
  int   y;
} t_layer_len;

typedef struct  s_oneline
{
  char    *data;
  size_t  data_size;
  void    *next;
} t_oneline;

main문

#include <stdio.h>
#include <stdlib.h>
#include <mlx.h>

#include <mlx_type.h>
#include <get_next_line.h>

t_oneline	*ft_new_oneline(char const *data)
{
	t_oneline   *new_oneline;

	new_oneline = (t_oneline *)malloc(sizeof(t_oneline));
	if (!new_oneline)
		return (NULL);
    ft_memset(new_oneline, 0, sizeof(t_oneline));
	if (!data)
		return (new_oneline);
    new_oneline->data_size = ft_strlen(data);
	new_oneline->data = malloc(new_oneline->data_size);
	if (!new_oneline->data)
		return (NULL);
	ft_memcpy(new_oneline->data, data, new_oneline->data_size);
	return (new_oneline);
}

t_oneline	*ft_oneline_add(t_oneline **oneline_ptr, char const *data)
{
	t_oneline   *new_oneline;
    t_oneline   *tmp_oneline;
    
    tmp_oneline = *oneline_ptr;
    new_oneline = ft_new_oneline(data);
    if (!tmp_oneline)
    {
        *oneline_ptr = new_oneline;
        return (new_oneline);
    }
    while (tmp_oneline->next)
        tmp_oneline = tmp_oneline->next;
    tmp_oneline->next = new_oneline;
    return (new_oneline);
}

t_oneline *readfile(char *file_name)
{
    t_oneline   *head_oneline;
    
    char  *line;
    int   fd1;

    head_oneline = NULL;
    fd1 = open(file_name, O_RDONLY);
    while (get_next_line(fd1, &line) > 0)
        ft_oneline_add(&head_oneline, line);
    return (head_oneline);
}

int		ft_atoi_move(char **str_ptr)
{
	int num;
	int sign;

	sign = 1;
	num = 0;
	while ((0x09 <= **str_ptr && **str_ptr <= 0x0D) || **str_ptr == 0x20)
		(*str_ptr)++;
	if ((**str_ptr == '-' || **str_ptr == '+'))
    {
	    if (**str_ptr == '-')
            sign = -1;
        (*str_ptr)++;
    }
	while (0x30 <= **str_ptr && **str_ptr <= 0x39)
		num = (num * 10) + (*(*str_ptr)++ - 0x30);
	return (num * sign);
}

int ft_int_layer_y_len(t_oneline *head_oneline)
{
    int y_len;

    y_len = 0;
    while (head_oneline)
    {
        head_oneline = head_oneline->next;
        y_len++;
    }
    return (y_len);
}

int ft_int_layer_x_len(t_oneline *head_oneline)
{
    int     x_len;
    int     flag;
    char    *str;

    x_len = 0;
    flag = 1;
    str = head_oneline->data;
    while (*str)
    {
        if ((0x09 <= *str && *str <= 0x0D) || *str == 0x20)
            flag = 1;
        else if ((0x30 <= *str && *str <= 0x39) || *str == '-' || *str == '+')
        {
            if (flag && flag--)
                x_len++;
        }
        else 
            return (0);
        str++;
    }
    return (x_len);
}


int *ft_make_layer_1D(t_oneline *head_oneline)
{
    int     *layer_1D;
    int     index;
    int     x_len;
    char    *str;

    index = 0;
    str = head_oneline->data;
    x_len = ft_int_layer_x_len(head_oneline);
    layer_1D = (int *)malloc(sizeof(int) * (x_len));
    if (!layer_1D)
        return (NULL);
    while (*str)
        layer_1D[index++] = ft_atoi_move(&str);
    return (layer_1D);
}

int **ft_make_layer_2D(t_oneline *head_oneline)
{
    int **layer_2D;
    int index;
    int y_len;

    if (!head_oneline)
        return (NULL);
    index = 0;
    y_len = ft_int_layer_y_len(head_oneline);
    layer_2D = (int **)malloc(sizeof(int *) * (y_len));
    if (!layer_2D)
        return (NULL);
    while (head_oneline)
    {
        layer_2D[index++] = ft_make_layer_1D(head_oneline);
        head_oneline = head_oneline->next;
    }
    return (layer_2D);
}

void ft_print_layer_2D(int **layer_2D, t_layer_len c_layer_len)
{
    int x = 0;
    int y = 0;
    while (y < c_layer_len.y)
    {
        x= 0;
        while (x < c_layer_len.x)
        {
            printf("%d\t", layer_2D[y][x]);
            x++;
        }
        printf("\n");
        y++;

    }
    printf("\n");
}

int **ft_make_layer(char *file_name)
{
    t_oneline   *head_oneline;
    t_dot   *head_dot;
    int     **layer_2D;
    t_layer_len c_layer_len;



    head_oneline = readfile(file_name);
    if (!head_oneline)
        return (NULL);
    c_layer_len.x = ft_int_layer_x_len(head_oneline);
    c_layer_len.y = ft_int_layer_y_len(head_oneline);
    layer_2D = ft_make_layer_2D(head_oneline);
    ft_print_layer_2D(layer_2D, c_layer_len);
    return (layer_2D);
}

int main(int ac, char **av)
{
    t_dot   *head_dot;
    int     **layer_2D;

    layer_2D = ft_make_layer(av[1]);
    if (layer_2D)
        return 0;

	return (0);
}

결과

kyoulee@kyouleeui-MacBookAir run % cat test.fdf 
1 2 3 4 5 6 7 8 9 10 
11 12 13 14 15 16 17 18 19 20
21 22 23 24 25 26 27 28 29 30
31 32 33 34 35 36 37 38 39 40
41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 
61 62 63 64 65 66 67 68 69 70
71 72 73 74 75 76 77 78 79 80
81 82 83 84 85 86 87 88 89 90
91 92 93 94 95 96 97 98 99 100
kyoulee@kyouleeui-MacBookAir run % ./a.out test.fdf 
1       2       3       4       5       6       7       8       9       10
11      12      13      14      15      16      17      18      19      20
21      22      23      24      25      26      27      28      29      30
31      32      33      34      35      36      37      38      39      40
41      42      43      44      45      46      47      48      49      50
51      52      53      54      55      56      57      58      59      60
61      62      63      64      65      66      67      68      69      70
71      72      73      74      75      76      77      78      79      80
81      82      83      84      85      86      87      88      89      90
91      92      93      94      95      96      97      98      99      100

kyoulee@kyouleeui-MacBookAir run %

이걸 만들고 

조금 문제가 있다 느겼다 

x와 y가 일정하지 않다면 점이 꼭 사각형이 아니라면 그것을 해결하기 위해 다시 생각하게 됨