a lot of grammar

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 19:02:48 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/12 20:35:20 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -108,6 +108,7 @@ enum	e_sym
 	SEQUENTIAL_SEP,
 	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\

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 19:18:45 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/12 20:53:36 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -25,6 +25,11 @@ t_aggrematch		g_aggrematch[] =
 
 	{TK_DONE, COMPOUND_LIST, DO_GROUP, ALL, tant 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},
@@ -36,6 +41,10 @@ t_aggrematch		g_aggrematch[] =
 //do one
 	{LINEBREAK, TK_PAREN_CLOSE, TK_ESAC, CASE_ITEM_NS, tant que pattern ou '('},
 	{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_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},
@@ -93,19 +102,60 @@ t_aggrematch		g_aggrematch[] =
 	{LOOP, WHILE, WHILE_CLAUSE, ALL, WHILE},
 	{LOOP, UNTIL, UNTIL_CLAUSE, ALL, UNTIL},
 
-	{BRACE_GROUP, ALL, COMMAND, ALL, 0},
+	{BRACE_GROUP, ALL, COMPOUND_COMMAND, ALL, 0},
 
 	{FUNCTION_BODY, FUNC, FUNCTION_DEFINITION, ALL, 0},
 
 	{FUNCTION_DEFINITION, ALL, COMMAND, ALL, 0},
 
-	{UNTIL_CLAUSE, ALL, COMMAND, ALL, 0},
+	{UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
 
-	{WHILE_CLAUSE, ALL, COMMAND, ALL, 0},
+	{WHILE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
 
 	{ELSE_PART, COMPOUND_LIST, ELSE_PART, ALL, ELIF},
 
-	{IF_CLAUSE, ALL, COMMAND, ALL, 0}
+	{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, TK_BANG, PIPE_SEQUENCE, ALL, 0},
+	{COMMAND, SEPARATOR_OP, PIPE_SEQUENCE, ALL, 0},
+	{COMMAND, NEWLINE_LIST, 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},
+	{PIPELINE, SEPARATOR_OP, AND_OR, ALL, 0},
+
+	{AND_OR, SEPARATOR_OP, LIST, ALL, LIST},
+	{AND_OR, NEWLINE_LIST, LIST, ALL, 0},
+
+	{LIST, NEWLINE_LIST, COMPLETE_COMMAND, ALL, 0},
+
+	{COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, ALL, COMPLETE_COMMANDS},
+	{COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, ALL, 0},
+	
 	{0, 0, 0},
 }
 

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 19:18:30 by ariard           ###   ########.fr       */
+/*   Updated: 2017/02/12 21:08:57 by ariard           ###   ########.fr       */
 /*                                                                            */
 /* ************************************************************************** */
 
@@ -30,6 +30,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_IO_NUMBER, TK_BANG},
 	{TK_IO_NUMBER, SEPARATOR_OP},
 	{TK_IO_NUMBER, NEWWLINE_LIST},
+	{TK_IO_NUMBER, PIPE_SEMI_SEQUENCE},
 
 	{TK_AND_IF, AND_OR},
 
@@ -48,6 +49,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DLESS, TK_BANG},
 	{TK_DLESS, SEPARATOR_OP},
 	{TK_DLESS, NEWLINE_LIST},
+	{TK_DLESS, PIPE_SEMI_SEQUENCE},
 
 	{TK_DLESSDASH, TK_IO_NUMBER},
 	{TK_DLESSDASH, REDIRECT_LIST},
@@ -59,6 +61,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DLESSDASH, TK_BANG},
 	{TK_DLESSDASH, SEPARATOR_OP},
 	{TK_DLESSDASH, NEWLINE_LIST},
+	{TK_DLESSDASH, PIPE_SEMI_SEQUENCE},
 
 	{TK_DGREAT, TK_IO_NUMBER},
 	{TK_DGREAT, REDIRECT_LIST},
@@ -70,6 +73,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DGREAT, TK_BANG},
 	{TK_DGREAT, SEPARATOR_OP},
 	{TK_DGREAT, NEWLINE_LIST},
+	{TK_DGREAT, PIPE_SEMI_SEQUENCE},
 
 	{TK_LESSAND, TK_IO_NUMBER},
 	{TK_LESSAND, REDIRECT_LIST},
@@ -81,6 +85,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LESSAND, TK_BANG},
 	{TK_LESSAND, SEPARATOR_OP},
 	{TK_LESSAND, NEWLINE_LIST},
+	{TK_LESSAND, PIPE_SEMI_SEQUENCE},
 
 	{TK_GREATAND, TK_IO_NUMBER},
 	{TK_GREATAND, REDIRECT_LIST},
@@ -92,6 +97,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_GREATAND, TK_BANG},
 	{TK_GREATAND, SEPARATOR_OP},
 	{TK_GREATAND, NEWLINE_LIST},
+	{TK_GREATAND, PIPE_SEMI_SEQUENCE},
 
 	{TK_LESSGREAT, TK_IO_NUMBER},
 	{TK_LESSGREAT, REDIRECT_LIST},
@@ -103,6 +109,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LESSGREAT, TK_BANG},
 	{TK_LESSGREAT, SEPARATOR_OP},
 	{TK_LESSGREAT, NEWLINE_LIST},
+	{TK_LESSGREAT, PIPE_SEMI_SEQUENCE},
 
 	{TK_CLOBBER, TK_IO_NUMBER},
 	{TK_CLOBBER, REDIRECT_LIST},
@@ -114,11 +121,13 @@ t_stackmatch	g_stackmatch[] =
 	{TK_CLOBBER, TK_BANG},
 	{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},
 	
@@ -139,6 +148,7 @@ t_stackmatch	g_stackmatch[] =
 	{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},
@@ -148,21 +158,25 @@ t_stackmatch	g_stackmatch[] =
 	{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},
 
@@ -190,6 +204,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_PAREN_OPEN, TK_BANG},
 	{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},
@@ -214,7 +229,7 @@ t_stackmatch	g_stackmatch[] =
 	{LINEBREAK, TK_OR_IF},
 	{LINEBREAK, TK_PIPE},
 	{LINEBREAK, LINEBREAK},
-	{LINEBREAK, COMPLETECOMMANDS},
+	{LINEBREAK, COMPLETE_COMMANDS},
 	
 	{NEWLINE_LIST, NEWLINE_LIST},
 	{NEWLINE_LIST, NAME},
@@ -237,6 +252,7 @@ t_stackmatch	g_stackmatch[] =
 	{IO_HERE, TK_BANG},
 	{IO_HERE, SEPARATOR_OP},
 	{IO_HERE, NEWLINE_LIST},
+	{IO_HERE, PIPE_SEMI_SEQUENCE},
 
 	{FILENAME, TK_LESS},
 	{FILENAME, TK_LESSAND},
@@ -256,6 +272,7 @@ t_stackmatch	g_stackmatch[] =
 	{IO_FILE, TK_BANG},
 	{IO_FILE, SEPARATOR_OP},
 	{IO_FILE, NEWLINE_LIST},
+	{IO_FILE, PIPE_SEMI_SEQUENCE},
 
 	{IO_REDIRECT, REDIRECT_LIST},
 	{IO_REDIRECT, CMD_SUFFIX},
@@ -266,6 +283,7 @@ t_stackmatch	g_stackmatch[] =
 	{IO_REDIRECT, TK_BANG},
 	{IO_REDIRECT, SEPARATOR_OP},
 	{IO_REDIRECT, NEWLINE_LIST},
+	{IO_REDIRECT, PIPE_SEMI_SEQUENCE},
 
 	{REDIRECT_LIST, COMPOUND_COMMAND}
 
@@ -276,6 +294,7 @@ t_stackmatch	g_stackmatch[] =
 	{CMD_PREFIX, TK_BANG},
 	{CMD_PREFIX, SEPARATOR_OP},
 	{CMD_PREFIX, NEWLINE_LIST},
+	{CMD_PREFIX, PIPE_SEMI_SEQUENCE},
 
 	{CMD_WORD, CMD_PREFIX},
 	
@@ -283,11 +302,13 @@ t_stackmatch	g_stackmatch[] =
 	{CMD_NAME, TK_BANG},
 	{CMD_NAME, SEPARATOR_OP},
 	{CMD_NAME, NEWLINE_LIST},
+	{CMD_NAME, PIPE_SEMI_SEQUENCE},
 
 	{SIMPLE_COMMNAND, 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},
@@ -300,11 +321,13 @@ t_stackmatch	g_stackmatch[] =
 	{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},
 
@@ -312,16 +335,19 @@ t_stackmatch	g_stackmatch[] =
 	{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},
 	
@@ -329,6 +355,88 @@ t_stackmatch	g_stackmatch[] =
 	{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},
+
+	{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},
+	{COMPOUND_LIST, TK_UNTIL},
+	{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},
+	
+	{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},
 };
 

42sh/test.sh

@@ -1,2 +0,0 @@
-while [ 1 ] ; do
-	ls