merge

42sh/src/main/main.c

@@ -6,7 +6,7 @@
 /*   By: jhalford <jhalford@student.42.fr>          +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2016/12/06 18:40:58 by jhalford          #+#    #+#             */
-/*   Updated: 2017/03/07 15:43:54 by jhalford         ###   ########.fr       */
+/*   Updated: 2017/03/07 16:41:02 by jhalford         ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -52,6 +52,7 @@ int		handle_instruction(int fd)
 		token_print(token);
 		if (insert_newline(&token))
 			return (1);
+		DG("exit newline");
 		if (ft_parse(&ast, &token, &parser))
 			continue ;
 		if (parser.state == SUCCESS)

42sh/src/parser/aggregate_sym.c

@@ -99,7 +99,7 @@ t_aggrematch		g_aggrematch[] =
 	{NEWLINE_LIST, COMPLETE_COMMANDS, LINEBREAK, 0},
 	{NEWLINE_LIST, LINEBREAK, PROGRAM, LINEBREAK},
 	{NEWLINE_LIST, FOR_WORDLIST, SEQUENTIAL_SEP, 0},
-
+	{SEQUENTIAL_SEP, FOR_WORDLIST, SEQUENTIAL_SEP, FOR_WORDLIST},
 //to check
 	{FILENAME, TK_LESS, IO_FILE, TK_LESS},
 	{FILENAME, TK_LESSAND, IO_FILE, TK_LESSAND},
@@ -322,6 +322,8 @@ int			aggregate_sym(t_list **stack, t_sym *new_sym, t_parstate *state)
 	t_sym		*head;
 	int		i;
 
+	if (!*stack || !*new_sym || !*state)
+		return (1);
 	i = 0;
 	head = (*stack)->content;
 	DG("aggregate head %s && sym %s",
@@ -336,13 +338,15 @@ int			aggregate_sym(t_list **stack, t_sym *new_sym, t_parstate *state)
 			*new_sym = g_aggrematch[i].new_sym;
 			if (g_aggrematch[i].erase_sym)
 			{
-				if (pop_stack(stack, g_aggrematch[i].erase_sym))
+				pop_stack(stack, g_aggrematch[i].erase_sym);
-				return (1);
 				head = (*stack)->content;
 				DG("stack after pop: %s", read_state(*head));
 			}
 			if (eval_sym(stack, *new_sym))
-				return ((*state = ERROR));
+			{
+				*state = ERROR;
+				return (1);
+			}
 			aggregate_sym(stack, new_sym, state);
 			return (0);
 		}

42sh/src/parser/eval_sym.c

@@ -343,7 +343,6 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LBRACE, CASE_LIST_NS},
 	{TK_LBRACE, COMPLETE_CONDITION},
 	{TK_LBRACE, TK_IN},
-	{SEQUENTIAL_SEP, NAME},
 	{TK_RBRACE, TK_SEMI},
 	{TK_RBRACE, END_COMMAND},
 	{TK_RBRACE, SEPARATOR_OP},
@@ -412,6 +411,7 @@ t_stackmatch	g_stackmatch[] =
 	{SEQUENTIAL_SEP, NAME},
 	{SEQUENTIAL_SEP, IN},
 	{SEQUENTIAL_SEP, WORDLIST},
+	{SEQUENTIAL_SEP, FOR_WORDLIST},
 	{END_COMMAND, SEQUENCE},
 	{END_COMMAND, PIPE_SEMI_SEQUENCE},
 	{END_COMMAND, AND_OR_MAJOR},
@@ -810,6 +810,7 @@ t_stackmatch	g_stackmatch[] =
 	{PATTERN, CASE_LIST},
 	{PATTERN, TK_IN},
 	{CASE_LIST_NS, LINEBREAK},
+	{CASE_LIST_NS, TK_IN},
 	{CASE_CLAUSE, LINEBREAK},
 	{CASE_CLAUSE, TK_PAREN_OPEN},
 	{CASE_CLAUSE, TK_LBRACE},
@@ -987,6 +988,26 @@ t_stackmatch	g_stackmatch[] =
 	{PIPE_SEMI_SEQUENCE, NEWLINE_LIST},
 	{PIPE_SEMI_SEQUENCE, AND_OR_MAJOR},
 	{SEQUENCE, PIPE_SEMI_SEQUENCE},
+	{SEQUENCE, TK_WHILE},
+	{SEQUENCE, TK_UNTIL},
+	{SEQUENCE, TK_DO},
+	{SEQUENCE, TK_PAREN_CLOSE},
+	{SEQUENCE, TK_IF},
+	{SEQUENCE, TK_ELIF},
+	{SEQUENCE, TK_THEN},
+	{SEQUENCE, TK_ELSE},
+	{SEQUENCE, COMPOUND_LIST},
+	{SEQUENCE, CASE_LIST_NS},
+	{SEQUENCE, COMPLETE_CONDITION},
+	{SEQUENCE, LINEBREAK},
+	{SEQUENCE, TK_PAREN_OPEN},
+	{SEQUENCE, TK_LBRACE},
+	{SEQUENCE, COMPLETE_COMMANDS},
+	{SEQUENCE, TK_BANG},
+	{SEQUENCE, TK_BANG},
+	{SEQUENCE, SEPARATOR_OP},
+	{SEQUENCE, NEWLINE_LIST},
+	{SEQUENCE, AND_OR_MAJOR},
 	{SEQUENCE, SEQUENCE},
 	{PIPELINE, TK_WHILE},
 	{PIPELINE, TK_UNTIL},
@@ -1038,6 +1059,7 @@ t_stackmatch	g_stackmatch[] =
 	{COMPLETE_COMMAND, COMPLETE_COMMANDS},
 	{COMPLETE_COMMAND, NEWLINE_LIST},
 	{COMPLETE_COMMANDS, COMPLETE_COMMANDS},
+	{PROGRAM, TERMINUS},
 	{0, 0},
 };
 
@@ -1046,6 +1068,8 @@ int			eval_sym(t_list **stack, t_sym new_sym)
 	t_sym		*head;	
 	int		i;
 
+	if (!*stack)
+		return (1);
 	head = (*stack)->content;
 	DG("eval head %s && sym %s", read_state(*head), read_state(new_sym));
 	i = 0;

42sh/src/parser/ft_parse.c

@@ -43,7 +43,7 @@ int			ft_parse(t_btree **ast, t_list **token, t_parser *parser)
 		else
 		{
 			if (aggregate_sym(&parser->stack, parser->new_sym, &parser->state))
-				return (1);
+				return (0);
 			push_stack(&parser->stack, *parser->new_sym);
 		}
 //		ft_read_stack(parser->stack);

42sh/src/parser/pop_stack.c

@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 19:12:44 by ariard            #+#    #+#             */
-/*   Updated: 2017/03/06 17:09:00 by ariard           ###   ########.fr       */
+/*   Updated: 2017/03/07 15:09:32 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -17,13 +17,14 @@ int			pop_stack(t_list **stack, t_sym erase_sym)
 	t_sym		*head;
 	t_list		*temp;
 
-	while ((*stack) && *(head = (*stack)->content) != erase_sym)
+	while ((*stack) && (*(head = (*stack)->content) != erase_sym
+		&& *head != TERMINUS))
 	{
-		temp = *stack;
+			temp = *stack;
 		(*stack) = (*stack)->next;
 		ft_lstdelone(&temp, NULL);	
 	}
-	if (*stack)
+	if ((*stack) && *(head = (*stack)->content) != TERMINUS)
 	{
 		temp = *stack;
 		(*stack) = (*stack)->next;

42sh/src/parser/produce_sym.c

@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 17:58:34 by ariard            #+#    #+#             */
-/*   Updated: 2017/03/07 15:09:59 by jhalford         ###   ########.fr       */
+/*   Updated: 2017/03/07 15:53:23 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -108,6 +108,8 @@ int		produce_sym(t_list **stack, t_sym *new_sym, t_list **lst)
 	t_sym		*head;
 	int		i;
 
+	if (!*stack || !*lst)
+		return (1);
 	token = (*lst)->content;
 	head = (*stack)->content;
 	DG("produce stack : %s && token : %s", read_state(*head),