diff --git a/42sh/sample/case/case.sh b/42sh/sample/case/case.sh index 3828871c..f84e34fc 100644 --- a/42sh/sample/case/case.sh +++ b/42sh/sample/case/case.sh @@ -1,8 +1,12 @@ case $rental in - "cat") echo "For $rental rental is Rs.20 per k/m.";; - "van") echo "For $rental rental is Rs.10 per k/m.";; - "jeep") echo "For $rental rental is Rs.5 per k/m.";; - "bicycle") echo "For $rental rental 20 paisa per k/m.";; - "enfield") echo "For $rental rental Rs.3 per k/m.";; - "thunderbird") echo "For $rental rental Rs.5 per k/m.";; + ("bus") case yolo in + ("bonjour") echo hello ;; + ("hello") echo bonjour ;; + esac + case yala in + ("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 diff --git a/42sh/src/lexer/get_reserved_words.c b/42sh/src/lexer/get_reserved_words.c index 0dc99e4b..139d4c1f 100644 --- a/42sh/src/lexer/get_reserved_words.c +++ b/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; } diff --git a/42sh/src/lexer/lexer_sep.c b/42sh/src/lexer/lexer_sep.c index eb4420a6..08fb1d1a 100644 --- a/42sh/src/lexer/lexer_sep.c +++ b/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)); } diff --git a/42sh/src/parser/aggregate_sym.c b/42sh/src/parser/aggregate_sym.c index 06546c3b..1ba587c6 100644 --- a/42sh/src/parser/aggregate_sym.c +++ b/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_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_LIST_NS, TK_IN, TK_IN, TK_IN}, {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}, diff --git a/42sh/src/parser/eval_sym.c b/42sh/src/parser/eval_sym.c index bfb3137c..ad767ee5 100644 --- a/42sh/src/parser/eval_sym.c +++ b/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}, diff --git a/42sh/src/parser/produce_sym.c b/42sh/src/parser/produce_sym.c index 75d3329a..bcbef58d 100644 --- a/42sh/src/parser/produce_sym.c +++ b/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}, diff --git a/42sh/src/parser/read_stack.c b/42sh/src/parser/read_stack.c index 8b262b95..3371958e 100644 --- a/42sh/src/parser/read_stack.c +++ b/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)