tvdu29/lem_in
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

IT WORKS !

Browse Source 
functionning ./lem_in that can read maps and display ants path
still need to clean leaks
still need remove debug info
This commit is contained in:
Tanguy MAZE 2019-04-09 19:09:29 +02:00
parent 434b629055
commit 3b893147e5
11 changed files with 364 additions and 235 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
Makefile
View File

@ -6,7 +6,7 @@
# By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2019/03/27 16:51:02 by tmaze #+# #+# #
# Updated: 2019/04/06 13:46:23 by tmaze ### ########.fr #
# Updated: 2019/04/09 18:17:50 by tmaze ### ########.fr #
# #
#******************************************************************************#
@ -36,15 +36,20 @@ OBJDIR = objs
INCDIR = includes libft/includes
# Source files
SRC = lm_parser.c \
lm_mem_utils.c \
lm_graph_utils.c \
lm_check_errors.c \
bfs.c \
lst_ind.c \
edmunds_karp.c \
push_ants.c \
# lem_in.c
SRC = lm_parser.c \
lm_mem_utils.c \
lm_check_errors.c \
lm_data_utils.c \
lm_initdata.c \
lm_mem_utils.c \
lm_graph_utils.c \
lm_parser_error_check.c \
lm_utils_parser.c \
bfs.c \
lst_ind.c \
edmunds_karp.c \
push_ants.c \
lem_in.c
OBJ = $(SRC:.c=.o)

47
includes/lem_in.h
View File

@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/23 17:31:19 by tmaze #+# #+# */
/* Updated: 2019/04/06 13:49:17 by tmaze ### ########.fr */
/* Updated: 2019/04/09 18:35:50 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
@ -38,7 +38,6 @@ typedef struct s_lmdata
{
int nbants;
int nb_nodes;
t_list *nodes;
t_node *nodes_data;
t_ind **adj;
} t_lmdata;
@ -67,6 +66,10 @@ typedef struct s_syntax
int s_cmd;
int s_pos;
int error;
int s_error;
int e_error;
int v_error;
int l_error;
int s_vert;
int e_vert;
int gr_status;
@ -99,10 +102,15 @@ typedef struct s_AdjList
t_adjlist *head;
} t_adj;
typedef struct s_lm_adj
{
t_ind *head;
} t_lm_adj;
typedef struct s_graph
{
int v;
t_adj *array;
t_lm_adj *array;
} t_graph;
typedef struct s_neighbour
@ -111,32 +119,45 @@ typedef struct s_neighbour
struct s_neighbor *next;
} t_neighbor;
typedef struct s_rdata
{
char *line;
struct s_rdata *next;
} t_rdata;
//MT-FUNCTIONS
int lm_error_exit(int flag);
int lm_error_exit(void);
int lm_validate(t_syntax *synt, t_lmdata *lmdata);
void lm_parser(int fd, t_syntax *synt, t_lmdata *ldata,
t_holder *holder);
int lm_check_room_before(char **tab, t_syntax *synt);
void lm_init_data(t_syntax *synt, t_lmdata *ldata, t_holder *holder);
int lm_add_vertex(t_lmdata *ldata, char *raw, char flag, t_syntax *synt);
t_adjlist *lm_new_node(int dest);
int lm_parser(t_syntax *synt, t_lmdata *ldata
, t_holder *holder);
int lm_check_room_before(char **tab, t_syntax *synt);
int lm_add_vertex(t_lmdata *ldata, char *raw, char flag, t_syntax *synt);
t_adjlist *lm_new_node(int dest);
t_graph *lm_creategraph(int v);
void lm_add_edge(t_graph *graph, int src, int dest);
int lm_ext_conn(t_holder *holder, t_lmdata *data, char *raw);
int lm_find_index(t_lmdata *data, char *str);
int lm_get_value(char *line);
void lm_get_cmd_vert(int count, t_syntax *synt
, t_lmdata *ldata, char *line);
void lm_get_vert_link(int count, t_syntax *synt, t_lmdata *ldata
, t_holder *holder, char *line);
int lm_validate_rooms(char *name, char *x, char *y);
int lm_adj_parser(t_lmdata *lmdata, t_holder *holder);
void lm_init_data(t_syntax *synt, t_holder *holder, t_lmdata *ldata);
void lm_initdata(t_lmdata *data);
int lm_getparams(t_lmdata *data);
t_ind **lst_indinit(t_lmdata *data);
int lst_indadd_link(t_lmdata *data, int n1, int n2);
t_ind *lst_indadd(t_ind **lst, int ind);
void lst_inddel(t_ind **lst);
void tablst_inddel(t_ind **tab);
void bfs(t_lmdata *data, t_bfs *tab, int start_ind, int end_ind);
t_ind **edmunds_karp(t_lmdata *data, int start_ind, int end_ind);
void push_ants(t_lmdata *data, t_ind **paths, int nb_paths);
#endif

3
srcs/edmunds_karp.c
View File

@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/28 16:21:19 by tmaze #+# #+# */
/* Updated: 2019/04/07 12:50:24 by tmaze ### ########.fr */
/* Updated: 2019/04/08 18:49:53 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
@ -93,6 +93,7 @@ t_ind **edmunds_karp(t_lmdata *data, int start_ind, int end_ind)
int nb_path;
nb_path = 0;
ft_printf("data: %p\ndata->adj: %p\n\n", data, data->adj);
if (data && data->adj)
{
bfs(data, tab, start_ind, end_ind);

159
srcs/lem_in.c
View File

@ -6,65 +6,134 @@
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/25 06:31:05 by mndhlovu #+# #+# */
/* Updated: 2019/04/05 14:40:50 by tmaze ### ########.fr */
/* Updated: 2019/04/09 19:08:36 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "lem_in.h"
int lm_error_exit(int flag)
int lm_error_exit(void)
{
if (flag == 0)
ft_printf("Invalid Map\n");
if (flag == 1)
ft_printf("Usage ./lem_in < map-file\n");
if (flag == 2)
ft_printf("Error opening the Map file\n");
return (1);
ft_putendl_fd("ERROR", 2);
return (1);
}
void ft_print_graph(t_graph *graph)
{
int v;
t_ind *crawl;
v = -1;
while (++v < graph->v)
{
crawl = graph->array[v].head;
printf("\n Adjacency list of vertex %d\n head", v);
while (crawl)
{
printf("->%d",crawl->index);
crawl = crawl->next;
}
printf("\n");
}
}
void lm_print_report(t_lmdata *ldata, t_syntax *synt, t_holder *holder)
{
t_node *nodes;
t_temp *data;
if (ldata != NULL)
{
nodes = ldata->nodes_data;
while (nodes)
{
ft_printf("name: %s x: %d y: %d index: %d role: %c\n", nodes->name, nodes->x, nodes->y, nodes->ind, nodes->role);
nodes = nodes->next;
}
}
if (holder != NULL)
{
data = holder->data;
while (data)
{
ft_printf("src: %d - dest: %d\n", data->src_ind, data->dest_ind);
data = data->next;
}
}
ft_printf("nb_state: %d\n s_cmd: %d\n e_cmd: %d\n s_error: %d\n e_rror: %d\n v_error: %d\n l_error: %d\n",
synt->nb_state, synt->s_cmd, synt->e_cmd, synt->s_error, synt->e_error, synt->v_error, synt->l_error);
}
static int lem_in(t_syntax *synt, t_holder *holder,
t_lmdata *lmdata)
{
if (!(lm_parser(synt, lmdata, holder)))
return (0);
if (!lst_indinit(lmdata))
return (0);
if (!(lm_adj_parser(lmdata, holder)))
return (0);
return (1);
}
int main(int ac, char **av)
{
t_syntax synt;
//t_graph graph;
t_lmdata ldata;
t_holder holder;
int fd;
t_syntax synt;
t_lmdata ldata;
t_holder holder;
t_ind **ret;
t_node *it;
t_node *start;
t_node *end;
t_ind *it2;
int i;
if (ac == 2)
{
if ((fd = open (av[1], O_RDONLY)) < -1)
return (lm_error_exit(2));
lm_init_data(&synt, &ldata, &holder);
lm_parser(fd, &synt, &ldata, &holder);
if (lm_validate(&synt, &ldata))
{
//validation works
ft_printf("Success\n");
ft_printf("=== ldata ===\nnbants: %d\nnb_nodes: %d\nnodes: %p\nnodes_data: %p\nadj: %d\n\n", ldata.nbants, ldata.nb_nodes, ldata.nodes, ldata.nodes_data, ldata.adj);
it = ldata.nodes_data;
while (it && it->role != 's')
(void)av;
i = 0;
if (ac == 1)
{
lm_init_data(&synt, &holder, &ldata);
if (!(lem_in(&synt, &holder, &ldata)))
return (lm_error_exit());
it = ldata.nodes_data;
start = NULL;
end = NULL;
while (it && (!start || !end))
{
if (it->role == 's')
start = it;
else if (it->role == 'e')
end = it;
it = it->next;
}
ft_printf("data->adj: %p\n", ldata.adj);
if ((!start) || (ret = edmunds_karp(&ldata, start->ind, end->ind)) == NULL)
return (lm_error_exit());
if (ret != NULL)
{
i = 0;
while (ret[i])
{
ft_printf("=== node ===\nindex: %d\nrole: %c\n\n", it->ind, it->role);
it = it->next;
it2 = ret[i];
while (it2)
{
ft_printf(" %d -> ", it2->index);
it2 = it2->next;
}
ft_putchar('\n');
i++;
}
ft_printf("=== node ===\nindex: %d\nrole: %c\n\n", it->ind, it->role);
start = it;
it = ldata.nodes_data;
while (it && it->role != 'e')
{
ft_printf("=== node ===\nindex: %d\nrole: %c\n\n", it->ind, it->role);
it = it->next;
}
ft_printf("=== node ===\nindex: %d\nrole: %c\n\n", it->ind, it->role);
end = it;
edmunds_karp(&ldata, start->ind, end->ind);
}
else
ft_printf("Fail\n");
}
return (0);
}
push_ants(&ldata, ret, i);
tablst_inddel(ret);
i = 0;
while (i < ldata.nb_nodes)
{
lst_inddel(&(ldata.adj[i]));
i++;
}
ft_memdel((void**)&(ldata.adj));
return (0);
}
return (1);
}

30
srcs/lm_check_errors.c
View File

@ -6,7 +6,7 @@
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/02 08:39:09 by mndhlovu #+# #+# */
/* Updated: 2019/04/02 08:39:22 by mndhlovu ### ########.fr */
/* Updated: 2019/04/08 15:43:01 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,15 +14,21 @@
int lm_check_room_before(char **tab, t_syntax *synt)
{
if ((ft_atoi(tab[1]) > INT_MIN && ft_atoi(tab[1]) < INT_MAX)
&& (ft_atoi(tab[2]) > INT_MIN && ft_atoi(tab[2]) < INT_MAX)
&& !(*tab[0] == 'L' || *tab[0] == '#'))
{
return (1);
}
else
{
synt->error = 1;
return (0);
}
if (tab[0] != NULL && tab[1] != NULL && tab[2] != NULL)
{
if (!lm_validate_rooms(tab[0], tab[1], tab[2]))
{
synt->v_error = 1;
return (0);
}
}
return (1);
}
int lm_verify_cmd(t_syntax *synt)
{
if (synt->s_cmd && synt->e_cmd && synt->v_error
&& synt->l_error && synt->e_error)
return (1);
return (0);
}

63
srcs/lm_graph_utils.c
View File

@ -6,57 +6,28 @@
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/29 07:17:06 by mndhlovu #+# #+# */
/* Updated: 2019/03/29 07:17:26 by mndhlovu ### ########.fr */
/* Updated: 2019/04/09 18:18:59 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "lem_in.h"
t_adjlist *lm_new_node(int dest)
int lm_adj_parser(t_lmdata *lmdata, t_holder *holder)
{
t_adjlist *newnode;
t_temp *data;
if (!(newnode = (t_adjlist *)malloc(sizeof(t_adjlist))))
return (NULL);
newnode->dest = dest;
newnode->next = NULL;
return (newnode);
}
t_graph *lm_creategraph(int v)
{
t_graph *newgraph;
int index;
index = -1;
if (!(newgraph = (t_graph *)malloc(sizeof(t_graph))))
return (NULL);
newgraph->v = v;
//create an array of adjacency list. size of array will be v
if (!(newgraph->array = (t_adj *)malloc(sizeof(t_adj) * v)))
return (NULL);
while (++index < v)
newgraph->array[
index].head = NULL;
return (newgraph);;
}
void lm_add_edge(t_graph *graph, int src, int dest)
{
t_adjlist *newnode;
/*
* Add an edge from src to dest. A new node is added to the adjacency list of
* src. The node is added at the beginning
*/
newnode = lm_new_node(dest);
newnode->next = graph->array[src].head;
graph->array[src].head = newnode;
/*
* Since graph is undirected, add an edge from dest to src also
*/
newnode = lm_new_node(src);
newnode->next = graph->array[dest].head;
graph->array[dest].head = newnode;
if (holder != NULL)
{
data = holder->data;
if (data != NULL)
{
while (data)
{
lst_indadd_link(lmdata, data->src_ind, data->dest_ind);
data = data->next;
}
return (1);
}
}
return (0);
}

4
srcs/lm_initdata.c
View File

@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/23 17:43:34 by tmaze #+# #+# */
/* Updated: 2019/03/23 17:45:09 by tmaze ### ########.fr */
/* Updated: 2019/04/08 18:26:13 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
@ -15,6 +15,6 @@
void lm_initdata(t_lmdata *data)
{
data->nbants = 0;
data->nodes = NULL;
data->nodes_data = NULL;
data->adj = NULL;
}

44
srcs/lm_mem_utils.c
View File

@ -6,34 +6,41 @@
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/25 06:31:37 by mndhlovu #+# #+# */
/* Updated: 2019/03/25 06:31:45 by mndhlovu ### ########.fr */
/* Updated: 2019/04/09 18:27:36 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "lem_in.h"
void lm_init_data(t_syntax *synt, t_lmdata *ldata,
t_holder *holder)
// void lm_destroy_data(t_syntax *synt, t_holder *holder, t_lmdata *ldata)
// {
// // destroy and free memory
// }
void lm_init_data(t_syntax *synt, t_holder *holder, t_lmdata *ldata)
{
synt->nb_state = 0;
synt->s_cmd = 0;
synt->s_pos = 0;
synt->e_cmd = 0;
synt->e_pos = 0;
synt->gr_status = 0;
synt->error = 0;
synt->e_vert = 0;
synt->s_error = 0;
synt->e_error = 0;
synt->v_error = 0;
synt->l_error = 0;
synt->s_vert = 0;
synt->e_vert = 0;
synt->gr_status = 0;
synt->s_pos = 0;
synt->e_pos = 0;
synt->v_flag = 0;
holder->count = 0;
holder->data = NULL;
ldata->nbants = 0;
ldata->nb_nodes = 0;
ldata->nodes_data = NULL;
ldata->nodes = NULL;
ldata->adj = NULL;
holder->count = 0;
holder->data = NULL;
ldata->adj = NULL;
}
static void lm_add_vertex_sub(t_lmdata *ldata, t_node *new)
static void lm_add_vertex_sub(t_lmdata *ldata, t_node *new)
{
t_node *tmp;
@ -49,7 +56,7 @@ static void lm_add_vertex_sub(t_lmdata *ldata, t_node *new)
(ldata->nb_nodes)++;
}
int lm_add_vertex(t_lmdata *ldata, char *raw, char flag,
int lm_add_vertex(t_lmdata *ldata, char *raw, char flag,
t_syntax *synt)
{
char **tab;
@ -75,9 +82,9 @@ int lm_add_vertex(t_lmdata *ldata, char *raw, char flag,
return (0);
}
int lm_find_index(t_lmdata *data, char *str)
int lm_find_index(t_lmdata *data, char *str)
{
t_node *nodes;
t_node *nodes;
nodes = data->nodes_data;
while (nodes)
@ -89,8 +96,7 @@ int lm_find_index(t_lmdata *data, char *str)
return (-1);
}
int lm_ext_conn(t_holder *holder, t_lmdata *data,
char *raw)
int lm_ext_conn(t_holder *holder, t_lmdata *data, char *raw)
{
char **tab;
t_temp *temp;
@ -103,6 +109,7 @@ int lm_ext_conn(t_holder *holder, t_lmdata *data,
{
new->src_ind = lm_find_index(data, tab[0]);
new->dest_ind = lm_find_index(data, tab[1]);
new->next = NULL;
if (holder->data == NULL)
holder->data = new;
else
@ -111,7 +118,6 @@ int lm_ext_conn(t_holder *holder, t_lmdata *data,
while (temp->next)
temp = temp->next;
temp->next = new;
}
(holder->count)++;
return (1);

190
srcs/lm_parser.c
View File

@ -6,124 +6,168 @@
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/25 06:30:51 by mndhlovu #+# #+# */
/* Updated: 2019/03/25 06:30:57 by mndhlovu ### ########.fr */
/* Updated: 2019/04/08 15:44:55 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "lem_in.h"
static void lm_locate_cmd(int count, char *raw, t_syntax *synt)
// void lm_locate_cmd(t_syntax *synt)
// {
// char *line;
// char *tmp;
// int index;
// index = 0;
// while (ft_getline(&line) > 0)
// {
// tmp = ft_strchr(line, '#');
// if ((!synt->s_cmd || !synt->e_cmd) && (tmp != NULL && line[1] == '#'))
// {
// if (!synt->s_cmd)
// {
// if (ft_strcmp(tmp, "##start") == 0)
// {
// synt->s_cmd = 1;
// }
// }
// if (!synt->e_cmd)
// {
// if (ft_strcmp(tmp, "##end") == 0)
// {
// synt->e_cmd = 1;
// synt->e_pos = index;
// }
// }
// }
// index++;
// }
// }
void lm_locate_cd(int index, t_syntax *synt, char *line)
{
char *tmp;
tmp = ft_strchr(raw, '#');
if ((!synt->s_cmd || !synt->e_cmd) && (tmp != NULL && raw[1] == '#'))
tmp = ft_strchr(line, '#');
if ((!synt->s_cmd || !synt->e_cmd) && (tmp != NULL && line[1] == '#'))
{
if (!synt->s_cmd)
{
if (ft_strcmp(tmp, "##start"))
if (ft_strcmp(tmp, "##start") == 0)
{
synt->s_cmd = 1;
synt->e_pos = count;
synt->s_pos = index;
}
}
if (!synt->e_cmd)
{
if (ft_strcmp(tmp, "##end"))
if (ft_strcmp(tmp, "##end") == 0)
{
synt->e_cmd = 1;
synt->s_pos = count;
synt->e_pos = index;
}
}
}
}
static int lm_get_vertices(int count, char *raw, t_syntax *synt,
t_lmdata *data, t_holder *holder)
{
int index;
char *tmp;
char *tmp2;
int value;
// void lm_locate_cmd(t_syntax *synt)
// {
// char *line;
// char *tmp;
// int index;
index = 0;
value = 0;
if (synt->s_cmd > 0 && (synt->e_pos == count - 1))
{
synt->s_vert = count;
return (lm_add_vertex(data, raw, 'e', synt));
}
if (synt->e_cmd > 0 && (synt->s_pos == count - 1))
{
synt->e_vert = count;
return (lm_add_vertex(data, raw, 's', synt));
}
if (count > 0 && (count != synt->s_vert && count != synt->e_vert)
&& (count != synt->s_pos && count != synt->e_pos))
{
tmp = ft_strchr(raw, '-');
tmp2 = ft_strchr(raw, '#');
if (tmp == NULL && tmp2 == NULL)
return (lm_add_vertex(data, raw, 'v', synt));
else if (tmp2 == NULL && tmp != NULL)
return (lm_ext_conn(holder, data, raw));
}
return (1);
}
// index = 0;
// while (ft_getline(&line) > 0)
// {
// tmp = ft_strchr(line, '#');
// if ((!synt->s_cmd || !synt->e_cmd) && (tmp != NULL && line[1] == '#'))
// {
// if (!synt->s_cmd)
// {
// if (ft_strcmp(tmp, "##start") == 0)
// {
// synt->s_cmd = 1;
// }
// }
// if (!synt->e_cmd)
// {
// if (ft_strcmp(tmp, "##end") == 0)
// {
// synt->e_cmd = 1;
// synt->e_pos = index;
// }
// }
// }
// index++;
// }
// }
static void lm_get_ant_num(int count, char *raw, t_lmdata *ldata, t_syntax *synt)
// int lm_get_ant_num(t_lmdata *ldata, t_syntax *synt)
// {
// char *line;
// int value;
// if (ft_getline(&line) > 0)
// {
// value = lm_get_value(line);
// if (value != -1)
// {
// ldata->nbants = value;
// synt->nb_state = 1;
// return (1);
// }
// free(line);
// }
// return (0);
// }
int lm_get_ant_(int counter, t_lmdata *ldata, t_syntax *synt, char *line)
{
int index;
int value;
index = 0;
if (count == 0)
if (counter == 0)
{
if (!ft_isdigit(raw[index + 1]))
value = lm_get_value(line);
if (value != -1)
{
value = raw[index] - '0';
ldata->nbants = (value > 0) ? value : 0;
synt->nb_state = 1;
}
if (ft_isdigit(raw[index + 1]))
{
ldata->nbants = (ft_atoi(raw) > 0) ? ft_atoi(raw) : 0;
ldata->nbants = value;
synt->nb_state = 1;
return (1);
}
free(line);
}
return (0);
}
int lm_validate(t_syntax *synt, t_lmdata *lmdata)
static int lm_get_vertices(int count, t_syntax *synt,
t_lmdata *data, t_holder *holder, char *line)
{
if (!synt->nb_state || !synt->s_cmd || !synt->e_cmd || synt->error)
return (0);
if (lmdata->nbants == 0 || lmdata->nb_nodes == 0)
return (0);
return (1);
lm_get_cmd_vert(count, synt, data, line);
if (!synt->s_error && !synt->e_error)
{
lm_get_vert_link(count, synt, data, holder, line);
if (!synt->v_error && !synt->l_error)
return (1);
}
return (0);
}
void lm_parser(int fd, t_syntax *synt, t_lmdata *ldata,
t_holder *tmp_data)
int lm_parser(t_syntax *synt, t_lmdata *ldata,
t_holder *holder)
{
char *raw;
int ret;
int index;
index = 0;
while ((ret = get_next_line(fd, &raw)))
while (ft_getline(&raw) > 0)
{
if (ret == -1)
{
synt->error = 1;
return ;
}
lm_get_ant_num(index, raw, ldata, synt);
lm_locate_cmd(index, raw, synt);
if (!lm_get_vertices(index, raw, synt, ldata, tmp_data))
{
synt->error = 1;
return ;
}
if (!(lm_get_ant_(index, ldata, synt, raw)) && index == 0)
return (0);
lm_locate_cd(index, synt, raw);
if (!(lm_get_vertices(index, synt, ldata, holder, raw)))
return (0);
index++;
}
free(raw);
return (1);
}

7
srcs/lst_ind.c
View File

@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/27 14:56:55 by tmaze #+# #+# */
/* Updated: 2019/04/09 14:32:04 by tmaze ### ########.fr */
/* Updated: 2019/04/09 19:04:33 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,13 +14,14 @@
t_ind **lst_indinit(t_lmdata *data)
{
data->adj = (t_ind**)ft_memalloc(sizeof(t_ind*) * data->nb_nodes)
data->adj = (t_ind**)ft_memalloc(sizeof(t_ind*) * data->nb_nodes);
return (data->adj);
}
int lst_indadd_link(t_lmdata *data, int n1, int n2)
{
return (lst_indadd(&(data->adj[n1]), n2) && lst_indadd(&(data->adj[n2]), n1));
return (lst_indadd(&(data->adj[n1]), n2) && lst_indadd(&(data->adj[n2])
, n1));
}
t_ind *lst_indadd(t_ind **lst, int ind)

23
srcs/push_ants.c
View File

@ -6,20 +6,20 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/06 11:37:56 by tmaze #+# #+# */
/* Updated: 2019/04/08 13:40:41 by tmaze ### ########.fr */
/* Updated: 2019/04/09 18:54:54 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "lem_in.h"
t_ants *add_ant(t_ants **ants, int *nb_ant, int nb_path, t_ind **paths)
t_ants *add_ant(t_ants **ants, int nb_ant, int nb_path, t_ind **paths)
{
t_ants *new;
t_ants *it;
if ((new = (t_ants*)ft_memalloc(sizeof(t_ants))) != NULL)
{
new->nb_ant = *nb_ant++;
new->nb_ant = nb_ant;
new->nb_path = nb_path;
new->nb_node = paths[nb_path]->index;
new->end = 0;
@ -59,7 +59,7 @@ t_node *get_node(t_lmdata *data, int index)
return (it);
}
void push_ants(t_lmdata *data, t_ind **paths, int nb_paths, int nb_ants)
void push_ants(t_lmdata *data, t_ind **paths, int nb_paths)
{
t_ants *ants;
t_ants *it;
@ -69,24 +69,29 @@ void push_ants(t_lmdata *data, t_ind **paths, int nb_paths, int nb_ants)
char has_start[nb_paths];
ant_c = 1;
ants = NULL;
ft_bzero(has_start, nb_paths);
if (add_ant(&ants, &ant_c, 0, paths) == NULL)
if (add_ant(&ants, ant_c, 0, paths) == NULL)
return ;
ant_c++;
has_start[0] = 1;
while (ants)
{
i = 0;
while (i < nb_paths)
if (ant_c <= nb_ants && !has_start[i])
{
if (ant_c <= data->nbants && !has_start[i])
{
if (add_ant(&ants, &ant_c, i, paths) == NULL)
if (add_ant(&ants, ant_c, i, paths) == NULL)
{
del_ants(&ants);
return ;
}
ant_c++;
has_start[i] = 1;
i++;
}
i++;
}
it = ants;
while (it)
{
@ -110,7 +115,7 @@ void push_ants(t_lmdata *data, t_ind **paths, int nb_paths, int nb_ants)
ft_memdel((void**)&it);
}
it = ants;
while (it->next && it->next->end)
while (it && it->next && it->next->end)
{
tmp = it->next;
it->next = tmp->next;