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> +#+ +:+ +#+ # # By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2019/03/27 16:51:02 by tmaze #+# #+# # # 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 INCDIR = includes libft/includes
# Source files # Source files
SRC = lm_parser.c \ SRC = lm_parser.c \
lm_mem_utils.c \ lm_mem_utils.c \
lm_graph_utils.c \ lm_check_errors.c \
lm_check_errors.c \ lm_data_utils.c \
bfs.c \ lm_initdata.c \
lst_ind.c \ lm_mem_utils.c \
edmunds_karp.c \ lm_graph_utils.c \
push_ants.c \ lm_parser_error_check.c \
# lem_in.c lm_utils_parser.c \
bfs.c \
lst_ind.c \
edmunds_karp.c \
push_ants.c \
lem_in.c
OBJ = $(SRC:.c=.o) OBJ = $(SRC:.c=.o)

47
includes/lem_in.h
View File

@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */ /* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/23 17:31:19 by tmaze #+# #+# */ /* 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 nbants;
int nb_nodes; int nb_nodes;
t_list *nodes;
t_node *nodes_data; t_node *nodes_data;
t_ind **adj; t_ind **adj;
} t_lmdata; } t_lmdata;
@ -67,6 +66,10 @@ typedef struct s_syntax
int s_cmd; int s_cmd;
int s_pos; int s_pos;
int error; int error;
int s_error;
int e_error;
int v_error;
int l_error;
int s_vert; int s_vert;
int e_vert; int e_vert;
int gr_status; int gr_status;
@ -99,10 +102,15 @@ typedef struct s_AdjList
t_adjlist *head; t_adjlist *head;
} t_adj; } t_adj;
typedef struct s_lm_adj
{
t_ind *head;
} t_lm_adj;
typedef struct s_graph typedef struct s_graph
{ {
int v; int v;
t_adj *array; t_lm_adj *array;
} t_graph; } t_graph;
typedef struct s_neighbour typedef struct s_neighbour
@ -111,32 +119,45 @@ typedef struct s_neighbour
struct s_neighbor *next; struct s_neighbor *next;
} t_neighbor; } t_neighbor;
typedef struct s_rdata
{
char *line;
struct s_rdata *next;
} t_rdata;
//MT-FUNCTIONS //MT-FUNCTIONS
int lm_error_exit(int flag); int lm_error_exit(void);
int lm_validate(t_syntax *synt, t_lmdata *lmdata); int lm_validate(t_syntax *synt, t_lmdata *lmdata);
void lm_parser(int fd, t_syntax *synt, t_lmdata *ldata, int lm_parser(t_syntax *synt, t_lmdata *ldata
t_holder *holder); , t_holder *holder);
int lm_check_room_before(char **tab, t_syntax *synt); 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);
int lm_add_vertex(t_lmdata *ldata, char *raw, char flag, t_syntax *synt); t_adjlist *lm_new_node(int dest);
t_adjlist *lm_new_node(int dest);
t_graph *lm_creategraph(int v); t_graph *lm_creategraph(int v);
void lm_add_edge(t_graph *graph, int src, int dest); 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_ext_conn(t_holder *holder, t_lmdata *data, char *raw);
int lm_find_index(t_lmdata *data, char *str); 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); void lm_initdata(t_lmdata *data);
int lm_getparams(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); t_ind *lst_indadd(t_ind **lst, int ind);
void lst_inddel(t_ind **lst); void lst_inddel(t_ind **lst);
void tablst_inddel(t_ind **tab); void tablst_inddel(t_ind **tab);
void bfs(t_lmdata *data, t_bfs *tab, int start_ind, int end_ind); 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); 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 #endif

3
srcs/edmunds_karp.c
View File

@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */ /* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/28 16:21:19 by tmaze #+# #+# */ /* 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; int nb_path;
nb_path = 0; nb_path = 0;
ft_printf("data: %p\ndata->adj: %p\n\n", data, data->adj);
if (data && data->adj) if (data && data->adj)
{ {
bfs(data, tab, start_ind, end_ind); bfs(data, tab, start_ind, end_ind);

159
srcs/lem_in.c
View File

@ -6,65 +6,134 @@
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */ /* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/25 06:31:05 by mndhlovu #+# #+# */ /* 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" #include "lem_in.h"
int lm_error_exit(int flag) int lm_error_exit(void)
{ {
if (flag == 0) ft_putendl_fd("ERROR", 2);
ft_printf("Invalid Map\n"); return (1);
if (flag == 1) }
ft_printf("Usage ./lem_in < map-file\n");
if (flag == 2) void ft_print_graph(t_graph *graph)
ft_printf("Error opening the Map file\n"); {
return (1); 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) int main(int ac, char **av)
{ {
t_syntax synt; t_syntax synt;
//t_graph graph; t_lmdata ldata;
t_lmdata ldata; t_holder holder;
t_holder holder; t_ind **ret;
int fd;
t_node *it; t_node *it;
t_node *start; t_node *start;
t_node *end; t_node *end;
t_ind *it2;
int i;
if (ac == 2) (void)av;
{ i = 0;
if ((fd = open (av[1], O_RDONLY)) < -1) if (ac == 1)
return (lm_error_exit(2)); {
lm_init_data(&synt, &ldata, &holder); lm_init_data(&synt, &holder, &ldata);
lm_parser(fd, &synt, &ldata, &holder); if (!(lem_in(&synt, &holder, &ldata)))
if (lm_validate(&synt, &ldata)) return (lm_error_exit());
{ it = ldata.nodes_data;
//validation works start = NULL;
ft_printf("Success\n"); end = NULL;
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); while (it && (!start || !end))
it = ldata.nodes_data; {
while (it && it->role != 's') 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); it2 = ret[i];
it = it->next; 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; push_ants(&ldata, ret, i);
it = ldata.nodes_data; tablst_inddel(ret);
while (it && it->role != 'e') i = 0;
{ while (i < ldata.nb_nodes)
ft_printf("=== node ===\nindex: %d\nrole: %c\n\n", it->ind, it->role); {
it = it->next; lst_inddel(&(ldata.adj[i]));
} i++;
ft_printf("=== node ===\nindex: %d\nrole: %c\n\n", it->ind, it->role); }
end = it; ft_memdel((void**)&(ldata.adj));
edmunds_karp(&ldata, start->ind, end->ind); return (0);
} }
else return (1);
ft_printf("Fail\n");
}
return (0);
} }

30
srcs/lm_check_errors.c
View File

@ -6,7 +6,7 @@
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */ /* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/02 08:39:09 by mndhlovu #+# #+# */ /* 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) int lm_check_room_before(char **tab, t_syntax *synt)
{ {
if ((ft_atoi(tab[1]) > INT_MIN && ft_atoi(tab[1]) < INT_MAX) if (tab[0] != NULL && tab[1] != NULL && tab[2] != NULL)
&& (ft_atoi(tab[2]) > INT_MIN && ft_atoi(tab[2]) < INT_MAX) {
&& !(*tab[0] == 'L' || *tab[0] == '#')) if (!lm_validate_rooms(tab[0], tab[1], tab[2]))
{ {
return (1); synt->v_error = 1;
} return (0);
else }
{ }
synt->error = 1; return (1);
return (0); }
}
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> +#+ +:+ +#+ */ /* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/29 07:17:06 by mndhlovu #+# #+# */ /* 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" #include "lem_in.h"
int lm_adj_parser(t_lmdata *lmdata, t_holder *holder)
t_adjlist *lm_new_node(int dest)
{ {
t_adjlist *newnode; t_temp *data;
if (!(newnode = (t_adjlist *)malloc(sizeof(t_adjlist)))) if (holder != NULL)
return (NULL); {
newnode->dest = dest; data = holder->data;
newnode->next = NULL; if (data != NULL)
return (newnode); {
} while (data)
{
t_graph *lm_creategraph(int v) lst_indadd_link(lmdata, data->src_ind, data->dest_ind);
{ data = data->next;
t_graph *newgraph; }
int index; return (1);
}
index = -1; }
if (!(newgraph = (t_graph *)malloc(sizeof(t_graph)))) return (0);
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;
} }

4
srcs/lm_initdata.c
View File

@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */ /* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/23 17:43:34 by tmaze #+# #+# */ /* 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) void lm_initdata(t_lmdata *data)
{ {
data->nbants = 0; data->nbants = 0;
data->nodes = NULL; data->nodes_data = NULL;
data->adj = NULL; data->adj = NULL;
} }

44
srcs/lm_mem_utils.c
View File

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

190
srcs/lm_parser.c
View File

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

7
srcs/lst_ind.c
View File

@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */ /* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/27 14:56:55 by tmaze #+# #+# */ /* 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) 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); return (data->adj);
} }
int lst_indadd_link(t_lmdata *data, int n1, int n2) 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) 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> +#+ +:+ +#+ */ /* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/06 11:37:56 by tmaze #+# #+# */ /* 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" #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 *new;
t_ants *it; t_ants *it;
if ((new = (t_ants*)ft_memalloc(sizeof(t_ants))) != NULL) 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_path = nb_path;
new->nb_node = paths[nb_path]->index; new->nb_node = paths[nb_path]->index;
new->end = 0; new->end = 0;
@ -59,7 +59,7 @@ t_node *get_node(t_lmdata *data, int index)
return (it); 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 *ants;
t_ants *it; 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]; char has_start[nb_paths];
ant_c = 1; ant_c = 1;
ants = NULL;
ft_bzero(has_start, nb_paths); 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 ; return ;
ant_c++;
has_start[0] = 1; has_start[0] = 1;
while (ants) while (ants)
{ {
i = 0; i = 0;
while (i < nb_paths) 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); del_ants(&ants);
return ; return ;
} }
ant_c++;
has_start[i] = 1; has_start[i] = 1;
i++;
} }
i++;
}
it = ants; it = ants;
while (it) 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); ft_memdel((void**)&it);
} }
it = ants; it = ants;
while (it->next && it->next->end) while (it && it->next && it->next->end)
{ {
tmp = it->next; tmp = it->next;
it->next = tmp->next; it->next = tmp->next;