diff --git a/42sh/Makefile b/42sh/Makefile index d6ca50db..4193e6da 100644 --- a/42sh/Makefile +++ b/42sh/Makefile @@ -6,7 +6,7 @@ # By: wescande +#+ +:+ +#+ # # +#+#+#+#+#+ +#+ # # Created: 2016/08/29 21:32:58 by wescande #+# #+# # -# Updated: 2017/02/21 21:32:36 by ariard ### ########.fr # +# Updated: 2017/02/24 18:49:55 by ariard ### ########.fr # # # # **************************************************************************** # @@ -225,6 +225,7 @@ main/shell_get_avdata.c\ main/shell_get_opts.c\ main/shell_init.c\ parser/add_cmd.c\ +parser/add_subshell.c\ parser/add_condition.c\ parser/add_file.c\ parser/add_loop.c\ diff --git a/42sh/includes/parser.h b/42sh/includes/parser.h index f3c28da4..2f840910 100644 --- a/42sh/includes/parser.h +++ b/42sh/includes/parser.h @@ -44,7 +44,6 @@ enum e_sym TK_PAREN_OPEN, TK_PAREN_CLOSE, TK_BQUOTE, - TK_SUBSHELL, TK_NEWLINE, TK_WHILE, TK_DO, @@ -63,6 +62,7 @@ enum e_sym TK_IO_NUMBER, TK_DLESSDASH, TK_LESSGREAT, + TK_SUBSHELL, TK_CASE, TK_IN, TK_ESAC, @@ -119,7 +119,6 @@ enum e_sym LOOP, FUNC, PIPE_SEMI_SEQUENCE, - PATTERN_CASE, CMD_SUPERIOR, AND_OR_MAJOR, AND_OR_MINOR, @@ -127,6 +126,7 @@ enum e_sym CONDITION, COMPLETE_CONDITION, FOR_WORDLIST, + PATTERN_CASE, ALL = 200, }; @@ -220,10 +220,13 @@ int add_branch(t_btree **ast, t_list **lst); int add_case_cmd(t_btree **ast, t_list **lst); int add_case_sep(t_btree **ast, t_list **lst); int add_pattern(t_btree **ast, t_list **lst); +int add_subshell_cmd(t_btree **ast, t_list **lst); +int add_subshell_sep(t_btree **ast, t_list **lst); int isloop(t_btree **ast, t_list **lst); int isdir(t_btree **ast); int iscase(t_btree **ast, t_list **lst); int iscondition(t_btree **ast, t_list **lst); +int issubshell(t_btree **ast, t_list **lst); int join_ast(t_btree **ast, t_btree **new_node); int gen_node(t_btree **ast); diff --git a/42sh/sample/case/case.sh b/42sh/sample/case/case.sh index 3642f40b..d89cd66d 100644 --- a/42sh/sample/case/case.sh +++ b/42sh/sample/case/case.sh @@ -3,5 +3,4 @@ case $rental in ("yolo") echo bonjour esac ;; ("van") echo yolo ;; - ("bicycle") echo hola ;; esac diff --git a/42sh/sample/subshell/subshell01.sh b/42sh/sample/subshell/subshell01.sh new file mode 100644 index 00000000..244aeed7 --- /dev/null +++ b/42sh/sample/subshell/subshell01.sh @@ -0,0 +1 @@ +(ls | cat && pwd) diff --git a/42sh/src/lexer/lexer_sep.c b/42sh/src/lexer/lexer_sep.c index 08fb1d1a..2c12ea8b 100644 --- a/42sh/src/lexer/lexer_sep.c +++ b/42sh/src/lexer/lexer_sep.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/11/30 16:29:57 by jhalford #+# #+# */ -/* Updated: 2017/02/20 20:54:07 by ariard ### ########.fr */ +/* Updated: 2017/02/24 19:14:57 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -39,6 +39,6 @@ int lexer_sep(t_list **alst, t_lexer *lexer) 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); + lexer->pos += 1 + (token->type & (TK_AND_IF | TK_OR_IF | TK_DSEMI) ? 1 : 0); return (lexer_lex(&(*alst)->next, lexer)); } diff --git a/42sh/src/main/ft_putast.c b/42sh/src/main/ft_putast.c index a535e33d..65e550aa 100644 --- a/42sh/src/main/ft_putast.c +++ b/42sh/src/main/ft_putast.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/11/14 18:18:04 by jhalford #+# #+# */ -/* Updated: 2017/02/24 16:24:19 by ariard ### ########.fr */ +/* Updated: 2017/02/24 19:06:19 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,6 +16,8 @@ char *ft_putast(void *nodein) { t_astnode *node; node = nodein; + if (node->type == SUBSHELL) + return ("SUBSHELL"); if (node->type == TK_NAME) return ("TK_NAME"); if (node->type == TK_FOR) diff --git a/42sh/src/main/main.c b/42sh/src/main/main.c index 03b10ea2..032b4529 100644 --- a/42sh/src/main/main.c +++ b/42sh/src/main/main.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/06 18:40:58 by jhalford #+# #+# */ -/* Updated: 2017/02/24 16:17:54 by ariard ### ########.fr */ +/* Updated: 2017/02/24 18:39:09 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/parser/add_cmd.c b/42sh/src/parser/add_cmd.c index f976f875..9b26dd7c 100644 --- a/42sh/src/parser/add_cmd.c +++ b/42sh/src/parser/add_cmd.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/15 20:49:15 by ariard #+# #+# */ -/* Updated: 2017/02/24 16:29:21 by ariard ### ########.fr */ +/* Updated: 2017/02/24 19:29:04 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -21,6 +21,8 @@ int add_cmd(t_btree **ast, t_list **lst) DG("add cmd"); if (!*ast) gen_node(ast); + else if ((token = (*lst)->content)->type == TK_IN) + return (0); else if (isdir(ast)) return (add_file(ast, lst)); else if (isloop(ast, lst) == 3) @@ -37,11 +39,12 @@ int add_cmd(t_btree **ast, t_list **lst) return (add_case_cmd(ast, lst)); else if (iscase(ast, lst) == 3) return (add_branch(ast, lst)); - else if ((node = (*ast)->item)->type != TK_DO && node->type != TK_THEN - && node->type != TK_PAREN_CLOSE && node->type != TK_ESAC) + else if (issubshell(ast, lst)) + return (add_subshell_cmd(ast, lst)); + else if ((node = (*ast)->item)->type != TK_DO && node->type != TK_THEN + && node->type != TK_PAREN_CLOSE) return (add_cmd(&(*ast)->right, lst)); my_tab = NULL; - token = (*lst)->content; node = (*ast)->item; node->type = token->type; if (token->type == TK_WORD) diff --git a/42sh/src/parser/add_loop.c b/42sh/src/parser/add_loop.c index 7a03b988..5f7ae736 100644 --- a/42sh/src/parser/add_loop.c +++ b/42sh/src/parser/add_loop.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/17 22:17:14 by ariard #+# #+# */ -/* Updated: 2017/02/24 16:28:27 by ariard ### ########.fr */ +/* Updated: 2017/02/24 18:47:29 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/parser/add_sep.c b/42sh/src/parser/add_sep.c index 7dbbb270..4fef29e4 100644 --- a/42sh/src/parser/add_sep.c +++ b/42sh/src/parser/add_sep.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/15 19:12:07 by ariard #+# #+# */ -/* Updated: 2017/02/24 16:08:47 by ariard ### ########.fr */ +/* Updated: 2017/02/24 18:54:09 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -25,6 +25,8 @@ int add_sep(t_btree **ast, t_list **lst) return (add_condition_sep(ast, lst)); else if (iscase(ast, lst) == 2) return (add_case_sep(ast, lst)); + else if (issubshell(ast, lst)) + return (add_subshell_sep(ast, lst)); if (!*ast) gen_node(ast); token = (*lst)->content; diff --git a/42sh/src/parser/add_subshell.c b/42sh/src/parser/add_subshell.c new file mode 100644 index 00000000..b42b8fad --- /dev/null +++ b/42sh/src/parser/add_subshell.c @@ -0,0 +1,48 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* add_subshell.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: ariard +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2017/02/24 18:41:50 by ariard #+# #+# */ +/* Updated: 2017/02/24 19:16:06 by ariard ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "parser.h" + +int issubshell(t_btree **ast, t_list **lst) +{ + t_astnode *node; + t_token *token; + + node = NULL; + token = (*lst)->content; + DG("test loop"); + if (*ast) + { + node = (*ast)->item; + if (node->type == SUBSHELL && node->full == 0) + return (1); + } + return (0); +} + +int add_subshell_cmd(t_btree **ast, t_list **lst) +{ + t_token *token; + t_astnode *node; + + DG("add subshell"); + token = (*lst)->content; + node = (*ast)->item; + if (token->type == TK_PAREN_CLOSE && node->type == SUBSHELL) + return ((node->full = 1)); + return (add_cmd(&(*ast)->right, lst)); +} + +int add_subshell_sep(t_btree **ast, t_list **lst) +{ + return (add_sep(&(*ast)->right, lst)); +} diff --git a/42sh/src/parser/aggregate_sym.c b/42sh/src/parser/aggregate_sym.c index e33fa3a5..d97e3261 100644 --- a/42sh/src/parser/aggregate_sym.c +++ b/42sh/src/parser/aggregate_sym.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 17:39:18 by ariard #+# #+# */ -/* Updated: 2017/02/21 20:40:31 by ariard ### ########.fr */ +/* Updated: 2017/02/24 18:25:45 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -20,6 +20,8 @@ t_aggrematch g_aggrematch[] = {TK_WORD, FOR_WORDLIST, FOR_WORDLIST, FOR_WORDLIST}, {TK_SEMI, FOR_WORDLIST, SEQUENTIAL_SEP, 0}, {TK_DSEMI, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE}, + {TK_PAREN_OPEN, TK_IN, PATTERN_CASE, 0}, + {TK_PAREN_OPEN, CASE_LIST_NS, PATTERN_CASE, 0}, {TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, 0}, {TK_PIPE, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR}, {TK_FI, ELSE_PART, IF_CLAUSE, TK_IF}, @@ -34,6 +36,9 @@ t_aggrematch g_aggrematch[] = {TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, TK_CASE}, {TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, TK_LBRACE}, {TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, TK_PAREN_OPEN}, + {TK_PAREN_CLOSE, CMD_SUPERIOR, SUBSHELL, TK_PAREN_OPEN}, + {TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE, SUBSHELL, TK_PAREN_OPEN}, + {TK_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR}, {TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR}, //watch this @@ -49,11 +54,8 @@ t_aggrematch g_aggrematch[] = {LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, TK_SEMI}, //to abstract TK_ESAC - {LINEBREAK, TK_PAREN_CLOSE, CASE_ITEM_NS, PATTERN_CASE}, {LINEBREAK, TK_PAREN_CLOSE, FUNC, FNAME}, //paren open - {LINEBREAK, TK_DSEMI, CASE_ITEM, PATTERN_CASE}, - {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK}, {LINEBREAK, TK_PIPE, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE}, {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK}, {LINEBREAK, CMD_SUPERIOR, SEPARATOR_OP, 0}, @@ -108,6 +110,7 @@ t_aggrematch g_aggrematch[] = {IO_REDIRECT, CMD_WORD, CMD_SUFFIX, 0}, {IO_REDIRECT, CMD_PREFIX, CMD_PREFIX, CMD_PREFIX}, {IO_REDIRECT, LINEBREAK, CMD_PREFIX, 0}, + {IO_REDIRECT, TK_PAREN_OPEN, CMD_PREFIX, 0}, {IO_REDIRECT, COMPLETE_COMMANDS, CMD_PREFIX, 0}, {IO_REDIRECT, TK_BANG, CMD_PREFIX, 0}, {IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, 0}, @@ -118,6 +121,7 @@ t_aggrematch g_aggrematch[] = {CMD_SUFFIX, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR}, //to abstract {CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, 0}, + {CMD_PREFIX, TK_PAREN_OPEN, SIMPLE_COMMAND, 0}, {CMD_PREFIX, COMPLETE_COMMANDS, SIMPLE_COMMAND, 0}, {CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, 0}, {CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, 0}, @@ -126,6 +130,7 @@ t_aggrematch g_aggrematch[] = {CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, CMD_PREFIX}, //to check {CMD_NAME, LINEBREAK, CMD_SUPERIOR, 0}, + {CMD_NAME, TK_PAREN_OPEN, CMD_SUPERIOR, 0}, {CMD_NAME, COMPLETE_COMMANDS, CMD_SUPERIOR, 0}, {CMD_NAME, TK_BANG, CMD_SUPERIOR, 0}, {CMD_NAME, SEPARATOR_OP, CMD_SUPERIOR, 0}, @@ -160,15 +165,13 @@ 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, CASE_LIST, PATTERN_CASE, 0}, {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, TK_PAREN_CLOSE, CASE_LIST_NS, PATTERN_CASE}, {COMPOUND_LIST, COMPLETE_CONDITION, COMPLETE_CONDITION, COMPLETE_CONDITION}, // {COMPOUND_LIST, TK_THEN, ELSE_PART, TK_ELIF}, {COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST}, @@ -177,6 +180,7 @@ t_aggrematch g_aggrematch[] = {COMPOUND_COMMAND, ALL, COMMAND, 0}, {AND_OR_MINOR, PIPE_SEMI_SEQUENCE, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE}, {AND_OR_MINOR, LINEBREAK, AND_OR_MAJOR, 0}, + {AND_OR_MINOR, TK_PAREN_OPEN, AND_OR_MAJOR, 0}, {AND_OR_MINOR, COMPLETE_COMMANDS, AND_OR_MAJOR, 0}, {AND_OR_MINOR, AND_OR_MAJOR, AND_OR_MAJOR, 0}, {COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE}, @@ -194,9 +198,9 @@ t_aggrematch g_aggrematch[] = {COMMAND, SEPARATOR_OP, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, NEWLINE_LIST, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, 0}, + {COMMAND, TK_PAREN_OPEN, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, COMPLETE_COMMANDS, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE, 0}, - {COMMAND, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, COMPLETE_CONDITION, PIPE_SEMI_SEQUENCE, 0}, {END_COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE}, {END_COMMAND, AND_OR_MAJOR, LIST, AND_OR_MAJOR}, @@ -204,6 +208,7 @@ t_aggrematch g_aggrematch[] = {END_COMMAND, TK_WHILE, PIPE_SEQUENCE, 0}, {END_COMMAND, TK_UNTIL, PIPE_SEQUENCE, 0}, {END_COMMAND, LINEBREAK, PIPE_SEQUENCE, 0}, + {END_COMMAND, TK_PAREN_OPEN, PIPE_SEQUENCE, 0}, {END_COMMAND, COMPLETE_COMMANDS, PIPE_SEQUENCE, 0}, {END_COMMAND, TK_DO, PIPE_SEQUENCE, 0}, {END_COMMAND, TK_PAREN_CLOSE, PIPE_SEQUENCE, 0}, @@ -220,6 +225,7 @@ t_aggrematch g_aggrematch[] = {PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, 0}, {PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, 0}, {PIPE_SEQUENCE, LINEBREAK, PIPELINE, 0}, + {PIPE_SEQUENCE, TK_PAREN_OPEN, PIPELINE, 0}, {PIPE_SEQUENCE, COMPLETE_COMMANDS, PIPELINE, 0}, {PIPE_SEQUENCE, AND_OR_MAJOR, PIPELINE, 0}, {PIPE_SEQUENCE, TK_DO, PIPELINE, 0}, @@ -243,6 +249,7 @@ t_aggrematch g_aggrematch[] = {PIPELINE, COMPOUND_LIST, AND_OR, 0}, {PIPELINE, CASE_LIST_NS, AND_OR, 0}, {PIPELINE, LINEBREAK, AND_OR, 0}, + {PIPELINE, TK_PAREN_OPEN, AND_OR, 0}, {PIPELINE, COMPLETE_COMMANDS, AND_OR, 0}, // {PIPELINE, LINEBREAK, AND_OR, AND_OR}, {PIPELINE, SEPARATOR_OP, AND_OR, 0}, @@ -263,12 +270,15 @@ t_aggrematch g_aggrematch[] = {AND_OR, SEPARATOR_OP, LIST, LIST}, {AND_OR, NEWLINE_LIST, LIST, 0}, {AND_OR, LINEBREAK, LIST, 0}, + {AND_OR, TK_PAREN_OPEN, LIST, 0}, {AND_OR, COMPLETE_COMMANDS, LIST, 0}, {LIST, NEWLINE_LIST, COMPLETE_COMMAND, 0}, {LIST, LINEBREAK, COMPLETE_COMMAND, 0}, + {LIST, TK_PAREN_OPEN, LIST, 0}, {LIST, COMPLETE_COMMANDS, COMPLETE_COMMAND, 0}, {COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, COMPLETE_COMMANDS}, {COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, 0}, + {COMPLETE_COMMAND, TK_PAREN_OPEN, COMPLETE_COMMANDS, 0}, {COMPLETE_COMMAND, COMPLETE_COMMANDS, COMPLETE_COMMANDS, 0}, {COMPLETE_COMMANDS, COMPLETE_COMMANDS, COMPLETE_COMMANDS, COMPLETE_COMMANDS}, {0, 0, 0, 0}, @@ -279,20 +289,20 @@ int aggregate_sym(t_sym **stack, t_sym *new_sym, t_parstate *state) int i; i = 0; -// DG("aggregate head %s && sym %s", -// read_state(**stack), read_state(*new_sym)); + DG("aggregate head %s && sym %s", + read_state(**stack), read_state(*new_sym)); while (g_aggrematch[i].top) { if (*new_sym == g_aggrematch[i].top && MATCH_STACK(**stack, g_aggrematch[i].under)) { -// DG("MATCH : %s", read_state(g_aggrematch[i].new_sym)); + 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)); + DG("stack after pop: %s", read_state(**stack)); } if (eval_sym(**stack, *new_sym)) return ((*state = ERROR)); diff --git a/42sh/src/parser/build_tree.c b/42sh/src/parser/build_tree.c index 021aef29..805dd403 100644 --- a/42sh/src/parser/build_tree.c +++ b/42sh/src/parser/build_tree.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/15 18:32:59 by ariard #+# #+# */ -/* Updated: 2017/02/24 16:24:44 by ariard ### ########.fr */ +/* Updated: 2017/02/24 19:27:32 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -33,17 +33,20 @@ t_treematch g_treematch[] = {TK_NEWLINE, &add_sep}, {TK_CASE, &add_cmd}, {TK_ESAC, &add_cmd}, + {TK_IN, &add_cmd}, + {TK_DSEMI, &add_cmd}, {TK_PAREN_OPEN, &add_cmd}, {TK_PAREN_CLOSE, &add_cmd}, {TK_FOR, &add_cmd}, + {SUBSHELL, &add_cmd}, {0, NULL}, }; -static int isseparator(int type, int cache) +static int isseparator(t_token *token, int cache) { - if (type == TK_NEWLINE && (cache == TK_WHILE || cache == TK_DO + if (token->type == TK_NEWLINE && (cache == TK_WHILE || cache == TK_DO || cache == TK_NEWLINE || cache == TK_THEN || cache == TK_IN - || cache == TK_WORD)) + || cache == TK_WORD || cache == TK_DSEMI)) return (0); return (1); } @@ -58,10 +61,11 @@ int build_tree(t_btree **ast, t_list **lst) token = (*lst)->content; //check bug de cache case ? // cache = token->type; + if (token->type == TK_PAREN_OPEN && cache != TK_IN && cache != TK_DSEMI) + token->type = SUBSHELL; while (g_treematch[i].type) { - if (g_treematch[i].type == token->type - && isseparator(token->type, cache)) + if ((isseparator(token, cache) && g_treematch[i].type == token->type)) { DG("func TK : '%s' TK : '%s'", diff --git a/42sh/src/parser/error_syntax.c b/42sh/src/parser/error_syntax.c index 827807be..169be95f 100644 --- a/42sh/src/parser/error_syntax.c +++ b/42sh/src/parser/error_syntax.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 20:15:35 by ariard #+# #+# */ -/* Updated: 2017/02/21 19:27:59 by jhalford ### ########.fr */ +/* Updated: 2017/02/24 19:12:35 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,6 +16,7 @@ t_errormatch g_errormatch[] = { {TK_NEWLINE, "newline"}, {TK_SEMI, ";"}, + {TK_DSEMI, ";;"}, {TK_PIPE, "|"}, {TK_AMP, "&"}, {TK_LESS, "<"}, diff --git a/42sh/src/parser/eval_sym.c b/42sh/src/parser/eval_sym.c index eeb9b093..eac28ec2 100644 --- a/42sh/src/parser/eval_sym.c +++ b/42sh/src/parser/eval_sym.c @@ -18,6 +18,7 @@ t_stackmatch g_stackmatch[] = {TK_WORD, TK_CASE}, {TK_WORD, WORDLIST}, {TK_WORD, LINEBREAK}, + {TK_WORD, TK_PAREN_OPEN}, {TK_WORD, COMPLETE_COMMANDS}, {TK_WORD, TK_IN}, {TK_WORD, FOR_WORDLIST}, @@ -28,6 +29,7 @@ t_stackmatch g_stackmatch[] = {TK_IO_NUMBER, CMD_NAME}, {TK_IO_NUMBER, CMD_WORD}, {TK_IO_NUMBER, LINEBREAK}, + {TK_IO_NUMBER, TK_PAREN_OPEN}, {TK_IO_NUMBER, COMPLETE_COMMANDS}, {TK_IO_NUMBER, TK_BANG}, {TK_IO_NUMBER, SEPARATOR_OP}, @@ -52,6 +54,7 @@ t_stackmatch g_stackmatch[] = {TK_LESS, CMD_WORD}, {TK_LESS, CMD_NAME}, {TK_LESS, LINEBREAK}, + {TK_LESS, TK_PAREN_OPEN}, {TK_LESS, COMPLETE_COMMANDS}, {TK_LESS, TK_BANG}, {TK_LESS, SEPARATOR_OP}, @@ -66,6 +69,7 @@ t_stackmatch g_stackmatch[] = {TK_GREAT, CMD_WORD}, {TK_GREAT, CMD_NAME}, {TK_GREAT, LINEBREAK}, + {TK_GREAT, TK_PAREN_OPEN}, {TK_GREAT, COMPLETE_COMMANDS}, {TK_GREAT, TK_BANG}, {TK_GREAT, SEPARATOR_OP}, @@ -82,6 +86,7 @@ t_stackmatch g_stackmatch[] = {TK_DLESS, CMD_WORD}, {TK_DLESS, CMD_NAME}, {TK_DLESS, LINEBREAK}, + {TK_DLESS, TK_PAREN_OPEN}, {TK_DLESS, COMPLETE_COMMANDS}, {TK_DLESS, TK_BANG}, {TK_DLESS, SEPARATOR_OP}, @@ -97,6 +102,7 @@ t_stackmatch g_stackmatch[] = {TK_DLESSDASH, CMD_WORD}, {TK_DLESSDASH, CMD_NAME}, {TK_DLESSDASH, LINEBREAK}, + {TK_DLESSDASH, TK_PAREN_OPEN}, {TK_DLESSDASH, COMPLETE_COMMANDS}, {TK_DLESSDASH, TK_BANG}, {TK_DLESSDASH, TK_BANG}, @@ -113,6 +119,7 @@ t_stackmatch g_stackmatch[] = {TK_DGREAT, CMD_WORD}, {TK_DGREAT, CMD_NAME}, {TK_DGREAT, LINEBREAK}, + {TK_DGREAT, TK_PAREN_OPEN}, {TK_DGREAT, COMPLETE_COMMANDS}, {TK_DGREAT, TK_BANG}, {TK_DGREAT, TK_BANG}, @@ -129,6 +136,7 @@ t_stackmatch g_stackmatch[] = {TK_LESSAND, CMD_WORD}, {TK_LESSAND, CMD_NAME}, {TK_LESSAND, LINEBREAK}, + {TK_LESSAND, TK_PAREN_OPEN}, {TK_LESSAND, COMPLETE_COMMANDS}, {TK_LESSAND, TK_BANG}, {TK_LESSAND, TK_BANG}, @@ -145,6 +153,7 @@ t_stackmatch g_stackmatch[] = {TK_GREATAND, CMD_WORD}, {TK_GREATAND, CMD_NAME}, {TK_GREATAND, LINEBREAK}, + {TK_GREATAND, TK_PAREN_OPEN}, {TK_GREATAND, COMPLETE_COMMANDS}, {TK_LESSAND, TK_BANG}, {TK_GREATAND, TK_BANG}, @@ -161,6 +170,7 @@ t_stackmatch g_stackmatch[] = {TK_LESSGREAT, CMD_WORD}, {TK_LESSGREAT, CMD_NAME}, {TK_LESSGREAT, LINEBREAK}, + {TK_LESSGREAT, TK_PAREN_OPEN}, {TK_LESSGREAT, COMPLETE_COMMANDS}, {TK_LESSGREAT, TK_BANG}, {TK_LESSGREAT, TK_BANG}, @@ -177,6 +187,7 @@ t_stackmatch g_stackmatch[] = {TK_CLOBBER, CMD_WORD}, {TK_CLOBBER, CMD_NAME}, {TK_CLOBBER, LINEBREAK}, + {TK_CLOBBER, TK_PAREN_OPEN}, {TK_CLOBBER, COMPLETE_COMMANDS}, {TK_CLOBBER, TK_BANG}, {TK_CLOBBER, TK_BANG}, @@ -187,6 +198,7 @@ t_stackmatch g_stackmatch[] = {TK_CLOBBER, AND_OR_MAJOR}, {TK_IF, LINEBREAK}, + {TK_IF, TK_PAREN_OPEN}, {TK_IF, TK_PAREN_CLOSE}, {TK_IF, COMPLETE_COMMANDS}, {TK_IF, TK_BANG}, @@ -226,6 +238,7 @@ t_stackmatch g_stackmatch[] = {TK_DONE, COMPOUND_LIST}, {TK_DONE, END_COMMAND}, {TK_CASE, LINEBREAK}, + {TK_CASE, TK_PAREN_OPEN}, {TK_CASE, COMPLETE_COMMANDS}, {TK_CASE, TK_BANG}, {TK_CASE, TK_DO}, @@ -248,6 +261,7 @@ t_stackmatch g_stackmatch[] = {TK_ESAC, LINEBREAK}, {TK_ESAC, TK_IN}, {TK_WHILE, LINEBREAK}, + {TK_WHILE, TK_PAREN_OPEN}, {TK_WHILE, COMPLETE_COMMANDS}, {TK_WHILE, TK_BANG}, {TK_WHILE, SEPARATOR_OP}, @@ -265,6 +279,7 @@ t_stackmatch g_stackmatch[] = {TK_WHILE, TK_THEN}, {TK_WHILE, COMPLETE_CONDITION}, {TK_UNTIL, LINEBREAK}, + {TK_UNTIL, TK_PAREN_OPEN}, {TK_UNTIL, COMPLETE_COMMANDS}, {TK_UNTIL, TK_BANG}, {TK_UNTIL, SEPARATOR_OP}, @@ -282,6 +297,7 @@ t_stackmatch g_stackmatch[] = {TK_UNTIL, TK_PAREN_CLOSE}, {TK_UNTIL, COMPLETE_CONDITION}, {TK_FOR, LINEBREAK}, + {TK_FOR, TK_PAREN_OPEN}, {TK_FOR, COMPLETE_COMMANDS}, {TK_FOR, TK_BANG}, {TK_FOR, TK_BANG}, @@ -300,6 +316,7 @@ t_stackmatch g_stackmatch[] = {TK_FOR, TK_PAREN_CLOSE}, {TK_FOR, COMPLETE_CONDITION}, {TK_LBRACE, LINEBREAK}, + {TK_LBRACE, TK_PAREN_OPEN}, {TK_LBRACE, COMPLETE_COMMANDS}, {TK_LBRACE, TK_BANG}, {TK_LBRACE, SEPARATOR_OP}, @@ -308,6 +325,7 @@ t_stackmatch g_stackmatch[] = {TK_RBRACE, COMPOUND_LIST}, {TK_RBRACE, CASE_LIST_NS}, {TK_BANG, LINEBREAK}, + {TK_BANG, TK_PAREN_OPEN}, {TK_BANG, COMPLETE_COMMANDS}, {TK_BANG, SEPARATOR_OP}, {TK_BANG, SEPARATOR_OP}, @@ -325,20 +343,29 @@ t_stackmatch g_stackmatch[] = {TK_AMP, TERM}, {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}, + {PATTERN_CASE, TK_IN}, + {PATTERN_CASE, CASE_LIST_NS}, {TK_PAREN_OPEN, COMPLETE_COMMANDS}, - {TK_PAREN_OPEN, TK_BANG}, + {TK_PAREN_OPEN, LINEBREAK}, + {TK_PAREN_OPEN, TK_PAREN_OPEN}, {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}, - {TK_PAREN_CLOSE, COMPOUND_LIST}, + {TK_PAREN_OPEN, AND_OR_MAJOR}, + {TK_PAREN_OPEN, TK_WHILE}, + {TK_PAREN_OPEN, TK_UNTIL}, + {TK_PAREN_OPEN, TK_DO}, + {TK_PAREN_OPEN, TK_PAREN_CLOSE}, + {TK_PAREN_OPEN, TK_PAREN_OPEN}, + {TK_PAREN_OPEN, TK_IF}, + {TK_PAREN_OPEN, TK_ELIF}, + {TK_PAREN_OPEN, TK_THEN}, + {TK_PAREN_OPEN, TK_ELSE}, + {TK_PAREN_OPEN, COMPOUND_LIST}, + {TK_PAREN_OPEN, CASE_LIST_NS}, + {TK_PAREN_OPEN, COMPLETE_CONDITION}, + {TK_PAREN_OPEN, TK_IN}, {SEQUENTIAL_SEP, NAME}, {SEQUENTIAL_SEP, IN}, {SEQUENTIAL_SEP, WORDLIST}, @@ -354,6 +381,7 @@ t_stackmatch g_stackmatch[] = {END_COMMAND, TK_ELIF}, {END_COMMAND, TK_ELSE}, {END_COMMAND, LINEBREAK}, + {END_COMMAND, TK_PAREN_OPEN}, {END_COMMAND, COMPLETE_COMMANDS}, {END_COMMAND, COMPOUND_LIST}, {END_COMMAND, CASE_LIST_NS}, @@ -372,7 +400,6 @@ t_stackmatch g_stackmatch[] = {LINEBREAK, TK_SEMI}, {LINEBREAK, END_COMMAND}, {LINEBREAK, SEPARATOR_OP}, - {LINEBREAK, SEPARATOR_OP}, {LINEBREAK, TK_PAREN_CLOSE}, {LINEBREAK, WORD}, {LINEBREAK, IN}, @@ -386,6 +413,25 @@ t_stackmatch g_stackmatch[] = {LINEBREAK, COMPOUND_LIST}, {LINEBREAK, CASE_LIST_NS}, {LINEBREAK, PROGRAM}, + {LINEBREAK, TK_PAREN_OPEN}, + {TK_PAREN_CLOSE, TK_SEMI}, + {TK_PAREN_CLOSE, END_COMMAND}, + {TK_PAREN_CLOSE, SEPARATOR_OP}, + {TK_PAREN_CLOSE, WORD}, + {TK_PAREN_CLOSE, IN}, + {TK_PAREN_CLOSE, TK_AND_IF}, + {TK_PAREN_CLOSE, TK_OR_IF}, + {TK_PAREN_CLOSE, TK_PIPE}, + {TK_PAREN_CLOSE, TK_PAREN_CLOSE}, + {TK_PAREN_CLOSE, COMPLETE_COMMANDS}, + {TK_PAREN_CLOSE, CMD_SUPERIOR}, + {TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE}, + {TK_PAREN_CLOSE, CASE_LIST_NS}, + {TK_PAREN_CLOSE, PROGRAM}, + {TK_PAREN_CLOSE, TK_PAREN_OPEN}, + {TK_PAREN_CLOSE, PATTERN_CASE}, + {TK_PAREN_CLOSE, PATTERN}, + {TK_PAREN_CLOSE, COMPOUND_LIST}, {NEWLINE_LIST, TK_DO}, {NEWLINE_LIST, CASE_LIST_NS}, {NEWLINE_LIST, TK_PAREN_CLOSE}, @@ -410,6 +456,7 @@ t_stackmatch g_stackmatch[] = {NEWLINE_LIST, COMPLETE_CONDITION}, {NEWLINE_LIST, CONDITION}, {NEWLINE_LIST, LINEBREAK}, + {NEWLINE_LIST, TK_PAREN_OPEN}, {HERE_END, TK_DLESS}, {HERE_END, TK_DLESS}, {HERE_END, TK_DLESSDASH}, @@ -421,6 +468,7 @@ t_stackmatch g_stackmatch[] = {IO_HERE, CMD_WORD}, {IO_HERE, CMD_NAME}, {IO_HERE, LINEBREAK}, + {IO_HERE, TK_PAREN_OPEN}, {IO_HERE, COMPLETE_COMMANDS}, {IO_HERE, TK_BANG}, {IO_HERE, TK_BANG}, @@ -455,6 +503,7 @@ t_stackmatch g_stackmatch[] = {IO_REDIRECT, CMD_WORD}, {IO_REDIRECT, CMD_NAME}, {IO_REDIRECT, LINEBREAK}, + {IO_REDIRECT, TK_PAREN_OPEN}, {IO_REDIRECT, COMPLETE_COMMANDS}, {IO_REDIRECT, TK_BANG}, {IO_REDIRECT, TK_BANG}, @@ -466,6 +515,7 @@ t_stackmatch g_stackmatch[] = {CMD_SUFFIX, CMD_NAME}, {CMD_SUFFIX, CMD_SUPERIOR}, {CMD_PREFIX, LINEBREAK}, + {CMD_PREFIX, TK_PAREN_OPEN}, {CMD_PREFIX, COMPLETE_COMMANDS}, {CMD_PREFIX, TK_BANG}, {CMD_PREFIX, TK_BANG}, @@ -475,6 +525,7 @@ t_stackmatch g_stackmatch[] = {CMD_WORD, CMD_PREFIX}, {CMD_NAME, COMPLETE_COMMANDS}, {CMD_NAME, LINEBREAK}, + {CMD_NAME, TK_PAREN_OPEN}, {CMD_NAME, TK_BANG}, {CMD_NAME, TK_BANG}, {CMD_NAME, SEPARATOR_OP}, @@ -485,6 +536,7 @@ t_stackmatch g_stackmatch[] = {CMD_NAME, TK_UNTIL}, {CMD_NAME, TK_DO}, {CMD_NAME, TK_PAREN_CLOSE}, + {CMD_NAME, TK_PAREN_OPEN}, {CMD_NAME, TK_IF}, {CMD_NAME, TK_ELIF}, {CMD_NAME, TK_THEN}, @@ -505,6 +557,7 @@ t_stackmatch g_stackmatch[] = {CMD_SUPERIOR, CASE_LIST_NS}, {CMD_SUPERIOR, COMPLETE_CONDITION}, {CMD_SUPERIOR, LINEBREAK}, + {CMD_SUPERIOR, TK_PAREN_OPEN}, {CMD_SUPERIOR, COMPLETE_COMMANDS}, {CMD_SUPERIOR, TK_BANG}, {CMD_SUPERIOR, TK_BANG}, @@ -526,6 +579,7 @@ t_stackmatch g_stackmatch[] = {SIMPLE_COMMAND, CASE_LIST_NS}, {SIMPLE_COMMAND, COMPLETE_CONDITION}, {SIMPLE_COMMAND, LINEBREAK}, + {SIMPLE_COMMAND, TK_PAREN_OPEN}, {SIMPLE_COMMAND, COMPLETE_COMMANDS}, {SIMPLE_COMMAND, TK_BANG}, {SIMPLE_COMMAND, TK_BANG}, @@ -540,15 +594,18 @@ t_stackmatch g_stackmatch[] = {LOOP, TK_WHILE}, {LOOP, TK_UNTIL}, {CONDITION, LINEBREAK}, + {CONDITION, TK_PAREN_OPEN}, {CONDITION, COMPLETE_COMMANDS}, {CONDITION, COMPOUND_LIST}, {CONDITION, CASE_LIST_NS}, {CONDITION, COMPLETE_CONDITION}, {COMPLETE_CONDITION, LINEBREAK}, + {COMPLETE_CONDITION, TK_PAREN_OPEN}, {COMPLETE_CONDITION, COMPLETE_COMMANDS}, {COMPLETE_CONDITION, COMPLETE_CONDITION}, {COMPLETE_CONDITION, COMPLETE_CONDITION}, {BRACE_GROUP, LINEBREAK}, + {BRACE_GROUP, TK_PAREN_OPEN}, {BRACE_GROUP, COMPLETE_COMMANDS}, {BRACE_GROUP, TK_BANG}, {BRACE_GROUP, TK_BANG}, @@ -556,6 +613,7 @@ t_stackmatch g_stackmatch[] = {BRACE_GROUP, NEWLINE_LIST}, {BRACE_GROUP, PIPE_SEMI_SEQUENCE}, {FNAME, LINEBREAK}, + {FNAME, TK_PAREN_OPEN}, {FNAME, COMPLETE_COMMANDS}, {FNAME, TK_BANG}, {FNAME, TK_BANG}, @@ -564,6 +622,7 @@ t_stackmatch g_stackmatch[] = {FNAME, PIPE_SEMI_SEQUENCE}, {FUNCTION_BODY, FUNC}, {FUNCTION_DEFINITION, LINEBREAK}, + {FUNCTION_DEFINITION, TK_PAREN_OPEN}, {FUNCTION_DEFINITION, COMPLETE_COMMANDS}, {FUNCTION_DEFINITION, TK_BANG}, {FUNCTION_DEFINITION, TK_BANG}, @@ -571,9 +630,9 @@ t_stackmatch g_stackmatch[] = {FUNCTION_DEFINITION, NEWLINE_LIST}, {FUNCTION_DEFINITION, PIPE_SEMI_SEQUENCE}, {UNTIL_CLAUSE, LINEBREAK}, + {UNTIL_CLAUSE, TK_PAREN_OPEN}, {UNTIL_CLAUSE, COMPLETE_COMMANDS}, {UNTIL_CLAUSE, TK_BANG}, - {UNTIL_CLAUSE, TK_BANG}, {UNTIL_CLAUSE, SEPARATOR_OP}, {UNTIL_CLAUSE, NEWLINE_LIST}, {UNTIL_CLAUSE, PIPE_SEMI_SEQUENCE}, @@ -588,7 +647,9 @@ t_stackmatch g_stackmatch[] = {UNTIL_CLAUSE, COMPOUND_LIST}, {UNTIL_CLAUSE, CASE_LIST_NS}, {UNTIL_CLAUSE, COMPLETE_CONDITION}, + {UNTIL_CLAUSE, AND_OR_MAJOR}, {WHILE_CLAUSE, LINEBREAK}, + {WHILE_CLAUSE, TK_PAREN_OPEN}, {WHILE_CLAUSE, COMPLETE_COMMANDS}, {WHILE_CLAUSE, TK_BANG}, {WHILE_CLAUSE, SEPARATOR_OP}, @@ -605,9 +666,11 @@ t_stackmatch g_stackmatch[] = {WHILE_CLAUSE, COMPOUND_LIST}, {WHILE_CLAUSE, CASE_LIST_NS}, {WHILE_CLAUSE, COMPLETE_CONDITION}, + {WHILE_CLAUSE, AND_OR_MAJOR}, // {ELSE_PART, COMPOUND_LIST}, // {ELSE_PART, COMPLETE_CONDITION}, {IF_CLAUSE, LINEBREAK}, + {IF_CLAUSE, TK_PAREN_OPEN}, {IF_CLAUSE, COMPLETE_COMMANDS}, {IF_CLAUSE, TK_BANG}, {IF_CLAUSE, SEPARATOR_OP}, @@ -625,13 +688,14 @@ t_stackmatch g_stackmatch[] = {IF_CLAUSE, CASE_LIST_NS}, {IF_CLAUSE, COMPLETE_COMMAND}, {IF_CLAUSE, COMPLETE_CONDITION}, + {IF_CLAUSE, AND_OR_MAJOR}, - {PATTERN, TK_PAREN_OPEN}, + {PATTERN, PATTERN_CASE}, {PATTERN, CASE_LIST}, {PATTERN, TK_IN}, - {PATTERN_CASE, CASE_LIST}, {CASE_LIST_NS, LINEBREAK}, {CASE_CLAUSE, LINEBREAK}, + {CASE_CLAUSE, TK_PAREN_OPEN}, {CASE_CLAUSE, COMPLETE_COMMANDS}, {CASE_CLAUSE, TK_BANG}, {CASE_CLAUSE, SEPARATOR_OP}, @@ -648,13 +712,15 @@ t_stackmatch g_stackmatch[] = {CASE_CLAUSE, TK_ELSE}, {CASE_CLAUSE, COMPOUND_LIST}, {CASE_CLAUSE, CASE_LIST_NS}, - {CASE_CLAUSE, COMPLETE_COMMAND}, + {CASE_CLAUSE, COMPLETE_CONDITION}, + {CASE_CLAUSE, AND_OR_MAJOR}, {WORDLIST, IN}, {IN, LINEBREAK}, {NAME, TK_FOR}, {FOR_WORDLIST, NAME}, {FOR_CLAUSE, LINEBREAK}, + {FOR_CLAUSE, TK_PAREN_OPEN}, {FOR_CLAUSE, COMPLETE_COMMANDS}, {FOR_CLAUSE, TK_BANG}, {FOR_CLAUSE, TK_BANG}, @@ -672,6 +738,7 @@ t_stackmatch g_stackmatch[] = {FOR_CLAUSE, COMPOUND_LIST}, {FOR_CLAUSE, CASE_LIST_NS}, {FOR_CLAUSE, COMPLETE_CONDITION}, + {FOR_CLAUSE, AND_OR_MAJOR}, {TERM, LINEBREAK}, {TERM, COMPLETE_COMMANDS}, {COMPOUND_LIST, TK_DO}, @@ -689,11 +756,26 @@ t_stackmatch g_stackmatch[] = {SUBSHELL, LINEBREAK}, {SUBSHELL, COMPLETE_COMMANDS}, {SUBSHELL, TK_BANG}, - {SUBSHELL, TK_BANG}, {SUBSHELL, SEPARATOR_OP}, {SUBSHELL, NEWLINE_LIST}, {SUBSHELL, PIPE_SEMI_SEQUENCE}, + {SUBSHELL, SEPARATOR_OP}, + {SUBSHELL, NEWLINE_LIST}, + {SUBSHELL, PIPE_SEMI_SEQUENCE}, + {SUBSHELL, TK_DO}, + {SUBSHELL, TK_PAREN_CLOSE}, + {SUBSHELL, TK_WHILE}, + {SUBSHELL, TK_UNTIL}, + {SUBSHELL, TK_IF}, + {SUBSHELL, TK_ELIF}, + {SUBSHELL, TK_THEN}, + {SUBSHELL, TK_ELSE}, + {SUBSHELL, COMPOUND_LIST}, + {SUBSHELL, CASE_LIST_NS}, + {SUBSHELL, COMPLETE_CONDITION}, + {SUBSHELL, AND_OR_MAJOR}, {COMPOUND_COMMAND, LINEBREAK}, + {COMPOUND_COMMAND, TK_PAREN_OPEN}, {COMPOUND_COMMAND, COMPLETE_COMMANDS}, {COMPOUND_COMMAND, TK_BANG}, {COMPOUND_COMMAND, TK_BANG}, @@ -712,9 +794,11 @@ t_stackmatch g_stackmatch[] = {COMPOUND_COMMAND, COMPOUND_LIST}, {COMPOUND_COMMAND, CASE_LIST_NS}, {COMPOUND_COMMAND, COMPLETE_CONDITION}, + {COMPOUND_COMMAND, AND_OR_MAJOR}, {COMMAND, TK_WHILE}, {COMMAND, TK_UNTIL}, {COMMAND, LINEBREAK}, + {COMMAND, TK_PAREN_OPEN}, {COMMAND, COMPLETE_COMMANDS}, {COMMAND, TK_DO}, {COMMAND, TK_PAREN_CLOSE}, @@ -732,9 +816,9 @@ t_stackmatch g_stackmatch[] = {COMMAND, AND_OR_MAJOR}, {AND_OR_MINOR, PIPE_SEMI_SEQUENCE}, {AND_OR_MINOR, LINEBREAK}, + {AND_OR_MINOR, TK_PAREN_OPEN}, {AND_OR_MINOR, COMPLETE_COMMANDS}, {AND_OR_MINOR, AND_OR_MAJOR}, - {AND_OR_MINOR, AND_OR_MAJOR}, {PIPE_SEQUENCE, TK_WHILE}, {PIPE_SEQUENCE, TK_UNTIL}, {PIPE_SEQUENCE, TK_DO}, @@ -747,6 +831,7 @@ t_stackmatch g_stackmatch[] = {PIPE_SEQUENCE, CASE_LIST_NS}, {PIPE_SEQUENCE, COMPLETE_CONDITION}, {PIPE_SEQUENCE, LINEBREAK}, + {PIPE_SEQUENCE, TK_PAREN_OPEN}, {PIPE_SEQUENCE, COMPLETE_COMMANDS}, {PIPE_SEQUENCE, TK_BANG}, {PIPE_SEQUENCE, TK_BANG}, @@ -765,6 +850,7 @@ t_stackmatch g_stackmatch[] = {PIPE_SEMI_SEQUENCE, CASE_LIST_NS}, {PIPE_SEMI_SEQUENCE, COMPLETE_CONDITION}, {PIPE_SEMI_SEQUENCE, LINEBREAK}, + {PIPE_SEMI_SEQUENCE, TK_PAREN_OPEN}, {PIPE_SEMI_SEQUENCE, COMPLETE_COMMANDS}, {PIPE_SEMI_SEQUENCE, TK_BANG}, {PIPE_SEMI_SEQUENCE, TK_BANG}, @@ -783,12 +869,14 @@ t_stackmatch g_stackmatch[] = {PIPELINE, CASE_LIST_NS}, {PIPELINE, COMPLETE_CONDITION}, {PIPELINE, LINEBREAK}, + {PIPELINE, TK_PAREN_OPEN}, {PIPELINE, COMPLETE_COMMANDS}, {PIPELINE, SEPARATOR_OP}, {PIPELINE, SEPARATOR_OP}, {PIPELINE, NEWLINE_LIST}, {PIPELINE, AND_OR_MAJOR}, {AND_OR_MAJOR, LINEBREAK}, + {AND_OR_MAJOR, TK_PAREN_OPEN}, {AND_OR_MAJOR, COMPLETE_COMMANDS}, {AND_OR_MAJOR, AND_OR_MAJOR}, {AND_OR_MAJOR, AND_OR_MAJOR}, @@ -804,17 +892,21 @@ t_stackmatch g_stackmatch[] = {AND_OR, CASE_LIST_NS}, {AND_OR, COMPLETE_CONDITION}, {AND_OR, LINEBREAK}, + {AND_OR, TK_PAREN_OPEN}, {AND_OR, COMPLETE_COMMANDS}, {AND_OR, SEPARATOR_OP}, {AND_OR, SEPARATOR_OP}, {AND_OR, NEWLINE_LIST}, {LIST, LINEBREAK}, + {LIST, TK_PAREN_OPEN}, {LIST, COMPLETE_COMMANDS}, {LIST, NEWLINE_LIST}, {COMPLETE_COMMAND, LINEBREAK}, + {COMPLETE_COMMAND, TK_PAREN_OPEN}, {COMPLETE_COMMAND, COMPLETE_COMMANDS}, {COMPLETE_COMMAND, NEWLINE_LIST}, {COMPLETE_COMMANDS, LINEBREAK}, + {COMPLETE_COMMANDS, TK_PAREN_OPEN}, {COMPLETE_COMMANDS, COMPLETE_COMMANDS}, {0, 0}, }; @@ -823,7 +915,7 @@ int eval_sym(t_sym stack, t_sym new_sym) { int i; -// DG("eval head %s && sym %s", read_state(stack), read_state(new_sym)); + DG("eval head %s && sym %s", read_state(stack), read_state(new_sym)); i = 0; while (g_stackmatch[i].top) { diff --git a/42sh/src/parser/ft_parse.c b/42sh/src/parser/ft_parse.c index 714d5b4e..01f978b8 100644 --- a/42sh/src/parser/ft_parse.c +++ b/42sh/src/parser/ft_parse.c @@ -43,7 +43,7 @@ int ft_parse(t_btree **ast, t_list **token, t_parser *parser) aggregate_sym(&parser->stack, parser->new_sym, &parser->state); push_stack(++parser->stack, *parser->new_sym); } -// ft_read_stack(parser->stack); + ft_read_stack(parser->stack); DG("\n"); if (*parser->stack == PROGRAM) parser->state = SUCCESS; @@ -56,5 +56,7 @@ int ft_parse(t_btree **ast, t_list **token, t_parser *parser) else ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free); } + if (parser->state == SUCCESS) + DG("sucessful parsing"); return (0); } diff --git a/42sh/src/parser/produce_sym.c b/42sh/src/parser/produce_sym.c index 505a21a6..1cc792f4 100644 --- a/42sh/src/parser/produce_sym.c +++ b/42sh/src/parser/produce_sym.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 17:58:34 by ariard #+# #+# */ -/* Updated: 2017/02/21 22:21:41 by ariard ### ########.fr */ +/* Updated: 2017/02/24 18:25:47 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -45,14 +45,17 @@ t_prodmatch g_prodmatch[] = {TK_WORD, TK_BANG, CMD_NAME}, {TK_WORD, PIPE_SEMI_SEQUENCE, CMD_NAME}, {TK_WORD, SEPARATOR_OP, CMD_NAME}, + {TK_WORD, TK_PAREN_OPEN, CMD_NAME}, {TK_WORD, CASE_LIST, PATTERN}, - {TK_WORD, TK_PAREN_OPEN, PATTERN}, + {TK_WORD, PATTERN_CASE, PATTERN}, {TK_WORD, COMPLETE_COMMANDS, CMD_NAME}, {TK_ASSIGNEMENT_WORD, LINEBREAK, CMD_PREFIX}, + {TK_ASSIGNEMENT_WORD, TK_PAREN_OPEN, 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_PAREN_OPEN, FNAME}, {TK_NAME, TK_BANG, FNAME}, {TK_NAME, SEPARATOR_OP, FNAME}, {TK_NAME, NEWLINE_LIST, FNAME}, @@ -71,6 +74,7 @@ t_prodmatch g_prodmatch[] = {TK_NEWLINE, CMD_NAME, NEWLINE_LIST}, {TK_NEWLINE, COMPLETE_COMMANDS, NEWLINE_LIST}, {TK_NEWLINE, LINEBREAK, NEWLINE_LIST}, + {TK_NEWLINE, TK_PAREN_OPEN, NEWLINE_LIST}, {TK_NEWLINE, CMD_SUPERIOR, LINEBREAK}, {TK_NEWLINE, PIPE_SEMI_SEQUENCE, LINEBREAK}, {TK_NEWLINE, CASE_LIST_NS, NEWLINE_LIST}, @@ -97,8 +101,8 @@ 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)); + DG("produce stack : %s && token : %s", read_state(stack), + read_state(token->type)); i = 0; *new_sym = 0; while (g_prodmatch[i].new_sym) @@ -106,7 +110,7 @@ int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst) if (token->type == g_prodmatch[i].token && stack == g_prodmatch[i].stack) { -// DG("MATCH : %s", read_state(g_prodmatch[i].new_sym)); + DG("MATCH : %s", read_state(g_prodmatch[i].new_sym)); *new_sym = g_prodmatch[i].new_sym; } i++;