fucking case grammar done

42sh/sample/case/case.sh

@@ -1,8 +1,12 @@
 case $rental in
-	"cat") echo "For $rental rental is Rs.20 per k/m.";;
+	("bus") case yolo in
-	"van") echo "For $rental rental is Rs.10 per k/m.";;
+			("bonjour") echo hello ;; 
-	"jeep") echo "For $rental rental is Rs.5 per k/m.";;
+			("hello") echo bonjour ;;
-	"bicycle") echo "For $rental rental 20 paisa per k/m.";;
+		esac
-	"enfield") echo "For $rental rental Rs.3  per k/m.";;
+		case yala in
-	"thunderbird") echo "For $rental rental Rs.5 per k/m.";;
+			("bonjour") echo hello ;;
+			("hello") echo yolo ;;
+		esac ;; 
+	("van") echo "For $rental rental is Rs.10 per k/m.";;
+	("jeep") echo "For $rental rental is Rs.5 per k/m.";;
 esac

42sh/src/lexer/get_reserved_words.c

@@ -49,6 +49,8 @@ int		get_reserved_words(t_list **alst)
 					token->type = TK_UNTIL;
 				else if (ft_strncmp(token->data, "case", 4) == 0)
 					token->type = TK_CASE;
+				else if (ft_strncmp(token->data, "esac", 4) == 0)
+					token->type = TK_ESAC;
 				else if (ft_strncmp(token->data, "for", 3) == 0)
 					token->type = TK_FOR;
 			}

42sh/src/lexer/lexer_sep.c

@@ -38,6 +38,7 @@ int		lexer_sep(t_list **alst, t_lexer *lexer)
 	else if (c == '|')
 		token->type = cn == '|' ? TK_OR_IF : TK_PIPE;
 	token->type = (c == ';') ? TK_SEMI : token->type;
+	token->type = (c == ';') && (cn == ';') ? TK_DSEMI : token->type;
 	lexer->pos += 1 + (token->type & (TK_AND_IF | TK_OR_IF) ? 1 : 0);
 	return (lexer_lex(&(*alst)->next, lexer));
 }

42sh/src/parser/aggregate_sym.c

@@ -18,7 +18,8 @@ t_aggrematch		g_aggrematch[] =
 	{TK_WORD, TK_PIPE, PATTERN, 0},
 	{TK_WORD, TK_IN, FOR_WORDLIST, TK_IN},
 	{TK_WORD, FOR_WORDLIST, FOR_WORDLIST, FOR_WORDLIST},
-	{TK_SEMI, FOR_WORDLIST, SEQUENTIAL_SEP, 0},
+	{TK_SEMI, FOR_WORDLIST, SEQUENTIAL_SEP, 0},	
+	{TK_DSEMI, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
 	{TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, 0},
 	{TK_PIPE, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR},
 	{TK_FI, ELSE_PART, IF_CLAUSE, TK_IF},
@@ -29,9 +30,8 @@ t_aggrematch		g_aggrematch[] =
 	{TK_DONE, CMD_SUPERIOR, DO_GROUP, TK_DO},
 	{TK_DONE, COMPOUND_LIST, DO_GROUP, TK_DO},
 //Esac ?
-	{TK_ESAC, CASE_LIST, CASE_CLAUSE, TK_CASE},
+	{TK_ESAC, TK_IN, CASE_CLAUSE, TK_CASE},	
 	{TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, TK_CASE},
-	{TK_ESAC, LINEBREAK, CASE_CLAUSE, TK_CASE},
 	{TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, TK_LBRACE},
 	{TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, TK_PAREN_OPEN},	
 	{TK_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
@@ -39,8 +39,10 @@ t_aggrematch		g_aggrematch[] =
 //watch this
 	{SEPARATOR_OP, CMD_SUPERIOR, SEPARATOR, 0},
 	{SEPARATOR_OP, COMPOUND_LIST, SEPARATOR, 0},
+	{SEPARATOR_OP, CASE_LIST_NS, SEPARATOR, 0},
 	{SEPARATOR_OP, PIPE_SEMI_SEQUENCE, SEPARATOR, 0},
 	{SEPARATOR, CMD_SUPERIOR, END_COMMAND, CMD_SUPERIOR},
+	{SEPARATOR, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS}, 
 	{SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
 	{SEPARATOR, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
 	{LINEBREAK, SEPARATOR_OP, SEPARATOR, SEPARATOR_OP},
@@ -57,11 +59,12 @@ t_aggrematch		g_aggrematch[] =
 	{LINEBREAK, CMD_SUPERIOR, SEPARATOR_OP, 0},
 	{LINEBREAK, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
 	{LINEBREAK, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
+	{LINEBREAK, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
 	{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
 	{NEWLINE_LIST, CMD_NAME, CMD_SUPERIOR, CMD_NAME},
 	{NEWLINE_LIST,  SEQUENTIAL_SEP, SEQUENTIAL_SEP, SEQUENTIAL_SEP},
 	{NEWLINE_LIST, TK_DO, TK_DO, TK_DO},
-	{NEWLINE_LIST, TK_DO, TK_DO, TK_DO},
+	{NEWLINE_LIST, TK_PAREN_CLOSE, TK_PAREN_CLOSE, TK_PAREN_CLOSE},
 	{NEWLINE_LIST, TK_IN, TK_IN, TK_IN},
 	{NEWLINE_LIST, TK_THEN, TK_THEN, TK_THEN},
 	{NEWLINE_LIST, TK_IF, TK_IF, TK_IF},
@@ -69,11 +72,13 @@ t_aggrematch		g_aggrematch[] =
 	{NEWLINE_LIST, TK_ELSE, TK_ELSE, TK_ELSE},
 	{NEWLINE_LIST, TK_WHILE, TK_WHILE, TK_WHILE},
 	{NEWLINE_LIST, TK_UNTIL, TK_UNTIL, TK_UNTIL},
+	{NEWLINE_LIST, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
 	{NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, NEWLINE},
 	{NEWLINE_LIST, NAME, SEQUENTIAL_SEP, 0},
 	{NEWLINE_LIST, IN, SEQUENTIAL_SEP, 0},
 	{NEWLINE_LIST, TERM, SEPARATOR, 0},
 	{NEWLINE_LIST, COMPOUND_LIST, SEPARATOR, 0},
+	{NEWLINE_LIST, CASE_LIST_NS, SEPARATOR, 0},
 	{NEWLINE_LIST, COMPLETE_CONDITION, COMPLETE_CONDITION, COMPLETE_CONDITION},
 	{NEWLINE_LIST, CONDITION, CONDITION, CONDITION},
 	{NEWLINE_LIST, COMPLETE_COMMANDS, LINEBREAK, 0},
@@ -128,11 +133,13 @@ t_aggrematch		g_aggrematch[] =
 	{CMD_NAME, TK_WHILE, CMD_SUPERIOR, 0},
 	{CMD_NAME, TK_UNTIL, CMD_SUPERIOR, 0},
 	{CMD_NAME, TK_DO, CMD_SUPERIOR, 0},
+	{CMD_NAME, TK_PAREN_CLOSE, CMD_SUPERIOR, 0},
 	{CMD_NAME, TK_IF, CMD_SUPERIOR, 0},
 	{CMD_NAME, TK_ELIF, CMD_SUPERIOR, 0},
 	{CMD_NAME, TK_ELSE, CMD_SUPERIOR, 0},
 	{CMD_NAME, TK_THEN, CMD_SUPERIOR, 0},
 	{CMD_NAME, COMPOUND_LIST, CMD_SUPERIOR, 0},
+	{CMD_NAME, CASE_LIST_NS, CMD_SUPERIOR, 0},
 	{CMD_NAME, COMPLETE_CONDITION, CMD_SUPERIOR, 0},
 	{CMD_NAME, TK_PIPE, CMD_SUPERIOR, 0},
 	{CMD_NAME, PIPE_SEMI_SEQUENCE, CMD_SUPERIOR, 0},
@@ -153,21 +160,19 @@ t_aggrematch		g_aggrematch[] =
 //	{ELSE_PART, COMPOUND_LIST, ELSE_PART, TK_ELIF},
 //	{ELSE_PART, COMPLETE_CONDITION, IF_CLAUSE, COMPLETE_CONDITION},
 	{IF_CLAUSE, ALL, COMPOUND_COMMAND, 0},
-	{PATTERN, TK_PAREN_OPEN, PATTERN_CASE, TK_PAREN_OPEN},
 	{PATTERN, CASE_LIST, PATTERN_CASE, 0},
-	{CASE_ITEM, CASE_LIST, CASE_LIST, CASE_LIST},
+	{CASE_LIST_NS, TK_IN, TK_IN, TK_IN},
-	{CASE_ITEM, LINEBREAK, CASE_LIST, CASE_LIST},
-	{CASE_ITEM_NS, CASE_LIST, CASE_LIST_NS, CASE_LIST},
-	{CASE_ITEM_NS, LINEBREAK, CASE_LIST_NS, CASE_LIST},
 	{CASE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
 	{FOR_CLAUSE, ALL, COMPOUND_COMMAND, 0},
 	{TERM, LINEBREAK, COMPOUND_LIST, LINEBREAK},
 //	{COMPOUND_LIST, TK_ELSE, ELSE_PART, TK_ELSE},
 	{COMPOUND_LIST, TK_IF, CONDITION, TK_IF},
 	{COMPOUND_LIST, TK_THEN, CONDITION, TK_THEN},
+	{COMPOUND_LIST, TK_PAREN_CLOSE, CASE_LIST_NS, TK_PAREN_OPEN},
 	{COMPOUND_LIST, COMPLETE_CONDITION, COMPLETE_CONDITION, COMPLETE_CONDITION},
 //	{COMPOUND_LIST, TK_THEN, ELSE_PART, TK_ELIF},
 	{COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
+	{COMPOUND_LIST, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
 	{SUBSHELL, ALL, COMPOUND_COMMAND, 0},
 	{COMPOUND_COMMAND, ALL, COMMAND, 0},
 	{AND_OR_MINOR, PIPE_SEMI_SEQUENCE, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE},
@@ -176,9 +181,11 @@ t_aggrematch		g_aggrematch[] =
 	{AND_OR_MINOR, AND_OR_MAJOR, AND_OR_MAJOR, 0},
 	{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE},
 	{COMMAND, COMPOUND_LIST, PIPE_SEMI_SEQUENCE, 0},
+	{COMMAND, CASE_LIST_NS, PIPE_SEMI_SEQUENCE, 0}, 
 	{COMMAND, TK_WHILE, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, TK_UNTIL, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, TK_DO, PIPE_SEMI_SEQUENCE, 0},
+	{COMMAND, TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, TK_IF, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, TK_THEN, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, TK_ELIF, PIPE_SEMI_SEQUENCE, 0},
@@ -199,13 +206,14 @@ t_aggrematch		g_aggrematch[] =
 	{END_COMMAND, LINEBREAK, PIPE_SEQUENCE, 0},
 	{END_COMMAND, COMPLETE_COMMANDS, PIPE_SEQUENCE, 0},
 	{END_COMMAND, TK_DO, PIPE_SEQUENCE, 0},
-	{END_COMMAND, TK_DO, PIPE_SEQUENCE, 0},
+	{END_COMMAND, TK_PAREN_CLOSE, PIPE_SEQUENCE, 0},
 	{END_COMMAND, TK_IF, PIPE_SEQUENCE, 0},
 	{END_COMMAND, TK_ELIF, PIPE_SEQUENCE, 0},
 	{END_COMMAND, TK_THEN, PIPE_SEQUENCE, 0},
 	{END_COMMAND, TK_ELSE, PIPE_SEQUENCE, 0},
 	{END_COMMAND, COMPLETE_CONDITION, PIPE_SEQUENCE, 0},
 	{END_COMMAND, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
+	{END_COMMAND, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
 	{PIPE_SEQUENCE, TK_WHILE, PIPELINE, 0},
 	{PIPE_SEQUENCE, TK_UNTIL, PIPELINE, 0},
 	{PIPE_SEQUENCE, TK_BANG, PIPELINE, TK_BANG},
@@ -215,20 +223,25 @@ t_aggrematch		g_aggrematch[] =
 	{PIPE_SEQUENCE, COMPLETE_COMMANDS, PIPELINE, 0},
 	{PIPE_SEQUENCE, AND_OR_MAJOR, PIPELINE, 0},
 	{PIPE_SEQUENCE, TK_DO, PIPELINE, 0},
+	{PIPE_SEQUENCE, TK_PAREN_CLOSE, PIPELINE, 0},
 	{PIPE_SEQUENCE, TK_IF, PIPELINE, 0},
 	{PIPE_SEQUENCE, TK_ELIF, PIPELINE, 0},
 	{PIPE_SEQUENCE, TK_THEN, PIPELINE, 0},
 	{PIPE_SEQUENCE, TK_ELSE, PIPELINE, 0},
 	{PIPE_SEQUENCE, COMPOUND_LIST, PIPELINE, 0},
+	{PIPE_SEQUENCE, CASE_LIST_NS, PIPELINE, 0},
 	{PIPE_SEQUENCE, COMPLETE_CONDITION, PIPELINE, 0},
 	{PIPELINE, TK_WHILE, AND_OR, 0},
 	{PIPELINE, TK_UNTIL, AND_OR, 0},
 	{PIPELINE, TK_DO, AND_OR, 0},
+	{PIPELINE, TK_PAREN_CLOSE, AND_OR, 0},
+	{PIPELINE, TK_IF, AND_OR, 0},
 	{PIPELINE, TK_IF, AND_OR, 0},
 	{PIPELINE, TK_ELIF, AND_OR, 0},
 	{PIPELINE, TK_THEN, AND_OR, 0},
 	{PIPELINE, TK_ELSE, AND_OR, 0},
 	{PIPELINE, COMPOUND_LIST, AND_OR, 0},
+	{PIPELINE, CASE_LIST_NS, AND_OR, 0},
 	{PIPELINE, LINEBREAK, AND_OR, 0},
 	{PIPELINE, COMPLETE_COMMANDS, AND_OR, 0},
 //	{PIPELINE, LINEBREAK, AND_OR, AND_OR},
@@ -237,6 +250,7 @@ t_aggrematch		g_aggrematch[] =
 	{PIPELINE, AND_OR_MAJOR, AND_OR, AND_OR_MAJOR},
 	{AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR},
 	{AND_OR, TK_DO, COMPOUND_LIST, 0},
+	{AND_OR, TK_PAREN_CLOSE, COMPOUND_LIST, 0},
 	{AND_OR, TK_WHILE, COMPOUND_LIST, 0},
 	{AND_OR, TK_UNTIL, COMPOUND_LIST, 0},
 	{AND_OR, TK_IF, COMPOUND_LIST, 0},
@@ -244,6 +258,7 @@ t_aggrematch		g_aggrematch[] =
 	{AND_OR, TK_THEN, COMPOUND_LIST, 0},
 	{AND_OR, TK_ELSE, COMPOUND_LIST, 0},
 	{AND_OR, COMPOUND_LIST, COMPOUND_LIST, 0},
+	{AND_OR, CASE_LIST_NS, CASE_LIST_NS, 0},
 	{AND_OR, COMPLETE_CONDITION, COMPOUND_LIST, 0},
 	{AND_OR, SEPARATOR_OP, LIST, LIST},
 	{AND_OR, NEWLINE_LIST, LIST, 0},

42sh/src/parser/eval_sym.c

@@ -43,6 +43,8 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DSEMI, LINEBREAK},
 	{TK_DSEMI, COMPLETE_COMMANDS},
 	{TK_DSEMI, COMPOUND_LIST},
+	{TK_DSEMI, CASE_LIST_NS},
+	{TK_DSEMI, PIPE_SEMI_SEQUENCE},
 	{TK_LESS, TK_IO_NUMBER},
 	{TK_LESS, REDIRECT_LIST},
 	{TK_LESS, CMD_SUFFIX},
@@ -185,9 +187,9 @@ t_stackmatch	g_stackmatch[] =
 	{TK_CLOBBER, AND_OR_MAJOR},
 
 	{TK_IF, LINEBREAK},
+	{TK_IF, TK_PAREN_CLOSE},
 	{TK_IF, COMPLETE_COMMANDS},
 	{TK_IF, TK_BANG},
-	{TK_IF, TK_BANG},
 	{TK_IF, SEPARATOR_OP},
 	{TK_IF, NEWLINE_LIST},
 	{TK_IF, PIPE_SEMI_SEQUENCE},
@@ -196,9 +198,12 @@ t_stackmatch	g_stackmatch[] =
 	{TK_IF, TK_IF},
 	{TK_IF, TK_DO},
 	{TK_IF, TK_ELIF},
+	{TK_IF, TK_ELSE},
 	{TK_IF, TK_THEN},
+	{TK_IF, TK_PAREN_CLOSE},
 	{TK_IF, COMPLETE_CONDITION},
 	{TK_IF, COMPOUND_LIST},
+	{TK_IF, CASE_LIST_NS},
 	{TK_THEN, CONDITION},
 	{TK_THEN, COMPOUND_LIST},
 	{TK_ELSE, COMPOUND_LIST},
@@ -223,15 +228,25 @@ t_stackmatch	g_stackmatch[] =
 	{TK_CASE, LINEBREAK},
 	{TK_CASE, COMPLETE_COMMANDS},
 	{TK_CASE, TK_BANG},
-	{TK_CASE, TK_BANG},
+	{TK_CASE, TK_DO},
+	{TK_CASE, TK_THEN},
+	{TK_CASE, TK_PAREN_CLOSE},
+	{TK_CASE, TK_WHILE},
+	{TK_CASE, TK_UNTIL},
+	{TK_CASE, TK_IF},
+	{TK_CASE, TK_ELIF},
+	{TK_CASE, TK_ELSE},
+	{TK_CASE, COMPLETE_CONDITION},
+	{TK_CASE, CASE_LIST_NS},
+	{TK_CASE, COMPOUND_LIST},
 	{TK_CASE, NEWLINE_LIST},
 	{TK_CASE, SEPARATOR_OP},
 	{TK_CASE, PIPE_SEMI_SEQUENCE},
 	{TK_IN, TK_WORD},
 	{TK_IN, NAME},
-	{TK_ESAC, CASE_LIST},
 	{TK_ESAC, CASE_LIST_NS},
 	{TK_ESAC, LINEBREAK},
+	{TK_ESAC, TK_IN},
 	{TK_WHILE, LINEBREAK},
 	{TK_WHILE, COMPLETE_COMMANDS},
 	{TK_WHILE, TK_BANG},
@@ -239,25 +254,32 @@ t_stackmatch	g_stackmatch[] =
 	{TK_WHILE, NEWLINE_LIST},
 	{TK_WHILE, PIPE_SEMI_SEQUENCE},
 	{TK_WHILE, TK_DO},
+	{TK_WHILE, TK_PAREN_CLOSE},
 	{TK_WHILE, TK_WHILE},
 	{TK_WHILE, COMPOUND_LIST},
+	{TK_WHILE, CASE_LIST_NS},
 	{TK_WHILE, TK_IF},
 	{TK_WHILE, TK_ELIF},
+	{TK_WHILE, TK_ELSE},
+	{TK_WHILE, TK_PAREN_CLOSE},
 	{TK_WHILE, TK_THEN},
 	{TK_WHILE, COMPLETE_CONDITION},
 	{TK_UNTIL, LINEBREAK},
 	{TK_UNTIL, COMPLETE_COMMANDS},
 	{TK_UNTIL, TK_BANG},
-	{TK_UNTIL, TK_BANG},
 	{TK_UNTIL, SEPARATOR_OP},
 	{TK_UNTIL, NEWLINE_LIST},
 	{TK_UNTIL, PIPE_SEMI_SEQUENCE},
 	{TK_UNTIL, TK_DO},
+	{TK_UNTIL, TK_PAREN_CLOSE},
 	{TK_UNTIL, TK_WHILE},
 	{TK_UNTIL, COMPOUND_LIST},
+	{TK_UNTIL, CASE_LIST_NS},
 	{TK_UNTIL, TK_IF},
 	{TK_UNTIL, TK_ELIF},
+	{TK_UNTIL, TK_ELSE},
 	{TK_UNTIL, TK_THEN},
+	{TK_UNTIL, TK_PAREN_CLOSE},
 	{TK_UNTIL, COMPLETE_CONDITION},
 	{TK_FOR, LINEBREAK},
 	{TK_FOR, COMPLETE_COMMANDS},
@@ -267,11 +289,15 @@ t_stackmatch	g_stackmatch[] =
 	{TK_FOR, NEWLINE_LIST},
 	{TK_FOR, PIPE_SEMI_SEQUENCE},
 	{TK_FOR, TK_DO},
+	{TK_FOR, TK_PAREN_CLOSE},
 	{TK_FOR, TK_WHILE},
 	{TK_FOR, COMPOUND_LIST},
+	{TK_FOR, CASE_LIST_NS},
 	{TK_FOR, TK_IF},
 	{TK_FOR, TK_ELIF},
 	{TK_FOR, TK_THEN},
+	{TK_FOR, TK_ELSE},
+	{TK_FOR, TK_PAREN_CLOSE},
 	{TK_FOR, COMPLETE_CONDITION},
 	{TK_LBRACE, LINEBREAK},
 	{TK_LBRACE, COMPLETE_COMMANDS},
@@ -280,6 +306,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LBRACE, NEWLINE_LIST},
 	{TK_LBRACE, PIPE_SEMI_SEQUENCE},
 	{TK_RBRACE, COMPOUND_LIST},
+	{TK_RBRACE, CASE_LIST_NS},
 	{TK_BANG, LINEBREAK},
 	{TK_BANG, COMPLETE_COMMANDS},
 	{TK_BANG, SEPARATOR_OP},
@@ -299,6 +326,8 @@ t_stackmatch	g_stackmatch[] =
 	{TK_PIPE, PATTERN},
 	{TK_PIPE, CMD_SUPERIOR},
 	{TK_PAREN_OPEN, FNAME},
+	{TK_PAREN_OPEN, CASE_LIST_NS},
+	{TK_PAREN_OPEN, TK_IN},
 	{TK_PAREN_OPEN, CASE_LIST},
 	{TK_PAREN_OPEN, LINEBREAK},
 	{TK_PAREN_OPEN, COMPLETE_COMMANDS},
@@ -319,6 +348,7 @@ t_stackmatch	g_stackmatch[] =
 	{END_COMMAND, TK_WHILE},
 	{END_COMMAND, TK_UNTIL},
 	{END_COMMAND, TK_DO},
+	{END_COMMAND, TK_PAREN_CLOSE},
 	{END_COMMAND, TK_IF},
 	{END_COMMAND, TK_THEN},
 	{END_COMMAND, TK_ELIF},
@@ -326,15 +356,17 @@ t_stackmatch	g_stackmatch[] =
 	{END_COMMAND, LINEBREAK},
 	{END_COMMAND, COMPLETE_COMMANDS},
 	{END_COMMAND, COMPOUND_LIST},
-	{END_COMMAND, COMPOUND_LIST},
+	{END_COMMAND, CASE_LIST_NS},
 	{END_COMMAND, COMPLETE_CONDITION},
 	{SEPARATOR, CMD_SUPERIOR},
 	{SEPARATOR, TERM},
 	{SEPARATOR, COMPOUND_LIST},
+	{SEPARATOR, CASE_LIST_NS},
 	{SEPARATOR, PIPE_SEMI_SEQUENCE},
 	{SEPARATOR_OP, CMD_SUPERIOR},
 	{SEPARATOR_OP, LIST},
 	{SEPARATOR_OP, TERM},
+	{SEPARATOR_OP, CASE_LIST_NS},
 	{SEPARATOR_OP, COMPOUND_LIST},
 	{SEPARATOR_OP, PIPE_SEMI_SEQUENCE},
 	{LINEBREAK, TK_SEMI},
@@ -352,8 +384,11 @@ t_stackmatch	g_stackmatch[] =
 	{LINEBREAK, CMD_SUPERIOR},
 	{LINEBREAK, PIPE_SEMI_SEQUENCE},
 	{LINEBREAK, COMPOUND_LIST},
+	{LINEBREAK, CASE_LIST_NS},
 	{LINEBREAK, PROGRAM},
 	{NEWLINE_LIST, TK_DO},
+	{NEWLINE_LIST, CASE_LIST_NS},
+	{NEWLINE_LIST, TK_PAREN_CLOSE},
 	{NEWLINE_LIST, SEQUENTIAL_SEP},
 	{NEWLINE_LIST, FOR_WORDLIST},
 	{NEWLINE_LIST, TK_IN},
@@ -370,6 +405,7 @@ t_stackmatch	g_stackmatch[] =
 	{NEWLINE_LIST, WORDLIST},
 	{NEWLINE_LIST, TERM},
 	{NEWLINE_LIST, COMPOUND_LIST},
+	{NEWLINE_LIST, CASE_LIST_NS},
 	{NEWLINE_LIST, COMPLETE_COMMANDS},
 	{NEWLINE_LIST, COMPLETE_CONDITION},
 	{NEWLINE_LIST, CONDITION},
@@ -448,21 +484,25 @@ t_stackmatch	g_stackmatch[] =
 	{CMD_NAME, TK_WHILE},
 	{CMD_NAME, TK_UNTIL},
 	{CMD_NAME, TK_DO},
+	{CMD_NAME, TK_PAREN_CLOSE},
 	{CMD_NAME, TK_IF},
 	{CMD_NAME, TK_ELIF},
 	{CMD_NAME, TK_THEN},
 	{CMD_NAME, TK_ELSE},
 	{CMD_NAME, COMPOUND_LIST},
+	{CMD_NAME, CASE_LIST_NS},
 	{CMD_NAME, COMPLETE_CONDITION},
 
 	{CMD_SUPERIOR, TK_WHILE},
 	{CMD_SUPERIOR, TK_UNTIL},
 	{CMD_SUPERIOR, TK_DO},
+	{CMD_SUPERIOR, TK_PAREN_CLOSE},
 	{CMD_SUPERIOR, TK_IF},
 	{CMD_SUPERIOR, TK_ELIF},
 	{CMD_SUPERIOR, TK_THEN},
 	{CMD_SUPERIOR, TK_ELSE},
 	{CMD_SUPERIOR, COMPOUND_LIST},
+	{CMD_SUPERIOR, CASE_LIST_NS},
 	{CMD_SUPERIOR, COMPLETE_CONDITION},
 	{CMD_SUPERIOR, LINEBREAK},
 	{CMD_SUPERIOR, COMPLETE_COMMANDS},
@@ -477,11 +517,13 @@ t_stackmatch	g_stackmatch[] =
 	{SIMPLE_COMMAND, TK_WHILE},
 	{SIMPLE_COMMAND, TK_UNTIL},
 	{SIMPLE_COMMAND, TK_DO},
+	{SIMPLE_COMMAND, TK_PAREN_CLOSE},
 	{SIMPLE_COMMAND, TK_IF},
 	{SIMPLE_COMMAND, TK_ELIF},
 	{SIMPLE_COMMAND, TK_THEN},
 	{SIMPLE_COMMAND, TK_ELSE},
 	{SIMPLE_COMMAND, COMPOUND_LIST},
+	{SIMPLE_COMMAND, CASE_LIST_NS},
 	{SIMPLE_COMMAND, COMPLETE_CONDITION},
 	{SIMPLE_COMMAND, LINEBREAK},
 	{SIMPLE_COMMAND, COMPLETE_COMMANDS},
@@ -500,7 +542,7 @@ t_stackmatch	g_stackmatch[] =
 	{CONDITION, LINEBREAK},
 	{CONDITION, COMPLETE_COMMANDS},
 	{CONDITION, COMPOUND_LIST},
-	{CONDITION, COMPOUND_LIST},
+	{CONDITION, CASE_LIST_NS},
 	{CONDITION, COMPLETE_CONDITION},
 	{COMPLETE_CONDITION, LINEBREAK},
 	{COMPLETE_CONDITION, COMPLETE_COMMANDS},
@@ -536,6 +578,7 @@ t_stackmatch	g_stackmatch[] =
 	{UNTIL_CLAUSE, NEWLINE_LIST},
 	{UNTIL_CLAUSE, PIPE_SEMI_SEQUENCE},
 	{UNTIL_CLAUSE, TK_DO},
+	{UNTIL_CLAUSE, TK_PAREN_CLOSE},
 	{UNTIL_CLAUSE, TK_WHILE},
 	{UNTIL_CLAUSE, TK_UNTIL},
 	{UNTIL_CLAUSE, TK_IF},
@@ -543,6 +586,7 @@ t_stackmatch	g_stackmatch[] =
 	{UNTIL_CLAUSE, TK_THEN},
 	{UNTIL_CLAUSE, TK_ELSE},
 	{UNTIL_CLAUSE, COMPOUND_LIST},
+	{UNTIL_CLAUSE, CASE_LIST_NS},
 	{UNTIL_CLAUSE, COMPLETE_CONDITION},
 	{WHILE_CLAUSE, LINEBREAK},
 	{WHILE_CLAUSE, COMPLETE_COMMANDS},
@@ -551,6 +595,7 @@ t_stackmatch	g_stackmatch[] =
 	{WHILE_CLAUSE, NEWLINE_LIST},
 	{WHILE_CLAUSE, PIPE_SEMI_SEQUENCE},
 	{WHILE_CLAUSE, TK_DO},
+	{WHILE_CLAUSE, TK_PAREN_CLOSE},
 	{WHILE_CLAUSE, TK_WHILE},
 	{WHILE_CLAUSE, TK_UNTIL},
 	{WHILE_CLAUSE, TK_IF},
@@ -558,6 +603,7 @@ t_stackmatch	g_stackmatch[] =
 	{WHILE_CLAUSE, TK_THEN},
 	{WHILE_CLAUSE, TK_ELSE},
 	{WHILE_CLAUSE, COMPOUND_LIST},
+	{WHILE_CLAUSE, CASE_LIST_NS},
 	{WHILE_CLAUSE, COMPLETE_CONDITION},
 //	{ELSE_PART, COMPOUND_LIST},
 //	{ELSE_PART, COMPLETE_CONDITION},
@@ -568,6 +614,7 @@ t_stackmatch	g_stackmatch[] =
 	{IF_CLAUSE, NEWLINE_LIST},
 	{IF_CLAUSE, PIPE_SEMI_SEQUENCE},
 	{IF_CLAUSE, TK_DO},
+	{IF_CLAUSE, TK_PAREN_CLOSE},
 	{IF_CLAUSE, TK_WHILE},
 	{IF_CLAUSE, TK_UNTIL},
 	{IF_CLAUSE, TK_IF},
@@ -575,6 +622,7 @@ t_stackmatch	g_stackmatch[] =
 	{IF_CLAUSE, TK_THEN},
 	{IF_CLAUSE, TK_ELSE},
 	{IF_CLAUSE, COMPOUND_LIST},
+	{IF_CLAUSE, CASE_LIST_NS},
 	{IF_CLAUSE, COMPLETE_COMMAND},
 	{IF_CLAUSE, COMPLETE_CONDITION},
 
@@ -582,19 +630,26 @@ t_stackmatch	g_stackmatch[] =
 	{PATTERN, CASE_LIST},
 	{PATTERN, TK_IN},
 	{PATTERN_CASE, 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, COMPLETE_COMMANDS},
 	{CASE_CLAUSE, TK_BANG},
-	{CASE_CLAUSE, TK_BANG},
 	{CASE_CLAUSE, SEPARATOR_OP},
 	{CASE_CLAUSE, NEWLINE_LIST},
 	{CASE_CLAUSE, PIPE_SEMI_SEQUENCE},
+	{CASE_CLAUSE, TK_PAREN_CLOSE},
+	{CASE_CLAUSE, CASE_LIST_NS},
+	{CASE_CLAUSE, TK_DO},
+	{CASE_CLAUSE, TK_WHILE},
+	{CASE_CLAUSE, TK_UNTIL},
+	{CASE_CLAUSE, TK_IF},
+	{CASE_CLAUSE, TK_ELIF},
+	{CASE_CLAUSE, TK_THEN},
+	{CASE_CLAUSE, TK_ELSE},
+	{CASE_CLAUSE, COMPOUND_LIST},
+	{CASE_CLAUSE, CASE_LIST_NS},
+	{CASE_CLAUSE, COMPLETE_COMMAND},
+	
 	{WORDLIST, IN},
 	{IN, LINEBREAK},
 	{NAME, TK_FOR},
@@ -607,6 +662,7 @@ t_stackmatch	g_stackmatch[] =
 	{FOR_CLAUSE, NEWLINE_LIST},
 	{FOR_CLAUSE, PIPE_SEMI_SEQUENCE},
 	{FOR_CLAUSE, TK_DO},
+	{FOR_CLAUSE, TK_PAREN_CLOSE},
 	{FOR_CLAUSE, TK_WHILE},
 	{FOR_CLAUSE, TK_UNTIL},
 	{FOR_CLAUSE, TK_IF},
@@ -614,11 +670,12 @@ t_stackmatch	g_stackmatch[] =
 	{FOR_CLAUSE, TK_THEN},
 	{FOR_CLAUSE, TK_ELSE},
 	{FOR_CLAUSE, COMPOUND_LIST},
+	{FOR_CLAUSE, CASE_LIST_NS},
 	{FOR_CLAUSE, COMPLETE_CONDITION},
 	{TERM, LINEBREAK},
 	{TERM, COMPLETE_COMMANDS},
 	{COMPOUND_LIST, TK_DO},
-	{COMPOUND_LIST, TK_DO},
+	{COMPOUND_LIST, TK_PAREN_CLOSE},
 	{COMPOUND_LIST, TK_LBRACE},
 	{COMPOUND_LIST, TK_WHILE},
 	{COMPOUND_LIST, TK_UNTIL},
@@ -645,6 +702,7 @@ t_stackmatch	g_stackmatch[] =
 	{COMPOUND_COMMAND, PIPE_SEMI_SEQUENCE},
 	{COMPOUND_COMMAND, FUNC},
 	{COMPOUND_COMMAND, TK_DO},
+	{COMPOUND_COMMAND, TK_PAREN_CLOSE},
 	{COMPOUND_COMMAND, TK_WHILE},
 	{COMPOUND_COMMAND, TK_UNTIL},
 	{COMPOUND_COMMAND, TK_IF},
@@ -652,18 +710,20 @@ t_stackmatch	g_stackmatch[] =
 	{COMPOUND_COMMAND, TK_THEN},
 	{COMPOUND_COMMAND, TK_ELSE},
 	{COMPOUND_COMMAND, COMPOUND_LIST},
+	{COMPOUND_COMMAND, CASE_LIST_NS},
 	{COMPOUND_COMMAND, COMPLETE_CONDITION},
 	{COMMAND, TK_WHILE},
 	{COMMAND, TK_UNTIL},
 	{COMMAND, LINEBREAK},
 	{COMMAND, COMPLETE_COMMANDS},
 	{COMMAND, TK_DO},
-	{COMMAND, TK_DO},
+	{COMMAND, TK_PAREN_CLOSE},
 	{COMMAND, TK_IF},
 	{COMMAND, TK_ELIF},
 	{COMMAND, TK_THEN},
 	{COMMAND, TK_ELSE},
 	{COMMAND, COMPOUND_LIST},
+	{COMMAND, CASE_LIST_NS},
 	{COMMAND, COMPLETE_CONDITION},
 	{COMMAND, TK_BANG},
 	{COMMAND, SEPARATOR_OP},
@@ -678,11 +738,13 @@ t_stackmatch	g_stackmatch[] =
 	{PIPE_SEQUENCE, TK_WHILE},
 	{PIPE_SEQUENCE, TK_UNTIL},
 	{PIPE_SEQUENCE, TK_DO},
+	{PIPE_SEQUENCE, TK_PAREN_CLOSE},
 	{PIPE_SEQUENCE, TK_IF},
 	{PIPE_SEQUENCE, TK_ELIF},
 	{PIPE_SEQUENCE, TK_THEN},
 	{PIPE_SEQUENCE, TK_ELSE},
 	{PIPE_SEQUENCE, COMPOUND_LIST},
+	{PIPE_SEQUENCE, CASE_LIST_NS},
 	{PIPE_SEQUENCE, COMPLETE_CONDITION},
 	{PIPE_SEQUENCE, LINEBREAK},
 	{PIPE_SEQUENCE, COMPLETE_COMMANDS},
@@ -694,11 +756,13 @@ t_stackmatch	g_stackmatch[] =
 	{PIPE_SEMI_SEQUENCE, TK_WHILE},
 	{PIPE_SEMI_SEQUENCE, TK_UNTIL},
 	{PIPE_SEMI_SEQUENCE, TK_DO},
+	{PIPE_SEMI_SEQUENCE, TK_PAREN_CLOSE},
 	{PIPE_SEMI_SEQUENCE, TK_IF},
 	{PIPE_SEMI_SEQUENCE, TK_ELIF},
 	{PIPE_SEMI_SEQUENCE, TK_THEN},
 	{PIPE_SEMI_SEQUENCE, TK_ELSE},
 	{PIPE_SEMI_SEQUENCE, COMPOUND_LIST},
+	{PIPE_SEMI_SEQUENCE, CASE_LIST_NS},
 	{PIPE_SEMI_SEQUENCE, COMPLETE_CONDITION},
 	{PIPE_SEMI_SEQUENCE, LINEBREAK},
 	{PIPE_SEMI_SEQUENCE, COMPLETE_COMMANDS},
@@ -710,11 +774,13 @@ t_stackmatch	g_stackmatch[] =
 	{PIPELINE, TK_WHILE},
 	{PIPELINE, TK_UNTIL},
 	{PIPELINE, TK_DO},
+	{PIPELINE, TK_PAREN_CLOSE},
 	{PIPELINE, TK_IF},
 	{PIPELINE, TK_ELIF},
 	{PIPELINE, TK_THEN},
 	{PIPELINE, TK_ELSE},
 	{PIPELINE, COMPOUND_LIST},
+	{PIPELINE, CASE_LIST_NS},
 	{PIPELINE, COMPLETE_CONDITION},
 	{PIPELINE, LINEBREAK},
 	{PIPELINE, COMPLETE_COMMANDS},
@@ -727,6 +793,7 @@ t_stackmatch	g_stackmatch[] =
 	{AND_OR_MAJOR, AND_OR_MAJOR},
 	{AND_OR_MAJOR, AND_OR_MAJOR},
 	{AND_OR, TK_DO},
+	{AND_OR, TK_PAREN_CLOSE},
 	{AND_OR, TK_WHILE},
 	{AND_OR, TK_UNTIL},
 	{AND_OR, TK_IF},
@@ -734,6 +801,7 @@ t_stackmatch	g_stackmatch[] =
 	{AND_OR, TK_THEN},
 	{AND_OR, TK_ELSE},
 	{AND_OR, COMPOUND_LIST},
+	{AND_OR, CASE_LIST_NS},
 	{AND_OR, COMPLETE_CONDITION},
 	{AND_OR, LINEBREAK},
 	{AND_OR, COMPLETE_COMMANDS},

42sh/src/parser/produce_sym.c

@@ -33,11 +33,13 @@ t_prodmatch		g_prodmatch[] =
 	{TK_WORD, TK_WHILE, CMD_NAME},
 	{TK_WORD, TK_UNTIL, CMD_NAME},
 	{TK_WORD, TK_DO, CMD_NAME},
+	{TK_WORD, TK_PAREN_CLOSE, CMD_NAME},
 	{TK_WORD, TK_IF, CMD_NAME},
 	{TK_WORD, TK_THEN, CMD_NAME},
 	{TK_WORD, TK_ELIF, CMD_NAME},
 	{TK_WORD, TK_ELSE, CMD_NAME},
 	{TK_WORD, COMPOUND_LIST, CMD_NAME},
+	{TK_WORD, CASE_LIST_NS, CMD_NAME},
 	{TK_WORD, COMPLETE_CONDITION, CMD_NAME},
 	{TK_WORD, NEWLINE_LIST, CMD_NAME},
 	{TK_WORD, TK_BANG, CMD_NAME},
@@ -55,7 +57,9 @@ t_prodmatch		g_prodmatch[] =
 	{TK_NAME, SEPARATOR_OP, FNAME},
 	{TK_NAME, NEWLINE_LIST, FNAME},
 	{TK_NAME, TK_FOR, NAME},
+	{TK_NEWLINE, CASE_LIST_NS, NEWLINE_LIST},
 	{TK_NEWLINE, TK_DO, NEWLINE_LIST},
+	{TK_NEWLINE, TK_PAREN_CLOSE, NEWLINE_LIST},
 	{TK_NEWLINE, TK_IN, NEWLINE_LIST},
 	{TK_NEWLINE, TK_WHILE, NEWLINE_LIST},
 	{TK_NEWLINE, TK_UNTIL, NEWLINE_LIST},
@@ -69,6 +73,7 @@ t_prodmatch		g_prodmatch[] =
 	{TK_NEWLINE, LINEBREAK, NEWLINE_LIST},
 	{TK_NEWLINE, CMD_SUPERIOR, LINEBREAK},
 	{TK_NEWLINE, PIPE_SEMI_SEQUENCE, LINEBREAK},
+	{TK_NEWLINE, CASE_LIST_NS, NEWLINE_LIST},
 	{TK_NEWLINE, COMPOUND_LIST, NEWLINE_LIST},
 	{TK_NEWLINE, COMPLETE_CONDITION, NEWLINE_LIST},
 	{TK_NEWLINE, CONDITION, NEWLINE_LIST},

42sh/src/parser/read_stack.c

@@ -14,6 +14,12 @@
 
 char			*read_state(t_sym current)
 {
+	if (current == CASE_CLAUSE)
+		return ("CASE_CLAUSE");
+	if (current == CASE_LIST_NS)
+		return ("CASE_LIST_NS");
+	if (current == TK_DSEMI)
+		return ("TK_DSEMI");
 	if (current == TK_PAREN_OPEN)
 		return ("TK_PAREN_OPEN");
 	if (current == TK_PAREN_CLOSE)