From 7f83e231aa773e19eebb8193218c96f08e8933be Mon Sep 17 00:00:00 2001 From: AntoHesse Date: Fri, 17 Feb 2017 02:38:56 +0100 Subject: [PATCH] && || --- 42sh/Makefile | 26 +++++++++++++------------- 42sh/file1 | 14 ++++++++++++++ 42sh/includes/lexer.h | 4 +--- 42sh/includes/parser.h | 6 +++++- 42sh/sample/stack.sh | 4 +++- 42sh/src/exec/ft_exec.c | 8 +++++--- 42sh/src/main/ft_putast.c | 2 ++ 42sh/src/main/shell_script.c | 14 ++++++-------- 42sh/src/parser/add_cmd.c | 2 +- 42sh/src/parser/aggregate_sym.c | 18 ++++++++++++++---- 42sh/src/parser/build_tree.c | 14 +++++++++++--- 42sh/src/parser/eval_sym.c | 31 ++++++++++++++++++++++++++++--- 42sh/src/parser/ft_parse.c | 2 +- 42sh/src/parser/old_parse.c | 1 - 42sh/src/parser/produce_sym.c | 6 ++++-- 42sh/src/parser/read_stack.c | 28 ++++++++++++++++++++++++++++ 16 files changed, 136 insertions(+), 44 deletions(-) create mode 100644 42sh/file1 diff --git a/42sh/Makefile b/42sh/Makefile index 0b41f6bb..fa337596 100644 --- a/42sh/Makefile +++ b/42sh/Makefile @@ -168,19 +168,7 @@ main/shell_get_opts.c\ main/shell_init.c\ main/shell_script.c\ main/sig_handler.c\ -parser/parse.c\ -parser/ft_parse.c\ parser/old_parse.c\ -parser/produce_sym.c\ -parser/eval_sym.c\ -parser/aggregate_sym.c\ -parser/pop_stack.c\ -parser/push_stack.c\ -parser/error_syntax.c\ -parser/build_tree.c\ -parser/tree_wrapper.c\ -parser/add_sep.c\ -parser/add_cmd.c\ parser/get_instruction.c\ parser/get_sub_instruction.c\ parser/parse_dgreat.c\ @@ -198,7 +186,19 @@ parser/parse_if.c\ parser/parse_elif.c\ parser/parse_else.c\ parser/parse_word.c\ -parser/read_stack.c +parser/read_stack.c\ +parser/parse.c\ +parser/ft_parse.c\ +parser/produce_sym.c\ +parser/eval_sym.c\ +parser/aggregate_sym.c\ +parser/pop_stack.c\ +parser/push_stack.c\ +parser/error_syntax.c\ +parser/build_tree.c\ +parser/tree_wrapper.c\ +parser/add_sep.c\ +parser/add_cmd.c SRCS = $(addprefix $(SRC_DIR), $(SRC_BASE)) OBJS = $(addprefix $(OBJ_DIR), $(SRC_BASE:.c=.o)) diff --git a/42sh/file1 b/42sh/file1 new file mode 100644 index 00000000..e75bc531 --- /dev/null +++ b/42sh/file1 @@ -0,0 +1,14 @@ +Makefile +blind.text +debug +file1 +grammar +includes +libft +pdf +sample +script.sh +src +test.sh +tofix +update_makefile.sh diff --git a/42sh/includes/lexer.h b/42sh/includes/lexer.h index b8891c65..705bef68 100644 --- a/42sh/includes/lexer.h +++ b/42sh/includes/lexer.h @@ -36,8 +36,8 @@ typedef long long t_type; * */ -/* +/* # define TK_LESS (1 << 0) //transparent # define TK_GREAT (1 << 1) //transparent # define TK_DLESS (1 << 2) @@ -67,10 +67,8 @@ typedef long long t_type; # define TK_ELIF (1 << 26) # define TK_ELSE (1 << 27) # define TK_UNTIL (1 << 28) - */ -# define TK_COMMAND (1 << 10) # define TK_WORD (TK_N_WORD | TK_Q_WORD | TK_DQ_WORD) # define TK_REDIR (0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20) # define TK_NON_FREEABLE (TK_PAREN_OPEN | TK_PAREN_CLOSE | TK_BQUOTE) diff --git a/42sh/includes/parser.h b/42sh/includes/parser.h index 9830855d..e226d0e5 100644 --- a/42sh/includes/parser.h +++ b/42sh/includes/parser.h @@ -20,9 +20,11 @@ * */ + enum e_sym { LINEBREAK = 1, + TK_COMMAND, TK_LESS, TK_GREAT, TK_DLESS, @@ -116,6 +118,8 @@ enum e_sym PIPE_SEMI_SEQUENCE, PATTERN_CASE, CMD_SUPERIOR, + AND_OR_MAJOR, + AND_OR_MINOR, ALL = 200, }; @@ -215,7 +219,7 @@ typedef long long t_type; struct s_parser { - t_type type; + t_type type; int (*f)(t_btree **ast, t_list **start, t_list **token); }; diff --git a/42sh/sample/stack.sh b/42sh/sample/stack.sh index 30cde0b2..5b2b1f27 100644 --- a/42sh/sample/stack.sh +++ b/42sh/sample/stack.sh @@ -1 +1,3 @@ -ls +cat && ls || ls | cat && ls | cat || ls + + diff --git a/42sh/src/exec/ft_exec.c b/42sh/src/exec/ft_exec.c index 9bf82ba0..1baf929c 100644 --- a/42sh/src/exec/ft_exec.c +++ b/42sh/src/exec/ft_exec.c @@ -28,7 +28,8 @@ t_execmap g_execmap[] = {TK_ELIF, &exec_elif}, {TK_ELSE, &exec_else}, {TK_UNTIL, &exec_until}, - {TK_COMMAND | TK_SUBSHELL, &exec_command}, + {TK_COMMAND, &exec_command}, + {TK_SUBSHELL, &exec_command}, {0, 0}, }; @@ -43,9 +44,10 @@ int ft_exec(t_btree **ast) item = (*ast)->item; while (g_execmap[i].type) { - if (item->type & g_execmap[i].type) - + if (item->type == g_execmap[i].type) { + DG("match : %s and %s", + read_state(item->type), read_state(g_execmap[i].type)); /* return ((*g_execmap[i].f)(ast)); */ (*g_execmap[i].f)(ast); } diff --git a/42sh/src/main/ft_putast.c b/42sh/src/main/ft_putast.c index acc9cfb8..2b5e4e7b 100644 --- a/42sh/src/main/ft_putast.c +++ b/42sh/src/main/ft_putast.c @@ -22,6 +22,8 @@ char *ft_putast(void *nodein) node = nodein; if (node->type == TK_AMP) return (" & "); + else if (node->type == TK_N_WORD) + return (" TK_N_WORD"); else if (node->type == TK_SEMI) return (" ; "); else if (node->type == TK_AND_IF) diff --git a/42sh/src/main/shell_script.c b/42sh/src/main/shell_script.c index bdb13254..2d2829b0 100644 --- a/42sh/src/main/shell_script.c +++ b/42sh/src/main/shell_script.c @@ -23,23 +23,21 @@ int shell_script() ast = NULL; list_ast = NULL; script = &data_singleton()->script; -// while (script->size) -// { + while (script->size) + { if (ft_lexer(&token, &data_singleton()->script.buffer) || !token) return (1); DG("after post_tokenize"); token_print(token); -// if (ft_parse2(&ast, &token)) -// return (1); - if (ft_parse(&ast, &token)) + if (ft_parse2(&ast, &token)) return (1); btree_print(STDBUG, ast, &ft_putast); - if (ft_exec(&ast)) - return (1); +// if (ft_exec(&ast)) +// return (1); ast = NULL; script->size = 0; get_script_content(script); -// } + } close(script->fd); return (0); } diff --git a/42sh/src/parser/add_cmd.c b/42sh/src/parser/add_cmd.c index b299c780..8d6f7ecd 100644 --- a/42sh/src/parser/add_cmd.c +++ b/42sh/src/parser/add_cmd.c @@ -25,7 +25,7 @@ int add_cmd(t_btree **ast, t_list **lst) my_tab = NULL; token = (*lst)->content; node = (*ast)->item; - node->type = TK_COMMAND; + node->type = token->type; my_tab = ft_sstradd(my_tab, token->data); my_tab = ft_sstradd(my_tab, (char *)token->esc); ft_ld_pushback(&node->data.token, my_tab); diff --git a/42sh/src/parser/aggregate_sym.c b/42sh/src/parser/aggregate_sym.c index 7d3434e5..e7eabeca 100644 --- a/42sh/src/parser/aggregate_sym.c +++ b/42sh/src/parser/aggregate_sym.c @@ -28,6 +28,8 @@ t_aggrematch g_aggrematch[] = {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}, + {TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR}, //watch this {SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, 0}, {LINEBREAK, SEPARATOR_OP, SEPARATOR, SEPARATOR_OP}, @@ -94,6 +96,7 @@ t_aggrematch g_aggrematch[] = {CMD_NAME, NEWLINE_LIST, CMD_SUPERIOR, 0}, {CMD_NAME, TK_PIPE, CMD_SUPERIOR, 0}, {CMD_NAME, PIPE_SEMI_SEQUENCE, CMD_SUPERIOR, 0}, + {CMD_NAME, AND_OR_MAJOR, CMD_SUPERIOR, 0}, {SIMPLE_COMMAND, ALL, COMMAND, 0}, {DO_GROUP, NAME, FOR_CLAUSE, TK_FOR}, {DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, TK_FOR}, @@ -120,18 +123,25 @@ t_aggrematch g_aggrematch[] = {COMPOUND_LIST, TK_THEN, ELSE_PART, TK_ELIF}, {SUBSHELL, ALL, COMPOUND_COMMAND, 0}, {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, AND_OR_MAJOR, AND_OR_MAJOR, 0}, {COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE}, {COMMAND, TK_BANG, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, SEPARATOR_OP, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, NEWLINE_LIST, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, 0}, + {COMMAND, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE, 0}, {PIPE_SEQUENCE, TK_BANG, PIPELINE, TK_BANG}, {PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, 0}, {PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, 0}, {PIPE_SEQUENCE, LINEBREAK, PIPELINE, 0}, + {PIPE_SEQUENCE, AND_OR_MAJOR, PIPELINE, 0}, {PIPELINE, LINEBREAK, AND_OR, 0}, // {PIPELINE, LINEBREAK, AND_OR, AND_OR}, {PIPELINE, SEPARATOR_OP, AND_OR, 0}, + {PIPELINE, AND_OR_MAJOR, AND_OR, AND_OR_MAJOR}, + {AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR}, {AND_OR, SEPARATOR_OP, LIST, LIST}, {AND_OR, NEWLINE_LIST, LIST, 0}, {AND_OR, LINEBREAK, LIST, 0}, @@ -149,20 +159,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 2441360a..60f50e24 100644 --- a/42sh/src/parser/build_tree.c +++ b/42sh/src/parser/build_tree.c @@ -16,6 +16,11 @@ t_treematch g_treematch[] = { {TK_N_WORD, &add_cmd}, {TK_PIPE, &add_sep}, + {TK_SEMI, &add_sep}, + {TK_GREAT, &add_sep}, + {TK_LESS, &add_sep}, + {TK_OR_IF, &add_sep}, + {TK_AND_IF, &add_sep}, {0, NULL}, }; @@ -28,10 +33,13 @@ int build_tree(t_btree **ast, t_list **lst) token = (*lst)->content; while (g_treematch[i].type) { - DG("func TK : '%s' TK : '%s'", - read_state(g_treematch[i].type) ,read_state(token->type)); if (g_treematch[i].type == token->type) - return (g_treematch[i].add(ast, lst)); + { + + DG("func TK : '%s' TK : '%s'", + read_state(g_treematch[i].type) ,read_state(token->type)); + return (g_treematch[i].add(ast, lst)); + } i++; } return (0); diff --git a/42sh/src/parser/eval_sym.c b/42sh/src/parser/eval_sym.c index 49f4acf3..b7520b85 100644 --- a/42sh/src/parser/eval_sym.c +++ b/42sh/src/parser/eval_sym.c @@ -31,7 +31,11 @@ t_stackmatch g_stackmatch[] = {TK_IO_NUMBER, NEWLINE_LIST}, {TK_IO_NUMBER, PIPE_SEMI_SEQUENCE}, {TK_IO_NUMBER, CMD_SUPERIOR}, + {TK_IO_NUMBER, AND_OR_MAJOR}, {TK_AND_IF, AND_OR}, + {TK_AND_IF, CMD_SUPERIOR}, + {TK_OR_IF, AND_OR}, + {TK_OR_IF, CMD_SUPERIOR}, {TK_OR_IF, AND_OR}, {TK_DSEMI, LINEBREAK}, {TK_DSEMI, COMPOUND_LIST}, @@ -47,6 +51,7 @@ t_stackmatch g_stackmatch[] = {TK_LESS, NEWLINE_LIST}, {TK_LESS, PIPE_SEMI_SEQUENCE}, {TK_LESS, CMD_SUPERIOR}, + {TK_LESS, AND_OR_MAJOR}, {TK_GREAT, TK_IO_NUMBER}, {TK_GREAT, REDIRECT_LIST}, {TK_GREAT, CMD_SUFFIX}, @@ -60,6 +65,7 @@ t_stackmatch g_stackmatch[] = {TK_GREAT, PIPE_SEMI_SEQUENCE}, //duplicate and extend {TK_GREAT, CMD_SUPERIOR}, + {TK_GREAT, AND_OR_MAJOR}, {TK_DLESS, TK_IO_NUMBER}, {TK_DLESS, REDIRECT_LIST}, @@ -73,6 +79,7 @@ t_stackmatch g_stackmatch[] = {TK_DLESS, NEWLINE_LIST}, {TK_DLESS, PIPE_SEMI_SEQUENCE}, {TK_DLESS, CMD_SUPERIOR}, + {TK_DLESS, AND_OR_MAJOR}, {TK_DLESSDASH, TK_IO_NUMBER}, {TK_DLESSDASH, REDIRECT_LIST}, @@ -86,6 +93,7 @@ t_stackmatch g_stackmatch[] = {TK_DLESSDASH, NEWLINE_LIST}, {TK_DLESSDASH, PIPE_SEMI_SEQUENCE}, {TK_DLESSDASH, CMD_SUPERIOR}, + {TK_DLESSDASH, AND_OR_MAJOR}, {TK_DGREAT, TK_IO_NUMBER}, {TK_DGREAT, REDIRECT_LIST}, @@ -99,6 +107,7 @@ t_stackmatch g_stackmatch[] = {TK_DGREAT, NEWLINE_LIST}, {TK_DGREAT, PIPE_SEMI_SEQUENCE}, {TK_DGREAT, CMD_SUPERIOR}, + {TK_DGREAT, AND_OR_MAJOR}, {TK_LESSAND, TK_IO_NUMBER}, {TK_LESSAND, REDIRECT_LIST}, @@ -112,6 +121,7 @@ t_stackmatch g_stackmatch[] = {TK_LESSAND, NEWLINE_LIST}, {TK_LESSAND, PIPE_SEMI_SEQUENCE}, {TK_LESSAND, CMD_SUPERIOR}, + {TK_LESSAND, AND_OR_MAJOR}, {TK_GREATAND, TK_IO_NUMBER}, {TK_GREATAND, REDIRECT_LIST}, @@ -125,6 +135,7 @@ t_stackmatch g_stackmatch[] = {TK_GREATAND, NEWLINE_LIST}, {TK_GREATAND, PIPE_SEMI_SEQUENCE}, {TK_GREATAND, CMD_SUPERIOR}, + {TK_GREATAND, AND_OR_MAJOR}, {TK_LESSGREAT, TK_IO_NUMBER}, {TK_LESSGREAT, REDIRECT_LIST}, @@ -138,6 +149,7 @@ t_stackmatch g_stackmatch[] = {TK_LESSGREAT, NEWLINE_LIST}, {TK_LESSGREAT, PIPE_SEMI_SEQUENCE}, {TK_LESSGREAT, CMD_SUPERIOR}, + {TK_LESSGREAT, AND_OR_MAJOR}, {TK_CLOBBER, TK_IO_NUMBER}, {TK_CLOBBER, REDIRECT_LIST}, @@ -151,6 +163,7 @@ t_stackmatch g_stackmatch[] = {TK_CLOBBER, NEWLINE_LIST}, {TK_CLOBBER, PIPE_SEMI_SEQUENCE}, {TK_CLOBBER, CMD_SUPERIOR}, + {TK_CLOBBER, AND_OR_MAJOR}, {TK_IF, LINEBREAK}, {TK_IF, TK_BANG}, @@ -305,19 +318,22 @@ t_stackmatch g_stackmatch[] = {CMD_NAME, SEPARATOR_OP}, {CMD_NAME, NEWLINE_LIST}, {CMD_NAME, PIPE_SEMI_SEQUENCE}, - + {CMD_NAME, AND_OR_MAJOR}, + {CMD_SUPERIOR, LINEBREAK,}, {CMD_SUPERIOR, TK_BANG}, {CMD_SUPERIOR, SEPARATOR_OP}, {CMD_SUPERIOR, NEWLINE_LIST}, {CMD_SUPERIOR, TK_PIPE}, {CMD_SUPERIOR, PIPE_SEMI_SEQUENCE}, - + {CMD_SUPERIOR, AND_OR_MAJOR}, + {SIMPLE_COMMAND, LINEBREAK}, {SIMPLE_COMMAND, TK_BANG}, {SIMPLE_COMMAND, SEPARATOR_OP}, {SIMPLE_COMMAND, NEWLINE_LIST}, {SIMPLE_COMMAND, PIPE_SEMI_SEQUENCE}, + {SIMPLE_COMMAND, AND_OR_MAJOR}, {DO_GROUP, COMPOUND_LIST}, {DO_GROUP, NAME}, {DO_GROUP, SEQUENTIAL_SEP}, @@ -401,17 +417,26 @@ t_stackmatch g_stackmatch[] = {COMMAND, SEPARATOR_OP}, {COMMAND, NEWLINE_LIST}, {COMMAND, PIPE_SEMI_SEQUENCE}, + {COMMAND, AND_OR_MAJOR}, + {AND_OR_MINOR, PIPE_SEMI_SEQUENCE}, + {AND_OR_MINOR, LINEBREAK}, + {AND_OR_MINOR, AND_OR_MAJOR}, {PIPE_SEQUENCE, LINEBREAK}, {PIPE_SEQUENCE, TK_BANG}, {PIPE_SEQUENCE, SEPARATOR_OP}, {PIPE_SEQUENCE, NEWLINE_LIST}, + {PIPE_SEQUENCE, AND_OR_MAJOR}, {PIPE_SEMI_SEQUENCE, LINEBREAK}, {PIPE_SEMI_SEQUENCE, TK_BANG}, {PIPE_SEMI_SEQUENCE, SEPARATOR_OP}, {PIPE_SEMI_SEQUENCE, NEWLINE_LIST}, + {PIPE_SEMI_SEQUENCE, AND_OR_MAJOR}, {PIPELINE, LINEBREAK}, {PIPELINE, SEPARATOR_OP}, {PIPELINE, NEWLINE_LIST}, + {PIPELINE, AND_OR_MAJOR}, + {AND_OR_MAJOR, LINEBREAK}, + {AND_OR_MAJOR, AND_OR_MAJOR}, {AND_OR, LINEBREAK}, {AND_OR, SEPARATOR_OP}, {AND_OR, NEWLINE_LIST}, @@ -427,7 +452,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 745b48aa..ef0280e8 100644 --- a/42sh/src/parser/ft_parse.c +++ b/42sh/src/parser/ft_parse.c @@ -27,7 +27,7 @@ int ft_parse2(t_btree **ast, t_list **token) while (*token) { produce_sym(*stack, new_sym, token); -// DG("new sym %s", read_state(*new_sym)); + DG("new sym %s", read_state(*new_sym)); if (eval_sym(*stack, *new_sym)) state = ERROR; else diff --git a/42sh/src/parser/old_parse.c b/42sh/src/parser/old_parse.c index 00969352..af5cb658 100644 --- a/42sh/src/parser/old_parse.c +++ b/42sh/src/parser/old_parse.c @@ -48,7 +48,6 @@ int ft_parse(t_btree **ast, t_list **start) { if ((lst = ft_lst_find(*start, &g_parser[i].type, &token_cmp_type))) { - DG("match : %s", read_state(g_parser[i].type)); if (g_parser[i].f) (*g_parser[i].f)(ast, start, &lst); return (0); diff --git a/42sh/src/parser/produce_sym.c b/42sh/src/parser/produce_sym.c index c5f415b6..ca1d7088 100644 --- a/42sh/src/parser/produce_sym.c +++ b/42sh/src/parser/produce_sym.c @@ -27,6 +27,8 @@ t_prodmatch g_prodmatch[] = {TK_N_WORD, CMD_NAME, CMD_SUFFIX}, {TK_N_WORD, LINEBREAK, CMD_NAME}, {TK_N_WORD, TK_PIPE, CMD_NAME}, + {TK_N_WORD, AND_OR, CMD_NAME}, + {TK_N_WORD, AND_OR_MAJOR, CMD_NAME}, {TK_N_WORD, NEWLINE_LIST, CMD_NAME}, {TK_N_WORD, TK_BANG, CMD_NAME}, @@ -64,8 +66,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) diff --git a/42sh/src/parser/read_stack.c b/42sh/src/parser/read_stack.c index dec9d797..89f4af57 100644 --- a/42sh/src/parser/read_stack.c +++ b/42sh/src/parser/read_stack.c @@ -14,8 +14,36 @@ char *read_state(t_sym current) { + if (current == AND_OR_MINOR) + return("AND_OR_MINOR"); + if (current == AND_OR_MAJOR) + return ("AND_OR_MAJOR"); + if (current == TK_COMMAND) + return ("TK_COMMAND"); + if (current == TK_AND_IF) + return ("TK_AND_IF"); + if (current == TK_OR_IF) + return ("TK_OR_IF"); + if (current == TK_AMP) + return ("TK_AMP"); + if (current == TK_PIPE) + return ("TK_PIPE"); + if (current == TK_LESS) + return ("TK_LESS"); + if (current == TK_GREAT) + return ("TK_GREAT"); if (current == TK_DLESS) return ("TK_DLESS"); + if (current == TK_DGREAT) + return ("TK_DGREAT"); + if (current == TK_DGREAT) + return ("TK_DGREAT"); + if (current == TK_LESSAND) + return ("TK_LESSAND"); + if (current == TK_GREATAND) + return ("TK_GREATAND"); + if (current == TK_SUBSHELL) + return ("TK_SUBSEHLL"); if (current == CMD_SUPERIOR) return ("CMD_SUPERIOR"); if (current == TK_IO_NUMBER)