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

Compare commits

merge into: tvdu29:master
Branches Tags
tvdu29:master
tvdu29:tmaze
tvdu29:Mthandazo42
...
pull from: tvdu29:Mthandazo42
Branches Tags
tvdu29:master
tvdu29:tmaze
tvdu29:Mthandazo42

1 Commits
master ... Mthandazo4

Author SHA1 Message Date
Mthandazo Ndhlovu
56537c0917 Semi Final Parser 
Parser working fine with valid maps.
only a few adjustments are yet to be made.
The adjustments will not affect the output
of the adjacency list.
FYI leaks like a garden pipe.
 2019-04-08 15:27:09 +02:00
9 changed files with 491 additions and 137 deletions
Show Stats Expand all files Collapse all files

93
srcs/lem_in.c
View File

@ -6,44 +6,91 @@
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/03/25 06:31:05 by mndhlovu #+# #+# */
/* Updated: 2019/03/25 06:31:09 by mndhlovu ### ########.fr */
/* Updated: 2019/04/08 15:15:17 by mndhlovu ### ########.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");
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, t_graph *graph)
{
if (!(lm_parser(synt, lmdata, holder)))
return (0);
graph = lm_creategraph(lmdata->nb_nodes);
if (!(lm_adj_parser(graph, holder)))
return (0);
ft_print_graph(graph);
return (1);
}
int main(int ac, char **av)
{
t_syntax synt;
//t_graph graph;
t_graph graph;
t_lmdata ldata;
t_holder holder;
int fd;
if (ac == 2)
(void)av;
if (ac == 1)
{
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");
}
else
ft_printf("Fail\n");
if (!(lm_init_memory(&synt, &holder, &ldata)))
return (lm_error_exit());
if (!(lem_in(&synt, &holder, &ldata, &graph)))
return (lm_error_exit());
return (0);
}
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:15:44 by mndhlovu ### ########.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);
}

39
srcs/lm_data_utils.c Normal file
View File

@ -0,0 +1,39 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lm_data_utils.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/05 06:35:40 by mndhlovu #+# #+# */
/* Updated: 2019/04/05 06:35:54 by mndhlovu ### ########.fr */
/* */
/* ************************************************************************** */
#include "lem_in.h"
t_rdata *lm_new_raw_line(char *raw)
{
t_rdata *line;
if (!(line = (t_rdata *)malloc(sizeof(t_rdata))))
return (NULL);
line->line = ft_strdup(raw);
line->next = NULL;
return (line);
}
void lm_append_line(t_rdata **line, char *raw)
{
if (*line)
{
if((*line)->next)
lm_append_line(&(*line)->next, raw);
else
(*line)->next = lm_new_raw_line(raw);
}
else
{
*line = lm_new_raw_line(raw);
}
}

54
srcs/lm_graph_utils.c
View File

@ -12,10 +12,22 @@
#include "lem_in.h"
t_adjlist *lm_new_node(int dest)
t_ind *lm_new_adjnode(int dest)
{
t_adjlist *newnode;
t_ind *new;
if (!(new = (t_ind *)ft_memalloc(sizeof(t_ind))))
return (NULL);
new->index = dest;
new->weight = 1;
new->next = NULL;
return (new);
}
t_adjlist *lm_new_node(int dest)
{
t_adjlist *newnode;
if (!(newnode = (t_adjlist *)malloc(sizeof(t_adjlist))))
return (NULL);
@ -24,17 +36,17 @@ t_adjlist *lm_new_node(int dest)
return (newnode);
}
t_graph *lm_creategraph(int v)
t_graph *lm_creategraph(int v)
{
t_graph *newgraph;
int index;
t_graph *newgraph;
int index;
index = -1;
if (!(newgraph = (t_graph *)malloc(sizeof(t_graph))))
if (!(newgraph = (t_graph *)ft_memalloc(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)))
if (!(newgraph->array = (t_lm_adj *)ft_memalloc(sizeof(t_lm_adj) * v)))
return (NULL);
while (++index < v)
newgraph->array[
@ -42,21 +54,41 @@ t_graph *lm_creategraph(int v)
return (newgraph);;
}
int lm_adj_parser(t_graph *graph, t_holder *holder)
{
t_temp *data;
if (holder != NULL)
{
data = holder->data;
if (data != NULL)
{
while (data)
{
lm_add_edge(graph, data->src_ind, data->dest_ind);
data = data->next;
}
return (1);
}
}
return (0);
}
void lm_add_edge(t_graph *graph, int src, int dest)
{
t_adjlist *newnode;
t_ind *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 = lm_new_adjnode(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 = lm_new_adjnode(src);
newnode->next = graph->array[dest].head;
graph->array[dest].head = newnode;
}

49
srcs/lm_mem_utils.c
View File

@ -12,25 +12,46 @@
#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
// }
static 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;
}
int lm_init_memory(t_syntax *synt, t_holder *holder,
t_lmdata *ldata)
{
// if (!(synt = (t_syntax *)malloc(sizeof(t_syntax))))
// return (0);
// if (!(holder = (t_holder *)malloc(sizeof(t_holder))))
// return (0);
// if (!(ldata = (t_lmdata *)malloc(sizeof(t_lmdata))))
// return (0);
// if (!(rdata = (t_rdata *)malloc(sizeof(t_rdata))))
// return (0);
lm_init_data(synt, holder, ldata);
return (1);
}
static void lm_add_vertex_sub(t_lmdata *ldata, t_node *new)
@ -75,9 +96,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)
@ -103,6 +124,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 +133,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:13:44 by mndhlovu ### ########.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);
}

75
srcs/lm_parser_error_check.c Normal file
View File

@ -0,0 +1,75 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lm_parser_error_check.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/08 06:42:37 by mndhlovu #+# #+# */
/* Updated: 2019/04/08 06:42:52 by mndhlovu ### ########.fr */
/* */
/* ************************************************************************** */
#include "lem_in.h"
int lm_chk_format_nbr(char *raw)
{
while (*raw)
{
if (*raw == '-' || *raw == '+')
raw++;
if (!ft_isdigit(*raw))
return (-1);
raw++;
}
return (0);
}
int lm_check_max(char *raw)
{
if (ft_atoi(raw) < INT_MIN || ft_atoi(raw) > INT_MAX)
return (-1);
return (0);
}
int lm_validate_name(char *name)
{
int index;
index = 0;
if (name[0] == 'L')
return (-1);
while (name[index])
{
if (name[index] == '-')
return (-1);
index++;
}
return (0);
}
int lm_validate_rooms(char *name, char *x, char *y)
{
if (lm_validate_name(name) == -1)
return (-1);
if (lm_chk_format_nbr(x) == -1 ||
lm_check_max(x) == -1 || (ft_atoi(x) > 0 &&
(ft_atoi(x) == 0)) ||
ft_strlen(x) > 19)
return (0);
if (lm_chk_format_nbr(y) == -1 ||
lm_check_max(y) == -1 || (ft_atoi(y) > 0 &&
(ft_atoi(y) == 0)) ||
ft_strlen(y) > 19)
return (0);
return (1);
}
int lm_error_nbr(char *raw)
{
if (lm_chk_format_nbr(raw) == -1 || lm_check_max(raw) == -1 ||
(ft_atoi(raw) > 0 && (ft_atoi(raw) == 0)) ||
ft_strlen(raw) > 19)
return (-1);
return (0);
}

90
srcs/lm_utils_parser.c Normal file
View File

@ -0,0 +1,90 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lm_utils_parser.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: mndhlovu <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/04/04 09:24:45 by mndhlovu #+# #+# */
/* Updated: 2019/04/08 15:14:34 by mndhlovu ### ########.fr */
/* */
/* ************************************************************************** */
#include "lem_in.h"
int lm_get_value(char *line)
{
int index;
if (line != NULL)
{
index = ft_atoi(line);
if (index > INT_MIN && index < INT_MAX)
{
if (index > 0)
return (index);
else
{
return (-1);
}
}
}
return (-1);
}
void lm_get_cmd_vert(int count, t_syntax *synt,
t_lmdata *ldata, char *line)
{
char *tmp;
if (synt->s_pos == count - 1)
{
tmp = ft_strchr(line, '#');
if (tmp == NULL && count != synt->e_vert)
{
synt->s_vert = count;
if (!(lm_add_vertex(ldata, line, 's', synt)))
synt->e_error = 1;
}
}
if (synt->e_pos == count - 1)
{
tmp = ft_strchr(line, '#');
if (tmp == NULL && count != synt->s_vert)
{
synt->e_vert = count;
if (!(lm_add_vertex(ldata, line, 'e', synt)))
synt->s_error = 1;
}
}
}
void lm_get_vert_link(int count, t_syntax *synt, t_lmdata *ldata,
t_holder *holder, char *line)
{
char *link_sign;
char *hash;
if (count > 0 && (count != synt->s_vert && count != synt->e_vert)
&& (count != synt->s_pos && count != synt->e_pos))
{
link_sign = ft_strchr(line, '-');
hash = ft_strchr(line, '#');
if (link_sign == NULL && hash == NULL)
{
if (!(lm_add_vertex(ldata, line, 'v', synt)))
{
synt->v_error = 1;
}
}
if (link_sign != NULL && hash == NULL)
{
if (!(lm_ext_conn(holder, ldata, line)))
{
synt->l_error = 1;
return ;
}
}
}
}