diff --git a/42sh/includes/.parser.h.swm b/42sh/includes/.parser.h.swm
deleted file mode 100644
index ba6e51fc..00000000
Binary files a/42sh/includes/.parser.h.swm and /dev/null differ
diff --git a/42sh/includes/.parser.h.swn b/42sh/includes/.parser.h.swn
index 2abcaac7..163f04d8 100644
Binary files a/42sh/includes/.parser.h.swn and b/42sh/includes/.parser.h.swn differ
diff --git a/42sh/includes/lexer.h b/42sh/includes/lexer.h
index d158daf4..c52567d4 100644
--- a/42sh/includes/lexer.h
+++ b/42sh/includes/lexer.h
@@ -6,7 +6,7 @@
 /*   By: jhalford <jack@crans.org>                  +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2016/12/01 12:15:50 by jhalford          #+#    #+#             */
-/*   Updated: 2017/02/10 01:43:45 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 19:41:57 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
diff --git a/42sh/includes/parser.h b/42sh/includes/parser.h
index 21d31f66..53701f4e 100644
--- a/42sh/includes/parser.h
+++ b/42sh/includes/parser.h
@@ -6,7 +6,7 @@
 /*   By: jhalford <jack@crans.org>                  +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2016/12/01 12:15:54 by jhalford          #+#    #+#             */
-/*   Updated: 2017/02/12 20:35:20 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 22:33:39 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -59,11 +59,14 @@ enum	e_sym
 	TK_DLESSDASH,
 	TK_LESSGREAT,
 	TK_CASE,
-	TK_LBRACE,
 	TK_IN,
-	TK_CASE,
 	TK_ESAC,
+	TK_CLOBBER,
+	TK_LBRACE,
+	TK_RBRACE,
+	TK_DSEMI,
 	PROGRAM = 100,
+	COMPLETE_COMMAND,
 	COMPLETE_COMMANDS,
 	LIST,
 	AND_OR,
@@ -79,7 +82,9 @@ enum	e_sym
 	IN,
 	WORDLIST,
 	CASE_CLAUSE,
+	CASE_LIST,
 	CASE_LIST_NS,
+	CASE_ITEM,
 	CASE_ITEM_NS,
 	PATTERN,
 	IF_CLAUSE,
@@ -109,21 +114,15 @@ enum	e_sym
 	LOOP,
 	FUNC,
 	PIPE_SEMI_SEQUENCE,
-	ALL = TK_LESS | TK_GREAT | TK_DLESS | TK_DGREAT | TK_LESSAND | TK_GREATAND\
-	| TK_SEMI | TK_PIPE | TK_AND_IF	| TK_OR_IF | TK_AMP | TK_PAREN_OPEN\
-  	| TK_PAREN_CLOSE | TK_BQUOTE | TK_SUBSHELL | TK_NEWLINE | TK_WHILE | TK_DO\
-	| TK_DONE | TK_IF | TK_THEN | TK_FI | TK_ELIF | TK_ELSE | TK_UNTIL | TK_N_WORD\
-   	| TK_Q_WORD | TK_DQ_WORD | PROGRAM | COMPLETE_COMMANDS | LIST\
-	| AND_OR | PIPELINE | PIPE_SEQUENCE | COMMAND | COMPOUND_COMMAND | SUBSHELL\
-	| COMPOUND_LIST | TERM | FOR_CLAUSE | NAME | IN | WORDLIST | CASE_CLAUSE\
-	| CASE_LIST_NS | CASE_ITEM_NS | PATTERN | IF_CLAUSE | ELSE_PART\
-	| WHILE_CLAUSE | UNTIL_CLAUSE | FUNCTION_DEFINITION | FUNCTION_BODY | FNAME\
-	| BRACE_GROUP | DO_GROUP | SIMPLE_COMMAND | CMD_NAME | CMD_WORD | CMD_PREFIX\
-	| CMD_SUFFIX | REDIRECT_LIST | IO_REDIRECT | IO_FILE | FILENAME | IO_HERE\
-	| HERE_END | NEWLINE_LIST | SEPARATOR_OP | SEPARATOR | SEQUENTIAL_SEP
+	ALL = 200,
+	PATTERN_CASE,
+	ALL_SEPERATOR,
 };
 
-typedef unsigned long long int		t_sym;
+# define PATTERN_CASE (PATTERN | TK_PAREN_OPEN)
+# define ALL_SEPARATOR (TK_NEWLINE | TK_SEMI | TK_AMP)
+
+typedef int		t_sym;
 
 /*
 typedef unsigned long long int 		t_sym;
@@ -181,12 +180,15 @@ typedef unsigned long long int 		t_sym;
 #define ALL_SYM 			!0
 //#define ALL_SYM 			-1UL
 */
+typedef int  t_parstate;
 
 struct	s_aggrematch
 {
-	t_sym 	under;
 	t_sym 	top;
+	t_sym 	under;
 	t_sym 	new_sym;
+	t_type	next_token;
+	t_sym	erase_sym;
 };
 
 typedef struct s_aggrematch t_aggrematch;
@@ -217,11 +219,11 @@ extern t_stackmatch g_stackmatch[];
 int		ft_parse(t_btree **ast, t_list **token);
 int		produce_sym(t_sym stack, t_sym *new_sym, t_list **lst);
 int		eval_sym(t_sym stack, t_sym new_sym);
-int		aggregate_sym(t_sym **stack, t_sym *new_sym);
-int		superflous_sym(t_sym stack, t_sym new_sym);
+int		aggregate_sym(t_sym **stack, t_sym *new_sym,
+		t_parstate *state, t_list *next_token);
 
 int		push_stack(t_sym *stack, t_sym new_sym);
-int		pop_stack(t_sym **stack, int k);
+int		pop_stack(t_sym **stack, t_sym erase_sym);
 
 int		error_syntax(t_list **token);
 
@@ -232,8 +234,6 @@ char	*read_state(t_sym current);
 #define ERROR		(1 << 1)
 #define SUCCESS		(1 << 2)
 
-typedef int  t_parstate;
-
 /*
  * Build AST
  * 
diff --git a/42sh/sample/stack.sh b/42sh/sample/stack.sh
index 9e2740c6..968d1077 100644
--- a/42sh/sample/stack.sh
+++ b/42sh/sample/stack.sh
@@ -1 +1 @@
-ls
+ls | cat | cat | cat 
diff --git a/42sh/src/parser/aggregate_sym.c b/42sh/src/parser/aggregate_sym.c
index 1bf8c8c6..f4424ef4 100644
--- a/42sh/src/parser/aggregate_sym.c
+++ b/42sh/src/parser/aggregate_sym.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 17:39:18 by ariard            #+#    #+#             */
-/*   Updated: 2017/02/12 20:53:36 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 22:59:11 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -17,54 +17,41 @@ t_aggrematch		g_aggrematch[] =
 	{TK_WORD, CMD_SUFFIX, CMD_SUFFIX, ALL, 0},
 	{TK_WORD, TK_PIPE, PATTERN, ALL, 0},
 	{TK_WORD, WORDLIST, WORDLIST, ALL, 0},
-
 	{TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, ALL, 0},
-
-	{TK_FI, ELSE_PART, IF_CLAUSE, ALL, tant que IF},
-	{TK_FI, COMPOUND_LIST, IF_CLAUSE, ALL, tant que IF},
-
-	{TK_DONE, COMPOUND_LIST, DO_GROUP, ALL, tant DO},
-
+	{TK_FI, ELSE_PART, IF_CLAUSE, ALL, IF},
+	{TK_FI, COMPOUND_LIST, IF_CLAUSE, ALL, IF},
+	{TK_DONE, COMPOUND_LIST, DO_GROUP, ALL, DO},
 //Esac ?
-	{TK_ESAC, CASE_LIST, CASE_CLAUSE, ALL, tant que CASE},
-	{TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, ALL, tant que CASE},
-	{TK_ESAC, LINEBREAK, CASE_CLAUSE, ALL, tant que CASE},
-
-	{TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, ALL tant que LBRACE},
-
-	{TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, ALL, tant que TK_PAREN_OPEN},
-	
+	{TK_ESAC, CASE_LIST, CASE_CLAUSE, ALL, TK_CASE},
+	{TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, ALL, TK_CASE},
+	{TK_ESAC, LINEBREAK, CASE_CLAUSE, ALL, TK_CASE},
+	{TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, ALL, TK_LBRACE},
+	{TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, ALL, TK_PAREN_OPEN},	
 //watch this
 	{SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, ALL, 0},
-
-	{LINEBREAK, TK_SEMI, SEPARATOR_OP, ALL, tant que TK_SEMI},
-//do one
-	{LINEBREAK, TK_PAREN_CLOSE, TK_ESAC, CASE_ITEM_NS, tant que pattern ou '('},
+	{LINEBREAK, SEPARATOR_OP, SEPARATOR, ALL, SEPARATOR_OP},
+	{LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, ALL, TK_SEMI},
+	{LINEBREAK, TK_PAREN_CLOSE, TK_ESAC, CASE_ITEM_NS, PATTERN_CASE},
 	{LINEBREAK, TK_PAREN_CLOSE, FUNC, ALL, FNAME},
-	{LINEBREAK, TK_DSEMI, CASE_ITEM, ALL, tant que pattern ou '('},
-	{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, tant que linebreak},
+	{LINEBREAK, TK_DSEMI, CASE_ITEM, ALL, PATTERN_CASE},
+	{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, LINEBREAK},
 	{LINEBREAK, TK_PIPE, PIPE_SEMI_SEQUENCE, ALL, PIPE_SEQUENCE},
 	{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, LINEBREAK}, 
-
-	{NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, ALL, tant que newline},
-	{NEWLINE_LIST, NAME, SEPARATOR_SEP, ALL, 0},
-	{NEWlINE_LIST, IN, SEPARATOR_SEP, ALL, 0},
-	{NEWLINE_LIST, WORDLIST, SEPARATOR_SEP, ALL, 0},
+	{NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, ALL, NEWLINE},
+	{NEWLINE_LIST, NAME, SEQUENTIAL_SEP, ALL, 0},
+	{NEWLINE_LIST, IN, SEQUENTIAL_SEP, ALL, 0},
+	{NEWLINE_LIST, WORDLIST, SEQUENTIAL_SEP, ALL, 0},
 	{NEWLINE_LIST, TERM, SEPARATOR, ALL, 0},
 	{NEWLINE_LIST, COMPOUND_LIST, SEPARATOR, ALL, 0},
-
 	{IO_HERE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER},
-	
 	{FILENAME, TK_LESS, IO_FILE, ALL, TK_LESS},
 	{FILENAME, TK_LESSAND, IO_FILE, ALL, TK_LESSAND},
 	{FILENAME, TK_GREAT, IO_FILE, ALL, TK_GREAT},
 	{FILENAME, TK_GREATAND, IO_FILE, ALL, TK_GREATAND},
 	{FILENAME, TK_DGREAT, IO_FILE, ALL, TK_DGREAT},
-	{FILENAME, TK_LESGREAT, IO_FILE, ALL, TK_LESSGREAT},
+	{FILENAME, TK_LESSGREAT, IO_FILE, ALL, TK_LESSGREAT},
 	{FILENAME, TK_CLOBBER, IO_FILE, ALL, TK_CLOBBER},
-	
 	{IO_FILE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER},
-
 	{IO_REDIRECT, COMPOUND_COMMAND, REDIRECT_LIST, ALL, REDIRECT_LIST},
 	{IO_REDIRECT, CMD_SUFFIX, CMD_SUFFIX, ALL, CMD_SUFFIX},
 	{IO_REDIRECT, CMD_NAME, CMD_SUFFIX, ALL, 0},
@@ -74,100 +61,105 @@ t_aggrematch		g_aggrematch[] =
 	{IO_REDIRECT, TK_BANG, CMD_PREFIX, ALL, 0},
 	{IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, ALL, 0},
 	{IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, ALL, 0},
-
 	{REDIRECT_LIST, COMPOUND_COMMAND, COMPOUND_COMMAND, ALL, COMPOUND_COMMAND},
-				
 	{CMD_SUFFIX, CMD_WORD, SIMPLE_COMMAND, ALL, CMD_PREFIX},
 	{CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, ALL, CMD_NAME},
-
-	{CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0},
-	{CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0},
-	{CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0},
-	{CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0},
-
-	{CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 
-		CMD_PREFIX},
-
-	{CMD_NAME, LINEBREAK, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0},
-	{CMD_NAME, TK_BANG, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0},
-	{CMD_NAME, SEPARATOR_OP, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0},
-	{CMD_NAME, NEWLINE_LIST, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0},
+	{CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, ALL_SEPARATOR, 0},
+	{CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, ALL_SEPARATOR, 0},
+	{CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, ALL_SEPARATOR, 0},
+	{CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, ALL_SEPARATOR, 0},
+	{CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, ALL_SEPARATOR, CMD_PREFIX},
+//to check	
+	{CMD_NAME, LINEBREAK, SIMPLE_COMMAND, ALL, 0},
+	{CMD_NAME, TK_BANG, SIMPLE_COMMAND, ALL, 0},
+	{CMD_NAME, SEPARATOR_OP, SIMPLE_COMMAND, ALL, 0},
+	{CMD_NAME, NEWLINE_LIST, SIMPLE_COMMAND, ALL, 0},
+	{CMD_NAME, PIPE_SEMI_SEQUENCE, SIMPLE_COMMAND, ALL, 0},
 
 	{SIMPLE_COMMAND, ALL, COMMAND, ALL, 0},
-
-	{DO_GROUP, NAME, FOR_CLAUSE, ALL, FOR},
-	{DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, ALL, FOR},
+	{DO_GROUP, NAME, FOR_CLAUSE, ALL, TK_FOR},
+	{DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, ALL, TK_FOR},
 	{DO_GROUP, COMPOUND_LIST, LOOP, ALL, COMPOUND_LIST},
-
 	{LOOP, WHILE, WHILE_CLAUSE, ALL, WHILE},
-	{LOOP, UNTIL, UNTIL_CLAUSE, ALL, UNTIL},
-
+	{LOOP, TK_UNTIL, UNTIL_CLAUSE, ALL, TK_UNTIL},
 	{BRACE_GROUP, ALL, COMPOUND_COMMAND, ALL, 0},
-
 	{FUNCTION_BODY, FUNC, FUNCTION_DEFINITION, ALL, 0},
-
 	{FUNCTION_DEFINITION, ALL, COMMAND, ALL, 0},
-
 	{UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
-
 	{WHILE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
-
-	{ELSE_PART, COMPOUND_LIST, ELSE_PART, ALL, ELIF},
-
+	{ELSE_PART, COMPOUND_LIST, ELSE_PART, ALL, TK_ELIF},
 	{IF_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
-
 	{CASE_ITEM, CASE_LIST, CASE_LIST, ALL, CASE_LIST},
 	{CASE_ITEM, LINEBREAK, CASE_LIST, ALL, CASE_LIST},
-
 	{CASE_ITEM_NS, CASE_LIST, CASE_LIST_NS, ALL, CASE_LIST},
 	{CASE_ITEM_NS, LINEBREAK, CASE_LIST_NS, ALL, CASE_LIST},
-
 	{CASE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
-
 	{FOR_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
-
 	{TERM, LINEBREAK, COMPOUND_LIST, ALL, LINEBREAK},
-
 	{COMPOUND_LIST, TK_ELSE, ELSE_PART, ALL, TK_ELSE},
 	{COMPOUND_LIST, TK_THEN, ELSE_PART, ALL, TK_ELIF},
-
 	{SUBSHELL, ALL, COMPOUND_COMMAND, ALL, 0},
-
 	{COMPOUND_COMMAND, ALL, COMMAND, ALL, 0},
-
-	{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, ALL, PIPE_SEQUENCE},
-	{COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, ALL, PIPE_SEQUENCE},
+	{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, ALL, PIPE_SEMI_SEQUENCE},
 	{COMMAND, TK_BANG, PIPE_SEQUENCE, ALL, 0},
 	{COMMAND, SEPARATOR_OP, PIPE_SEQUENCE, ALL, 0},
 	{COMMAND, NEWLINE_LIST, PIPE_SEQUENCE, ALL, 0},
-
+	{COMMAND, LINEBREAK, PIPE_SEQUENCE, ALL, 0},
 	{PIPE_SEQUENCE, TK_BANG, PIPELINE, ALL, TK_BANG},
 	{PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, ALL, 0},
 	{PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, ALL, 0},
-
-	{PIPELINE, LINEBREAK, AND_OR, ALL, AND_OR},
+	{PIPE_SEQUENCE, LINEBREAK, PIPELINE, ALL_SEPARATOR, 0},
+	{PIPELINE, LINEBREAK, AND_OR, ALL, 0},
+//	{PIPELINE, LINEBREAK, AND_OR, ALL, AND_OR},
 	{PIPELINE, SEPARATOR_OP, AND_OR, ALL, 0},
-
 	{AND_OR, SEPARATOR_OP, LIST, ALL, LIST},
 	{AND_OR, NEWLINE_LIST, LIST, ALL, 0},
-
+	{AND_OR, LINEBREAK, LIST, ALL, 0},
 	{LIST, NEWLINE_LIST, COMPLETE_COMMAND, ALL, 0},
-
+	{LIST, LINEBREAK, COMPLETE_COMMAND, ALL, 0},
 	{COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, ALL, COMPLETE_COMMANDS},
 	{COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, ALL, 0},
-	
-	{0, 0, 0},
-}
+//	voir decoupe separateur au lexer 
+	{COMPLETE_COMMANDS, LINEBREAK, PROGRAM, ALL_SEPARATOR, 0},
+	{0, 0, 0, 0, 0},
+};
 
-int			aggregate_sym(t_sym **stack, t_sym *new_sym)
+int			aggregate_sym(t_sym **stack, t_sym *new_sym, 
+			t_parstate *state, t_list *next_token)
 {
-	DG("aggregate head %s && sym %s", read_state(**stack), read_state(*new_sym));
-	if (**stack == 0  && *new_sym == CMD_NAME)
+	int		i;
+	int		next;
+	t_token	*token;
+
+	i = 0;
+	next = 0;
+	if (next_token)
+		if ((token = next_token->content))
+			next = token->type;
+	DG("aggregate head %s && sym %s && next %s", 
+	read_state(**stack), read_state(*new_sym), read_state(next));
+	while (g_aggrematch[i].top)
 	{
-		*new_sym = SIMPLE_COMMAND;
-		aggregate_sym(stack, new_sym);
+		if (*new_sym == g_aggrematch[i].top && (**stack == g_aggrematch[i].under
+			|| g_aggrematch[i].under == ALL 
+			|| g_aggrematch[i].under == ALL_SEPARATOR)
+			&& (next == g_aggrematch[i].next_token || next == 0 
+			|| g_aggrematch[i].next_token == ALL 
+			|| (g_aggrematch[i].next_token == ALL_SEPARATOR && next == TK_SEMI)))
+		{
+			DG("MATCH : %s", read_state(g_aggrematch[i].new_sym));
+			*new_sym = g_aggrematch[i].new_sym;
+			if (g_aggrematch[i].erase_sym)
+			{
+				pop_stack(stack, g_aggrematch[i].erase_sym);
+				DG("stack after pop: %s", read_state(**stack));
+			}
+			if (eval_sym(**stack, *new_sym))
+				return ((*state = ERROR));
+			aggregate_sym(stack, new_sym, state, next_token);
+			return (0);
+		}
+		i++;
 	}
-	if (**stack == 0 && *new_sym == SIMPLE_COMMAND)
-		*new_sym = PROGRAM;
 	return (0);
 }
diff --git a/42sh/src/parser/error_syntax.c b/42sh/src/parser/error_syntax.c
index bfbeb805..c5c668a1 100644
--- a/42sh/src/parser/error_syntax.c
+++ b/42sh/src/parser/error_syntax.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 20:15:35 by ariard            #+#    #+#             */
-/*   Updated: 2017/02/09 20:31:48 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 22:09:03 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
diff --git a/42sh/src/parser/eval_sym.c b/42sh/src/parser/eval_sym.c
index 3f927208..510970b5 100644
--- a/42sh/src/parser/eval_sym.c
+++ b/42sh/src/parser/eval_sym.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 16:26:30 by ariard            #+#    #+#             */
-/*   Updated: 2017/02/12 21:08:57 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 22:59:09 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,13 +14,12 @@
 
 t_stackmatch	g_stackmatch[] =
 {
-	{TK_WORD, CMD_SUFFIX},
-	{TK_WORD, TK_PIPE},
-	{TK_WORD, CASE},
-	{TK_WORD, WORDLIST},
-
+	{TK_N_WORD, CMD_SUFFIX},
+	{TK_N_WORD, TK_PIPE},
+	{TK_N_WORD, TK_CASE},
+	{TK_N_WORD, WORDLIST},
+	{TK_N_WORD, LINEBREAK},
 	{TK_ASSIGNEMENT_WORD, CMD_PREFIX},
-	
 	{TK_IO_NUMBER, REDIRECT_LIST},
 	{TK_IO_NUMBER, CMD_SUFFIX},
 	{TK_IO_NUMBER, CMD_PREFIX},
@@ -29,16 +28,12 @@ t_stackmatch	g_stackmatch[] =
 	{TK_IO_NUMBER, LINEBREAK},
 	{TK_IO_NUMBER, TK_BANG},
 	{TK_IO_NUMBER, SEPARATOR_OP},
-	{TK_IO_NUMBER, NEWWLINE_LIST},
+	{TK_IO_NUMBER, NEWLINE_LIST},
 	{TK_IO_NUMBER, PIPE_SEMI_SEQUENCE},
-
 	{TK_AND_IF, AND_OR},
-
 	{TK_OR_IF, AND_OR},
-
 	{TK_DSEMI, LINEBREAK},
 	{TK_DSEMI, COMPOUND_LIST},
-
 	{TK_DLESS, TK_IO_NUMBER},
 	{TK_DLESS, REDIRECT_LIST},
 	{TK_DLESS, CMD_SUFFIX},
@@ -50,7 +45,6 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DLESS, SEPARATOR_OP},
 	{TK_DLESS, NEWLINE_LIST},
 	{TK_DLESS, PIPE_SEMI_SEQUENCE},
-
 	{TK_DLESSDASH, TK_IO_NUMBER},
 	{TK_DLESSDASH, REDIRECT_LIST},
 	{TK_DLESSDASH, CMD_SUFFIX},
@@ -62,7 +56,6 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DLESSDASH, SEPARATOR_OP},
 	{TK_DLESSDASH, NEWLINE_LIST},
 	{TK_DLESSDASH, PIPE_SEMI_SEQUENCE},
-
 	{TK_DGREAT, TK_IO_NUMBER},
 	{TK_DGREAT, REDIRECT_LIST},
 	{TK_DGREAT, CMD_SUFFIX},
@@ -74,7 +67,6 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DGREAT, SEPARATOR_OP},
 	{TK_DGREAT, NEWLINE_LIST},
 	{TK_DGREAT, PIPE_SEMI_SEQUENCE},
-
 	{TK_LESSAND, TK_IO_NUMBER},
 	{TK_LESSAND, REDIRECT_LIST},
 	{TK_LESSAND, CMD_SUFFIX},
@@ -86,7 +78,6 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LESSAND, SEPARATOR_OP},
 	{TK_LESSAND, NEWLINE_LIST},
 	{TK_LESSAND, PIPE_SEMI_SEQUENCE},
-
 	{TK_GREATAND, TK_IO_NUMBER},
 	{TK_GREATAND, REDIRECT_LIST},
 	{TK_GREATAND, CMD_SUFFIX},
@@ -98,7 +89,6 @@ t_stackmatch	g_stackmatch[] =
 	{TK_GREATAND, SEPARATOR_OP},
 	{TK_GREATAND, NEWLINE_LIST},
 	{TK_GREATAND, PIPE_SEMI_SEQUENCE},
-
 	{TK_LESSGREAT, TK_IO_NUMBER},
 	{TK_LESSGREAT, REDIRECT_LIST},
 	{TK_LESSGREAT, CMD_SUFFIX},
@@ -110,7 +100,6 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LESSGREAT, SEPARATOR_OP},
 	{TK_LESSGREAT, NEWLINE_LIST},
 	{TK_LESSGREAT, PIPE_SEMI_SEQUENCE},
-
 	{TK_CLOBBER, TK_IO_NUMBER},
 	{TK_CLOBBER, REDIRECT_LIST},
 	{TK_CLOBBER, CMD_SUFFIX},
@@ -122,82 +111,64 @@ t_stackmatch	g_stackmatch[] =
 	{TK_CLOBBER, SEPARATOR_OP},
 	{TK_CLOBBER, NEWLINE_LIST},
 	{TK_CLOBBER, PIPE_SEMI_SEQUENCE},
-
 	{TK_IF, LINEBREAK},
 	{TK_IF, TK_BANG},
 	{TK_IF, SEPARATOR_OP},
 	{TK_IF, NEWLINE_LIST},
 	{TK_IF, PIPE_SEMI_SEQUENCE},
-		
 	{TK_THEN, COMPOUND_LIST},
-	
 	{TK_ELSE, COMPOUND_LIST},
-	
-	{TK_ELIF, COMPOUND_LIST},
-				
+	{TK_ELIF, COMPOUND_LIST},	
 	{TK_FI, ELSE_PART},
 	{TK_FI, COMPOUND_LIST},	
-	
 	{TK_DO, COMPOUND_LIST},
 	{TK_DO, NAME},
 	{TK_DO, SEQUENTIAL_SEP},
-
 	{TK_DONE, COMPOUND_LIST},
-
 	{TK_CASE, LINEBREAK},
 	{TK_CASE, TK_BANG},
 	{TK_CASE, NEWLINE_LIST},
 	{TK_CASE, SEPARATOR_OP},
 	{TK_CASE, PIPE_SEMI_SEQUENCE},
-
 	{TK_ESAC, CASE_LIST},
 	{TK_ESAC, CASE_LIST_NS},
 	{TK_ESAC, LINEBREAK},
-
 	{TK_WHILE, LINEBREAK},
 	{TK_WHILE, TK_BANG},
 	{TK_WHILE, SEPARATOR_OP},
 	{TK_WHILE, NEWLINE_LIST},
 	{TK_WHILE, PIPE_SEMI_SEQUENCE},
-
 	{TK_UNTIL, LINEBREAK},
 	{TK_UNTIL, TK_BANG},
 	{TK_UNTIL, SEPARATOR_OP},
 	{TK_UNTIL, NEWLINE_LIST},
 	{TK_UNTIL, PIPE_SEMI_SEQUENCE},
-
 	{TK_FOR, LINEBREAK},
 	{TK_FOR, TK_BANG},
 	{TK_FOR, SEPARATOR_OP},
 	{TK_FOR, NEWLINE_LIST},
 	{TK_FOR, PIPE_SEMI_SEQUENCE},
-
 	{TK_LBRACE, LINEBREAK},
 	{TK_LBRACE, TK_BANG},
 	{TK_LBRACE, SEPARATOR_OP},
 	{TK_LBRACE, NEWLINE_LIST},
 	{TK_LBRACE, PIPE_SEMI_SEQUENCE},
-
 	{TK_RBRACE, COMPOUND_LIST},
-
 	{TK_BANG, LINEBREAK},
 	{TK_BANG, SEPARATOR_OP},
 	{TK_BANG, NEWLINE_LIST},
-
 	{TK_IN, LINEBREAK},
-
 	{TK_SEMI, NAME},
 	{TK_SEMI, IN},
 	{TK_SEMI, WORDLIST},
 	{TK_SEMI, LIST},
 	{TK_SEMI, TERM},
-	
+	{TK_SEMI, CMD_NAME},
+	{TK_SEMI, PROGRAM},
 	{TK_AMP, LIST},
 	{TK_AMP, TERM},
-
 	{TK_PIPE, PATTERN},
 	{TK_PIPE, PIPE_SEQUENCE},
-
 	{TK_PAREN_OPEN, FNAME},
 	{TK_PAREN_OPEN, CASE_LIST},
 	{TK_PAREN_OPEN, LINEBREAK},
@@ -205,23 +176,19 @@ t_stackmatch	g_stackmatch[] =
 	{TK_PAREN_OPEN, SEPARATOR_OP},
 	{TK_PAREN_OPEN, NEWLINE_LIST},
 	{TK_PAREN_OPEN, PIPE_SEMI_SEQUENCE},
-
 	{TK_PAREN_CLOSE, TK_PAREN_OPEN},
 	{TK_PAREN_CLOSE, PATTERN},
 	{TK_PAREN_CLOSE, COMPOUND_LIST},
-
 	{SEQUENTIAL_SEP, NAME},
 	{SEQUENTIAL_SEP, IN},
 	{SEQUENTIAL_SEP, WORDLIST},
-	
 	{SEPARATOR, TERM},
 	{SEPARATOR, COMPOUND_LIST},
-		
 	{SEPARATOR_OP, LIST},
 	{SEPARATOR_OP, TERM},
 	{SEPARATOR_OP, COMPOUND_LIST},
-
-	{LINEBREAK, TK_SEMI},	
+	{LINEBREAK, TK_SEMI},
+	{LINEBREAK, SEPARATOR_OP},	
 	{LINEBREAK, TK_PAREN_CLOSE},
 	{LINEBREAK, WORD},
 	{LINEBREAK, IN},
@@ -230,7 +197,6 @@ t_stackmatch	g_stackmatch[] =
 	{LINEBREAK, TK_PIPE},
 	{LINEBREAK, LINEBREAK},
 	{LINEBREAK, COMPLETE_COMMANDS},
-	
 	{NEWLINE_LIST, NEWLINE_LIST},
 	{NEWLINE_LIST, NAME},
 	{NEWLINE_LIST, IN},
@@ -238,10 +204,8 @@ t_stackmatch	g_stackmatch[] =
 	{NEWLINE_LIST, TERM},
 	{NEWLINE_LIST, COMPOUND_LIST},
 	{NEWLINE_LIST, COMPLETE_COMMANDS}, 
-
-	{HERE_END, DLESS},
-	{HERE_END, DLESSDASH},
-
+	{HERE_END, TK_DLESS},
+	{HERE_END, TK_DLESSDASH},
 	{IO_HERE, TK_IO_NUMBER},
 	{IO_HERE, REDIRECT_LIST},
 	{IO_HERE, CMD_SUFFIX},
@@ -253,7 +217,6 @@ t_stackmatch	g_stackmatch[] =
 	{IO_HERE, SEPARATOR_OP},
 	{IO_HERE, NEWLINE_LIST},
 	{IO_HERE, PIPE_SEMI_SEQUENCE},
-
 	{FILENAME, TK_LESS},
 	{FILENAME, TK_LESSAND},
 	{FILENAME, TK_GREAT},
@@ -261,7 +224,6 @@ t_stackmatch	g_stackmatch[] =
 	{FILENAME, TK_DGREAT},
 	{FILENAME, TK_LESSGREAT},
 	{FILENAME, TK_CLOBBER},
-
 	{IO_FILE, TK_IO_NUMBER},
 	{IO_FILE, REDIRECT_LIST},
 	{IO_FILE, CMD_SUFFIX},
@@ -273,7 +235,6 @@ t_stackmatch	g_stackmatch[] =
 	{IO_FILE, SEPARATOR_OP},
 	{IO_FILE, NEWLINE_LIST},
 	{IO_FILE, PIPE_SEMI_SEQUENCE},
-
 	{IO_REDIRECT, REDIRECT_LIST},
 	{IO_REDIRECT, CMD_SUFFIX},
 	{IO_REDIRECT, CMD_PREFIX},
@@ -284,112 +245,84 @@ t_stackmatch	g_stackmatch[] =
 	{IO_REDIRECT, SEPARATOR_OP},
 	{IO_REDIRECT, NEWLINE_LIST},
 	{IO_REDIRECT, PIPE_SEMI_SEQUENCE},
-
-	{REDIRECT_LIST, COMPOUND_COMMAND}
-
+	{REDIRECT_LIST, COMPOUND_COMMAND},
 	{CMD_SUFFIX, CMD_WORD},
 	{CMD_SUFFIX, CMD_NAME},
-
 	{CMD_PREFIX, LINEBREAK},
 	{CMD_PREFIX, TK_BANG},
 	{CMD_PREFIX, SEPARATOR_OP},
 	{CMD_PREFIX, NEWLINE_LIST},
 	{CMD_PREFIX, PIPE_SEMI_SEQUENCE},
-
 	{CMD_WORD, CMD_PREFIX},
-	
 	{CMD_NAME, LINEBREAK},
 	{CMD_NAME, TK_BANG},
 	{CMD_NAME, SEPARATOR_OP},
 	{CMD_NAME, NEWLINE_LIST},
 	{CMD_NAME, PIPE_SEMI_SEQUENCE},
-
-	{SIMPLE_COMMNAND, LINEBREAK},
+	{SIMPLE_COMMAND, LINEBREAK},
 	{SIMPLE_COMMAND, TK_BANG},
 	{SIMPLE_COMMAND, SEPARATOR_OP},
 	{SIMPLE_COMMAND, NEWLINE_LIST},
 	{SIMPLE_COMMAND, PIPE_SEMI_SEQUENCE},
-
 	{DO_GROUP, COMPOUND_LIST},
 	{DO_GROUP, NAME},
 	{DO_GROUP, SEQUENTIAL_SEP},
-
-	{LOOP, WHILE},
-	{LOOP, UNTIL},
-
+	{LOOP, TK_WHILE},
+	{LOOP, TK_UNTIL},
 	{BRACE_GROUP, LINEBREAK},
 	{BRACE_GROUP, TK_BANG},
 	{BRACE_GROUP, SEPARATOR_OP},
 	{BRACE_GROUP, NEWLINE_LIST},
 	{BRACE_GROUP, PIPE_SEMI_SEQUENCE},
-
 	{FNAME, LINEBREAK},
 	{FNAME, TK_BANG},
 	{FNAME, SEPARATOR_OP},
 	{FNAME, NEWLINE_LIST},
 	{FNAME, PIPE_SEMI_SEQUENCE},
-
 	{FUNCTION_BODY, FUNC},
-
 	{FUNCTION_DEFINITION, LINEBREAK},
 	{FUNCTION_DEFINITION, TK_BANG},
 	{FUNCTION_DEFINITION, SEPARATOR_OP},
 	{FUNCTION_DEFINITION, NEWLINE_LIST},
 	{FUNCTION_DEFINITION, PIPE_SEMI_SEQUENCE},
-
 	{UNTIL_CLAUSE, LINEBREAK},
 	{UNTIL_CLAUSE, TK_BANG},
 	{UNTIL_CLAUSE, SEPARATOR_OP},
 	{UNTIL_CLAUSE, NEWLINE_LIST},
 	{UNTIL_CLAUSE, PIPE_SEMI_SEQUENCE},
-
 	{WHILE_CLAUSE, LINEBREAK},
 	{WHILE_CLAUSE, TK_BANG},
 	{WHILE_CLAUSE, SEPARATOR_OP},
 	{WHILE_CLAUSE, NEWLINE_LIST},
 	{WHILE_CLAUSE, PIPE_SEMI_SEQUENCE},
-
 	{ELSE_PART, COMPOUND_LIST},
-	
 	{IF_CLAUSE, LINEBREAK},
 	{IF_CLAUSE, TK_BANG},
 	{IF_CLAUSE, SEPARATOR_OP},
 	{IF_CLAUSE, NEWLINE_LIST},
 	{IF_CLAUSE, PIPE_SEMI_SEQUENCE},
-
 	{PATTERN, TK_PAREN_OPEN},
 	{PATTERN, CASE_LIST},
-
 	{CASE_ITEM, CASE_LIST},
 	{CASE_ITEM, LINEBREAK},
-
 	{CASE_ITEM_NS, CASE_LIST},
 	{CASE_ITEM_NS, LINEBREAK},
-
 	{CASE_LIST, LINEBREAK},
-
 	{CASE_LIST_NS, LINEBREAK},
-
 	{CASE_CLAUSE, LINEBREAK},
 	{CASE_CLAUSE, TK_BANG},
 	{CASE_CLAUSE, SEPARATOR_OP},
 	{CASE_CLAUSE, NEWLINE_LIST},
 	{CASE_CLAUSE, PIPE_SEMI_SEQUENCE},
-
 	{WORDLIST, IN},
-
 	{IN, LINEBREAK},
-
-	{NAME, FOR},
-
+	{NAME, TK_FOR},
 	{FOR_CLAUSE, LINEBREAK},
 	{FOR_CLAUSE, TK_BANG},
 	{FOR_CLAUSE, SEPARATOR_OP},
 	{FOR_CLAUSE, NEWLINE_LIST},
 	{FOR_CLAUSE, PIPE_SEMI_SEQUENCE},
-
 	{TERM, LINEBREAK},
-
 	{COMPOUND_LIST, TK_DO},
 	{COMPOUND_LIST, TK_LBRACE},
 	{COMPOUND_LIST, TK_WHILE},
@@ -397,45 +330,40 @@ t_stackmatch	g_stackmatch[] =
 	{COMPOUND_LIST, TK_ELIF},
 	{COMPOUND_LIST, TK_ELSE},
 	{COMPOUND_LIST, TK_IF},
-
 	{SUBSHELL, LINEBREAK},
 	{SUBSHELL, TK_BANG},
 	{SUBSHELL, SEPARATOR_OP},
 	{SUBSHELL, NEWLINE_LIST},
 	{SUBSHELL, PIPE_SEMI_SEQUENCE},
-
 	{COMPOUND_COMMAND, LINEBREAK},
 	{COMPOUND_COMMAND, TK_BANG},
 	{COMPOUND_COMMAND, SEPARATOR_OP},
 	{COMPOUND_COMMAND, NEWLINE_LIST},
 	{COMPOUND_COMMAND, PIPE_SEMI_SEQUENCE},
 	{COMPOUND_COMMAND, FUNC},
-
 	{COMMAND, LINEBREAK},
 	{COMMAND, TK_BANG},
 	{COMMAND, SEPARATOR_OP},
 	{COMMAND, NEWLINE_LIST},
 	{COMMAND, PIPE_SEMI_SEQUENCE},
-
 	{PIPE_SEQUENCE, LINEBREAK},
 	{PIPE_SEQUENCE, TK_BANG},
 	{PIPE_SEQUENCE, SEPARATOR_OP},
 	{PIPE_SEQUENCE, NEWLINE_LIST},
-	
+	{PIPE_SEMI_SEQUENCE, LINEBREAK},
+	{PIPE_SEMI_SEQUENCE, TK_BANG},
+	{PIPE_SEMI_SEQUENCE, SEPARATOR_OP},
+	{PIPE_SEMI_SEQUENCE, NEWLINE_LIST},
 	{PIPELINE, LINEBREAK},
 	{PIPELINE, SEPARATOR_OP},
 	{PIPELINE, NEWLINE_LIST},
-
 	{AND_OR, LINEBREAK},
 	{AND_OR, SEPARATOR_OP},
 	{AND_OR, NEWLINE_LIST},
-	
 	{LIST, LINEBREAK},
 	{LIST, NEWLINE_LIST},
-
 	{COMPLETE_COMMAND, LINEBREAK},
 	{COMPLETE_COMMAND, NEWLINE_LIST},
-
 	{COMPLETE_COMMANDS, LINEBREAK},
 	{0, 0},
 };
@@ -448,7 +376,7 @@ int			eval_sym(t_sym stack, t_sym new_sym)
 	i = 0;
 	while (g_stackmatch[i].top)
 	{
-		if (new_sym == g_stackmatch[i].top && stack == g.stackmatch[i].under)
+		if (new_sym == g_stackmatch[i].top && stack == g_stackmatch[i].under)
 			return (0);
 		i++;
 	}
diff --git a/42sh/src/parser/ft_parse.c b/42sh/src/parser/ft_parse.c
index 8a2e2a44..a774e88f 100644
--- a/42sh/src/parser/ft_parse.c
+++ b/42sh/src/parser/ft_parse.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 14:30:22 by ariard            #+#    #+#             */
-/*   Updated: 2017/02/11 16:22:51 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 22:59:00 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -17,6 +17,8 @@ int			ft_parse(t_btree **ast, t_list **token)
 	t_sym			*new_sym;
 	t_sym			*stack;
 	t_parstate		state;
+//to delete
+	t_token			*content;
 
 	(void)ast;
 	state = UNDEFINED;
@@ -25,16 +27,18 @@ int			ft_parse(t_btree **ast, t_list **token)
 	push_stack(stack, LINEBREAK);
 	while (*token)
 	{
+		content = (*token)->content;
 		produce_sym(*stack, new_sym, token);	
 		DG("new sym %s", read_state(*new_sym));
 		if (eval_sym(*stack, *new_sym))
 			state = ERROR;
 		else
 		{
-//			aggregate_sym(&stack, new_sym);
-			//superflous sym
+			aggregate_sym(&stack, new_sym, &state, (*token)->next);
 			push_stack(++stack, *new_sym);
 		}
+		ft_putstr("\n");
+		ft_read_stack(stack);
 		if (*stack == PROGRAM)
 			state = SUCCESS;
 		if (state == ERROR)
@@ -42,8 +46,10 @@ int			ft_parse(t_btree **ast, t_list **token)
 		if (state == SUCCESS)
 			ft_putstr("success");
 //		build_tree(token, ast);
-		ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free);
+		if (*stack == TK_PIPE)
+			content->type = LINEBREAK;	
+		else
+			ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free);
 	}
-	ft_read_stack(stack);
 	return (0);
 }
diff --git a/42sh/src/parser/pop_stack.c b/42sh/src/parser/pop_stack.c
index 29e7045f..597d3867 100644
--- a/42sh/src/parser/pop_stack.c
+++ b/42sh/src/parser/pop_stack.c
@@ -6,15 +6,21 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 19:12:44 by ariard            #+#    #+#             */
-/*   Updated: 2017/02/09 20:02:05 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 22:51:52 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
 #include "parser.h"
 
-int			pop_stack(t_sym **stack, int k)
+int			pop_stack(t_sym **stack, t_sym erase_sym)
 {
-	while (k--)
-		*stack-- = 0;
+	t_sym	*temp;
+
+	DG("pop until :%s", read_state(erase_sym));
+	temp = *stack; 
+	while (*temp != erase_sym)
+		*temp-- = 0;
+	*temp-- = 0;
+	*stack = temp;
 	return (0);
 }	
diff --git a/42sh/src/parser/produce_sym.c b/42sh/src/parser/produce_sym.c
index 8dea1220..bf36bd82 100644
--- a/42sh/src/parser/produce_sym.c
+++ b/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/02/12 17:41:45 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 22:59:16 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,37 +14,49 @@
 
 t_prodmatch		g_prodmatch[] =
 {
-	{TK_WORD, TK_DLESS, HERE_END},
-	{TK_WORD, TK_DLESSDASH, HERE_END},
-	{TK_WORD, TK_LESS, FILENAME},
-	{TK_WORD, TK_LESSAND, FILENAME},
-	{TK_WORD, TK_GREAT, FILENAME},
-	{TK_WORD, TK_GREATAND, FILENAME},
-	{TK_WORD, TK_DGREAT, FILENAME},
-	{TK_WORD, TK_LESSGREAT, FILENAME},
-	{TK_WORD, TK_CLOBBER, FILENAME},
-	{TK_WORD, CMD_WORD, CMD_SUFFIX},
-	{TK_WORD, CMD_NAME, CMD_SUFFIX},
-	{TK_WORD, LINEBREAK, CMD_NAME},
-	{TK_WORD, NEWLINE_LIST, CMD_NAME},
-	{TK_WORD, IN, WORDLIST},
-	{{TK_WORD, CASE_LIST, PATTERN},
-	{TK_WORD, TK_PAREN_OPEN, PATTERN},	
-	
+	{TK_N_WORD, TK_DLESS, HERE_END},
+	{TK_N_WORD, TK_DLESSDASH, HERE_END},
+	{TK_N_WORD, TK_LESS, FILENAME},
+	{TK_N_WORD, TK_LESSAND, FILENAME},
+	{TK_N_WORD, TK_GREAT, FILENAME},
+	{TK_N_WORD, TK_GREATAND, FILENAME},
+	{TK_N_WORD, TK_DGREAT, FILENAME},
+	{TK_N_WORD, TK_LESSGREAT, FILENAME},
+	{TK_N_WORD, TK_CLOBBER, FILENAME},
+	{TK_N_WORD, CMD_WORD, CMD_SUFFIX},
+	{TK_N_WORD, CMD_NAME, CMD_SUFFIX},
+	{TK_N_WORD, LINEBREAK, CMD_NAME},
+	{TK_N_WORD, NEWLINE_LIST, CMD_NAME},
+//to delete	
+	{TK_N_WORD, TK_SEMI, CMD_NAME},
+
+	{TK_N_WORD, TK_BANG, CMD_NAME},
+	{TK_N_WORD, PIPE_SEMI_SEQUENCE, CMD_NAME},
+	{TK_N_WORD, SEPARATOR_OP, CMD_NAME},
+	{TK_N_WORD, IN, WORDLIST},
+	{TK_N_WORD, CASE_LIST, PATTERN},
+	{TK_N_WORD, TK_PAREN_OPEN, PATTERN},	
 	{TK_ASSIGNEMENT_WORD, LINEBREAK, CMD_PREFIX},
 	{TK_ASSIGNEMENT_WORD, TK_BANG, CMD_PREFIX},
 	{TK_ASSIGNEMENT_WORD, SEPARATOR_OP, CMD_PREFIX},
 	{TK_ASSIGNEMENT_WORD, NEWLINE_LIST, CMD_PREFIX},
-
 	{TK_NAME, LINEBREAK, FNAME},
 	{TK_NAME, TK_BANG, FNAME},
 	{TK_NAME, SEPARATOR_OP, FNAME},
 	{TK_NAME, NEWLINE_LIST, FNAME},
 	{TK_NAME, TK_FOR, NAME},
-
 	{TK_NEWLINE, COMPLETE_COMMANDS, NEWLINE_LIST},
 	{TK_NEWLINE, LINEBREAK, NEWLINE_LIST},
-	
+	{TK_SEMI, TERM, SEPARATOR_OP},
+	{TK_SEMI, LIST, SEPARATOR_OP},
+	{TK_SEMI, COMPLETE_COMMAND, SEPARATOR_OP},
+	{TK_SEMI, COMPLETE_COMMANDS, SEPARATOR_OP},
+	{TK_AMP, TERM, SEPARATOR_OP},
+	{TK_AMP, LIST, SEPARATOR_OP},	
+	{TK_AMP, COMPLETE_COMMAND, SEPARATOR_OP},
+	{TK_AMP, COMPLETE_COMMANDS, SEPARATOR_OP},
+
+
 	{0, 0, 0},
 };
 
@@ -54,13 +66,18 @@ int		produce_sym(t_sym stack, t_sym *new_sym, t_list **lst)
 	int			i;
 
 	token = (*lst)->content;
+	DG("produce stack : %s && token : %s", read_state(stack),
+	read_state(token->type));
 	i = 0;
-	*new_sym = NULL;
+	*new_sym = 0;
 	while (g_prodmatch[i].new_sym)
 	{
 		if (token->type == g_prodmatch[i].token
-			&& stack & g_prodmatch[i].stack)
+			&& stack == g_prodmatch[i].stack)
+		{
+			DG("MATCH : %s", read_state(g_prodmatch[i].new_sym));
 			*new_sym = g_prodmatch[i].new_sym;
+		}
 		i++;
 	}
 	if (!*new_sym)
diff --git a/42sh/src/parser/push_stack.c b/42sh/src/parser/push_stack.c
index a3cd4af9..1d0d9278 100644
--- a/42sh/src/parser/push_stack.c
+++ b/42sh/src/parser/push_stack.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 16:48:30 by ariard            #+#    #+#             */
-/*   Updated: 2017/02/09 20:00:35 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 20:19:33 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
diff --git a/42sh/src/parser/read_stack.c b/42sh/src/parser/read_stack.c
index e7505232..31c9bebc 100644
--- a/42sh/src/parser/read_stack.c
+++ b/42sh/src/parser/read_stack.c
@@ -6,7 +6,7 @@
 /*   By: ariard <ariard@student.42.fr>              +#+  +:+       +#+        */
 /*                                                +#+#+#+#+#+   +#+           */
 /*   Created: 2017/02/09 15:32:10 by ariard            #+#    #+#             */
-/*   Updated: 2017/02/10 01:41:47 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/13 22:40:40 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -14,8 +14,42 @@
 
 char			*read_state(t_sym current)
 {
+	if (current == PIPE_SEMI_SEQUENCE)
+		return ("PIPE_SEMI_SEQUENCE");
+	if (current == TK_PIPE)
+		return ("TK_PIPE");
+	if (current == PROGRAM)
+		return ("PROGRAM");
+	if (current == COMMAND)
+		return ("COMMAND");
+	if (current == PIPE_SEQUENCE)
+		return ("PIPE_SEQUENCE");
+	if (current == PIPELINE)
+		return ("PIPELINE");
+	if (current == AND_OR)
+		return ("AND_OR");
+	if (current == LIST)
+		return ("LIST");
+	if (current == COMPLETE_COMMAND)
+		return ("COMPLETE_COMMAND");
+	if (current == COMPLETE_COMMANDS)
+		return ("COMPLETE_COMMANDS");
+	if (current == TK_N_WORD)
+		return ("TK_WORD");
 	if (current == CMD_NAME)
 		return ("CMD_NAME");
+	if (current == HERE_END)
+		return ("HERE_END");
+	if (current == FILENAME)
+		return ("FILENAME");
+	if (current == CMD_SUFFIX)
+		return ("CMD_SUFFIX");
+	if (current == SIMPLE_COMMAND)
+		return ("SIMPLE_COMMAND");
+	if (current == TK_SEMI)
+		return ("TK_SEMI");
+	if (current == ALL)
+		return ("ALL");
 /*	if (current == NEWLINE_LIST)
 		return ("NEWLINE_LIST");
 	if (current == SYM_DLESS)
diff --git a/42sh/tofix b/42sh/tofix
new file mode 100644
index 00000000..f031f6a3
--- /dev/null
+++ b/42sh/tofix
@@ -0,0 +1,13 @@
+valeur all, all_separator, paren_case,
+integrer decoupe temporaire
+soigner les regles avec les separateurs
+ajouter linebreak sur token needed
+
+pour jack, jerter les separateurs a la formation
+rajouter les noms de tous les tokens pour la sortie d erreur
+
+->passer a une stack infinie
+->construire if, while, else if
+->tester les combinaisons deja existantes
+->integrer erreurs
+->erreur speciale : EOF