95 lines
2.2 KiB
C
95 lines
2.2 KiB
C
|
|
#include "push_swap.h"
|
|
|
|
/*
|
|
** this function check errors in the arguments
|
|
** like, is there arguments, and are they a valid list without equals values
|
|
** if there are no arguments it calls the stop function with value 1 to print usage
|
|
*/
|
|
void is_valid(int ac, char **av)
|
|
{
|
|
if (ac < 2)
|
|
ps_stop(NULL, NULL, NULL, 1);
|
|
(void)av;
|
|
// check more error
|
|
}
|
|
|
|
/*
|
|
** this function check if there are flags (currently only one flag) :
|
|
** -p to print the evolution of the list while the sorting is done
|
|
*/
|
|
int check_flag(int *ac, char ***av)
|
|
{
|
|
if (ft_strcmp((*av)[1], "-p") != 0)
|
|
return (0);
|
|
(*av)++;;
|
|
(*ac)--;
|
|
return (1);
|
|
}
|
|
|
|
/*
|
|
** create the stack for list a, as a linked list, and fill it with the values given in arguments argv
|
|
*/
|
|
t_stack *init_stack(int ac, char **av)
|
|
{
|
|
t_stack *start;
|
|
t_stack *tmp;
|
|
|
|
tmp = NULL;
|
|
while (--ac)
|
|
{
|
|
if (!(start = ft_calloc(1, sizeof(t_stack))))
|
|
ps_stop(start, NULL, NULL, 2);
|
|
start->n = ft_atoi(av[ac]);
|
|
start->next = tmp;
|
|
tmp = start;
|
|
}
|
|
return (start);
|
|
}
|
|
|
|
/*
|
|
** this function creates the stack b and the list solution
|
|
** then it init the list solution with :
|
|
** - first element : pointer to stack a
|
|
** - secnd element : pointer to stack b
|
|
** - third element : initial values of stack a (in case of flag -p)
|
|
** then it calls the sorting algorithm
|
|
** then it calls ps_stop() to free everything that needs to be freed
|
|
*/
|
|
t_list *launch_algo(t_stack *a)
|
|
{
|
|
t_stack *b;
|
|
t_list *solution;
|
|
|
|
b = NULL;
|
|
solution = NULL;
|
|
ft_lstadd_back(&solution, ft_lstnew(&a));
|
|
ft_lstadd_back(&solution, ft_lstnew(&b));
|
|
fill_solution(solution, ft_strdup("start"));
|
|
hugo_sort(&a, &b, solution);
|
|
//bubble_sort(&a, &b, solution);
|
|
return (solution);
|
|
}
|
|
|
|
/*
|
|
** this programme will sort a list
|
|
** this function first check the validity of the arguments
|
|
** then it checks for flags (currently only -p)
|
|
** then it parse the list into a linked list
|
|
** then it calls the sorting algorithm (it actually calls a launch function that will execute some actions and calls the sorting algorithm)
|
|
** and finally it frees everything and leaves
|
|
*/
|
|
int main(int ac, char **av)
|
|
{
|
|
t_stack *stack;
|
|
t_list *result;
|
|
int flag;
|
|
|
|
is_valid(ac, av);
|
|
flag = check_flag(&ac, &av);
|
|
stack = init_stack(ac, av);
|
|
result = launch_algo(stack);
|
|
print_result(result, flag);
|
|
return(0);
|
|
}
|