diff --git a/42sh/Makefile b/42sh/Makefile index 0585fe4c..6dd30607 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 16:38:00 by ariard ### ########.fr # +# Updated: 2017/02/25 00:13:39 by ariard ### ########.fr # # # # **************************************************************************** # @@ -74,12 +74,14 @@ exec/exec_redir.c\ exec/exec_semi.c\ exec/exec_until.c\ exec/exec_while.c\ +exec/exec_var.c\ +exec/exec_for.c\ +exec/exec_case.c\ +exec/exec_case_branch.c\ exec/fd_is_valid.c\ exec/ft_exec.c\ exec/ft_findexec.c\ exec/launch_process.c\ -exec/loop_del.c\ -exec/loop_exec.c\ exec/process_redirect.c\ exec/process_reset.c\ exec/process_setexec.c\ @@ -170,6 +172,7 @@ lexer/get_lexer_stack.c\ lexer/get_reserved_words.c\ lexer/get_state_global.c\ lexer/get_state_redir.c\ +lexer/insert_newline.c\ lexer/lexer_backslash.c\ lexer/lexer_bquote.c\ lexer/lexer_comment.c\ @@ -187,6 +190,8 @@ lexer/lexer_lex.c\ lexer/lexer_newline.c\ lexer/lexer_number.c\ lexer/lexer_paren.c\ +lexer/lexer_curly_brackets.c\ +lexer/lexer_assignement_word.c\ lexer/lexer_quote.c\ lexer/lexer_sep.c\ lexer/lexer_word.c\ @@ -223,10 +228,13 @@ 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\ parser/add_sep.c\ +parser/add_case.c\ +parser/add_func.c\ parser/aggregate_sym.c\ parser/build_tree.c\ parser/error_syntax.c\ diff --git a/42sh/includes/exec.h b/42sh/includes/exec.h index d5666a6e..22280dc8 100644 --- a/42sh/includes/exec.h +++ b/42sh/includes/exec.h @@ -33,8 +33,6 @@ # define IS_PIPEEND(p) (p->fdout == STDOUT) # define IS_PIPESINGLE(p) (IS_PIPESTART(p) && IS_PIPEEND(p)) -# define SCRIPT_LOOP (1 << 0) - # include "libft.h" # include "types.h" # include "job_control.h" @@ -52,7 +50,9 @@ struct s_process t_list *redirs; int status; t_flag attributes; - t_flag script; + t_condition if_branch; + t_condition case_branch; + char *case_pattern; }; struct s_exec @@ -101,7 +101,10 @@ int exec_elif(t_btree **ast); int exec_else(t_btree **ast); int exec_until(t_btree **ast); int exec_default(t_btree **ast); - +int exec_var(t_btree **ast); +int exec_for(t_btree **ast); +int exec_case(t_btree **ast); +int exec_case_branch(t_btree **ast); int launch_process(t_process *p); int process_setexec(t_type type, t_process *p); @@ -127,7 +130,6 @@ void set_exitstatus(int status, int override); void ast_free(void *data, size_t content_size); -int loop_exec(t_list *list_ast); -int loop_del(t_list *list_ast); +char **token_to_argv(t_astnode *node); #endif diff --git a/42sh/includes/lexer.h b/42sh/includes/lexer.h index f9d7f709..3551dd8f 100644 --- a/42sh/includes/lexer.h +++ b/42sh/includes/lexer.h @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/01 12:15:50 by jhalford #+# #+# */ -/* Updated: 2017/02/21 22:39:19 by jhalford ### ########.fr */ +/* Updated: 2017/02/24 21:46:08 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -39,9 +39,9 @@ enum e_lexstate BQUOTE, DQUOTE_BQUOTE, BACKSLASH, - VAR, - SPECIAL, PAREN, + CURLY_BRACKETS, + ASSIGNEMENT_WORD, COMMENT, END, }; @@ -91,6 +91,8 @@ char *stack_to_prompt(t_list *stack); t_lexstate get_state_global(t_lexer *lexer); t_lexstate get_state_redir(t_lexer *lexer); int get_lexer_stack(t_lexer lexer); +int get_reserved_words(t_list **alst); +int insert_newline(t_list **alst); void lexer_init(t_lexer *lexer); int lexer_lex(t_list **alst, t_lexer *lexer); int lexer_default(t_list **alst, t_lexer *lexer); @@ -109,6 +111,8 @@ int lexer_dquote(t_list **alst, t_lexer *lexer); int lexer_bquote(t_list **alst, t_lexer *lexer); int lexer_backslash(t_list **alst, t_lexer *lexer); int lexer_paren(t_list **alst, t_lexer *lexer); +int lexer_curly_brackets(t_list **alst, t_lexer *lexer); +int lexer_assignement_word(t_list **alst, t_lexer *lexer); int lexer_comment(t_list **alst, t_lexer *lexer); int lexer_end(t_list **alst, t_lexer *lexer); diff --git a/42sh/includes/minishell.h b/42sh/includes/minishell.h index 23c31ae2..fd9768fd 100644 --- a/42sh/includes/minishell.h +++ b/42sh/includes/minishell.h @@ -65,6 +65,8 @@ struct s_data t_comp *comp; t_exec exec; t_jobc jobc; + char **local_var; + t_list *lst_func; }; extern t_stof g_builtins[]; diff --git a/42sh/includes/parser.h b/42sh/includes/parser.h index 3cc848c9..1812e496 100644 --- a/42sh/includes/parser.h +++ b/42sh/includes/parser.h @@ -6,7 +6,6 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/01 12:15:54 by jhalford #+# #+# */ -/* Updated: 2017/02/21 20:13:57 by jhalford ### ########.fr */ /* */ /* ************************************************************************** */ @@ -22,112 +21,9 @@ enum e_parstate { + ERROR = 0, UNDEFINED, SUCCESS, - ERROR, -}; - -enum e_sym -{ - LINEBREAK = 1, - TK_COMMAND, - TK_LESS, - TK_GREAT, - TK_DLESS, - TK_DGREAT, - TK_LESSAND, - TK_GREATAND, - TK_SEMI, - TK_PIPE, - TK_AND_IF, - TK_OR_IF, - TK_AMP, - TK_PAREN_OPEN, - TK_PAREN_CLOSE, - TK_BQUOTE, - TK_SUBSHELL, - TK_NEWLINE, - TK_WHILE, - TK_DO, - TK_DONE, - TK_IF, - TK_THEN, - TK_FI, - TK_ELIF, - TK_ELSE, - TK_UNTIL, - TK_WORD, - TK_ASSIGNEMENT_WORD = 50, - TK_BANG, - TK_NAME, - TK_FOR, - TK_IO_NUMBER, - TK_DLESSDASH, - TK_LESSGREAT, - TK_CASE, - TK_IN, - TK_ESAC, - TK_CLOBBER, - TK_LBRACE, - TK_RBRACE, - TK_DSEMI, - PROGRAM = 100, - COMPLETE_COMMAND, - COMPLETE_COMMANDS, - LIST, - AND_OR, - PIPELINE, - PIPE_SEQUENCE, - COMMAND, - COMPOUND_COMMAND, - SUBSHELL, - COMPOUND_LIST, - TERM, - FOR_CLAUSE, - NAME, - IN, - WORDLIST, - CASE_CLAUSE, - CASE_LIST, - CASE_LIST_NS, - CASE_ITEM, - CASE_ITEM_NS, - PATTERN, - IF_CLAUSE, - ELSE_PART, - WHILE_CLAUSE, - UNTIL_CLAUSE, - FUNCTION_DEFINITION, - FUNCTION_BODY, - FNAME, - BRACE_GROUP, - DO_GROUP, - SIMPLE_COMMAND, - CMD_NAME, - CMD_WORD, - CMD_PREFIX, - CMD_SUFFIX, - REDIRECT_LIST, - IO_REDIRECT, - IO_FILE, - FILENAME, - IO_HERE, - HERE_END, - NEWLINE_LIST, - SEPARATOR_OP, - SEPARATOR, - SEQUENTIAL_SEP, - LOOP, - FUNC, - PIPE_SEMI_SEQUENCE, - PATTERN_CASE, - CMD_SUPERIOR, - AND_OR_MAJOR, - AND_OR_MINOR, - END_COMMAND, - CONDITION, - COMPLETE_CONDITION, - ALL = 200, }; # define TK_REDIR(x) (TK_LESS <= x && x <= TK_GREATAND) @@ -211,14 +107,27 @@ int build_tree(t_btree **ast, t_list **lst); int add_sep(t_btree **ast, t_list **lst); int add_cmd(t_btree **ast, t_list **lst); int add_file(t_btree **ast, t_list **lst); +int add_redir(t_btree **ast, t_list **lst); int add_loop_cmd(t_btree **ast, t_list **lst); int add_loop_sep(t_btree **ast, t_list **lst); +int add_loop_condition(t_btree **ast, t_list **lst); int add_condition_cmd(t_btree **ast, t_list **lst); int add_condition_sep(t_btree **ast, t_list **lst); int add_branch(t_btree **ast, t_list **lst); -int isloop(t_btree **ast); -int isdir(t_btree **ast); +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 add_func_cmd(t_btree **ast, t_list **lst); +int add_func_sep(t_btree **ast, t_list **lst); +int add_one_func(t_btree **ast, t_list **lst); +int isloop(t_btree **ast, t_list **lst); +int isdir(t_btree **ast, t_list **lst); +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 isfunc(t_btree **ast, t_list **lst); int join_ast(t_btree **ast, t_btree **new_node); int gen_node(t_btree **ast); @@ -246,6 +155,7 @@ union u_astdata { t_redir redir; t_ld *token; + t_list *wordlist; char **sstr; char *str; }; @@ -255,35 +165,9 @@ struct s_astnode int nest; int full; + int pattern; t_type type; t_astdata data; }; -int parse(t_btree **ast, t_list **token); - -int get_instruction(t_list **lst); -int get_sub_instruction(t_btree **ast, t_list **start, t_list **lst); - -int parse_newline(t_btree **ast, t_list **start, t_list **lst); -int parse_separator(t_btree **ast, t_list **start, t_list **lst); -int parse_redir(t_btree **ast, t_list **start, t_list **lst); -int parse_less(t_btree **ast, t_list **start, t_list **lst); -int parse_great(t_btree **ast, t_list **start, t_list **lst); -int parse_dless(t_btree **ast, t_list **start, t_list **lst); -int parse_dgreat(t_btree **ast, t_list **start, t_list **lst); -int parse_lessand(t_btree **ast, t_list **start, t_list **lst); -int parse_greatand(t_btree **ast, t_list **start, t_list **lst); -int parse_word(t_btree **ast, t_list **start, t_list **lst); -int parse_subshell(t_btree **ast, t_list **start, t_list **lst); -int parse_newline(t_btree **ast, t_list **start, t_list **lst); -int parse_while(t_btree **ast, t_list **start, t_list **lst); -int parse_if(t_btree **ast, t_list **start, t_list **lst); -int parse_do(t_btree **ast, t_list **start, t_list **lst); -int parse_done(t_btree **ast, t_list **start, t_list **lst); -int parse_elif(t_btree **ast, t_list **start, t_list **lst); -int parse_else(t_btree **ast, t_list **start, t_list **lst); - -int delete_newline(t_list **start, t_list **lst); -int parse_head(t_btree **ast, t_btree **new_ast, t_list **start, t_list **lst); - #endif diff --git a/42sh/includes/types.h b/42sh/includes/types.h index f365bd63..e0f7ade6 100644 --- a/42sh/includes/types.h +++ b/42sh/includes/types.h @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/13 17:11:48 by jhalford #+# #+# */ -/* Updated: 2017/02/21 16:15:41 by ariard ### ########.fr */ +/* Updated: 2017/02/25 19:37:31 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -34,6 +34,7 @@ typedef union u_astdata t_astdata; typedef union u_word t_word; typedef long long t_type; +typedef int t_condition; typedef struct s_job t_job; typedef struct s_execmap t_execmap; typedef struct s_redirmap t_redirmap; @@ -51,4 +52,112 @@ typedef struct s_treematch t_treematch; t_data *data_singleton(); +enum e_sym +{ + LINEBREAK = 1, + TK_COMMAND, + TK_LESS, + TK_GREAT, + TK_DLESS, + TK_DGREAT, + TK_LESSAND, + TK_GREATAND, + TK_SEMI, + TK_PIPE, + TK_AND_IF, + TK_OR_IF, + TK_AMP, + TK_PAREN_OPEN, + TK_PAREN_CLOSE, + TK_BQUOTE, + TK_NEWLINE, + TK_WHILE, + TK_DO, + TK_DONE, + TK_IF, + TK_THEN, + TK_FI, + TK_ELIF, + TK_ELSE, + TK_UNTIL, + TK_WORD, + TK_ASSIGNEMENT_WORD = 50, + TK_BANG, + TK_NAME, + TK_FOR, + TK_IO_NUMBER, + TK_DLESSDASH, + TK_LESSGREAT, + TK_SUBSHELL, + TK_CASE, + TK_IN, + TK_ESAC, + TK_CLOBBER, + TK_LBRACE, + TK_RBRACE, + TK_DSEMI, + PROGRAM = 100, + COMPLETE_COMMAND, + COMPLETE_COMMANDS, + LIST, + AND_OR, + PIPELINE, + PIPE_SEQUENCE, + COMMAND, + COMPOUND_COMMAND, + SUBSHELL, + COMPOUND_LIST, + TERM, + FOR_CLAUSE, + NAME, + IN, + WORDLIST, + CASE_CLAUSE, + CASE_LIST, + CASE_LIST_NS, + CASE_ITEM, + CASE_ITEM_NS, + PATTERN, + IF_CLAUSE, + BRACE_CLAUSE, + ELSE_PART, + WHILE_CLAUSE, + UNTIL_CLAUSE, + FUNCTION_DEFINITION, + FUNCTION_BODY, + FNAME, + BRACE_GROUP, + DO_GROUP, + SIMPLE_COMMAND, + CMD_NAME, + CMD_WORD, + CMD_PREFIX, + CMD_SUFFIX, + REDIRECT_LIST, + IO_REDIRECT, + IO_FILE, + FILENAME, + IO_HERE, + HERE_END, + NEWLINE_LIST, + SEPARATOR_OP, + SEPARATOR, + SEQUENTIAL_SEP, + BRACE, + LOOP, + FUNC, + PIPE_SEMI_SEQUENCE, + CMD_SUPERIOR, + AND_OR_MAJOR, + AND_OR_MINOR, + END_COMMAND, + CONDITION, + COMPLETE_CONDITION, + FOR_WORDLIST, + PATTERN_CASE, + FUNC_NAME, + CLOSE_LIST, + ALL = 200, +}; + #endif diff --git a/42sh/sample/assignement/var_01.sh b/42sh/sample/assignement/var_01.sh new file mode 100644 index 00000000..d77e8f12 --- /dev/null +++ b/42sh/sample/assignement/var_01.sh @@ -0,0 +1 @@ +HELLO=WORLD diff --git a/42sh/sample/brace/brace_01.sh b/42sh/sample/brace/brace_01.sh new file mode 100644 index 00000000..54b84d56 --- /dev/null +++ b/42sh/sample/brace/brace_01.sh @@ -0,0 +1 @@ +{ ls | cat } diff --git a/42sh/sample/case/case.sh b/42sh/sample/case/case.sh new file mode 100644 index 00000000..d89cd66d --- /dev/null +++ b/42sh/sample/case/case.sh @@ -0,0 +1,6 @@ +case $rental in + ("bus") case $rental in + ("yolo") echo bonjour + esac ;; + ("van") echo yolo ;; +esac diff --git a/42sh/sample/for/for.sh b/42sh/sample/for/for.sh new file mode 100644 index 00000000..90cfffe6 --- /dev/null +++ b/42sh/sample/for/for.sh @@ -0,0 +1,11 @@ +for i in hello bonjour salut comment +do + for i in echo + do + pwd + done + for i in echo + do + pwd + done +done diff --git a/42sh/sample/func/func01.sh b/42sh/sample/func/func01.sh new file mode 100644 index 00000000..d559c7d2 --- /dev/null +++ b/42sh/sample/func/func01.sh @@ -0,0 +1,6 @@ +hello() { + yolo() { + echo bonjour + } +} + diff --git a/42sh/sample/if/01_if_easy.sh b/42sh/sample/if/01_if_easy.sh index 171c2a03..f7d0a10c 100644 --- a/42sh/sample/if/01_if_easy.sh +++ b/42sh/sample/if/01_if_easy.sh @@ -1,8 +1,10 @@ if ls then - if ls - then - ls | cat - pwd ; ls - fi + ls +elif ls +then + ls +elif ls +then + ls fi diff --git a/42sh/sample/mix/mix.sh b/42sh/sample/mix/mix.sh index d9e02158..36437d5c 100644 --- a/42sh/sample/mix/mix.sh +++ b/42sh/sample/mix/mix.sh @@ -1,6 +1,6 @@ if ls then - ls | cat + ls ; cat while ls do until ls diff --git a/42sh/sample/redir/redir.sh b/42sh/sample/redir/redir.sh new file mode 100644 index 00000000..8b137891 --- /dev/null +++ b/42sh/sample/redir/redir.sh @@ -0,0 +1 @@ + diff --git a/42sh/sample/subshell/subshell01.sh b/42sh/sample/subshell/subshell01.sh new file mode 100644 index 00000000..f1f04671 --- /dev/null +++ b/42sh/sample/subshell/subshell01.sh @@ -0,0 +1,2 @@ +(ls | cat +pwd ; ls) diff --git a/42sh/sample/while/while01.sh b/42sh/sample/while/while01.sh new file mode 100644 index 00000000..f2897742 --- /dev/null +++ b/42sh/sample/while/while01.sh @@ -0,0 +1,11 @@ +while ls +do + while ls + do + pwd + done + while ls + do + pwd + done +done diff --git a/42sh/src/exec/loop_exec.c b/42sh/src/exec/exec_case.c similarity index 64% rename from 42sh/src/exec/loop_exec.c rename to 42sh/src/exec/exec_case.c index cf285ee4..3a2847f8 100644 --- a/42sh/src/exec/loop_exec.c +++ b/42sh/src/exec/exec_case.c @@ -1,27 +1,25 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* loop_exec.c :+: :+: :+: */ +/* exec_if.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ -/* Created: 2017/01/30 21:02:10 by ariard #+# #+# */ -/* Updated: 2017/01/31 19:27:49 by ariard ### ########.fr */ +/* Created: 2017/02/06 18:07:31 by ariard #+# #+# */ +/* Updated: 2017/02/20 22:31:46 by jhalford ### ########.fr */ /* */ /* ************************************************************************** */ #include "exec.h" -int loop_exec(t_list *list_ast) +int exec_case(t_btree **ast) { + t_astnode *node; + char **av; -// DG("begin exec loop"); -// ft_print_all_ast(*list_ast); - while (list_ast) - { - if (ft_exec((t_btree **)list_ast->content)) - return (1); - list_ast = list_ast->next; - } + data_singleton()->exec.process.case_branch = 0; + node = (*ast)->item; + av = token_to_argv(node); + data_singleton()->exec.process.case_pattern = av[0]; return (0); } diff --git a/42sh/src/exec/exec_case_branch.c b/42sh/src/exec/exec_case_branch.c new file mode 100644 index 00000000..2102769c --- /dev/null +++ b/42sh/src/exec/exec_case_branch.c @@ -0,0 +1,30 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* exec_if.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: ariard +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2017/02/06 18:07:31 by ariard #+# #+# */ +/* Updated: 2017/02/20 22:31:46 by jhalford ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "exec.h" + +int exec_case_branch(t_btree **ast) +{ + t_astnode *node; + char **av; + + if (data_singleton()->exec.process.case_branch == 1) + return (0); + node = (*ast)->item; + av = token_to_argv(node); + if (ft_strcmp(av[0], data_singleton()->exec.process.case_pattern) == 1) + { + data_singleton()->exec.process.case_branch = 1; + ft_exec(&(*ast)->right); + } + return (0); +} diff --git a/42sh/src/exec/exec_command.c b/42sh/src/exec/exec_command.c index 37d8153a..5d1f9b07 100644 --- a/42sh/src/exec/exec_command.c +++ b/42sh/src/exec/exec_command.c @@ -12,7 +12,7 @@ #include "exec.h" -static char **token_to_argv(t_astnode *node) +char **token_to_argv(t_astnode *node) { char **my_tab; int index; @@ -20,7 +20,7 @@ static char **token_to_argv(t_astnode *node) char **content; t_ld *ld; - if (node->type == TK_COMMAND) + if (node->type == TK_WORD || node->type == TK_ASSIGNEMENT_WORD) { ld = node->data.token; my_tab = NULL; diff --git a/42sh/src/exec/exec_elif.c b/42sh/src/exec/exec_elif.c index 235b1938..ffefcdba 100644 --- a/42sh/src/exec/exec_elif.c +++ b/42sh/src/exec/exec_elif.c @@ -14,14 +14,13 @@ int exec_elif(t_btree **ast) { - int test; - - (void)ast; - test = 0; - if (test) + if (data_singleton()->exec.process.if_branch == 1) + return (0); + ft_exec(&(*ast)->left); + if (data_singleton()->exec.process.status == 1) { + data_singleton()->exec.process.if_branch = 1; ft_exec(&(*ast)->right); } - // btree_delone(ast, &ast_free); return (0); } diff --git a/42sh/src/exec/exec_else.c b/42sh/src/exec/exec_else.c index f94735c1..9b31f5c6 100644 --- a/42sh/src/exec/exec_else.c +++ b/42sh/src/exec/exec_else.c @@ -14,7 +14,10 @@ int exec_else(t_btree **ast) { - ft_exec(&(*ast)->right); - //btree_delone(ast, &ast_free); + if (data_singleton()->exec.process.if_branch == 0) + { + data_singleton()->exec.process.if_branch = 1; + ft_exec(&(*ast)->right); + } return (0); } diff --git a/42sh/src/exec/exec_for.c b/42sh/src/exec/exec_for.c new file mode 100644 index 00000000..e1defebc --- /dev/null +++ b/42sh/src/exec/exec_for.c @@ -0,0 +1,35 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* exec_until.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: ariard +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2017/02/06 20:42:20 by ariard #+# #+# */ +/* Updated: 2017/02/06 20:42:21 by ariard ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "exec.h" + +int exec_for(t_btree **ast) +{ + t_astnode *node; + t_list *temp; +// char **av = NULL; + char *var; + + + node = (*ast)->item; + temp = node->data.wordlist; + var = temp->content; + builtin_setenv("setenv", (char*[]){var, 0}, data_singleton()->local_var); + while (temp) + { + //process expansion av = token_to_char(temp->content) + builtin_setenv("setenv", (char*[]){var, 0}, data_singleton()->local_var); + ft_exec(&(*ast)->right); + temp = temp->next; + } + return (0); +} diff --git a/42sh/src/exec/exec_func.c b/42sh/src/exec/exec_func.c new file mode 100644 index 00000000..a4a34f66 --- /dev/null +++ b/42sh/src/exec/exec_func.c @@ -0,0 +1,15 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* exec_while.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: ariard +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2017/01/30 17:33:53 by ariard #+# #+# */ +/* Updated: 2017/02/06 22:05:35 by ariard ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "exec.h" + + diff --git a/42sh/src/exec/exec_if.c b/42sh/src/exec/exec_if.c index 667c32de..81aab2a7 100644 --- a/42sh/src/exec/exec_if.c +++ b/42sh/src/exec/exec_if.c @@ -14,7 +14,12 @@ int exec_if(t_btree **ast) { - ft_exec(&(*ast)->right); -// btree_delone(ast, &ast_free); + data_singleton()->exec.process.if_branch = 0; + ft_exec(&(*ast)->left); + if (data_singleton()->exec.process.status == 1) + { + data_singleton()->exec.process.if_branch = 1; + ft_exec(&(*ast)->right); + } return (0); } diff --git a/42sh/src/exec/exec_until.c b/42sh/src/exec/exec_until.c index 62b2a567..6f1e0c33 100644 --- a/42sh/src/exec/exec_until.c +++ b/42sh/src/exec/exec_until.c @@ -14,12 +14,11 @@ int exec_until(t_btree **ast) { - int test; - - test = 0; - while (test++ != 10) + ft_exec(&(*ast)->left); + while (data_singleton()->exec.process.status == 0) + { ft_exec(&(*ast)->right); - -// btree_delone(ast, &ast_free); + ft_exec(&(*ast)->left); + } return (0); } diff --git a/42sh/src/exec/loop_del.c b/42sh/src/exec/exec_var.c similarity index 65% rename from 42sh/src/exec/loop_del.c rename to 42sh/src/exec/exec_var.c index 1bdda0fd..e830950d 100644 --- a/42sh/src/exec/loop_del.c +++ b/42sh/src/exec/exec_var.c @@ -1,27 +1,24 @@ /* ************************************************************************** */ /* */ /* ::: :::::::: */ -/* loop_del.c :+: :+: :+: */ +/* exec_while.c :+: :+: :+: */ /* +:+ +:+ +:+ */ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ -/* Created: 2017/01/31 22:39:20 by ariard #+# #+# */ -/* Updated: 2017/01/31 23:20:40 by ariard ### ########.fr */ +/* Created: 2017/01/30 17:33:53 by ariard #+# #+# */ +/* Updated: 2017/02/06 22:05:35 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ #include "exec.h" -int loop_del(t_list *list_ast) +int exec_var(t_btree **ast) { - t_list *temp; + t_astnode *node; + char **av; - while (list_ast) - { - btree_del((t_btree **)list_ast->content, &ast_free); - temp = list_ast; - list_ast = list_ast->next; - ft_lstdelone(&temp, NULL); - } + node = (*ast)->item; + av = token_to_argv(node); + builtin_setenv("setenv", av, data_singleton()->local_var); return (0); } diff --git a/42sh/src/exec/exec_while.c b/42sh/src/exec/exec_while.c index cae778e1..d9824950 100644 --- a/42sh/src/exec/exec_while.c +++ b/42sh/src/exec/exec_while.c @@ -14,12 +14,11 @@ int exec_while(t_btree **ast) { - int test; - - test = 10; - while (test--) + ft_exec(&(*ast)->left); + while (data_singleton()->exec.process.status == 1) + { ft_exec(&(*ast)->right); - -// btree_delone(ast, &ast_free); + ft_exec(&(*ast)->left); + } return (0); } diff --git a/42sh/src/exec/ft_exec.c b/42sh/src/exec/ft_exec.c index 6313a504..1994a502 100644 --- a/42sh/src/exec/ft_exec.c +++ b/42sh/src/exec/ft_exec.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/11/27 20:30:32 by jhalford #+# #+# */ -/* Updated: 2017/02/21 21:37:58 by jhalford ### ########.fr */ +/* Updated: 2017/02/21 18:50:05 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/command_getoutput.c b/42sh/src/glob/command_getoutput.c index 00ef6581..fdf3dda4 100644 --- a/42sh/src/glob/command_getoutput.c +++ b/42sh/src/glob/command_getoutput.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/01/12 14:01:59 by jhalford #+# #+# */ -/* Updated: 2017/02/03 14:46:27 by ariard ### ########.fr */ +/* Updated: 2017/02/24 22:04:43 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/dir_glob.c b/42sh/src/glob/dir_glob.c index 8dc2d0da..f4be218d 100644 --- a/42sh/src/glob/dir_glob.c +++ b/42sh/src/glob/dir_glob.c @@ -6,7 +6,7 @@ /* By: wescande +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/01/30 12:07:16 by wescande #+# #+# */ -/* Updated: 2017/02/07 19:48:12 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:04:49 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/esc_print.c b/42sh/src/glob/esc_print.c index 8938302d..44de1fb5 100644 --- a/42sh/src/glob/esc_print.c +++ b/42sh/src/glob/esc_print.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/17 15:38:14 by jhalford #+# #+# */ -/* Updated: 2017/02/20 18:49:02 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:05:04 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/expand_bquote.c b/42sh/src/glob/expand_bquote.c index d24e3892..7c7c0667 100644 --- a/42sh/src/glob/expand_bquote.c +++ b/42sh/src/glob/expand_bquote.c @@ -6,7 +6,7 @@ /* By: wescande +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/17 17:47:53 by wescande #+# #+# */ -/* Updated: 2017/02/20 19:11:11 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:04:59 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/expand_brace.c b/42sh/src/glob/expand_brace.c index 13cacf4d..c0055817 100644 --- a/42sh/src/glob/expand_brace.c +++ b/42sh/src/glob/expand_brace.c @@ -6,7 +6,7 @@ /* By: wescande +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/01/12 19:00:29 by wescande #+# #+# */ -/* Updated: 2017/02/20 18:54:19 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:05:14 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/expand_esc.c b/42sh/src/glob/expand_esc.c index 35777c6f..f66bf422 100644 --- a/42sh/src/glob/expand_esc.c +++ b/42sh/src/glob/expand_esc.c @@ -6,7 +6,7 @@ /* By: wescande +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/01/31 23:18:56 by wescande #+# #+# */ -/* Updated: 2017/02/20 17:25:43 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:05:26 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/expand_var.c b/42sh/src/glob/expand_var.c index bcf85bc9..05c77e8a 100644 --- a/42sh/src/glob/expand_var.c +++ b/42sh/src/glob/expand_var.c @@ -6,7 +6,7 @@ /* By: wescande +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/06 16:09:27 by wescande #+# #+# */ -/* Updated: 2017/02/20 18:56:50 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:05:34 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/ft_strsplit_esc.c b/42sh/src/glob/ft_strsplit_esc.c index f37c7b14..6e050cb7 100644 --- a/42sh/src/glob/ft_strsplit_esc.c +++ b/42sh/src/glob/ft_strsplit_esc.c @@ -6,7 +6,7 @@ /* By: wescande +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/01/31 22:18:46 by wescande #+# #+# */ -/* Updated: 2017/01/31 23:15:17 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:05:41 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/ft_strsplit_spe.c b/42sh/src/glob/ft_strsplit_spe.c index 8c11de67..3d69627c 100644 --- a/42sh/src/glob/ft_strsplit_spe.c +++ b/42sh/src/glob/ft_strsplit_spe.c @@ -6,7 +6,7 @@ /* By: wescande +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/01/31 20:49:30 by wescande #+# #+# */ -/* Updated: 2017/02/20 18:57:58 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:03:22 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/glob.c b/42sh/src/glob/glob.c index d5832efd..b25b86ec 100644 --- a/42sh/src/glob/glob.c +++ b/42sh/src/glob/glob.c @@ -6,7 +6,7 @@ /* By: wescande +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/01/04 16:29:54 by wescande #+# #+# */ -/* Updated: 2017/02/20 19:04:44 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:05:48 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/glob/match_pattern.c b/42sh/src/glob/match_pattern.c index 536cb08c..d98fd7e2 100644 --- a/42sh/src/glob/match_pattern.c +++ b/42sh/src/glob/match_pattern.c @@ -6,7 +6,7 @@ /* By: wescande +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/01/24 17:30:23 by wescande #+# #+# */ -/* Updated: 2017/02/20 14:00:41 by wescande ### ########.fr */ +/* Updated: 2017/02/24 22:06:01 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/hash_table/hash.c b/42sh/src/hash_table/hash.c index fa3604fd..8a9a1eea 100644 --- a/42sh/src/hash_table/hash.c +++ b/42sh/src/hash_table/hash.c @@ -6,7 +6,7 @@ /* By: gwojda +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/18 11:06:19 by gwojda #+# #+# */ -/* Updated: 2017/02/18 14:16:35 by gwojda ### ########.fr */ +/* Updated: 2017/02/21 20:57:19 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/hash_table/hash_str.c b/42sh/src/hash_table/hash_str.c index f7e70f11..a7aa38f1 100644 --- a/42sh/src/hash_table/hash_str.c +++ b/42sh/src/hash_table/hash_str.c @@ -6,7 +6,7 @@ /* By: gwojda +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/18 11:32:18 by gwojda #+# #+# */ -/* Updated: 2017/02/19 12:58:47 by gwojda ### ########.fr */ +/* Updated: 2017/02/21 20:57:42 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/lexer/get_reserved_words.c b/42sh/src/lexer/get_reserved_words.c index 7a24e372..139d4c1f 100644 --- a/42sh/src/lexer/get_reserved_words.c +++ b/42sh/src/lexer/get_reserved_words.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/01/26 00:07:05 by ariard #+# #+# */ -/* Updated: 2017/02/20 22:06:20 by jhalford ### ########.fr */ +/* Updated: 2017/02/21 21:06:16 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,10 +16,12 @@ int get_reserved_words(t_list **alst) { t_token *token; t_token *previous_token; + t_token *ante_token; t_list *temp; temp = *alst; previous_token = NULL; + ante_token = NULL; while (temp) { token = temp->content; @@ -45,8 +47,20 @@ int get_reserved_words(t_list **alst) token->type = TK_ELSE; else if (ft_strncmp(token->data, "until", 5) == 0) 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; } } + if (ante_token && (ante_token->type == TK_CASE || ante_token->type == TK_FOR) + && ft_strncmp(token->data, "in", 2) == 0) + token->type = TK_IN; + if (previous_token && previous_token->type == TK_FOR && token->type == TK_WORD) + token->type = TK_NAME; + ante_token = previous_token; previous_token = token; temp = temp->next; } diff --git a/42sh/src/lexer/get_state_global.c b/42sh/src/lexer/get_state_global.c index 41ae160e..78530edc 100644 --- a/42sh/src/lexer/get_state_global.c +++ b/42sh/src/lexer/get_state_global.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 20:39:06 by jhalford #+# #+# */ -/* Updated: 2017/02/20 20:48:53 by ariard ### ########.fr */ +/* Updated: 2017/02/24 21:39:47 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -33,6 +33,10 @@ t_lexstate get_state_global(t_lexer *lexer) return (BQUOTE); else if (c == '(' || c == ')') return (PAREN); + else if (c == '{' || c == '}') + return (CURLY_BRACKETS); + else if (c == '=') + return (ASSIGNEMENT_WORD); else if (c == 0) return (END); return (0); diff --git a/42sh/src/lexer/get_state_redir.c b/42sh/src/lexer/get_state_redir.c index 7b6acd31..6ea22d94 100644 --- a/42sh/src/lexer/get_state_redir.c +++ b/42sh/src/lexer/get_state_redir.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 20:37:28 by jhalford #+# #+# */ -/* Updated: 2017/02/09 20:39:11 by jhalford ### ########.fr */ +/* Updated: 2017/02/24 20:44:40 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/lexer/insert_newline.c b/42sh/src/lexer/insert_newline.c new file mode 100644 index 00000000..6d39ec5d --- /dev/null +++ b/42sh/src/lexer/insert_newline.c @@ -0,0 +1,24 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* insert_newline.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: ariard +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2017/02/21 21:05:23 by ariard #+# #+# */ +/* Updated: 2017/02/24 16:22:08 by ariard ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "parser.h" + +int insert_newline(t_list **alst) +{ + t_token *token; + + DG("insert newline"); + token = token_init(); + token->type = TK_NEWLINE; + ft_lsteadd(alst, ft_lstnew(token, sizeof(*token))); + return (0); +} diff --git a/42sh/src/lexer/lexer_assignement_word.c b/42sh/src/lexer/lexer_assignement_word.c new file mode 100644 index 00000000..70429bed --- /dev/null +++ b/42sh/src/lexer/lexer_assignement_word.c @@ -0,0 +1,37 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* lexer_assignement_word.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: ariard +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2017/02/24 20:28:13 by ariard #+# #+# */ +/* Updated: 2017/02/24 21:00:13 by ariard ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "lexer.h" + +int lexer_assignement_word(t_list **alst, t_lexer *lexer) +{ + t_token *token; + char c; + + token = (*alst)->content; + if (token->type != TK_WORD && token->type != TK_ASSIGNEMENT_WORD) + { + token_append(token, lexer, 0, 0); + lexer->pos++; + return (lexer_lex(alst, lexer)); + } + token->type = TK_ASSIGNEMENT_WORD; + token_append(token, lexer, 0, 0); + lexer->pos++; + c = lexer->str[lexer->pos]; + if ((lexer->state = get_state_global(lexer))) + return (lexer_lex(alst, lexer)); + if ((lexer->state = get_state_redir(lexer))) + return (lexer_lex(alst, lexer)); + lexer->state = ft_isdigit(c) ? NUMBER : ASSIGNEMENT_WORD; + return(lexer_lex(alst, lexer)); +} diff --git a/42sh/src/lexer/lexer_curly_brackets.c b/42sh/src/lexer/lexer_curly_brackets.c new file mode 100644 index 00000000..e63356d1 --- /dev/null +++ b/42sh/src/lexer/lexer_curly_brackets.c @@ -0,0 +1,46 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* lexer_curly_brackets.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: ariard +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2017/02/24 21:24:50 by ariard #+# #+# */ +/* Updated: 2017/02/24 21:48:52 by ariard ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "parser.h" + +int lexer_curly_brackets(t_list **alst, t_lexer *lexer) +{ + t_token *token; + t_list **lst; + + DG("lexer curly brackets"); + lst = alst; + if (*alst) + { + token = (*alst)->content; + if (token->type) + lst = &(*alst)->next; + } + token = token_init(); + *lst = ft_lstnew(token, sizeof(*token)); + token = (*lst)->content; + if (lexer->str[lexer->pos] == '{') + { + DG("lbrace"); + token->type = TK_LBRACE; + push(&lexer->stack, CURLY_BRACKETS); + } + else if (lexer->stack && *(int*)lexer->stack->content == CURLY_BRACKETS) + { + DG("rbrace"); + token->type = TK_RBRACE; + pop(&lexer->stack); + } + lexer->pos++; + lexer->state = DEFAULT; + return (lexer_lex(&(*lst)->next, lexer)); +} diff --git a/42sh/src/lexer/lexer_default.c b/42sh/src/lexer/lexer_default.c index 4d67d8cc..d8799ebe 100644 --- a/42sh/src/lexer/lexer_default.c +++ b/42sh/src/lexer/lexer_default.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/11/28 18:36:21 by jhalford #+# #+# */ -/* Updated: 2017/02/20 20:50:30 by ariard ### ########.fr */ +/* Updated: 2017/02/25 20:04:41 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/lexer/lexer_delim.c b/42sh/src/lexer/lexer_delim.c index 3809a674..026a0f4a 100644 --- a/42sh/src/lexer/lexer_delim.c +++ b/42sh/src/lexer/lexer_delim.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/03 11:58:44 by jhalford #+# #+# */ -/* Updated: 2017/02/21 22:14:48 by jhalford ### ########.fr */ +/* Updated: 2017/02/25 19:56:31 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -21,9 +21,7 @@ int lexer_delim(t_list **alst, t_lexer *lexer) lexer->pos++; lexer->state = DEFAULT; if (token->type) - { return (lexer_lex(&(*alst)->next, lexer)); - } else { if (lexer->str[lexer->pos] == 0) diff --git a/42sh/src/lexer/lexer_great.c b/42sh/src/lexer/lexer_great.c index 48c1a33b..8bbb462b 100644 --- a/42sh/src/lexer/lexer_great.c +++ b/42sh/src/lexer/lexer_great.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/03 12:06:35 by jhalford #+# #+# */ -/* Updated: 2017/02/20 20:52:38 by ariard ### ########.fr */ +/* Updated: 2017/02/25 20:12:58 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -21,6 +21,7 @@ int lexer_great(t_list **alst, t_lexer *lexer) lexer->pos++; if (lexer->str[lexer->pos] == '&') { + DG("lex greatand"); token->type = TK_GREATAND; token_append(token, lexer, 0, 0); lexer->pos++; @@ -28,6 +29,7 @@ int lexer_great(t_list **alst, t_lexer *lexer) } if (lexer->str[lexer->pos] == '>') { + DG("lex great"); token->type = TK_DGREAT; token_append(token, lexer, 0, 0); lexer->pos++; diff --git a/42sh/src/lexer/lexer_greatand.c b/42sh/src/lexer/lexer_greatand.c index 350bbec1..af86cb7f 100644 --- a/42sh/src/lexer/lexer_greatand.c +++ b/42sh/src/lexer/lexer_greatand.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/03 11:56:58 by jhalford #+# #+# */ -/* Updated: 2017/02/20 20:52:49 by ariard ### ########.fr */ +/* Updated: 2017/02/25 20:11:03 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/lexer/lexer_less.c b/42sh/src/lexer/lexer_less.c index 241f9ae1..0aa0174c 100644 --- a/42sh/src/lexer/lexer_less.c +++ b/42sh/src/lexer/lexer_less.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/03 12:06:53 by jhalford #+# #+# */ -/* Updated: 2017/02/20 20:53:06 by ariard ### ########.fr */ +/* Updated: 2017/02/25 20:11:17 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/lexer/lexer_lessand.c b/42sh/src/lexer/lexer_lessand.c index f411b225..d0e79268 100644 --- a/42sh/src/lexer/lexer_lessand.c +++ b/42sh/src/lexer/lexer_lessand.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/03 11:58:51 by jhalford #+# #+# */ -/* Updated: 2017/02/09 19:56:29 by jhalford ### ########.fr */ +/* Updated: 2017/02/25 20:11:10 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/lexer/lexer_lex.c b/42sh/src/lexer/lexer_lex.c index a8e8818f..27535a56 100644 --- a/42sh/src/lexer/lexer_lex.c +++ b/42sh/src/lexer/lexer_lex.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 17:08:51 by jhalford #+# #+# */ -/* Updated: 2017/02/21 22:14:51 by jhalford ### ########.fr */ +/* Updated: 2017/02/24 21:38:42 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -31,6 +31,8 @@ int (*g_lexer[])(t_list **alst, t_lexer *lexer) = &lexer_bquote, &lexer_backslash, &lexer_paren, + &lexer_curly_brackets, + &lexer_assignement_word, &lexer_comment, &lexer_end, }; diff --git a/42sh/src/lexer/lexer_number.c b/42sh/src/lexer/lexer_number.c index 0508f70f..11e9eb6e 100644 --- a/42sh/src/lexer/lexer_number.c +++ b/42sh/src/lexer/lexer_number.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/03 12:06:45 by jhalford #+# #+# */ -/* Updated: 2017/02/20 20:53:20 by ariard ### ########.fr */ +/* Updated: 2017/02/25 19:55:30 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -18,6 +18,7 @@ int lexer_number(t_list **alst, t_lexer *lexer) t_lexstate state; token = (*alst)->content; + token->type = TK_IO_NUMBER; if ((state = get_state_global(lexer))) { lexer->state = state; diff --git a/42sh/src/lexer/lexer_sep.c b/42sh/src/lexer/lexer_sep.c index eb4420a6..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 */ /* */ /* ************************************************************************** */ @@ -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; - lexer->pos += 1 + (token->type & (TK_AND_IF | TK_OR_IF) ? 1 : 0); + token->type = (c == ';') && (cn == ';') ? TK_DSEMI : token->type; + 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/lexer/lexer_word.c b/42sh/src/lexer/lexer_word.c index f8c7ea6b..157668ba 100644 --- a/42sh/src/lexer/lexer_word.c +++ b/42sh/src/lexer/lexer_word.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/03 12:07:11 by jhalford #+# #+# */ -/* Updated: 2017/02/20 20:54:32 by ariard ### ########.fr */ +/* Updated: 2017/02/25 20:10:39 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -19,6 +19,7 @@ int lexer_word(t_list **alst, t_lexer *lexer) token = (*alst)->content; token->type = TK_WORD; + DG("lexer word"); if ((state = get_state_global(lexer))) { lexer->state = state; diff --git a/42sh/src/lexer/token_append.c b/42sh/src/lexer/token_append.c index 8a65c2b5..0ec12be6 100644 --- a/42sh/src/lexer/token_append.c +++ b/42sh/src/lexer/token_append.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/11/11 17:18:42 by jhalford #+# #+# */ -/* Updated: 2017/02/20 21:03:57 by ariard ### ########.fr */ +/* Updated: 2017/02/24 20:33:59 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/lexer/token_print.c b/42sh/src/lexer/token_print.c index 18d9b38e..0c2ca145 100644 --- a/42sh/src/lexer/token_print.c +++ b/42sh/src/lexer/token_print.c @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/11/28 14:39:01 by jhalford #+# #+# */ -/* Updated: 2017/02/20 20:55:43 by ariard ### ########.fr */ +/* Updated: 2017/02/24 21:48:47 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,19 +15,14 @@ void token_print(t_list *lst) { t_token *token; - int i; - t_type type; - int index; while (lst) { - i = -1; - token = lst->content; - type = token->type; - while (type >> (i++ + 2)) - ; - DG("%02i:[%s]", i, token->data); - index = -1; + DG("token print"); + if (lst->content) + token = lst->content; + if (token->type) + DG("token : %s data [%s]\n", read_state(token->type), token->data); lst = lst->next; } } diff --git a/42sh/src/main/data_init.c b/42sh/src/main/data_init.c index 95e59dec..56e9179d 100644 --- a/42sh/src/main/data_init.c +++ b/42sh/src/main/data_init.c @@ -23,7 +23,6 @@ int data_init(void) data->env = ft_sstrdup(environ); data->comp = NULL; data->opts = SH_OPTS_JOBC; - data->exec.process.path = NULL; data->exec.process.av = NULL; data->exec.process.to_close = 0; @@ -46,6 +45,9 @@ int data_init(void) data->jobc.first_job = NULL; data->jobc.current_id = 1; + + data->local_var = NULL; + data->lst_func = NULL; if ((term_name = ft_getenv(data->env, "TERM")) == NULL) return (-1); if (tgetent(NULL, term_name) != 1) diff --git a/42sh/src/main/ft_putast.c b/42sh/src/main/ft_putast.c index 43f53e0a..60d40e35 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/21 19:20:20 by jhalford ### ########.fr */ +/* Updated: 2017/02/25 00:17:44 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,7 +16,32 @@ char *ft_putast(void *nodein) { t_astnode *node; node = nodein; - if (node->type == TK_THEN) + + if (node->type == CLOSE_LIST) + return ("CLOSE_LIST"); + if (node->type == FNAME) + return ("FNAME"); + if (node->type == TK_LBRACE) + return ("TK_LBRACE"); + if (node->type == TK_ASSIGNEMENT_WORD) + return ("ASSIGNEMENT_WORD"); + if (node->type == SUBSHELL) + return ("SUBSHELL"); + if (node->type == TK_NAME) + return ("TK_NAME"); + if (node->type == TK_FOR) + return ("TK_FOR"); + if (node->type == TK_CASE) + return ("TK_CASE"); + else if (node->type == TK_PAREN_OPEN) + return ("TK_OPE"); + else if (node->type == TK_PAREN_CLOSE) + return ("TK_CLO"); + else if (node->type == TK_IN) + return ("TK_IN"); + else if (node->type ==TK_ESAC) + return ("TK_ESAC"); + else if (node->type == TK_THEN) return ("THEN"); else if (node->type == TK_FI) return ("FI"); diff --git a/42sh/src/main/main.c b/42sh/src/main/main.c index d0b607d1..bcd21b3c 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/21 20:32:39 by jhalford ### ########.fr */ +/* Updated: 2017/02/25 20:34:27 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -44,12 +44,22 @@ int handle_instruction(int fd) return (1); if (get_lexer_stack(lexer)) continue ; + lexer.state = DEFAULT; + token_print(token); + if (get_reserved_words(&token)) + return (1); + if (insert_newline(&token)) + return (1); if (ft_parse(&ast, &token, &parser)) continue ; if (parser.state == SUCCESS) break ; - else if (parser.state == ERROR) + else if (parser.state == ERROR && !SH_IS_INTERACTIVE(data_singleton()->opts)) return (error_syntax(&token)); + else if (parser.state == ERROR) + error_syntax(&token); + token = NULL; + ast = NULL; } DG("Before execution:"); btree_print(STDBUG, ast, &ft_putast); diff --git a/42sh/src/parser/add_case.c b/42sh/src/parser/add_case.c new file mode 100644 index 00000000..7eba9636 --- /dev/null +++ b/42sh/src/parser/add_case.c @@ -0,0 +1,61 @@ +#include "parser.h" + +int iscase(t_btree **ast, t_list **lst) +{ + t_astnode *node; + t_token *token; + + node = NULL; + token = (*lst)->content; + if (*ast) + { + node = (*ast)->item; + if ((node->type == TK_CASE || node->type == TK_PAREN_OPEN) + && token->type == TK_WORD && node->pattern == 0) + return (1); + if ((node->type == TK_PAREN_OPEN || node->type == TK_CASE) + && node->nest == 0 && token->type == TK_PAREN_OPEN) + return (3); + if (node->type == TK_CASE || node->type == TK_PAREN_OPEN) + return (2); + } + return (0); +} + +int add_case_cmd(t_btree **ast, t_list **lst) +{ + t_astnode *node; + t_token *token; + + token = (*lst)->content; + node = (*ast)->item; + if (token->type == TK_CASE && (node->type == TK_PAREN_OPEN + || node->type == TK_CASE)) + node->nest++; + if (token->type == TK_ESAC && (node->type == TK_PAREN_OPEN + || node->type == TK_CASE) && node->nest > 0) + return ((node->nest--)); + else if (token->type == TK_DSEMI && node->type == TK_PAREN_OPEN + && node->nest == 0) + return ((node->full = 1)); + else if (token->type == TK_ESAC) + return (0); + return (add_cmd(&(*ast)->right, lst)); +} + +int add_case_sep(t_btree **ast, t_list **lst) +{ + return (add_sep(&(*ast)->right, lst)); +} + +int add_pattern(t_btree **ast, t_list **lst) +{ + t_astnode *node; + t_token *token; + + token = (*lst)->content; + node = (*ast)->item; + node->data.str = ft_strdup(token->data); + node->pattern = 1; + return (0); +} diff --git a/42sh/src/parser/add_cmd.c b/42sh/src/parser/add_cmd.c index bf8038ce..d2e3e825 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/21 22:40:29 by jhalford ### ########.fr */ +/* Updated: 2017/02/25 18:50:30 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -19,27 +19,41 @@ int add_cmd(t_btree **ast, t_list **lst) char **my_tab; DG("add cmd"); - if (!*ast) + if ((token = (*lst)->content)->type == TK_IN || token->type == TK_PAREN_OPEN) + return (0); + else if (!*ast) gen_node(ast); - else if (isdir(ast)) + else if (isdir(ast, lst)) return (add_file(ast, lst)); - else if (isloop(ast)) + else if (isloop(ast, lst) == 3) + return (add_loop_condition(ast, lst)); + else if (isloop(ast, lst)) return (add_loop_cmd(ast, lst)); else if (iscondition(ast, lst) == 1) return (add_condition_cmd(ast, lst)); else if (iscondition(ast, lst) == 2) return (add_branch(ast, lst)); - else if ((node = (*ast)->item)->type != TK_DO && node->type != TK_THEN) + else if (iscase(ast, lst) == 1) + return (add_pattern(ast, lst)); + else if (iscase(ast, lst) == 2) + return (add_case_cmd(ast, lst)); + else if (iscase(ast, lst) == 3) + return (add_branch(ast, lst)); + else if (issubshell(ast, lst)) + return (add_subshell_cmd(ast, lst)); + else if (isfunc(ast, lst)) + return (add_func_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) + if (token->type == TK_WORD || token->type == TK_ASSIGNEMENT_WORD) { 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); + ft_ld_pushback(&node->data.token, my_tab); } return (0); } diff --git a/42sh/src/parser/add_condition.c b/42sh/src/parser/add_condition.c index b1d43125..abadea9c 100644 --- a/42sh/src/parser/add_condition.c +++ b/42sh/src/parser/add_condition.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/19 18:12:52 by ariard #+# #+# */ -/* Updated: 2017/02/20 18:18:56 by ariard ### ########.fr */ +/* Updated: 2017/02/25 00:11:09 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/parser/add_file.c b/42sh/src/parser/add_file.c index 66f13d1b..c056049c 100644 --- a/42sh/src/parser/add_file.c +++ b/42sh/src/parser/add_file.c @@ -6,24 +6,35 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/17 16:39:05 by ariard #+# #+# */ -/* Updated: 2017/02/18 16:43:28 by ariard ### ########.fr */ +/* Updated: 2017/02/25 20:33:12 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ #include "parser.h" -int isdir(t_btree **ast) +int isdir(t_btree **ast, t_list **list) { t_astnode *node; + t_token *token; - node = (*ast)->item; - if (node->data.redir.word.word) - return (0); - if (node->type == TK_LESS || node->type == TK_GREAT - || node->type == TK_LESSAND || node->type == TK_GREATAND - || node->type == TK_DGREAT || node->type == TK_LESSGREAT - || node->type == TK_CLOBBER) - return (1); + token = (*list)->content; + if (*ast) + { + DG("isdir"); + node = (*ast)->item; + if ((node->type == TK_LESS || node->type == TK_GREAT + || node->type == TK_LESSAND || node->type == TK_GREATAND + || node->type == TK_DGREAT) + && token->type == TK_WORD) + return (1); + if ((node->type == TK_LESS || node->type == TK_GREAT + || node->type == TK_LESSAND || node->type == TK_GREATAND + || node->type == TK_DGREAT) + && (token->type == TK_LESS || token->type == TK_GREAT + || token->type == TK_LESSAND || token->type == TK_GREATAND + || token->type == TK_DGREAT)) + return (2); + } return (0); } @@ -31,10 +42,32 @@ int add_file(t_btree **ast, t_list **lst) { t_astnode *node; t_token *token; - + t_redir *redir; + token = (*lst)->content; node = (*ast)->item; - node->data.redir.n = ft_atoi(token->data); - node->data.redir.word.word = ft_strdup(token->data); + if (node->data.wordlist) + { + DG("add file"); + redir = (ft_lstlast(node->data.wordlist))->content; + redir->word.word = token->data; + } return (0); -} +} + +int add_redir(t_btree **ast, t_list **lst) +{ + t_astnode *node; + t_token *token; + t_redir *redir; + + DG("add redir"); + if (!ast) + gen_node(ast); + token = (*lst)->content; + node = (*ast)->item; + redir = ft_memalloc(sizeof(redir)); + redir->type = token->type; + ft_lsteadd(&node->data.wordlist, ft_lstnew(redir, sizeof(redir))); + return (0); +} diff --git a/42sh/src/parser/add_func.c b/42sh/src/parser/add_func.c new file mode 100644 index 00000000..ada2a7be --- /dev/null +++ b/42sh/src/parser/add_func.c @@ -0,0 +1,73 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* add_func.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: ariard +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2017/02/24 23:43:07 by ariard #+# #+# */ +/* Updated: 2017/02/25 00:32:00 by ariard ### ########.fr */ +/* */ +/* ************************************************************************** */ + +#include "parser.h" + +int isfunc(t_btree **ast, t_list **lst) +{ + t_astnode *node; + t_token *token; + + node = NULL; + token = (*lst)->content; + if (*ast) + { + node = (*ast)->item; + if (node->type == TK_WORD && token->type == CLOSE_LIST) + { + node->type = FNAME; + add_one_func(ast, lst); + } + if (node->type == FNAME && node->full == 0) + return (1); + if (isfunc(&(*ast)->right, lst) == 1) + return (1); + } + return (0); +} + +int add_func_cmd(t_btree **ast, t_list **lst) +{ + t_astnode *node; + t_token *token; + + token = (*lst)->content; + node = (*ast)->item; + if (token->type == CLOSE_LIST && node->nest == 0) + return (0); + if ((token->type == TK_CASE || token->type == TK_WHILE || token->type == TK_IF + || token->type == TK_UNTIL || token->type == TK_FOR + || token->type == SUBSHELL || token->type == TK_LBRACE) + && node->type == FNAME) + node->nest++; + if ((token->type == TK_DONE || token->type == TK_ESAC || token->type == TK_FI + || token->type == TK_RBRACE || token->type == TK_PAREN_OPEN) + && node->type == FNAME && node->nest > 0) + node->nest--; + if ((token->type == TK_DONE || token->type == TK_ESAC || token->type == TK_FI + || token->type == TK_RBRACE || token->type == TK_PAREN_OPEN) + && node->type == FNAME && node->nest == 0) + node->full = 1; + return (add_cmd(&(*ast)->right, lst)); +} + +int add_func_sep(t_btree **ast, t_list **lst) +{ + return (add_sep(&(*ast)->right, lst)); +} + +int add_one_func(t_btree **ast, t_list **lst) +{ + (void)lst; + ft_lsteadd(&data_singleton()->lst_func, ft_lstnew(ast, sizeof(*ast))); + return (0); +} diff --git a/42sh/src/parser/add_loop.c b/42sh/src/parser/add_loop.c index 22c7865b..78608a48 100644 --- a/42sh/src/parser/add_loop.c +++ b/42sh/src/parser/add_loop.c @@ -6,34 +6,33 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/17 22:17:14 by ariard #+# #+# */ -/* Updated: 2017/02/20 19:03:04 by ariard ### ########.fr */ +/* Updated: 2017/02/25 19:18:01 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ #include "parser.h" -int isloop(t_btree **ast) +int isloop(t_btree **ast, t_list **lst) { t_astnode *node; + t_token *token; node = NULL; + token = (*lst)->content; if (*ast) { node = (*ast)->item; - DG("TEST LOOP"); + if (node->type == TK_FOR && token->type == TK_WORD && node->pattern == 0) + return (3); if ((node->type == TK_NEWLINE || node->type == TK_SEMI - || node->type == TK_AMP) && isloop(&(*ast)->right) == 1) + || node->type == TK_AMP) && isloop(&(*ast)->right, lst) == 1) return (1); - if ((node->type == TK_WHILE || node->type == TK_UNTIL) && node->full == 1) - { - DG("DON ENTER"); + if ((node->type == TK_WHILE || node->type == TK_UNTIL + || node->type == TK_FOR) && node->full == 1) return (2); - } - if ((node->type == TK_WHILE || node->type == TK_UNTIL) && node->full == 0) - { - DG(" NOFULL"); + if ((node->type == TK_WHILE || node->type == TK_UNTIL + || node->type == TK_FOR) && node->full == 0) return (1); - } } return (0); } @@ -46,27 +45,20 @@ int add_loop_cmd(t_btree **ast, t_list **lst) token = (*lst)->content; node = (*ast)->item; DG("add loop cmd"); - if ((token->type == TK_WHILE || token->type == TK_UNTIL) - && (node->type == TK_WHILE || node->type == TK_UNTIL)) - { - DG("nest one more"); + if (token->type == TK_DO && node->type == TK_FOR) + node->pattern = 1; + if ((token->type == TK_WHILE || token->type == TK_UNTIL || token->type == TK_FOR) + && (node->type == TK_WHILE || node->type == TK_UNTIL || node->type == TK_FOR)) node->nest++; - } - if (token->type == TK_DONE && (node->type == TK_WHILE || node->type == TK_UNTIL) - && node->nest > 0) - { + if (token->type == TK_DONE && (node->type == TK_WHILE + || node->type == TK_UNTIL || node->type == TK_FOR) && node->nest > 0) node->nest--; - DG("nest one less"); - } else if (token->type == TK_DONE && (node->type == TK_WHILE - || node->type == TK_UNTIL) && node->nest == 0) - { - DG("WHILE FULL"); + || node->type == TK_UNTIL || node->type == TK_FOR) && node->nest == 0) return ((node->full = 1)); - } if (token->type == TK_DO && node->nest == 0) return (add_cmd(&(*ast)->right, lst)); - else if (!(*ast)->right && isloop(&(*ast)->left) != 2) + else if (!(*ast)->right && isloop(&(*ast)->left, lst) != 2) return (add_cmd(&(*ast)->left, lst)); else return (add_cmd(&(*ast)->right, lst)); @@ -81,3 +73,15 @@ int add_loop_sep(t_btree **ast, t_list **lst) return (add_sep(&(*ast)->right, lst)); return (0); } + +int add_loop_condition(t_btree **ast, t_list **lst) +{ + t_astnode *node; + t_token *token; + + token = (*lst)->content; + node = (*ast)->item; + ft_lsteadd(&node->data.wordlist, ft_lstnew(ft_strdup(token->data), + ft_strlen(token->data))); + return (0); +} diff --git a/42sh/src/parser/add_sep.c b/42sh/src/parser/add_sep.c index e9243154..a80093f4 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/20 17:46:54 by ariard ### ########.fr */ +/* Updated: 2017/02/25 19:28:47 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -19,20 +19,26 @@ int add_sep(t_btree **ast, t_list **lst) t_btree *new_node; DG("add sep"); - if (isloop(ast) == 1) + if (isloop(ast, lst) == 1) return (add_loop_sep(ast, lst)); else if (iscondition(ast, lst) == 1) 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)); + else if (isdir(ast, lst) == 2) + return (add_redir(ast, lst)); + else if (isfunc(ast, lst)) + return (add_func_sep(ast, lst)); if (!*ast) gen_node(ast); token = (*lst)->content; -// if (node->type != TK_DO) -// { - new_node = NULL; - gen_node(&new_node); - join_ast(ast, &new_node); - node = (new_node)->item; -// } +//watch != TK_DO + new_node = NULL; + gen_node(&new_node); + join_ast(ast, &new_node); + node = (new_node)->item; node->type = token->type; return (0); } diff --git a/42sh/src/parser/add_subshell.c b/42sh/src/parser/add_subshell.c new file mode 100644 index 00000000..17e83953 --- /dev/null +++ b/42sh/src/parser/add_subshell.c @@ -0,0 +1,52 @@ +/* ************************************************************************** */ +/* */ +/* ::: :::::::: */ +/* add_subshell.c :+: :+: :+: */ +/* +:+ +:+ +:+ */ +/* By: ariard +#+ +:+ +#+ */ +/* +#+#+#+#+#+ +#+ */ +/* Created: 2017/02/24 18:41:50 by ariard #+# #+# */ +/* Updated: 2017/02/24 23:38:40 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); + if (node->type == TK_LBRACE && 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)); + if (token->type == TK_RBRACE && node->type == TK_LBRACE) + 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 96a82d56..dba05036 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 10:49:53 by ariard ### ########.fr */ +/* Updated: 2017/02/25 13:53:57 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -16,7 +16,13 @@ t_aggrematch g_aggrematch[] = { {TK_WORD, CMD_SUFFIX, CMD_SUFFIX, 0}, {TK_WORD, TK_PIPE, PATTERN, 0}, - {TK_WORD, WORDLIST, WORDLIST, 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_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_PAREN_OPEN, CMD_SUPERIOR, FUNC_NAME, CMD_SUPERIOR}, {TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, 0}, {TK_PIPE, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR}, {TK_FI, ELSE_PART, IF_CLAUSE, TK_IF}, @@ -27,52 +33,66 @@ 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_PAREN_CLOSE, CMD_SUPERIOR, SUBSHELL, TK_PAREN_OPEN}, + {TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE, SUBSHELL, TK_PAREN_OPEN}, + + {TK_RBRACE, COMPOUND_LIST, BRACE_CLAUSE, TK_LBRACE}, + {TK_RBRACE, CMD_SUPERIOR, BRACE_CLAUSE, TK_LBRACE}, + {TK_RBRACE, PIPE_SEMI_SEQUENCE, BRACE_CLAUSE, TK_LBRACE}, {TK_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR}, {TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR}, //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}, {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}, {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_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}, {NEWLINE_LIST, TK_ELIF, TK_ELIF, TK_ELIF}, {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, WORDLIST, 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}, + {NEWLINE_LIST, LINEBREAK, PROGRAM, LINEBREAK}, + {NEWLINE_LIST, FOR_WORDLIST, SEQUENTIAL_SEP, 0}, //to check + {HERE_END, TK_DLESS, IO_HERE, TK_DLESS}, {IO_HERE, TK_IO_NUMBER, IO_REDIRECT, TK_IO_NUMBER}, {IO_HERE, ALL, IO_REDIRECT, 0}, {FILENAME, TK_LESS, IO_FILE, TK_LESS}, @@ -95,6 +115,9 @@ 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, TK_LBRACE, CMD_PREFIX, 0}, + {IO_REDIRECT, COMPLETE_COMMANDS, CMD_PREFIX, 0}, {IO_REDIRECT, TK_BANG, CMD_PREFIX, 0}, {IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, 0}, {IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, 0}, @@ -104,6 +127,9 @@ 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, TK_LBRACE, SIMPLE_COMMAND, 0}, + {CMD_PREFIX, COMPLETE_COMMANDS, SIMPLE_COMMAND, 0}, {CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, 0}, {CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, 0}, {CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, 0}, @@ -111,23 +137,29 @@ 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, TK_LBRACE, CMD_SUPERIOR, 0}, + {CMD_NAME, COMPLETE_COMMANDS, CMD_SUPERIOR, 0}, {CMD_NAME, TK_BANG, CMD_SUPERIOR, 0}, {CMD_NAME, SEPARATOR_OP, CMD_SUPERIOR, 0}, {CMD_NAME, NEWLINE_LIST, CMD_SUPERIOR, 0}, {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}, {CMD_NAME, AND_OR_MAJOR, CMD_SUPERIOR, 0}, {SIMPLE_COMMAND, ALL, COMMAND, 0}, {DO_GROUP, NAME, FOR_CLAUSE, TK_FOR}, + {DO_GROUP, IN, FOR_CLAUSE, TK_FOR}, {DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, TK_FOR}, {DO_GROUP, CMD_SUPERIOR, LOOP, CMD_SUPERIOR}, {DO_GROUP, COMPOUND_LIST, LOOP, COMPOUND_LIST}, @@ -141,31 +173,35 @@ 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, CLOSE_LIST, TK_PAREN_CLOSE}, {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}, + {CLOSE_LIST, PATTERN, CASE_LIST_NS, PATTERN_CASE}, + {CLOSE_LIST, FUNC_NAME, FUNCTION_DEFINITION, FUNC_NAME}, {SUBSHELL, ALL, COMPOUND_COMMAND, 0}, + {BRACE_CLAUSE, 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, TK_PAREN_OPEN, AND_OR_MAJOR, 0}, + {AND_OR_MINOR, TK_LBRACE, 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}, {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}, @@ -174,48 +210,70 @@ 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, TK_LBRACE, PIPE_SEMI_SEQUENCE, 0}, + {COMMAND, COMPLETE_COMMANDS, 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}, + {END_COMMAND, TK_WHILE, PIPE_SEQUENCE, 0}, {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, TK_LBRACE, 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}, {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}, {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, TK_LBRACE, PIPELINE, 0}, + {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, TK_PAREN_OPEN, AND_OR, 0}, + {PIPELINE, TK_LBRACE, AND_OR, 0}, + {PIPELINE, COMPLETE_COMMANDS, AND_OR, 0}, // {PIPELINE, LINEBREAK, AND_OR, AND_OR}, {PIPELINE, SEPARATOR_OP, AND_OR, 0}, {PIPELINE, COMPLETE_CONDITION, 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, 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}, @@ -223,15 +281,22 @@ 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, TK_PAREN_OPEN, COMPOUND_LIST, 0}, + {AND_OR, TK_LBRACE, 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}, {AND_OR, LINEBREAK, LIST, 0}, + {AND_OR, TK_LBRACE, LIST, 0}, + {AND_OR, COMPLETE_COMMANDS, LIST, 0}, {LIST, NEWLINE_LIST, COMPLETE_COMMAND, 0}, {LIST, LINEBREAK, COMPLETE_COMMAND, 0}, + {LIST, COMPLETE_COMMANDS, COMPLETE_COMMAND, 0}, {COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, COMPLETE_COMMANDS}, {COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, 0}, - {COMPLETE_COMMANDS, LINEBREAK, PROGRAM, LINEBREAK}, + {COMPLETE_COMMAND, COMPLETE_COMMANDS, COMPLETE_COMMANDS, 0}, + {COMPLETE_COMMANDS, COMPLETE_COMMANDS, COMPLETE_COMMANDS, COMPLETE_COMMANDS}, {0, 0, 0, 0}, }; @@ -240,20 +305,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 b602bead..2d8a7e70 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/20 22:16:04 by jhalford ### ########.fr */ +/* Updated: 2017/02/25 19:21:05 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -19,6 +19,8 @@ t_treematch g_treematch[] = {TK_SEMI, &add_sep}, {TK_GREAT, &add_sep}, {TK_LESS, &add_sep}, + {TK_DGREAT, &add_sep}, + {TK_DLESS, &add_sep}, {TK_OR_IF, &add_sep}, {TK_AND_IF, &add_sep}, {TK_WHILE, &add_cmd}, @@ -31,14 +33,28 @@ t_treematch g_treematch[] = {TK_THEN, &add_cmd}, {TK_FI, &add_cmd}, {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}, + {TK_ASSIGNEMENT_WORD, &add_cmd}, + {SUBSHELL, &add_cmd}, + {TK_LBRACE, &add_cmd}, + {TK_RBRACE, &add_cmd}, + {CLOSE_LIST, &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 - || cache == TK_NEWLINE || cache == TK_THEN)) + if (token->type == TK_NEWLINE && (cache == TK_WHILE || cache == TK_DO + || cache == TK_NEWLINE || cache == TK_THEN || cache == TK_IN + || cache == TK_DSEMI)) return (0); +//check cache == WORD return (1); } @@ -50,14 +66,20 @@ int build_tree(t_btree **ast, t_list **lst) i = 0; token = (*lst)->content; +//check bug de cache case ? +// cache = token->type; + if (token->type == TK_PAREN_OPEN && cache != TK_IN && cache != TK_DSEMI + && cache != TK_WORD) + token->type = SUBSHELL; + if (token->type == TK_PAREN_CLOSE && cache == TK_PAREN_OPEN) + token->type = CLOSE_LIST; 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'", - read_state(g_treematch[i].type) ,read_state(token->type)); + read_state(g_treematch[i].type) ,read_state(token->type)); cache = token->type; return (g_treematch[i].add(ast, lst)); } diff --git a/42sh/src/parser/error_syntax.c b/42sh/src/parser/error_syntax.c index ab5655ca..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, "<"}, @@ -60,9 +61,9 @@ int error_syntax(t_list **lst) { if (g_errormatch[i].token == token->type) { - ft_putstr_fd("syntax error near unexpetcted token `", 2); + ft_putstr_fd("syntax error near unexpected token `", 2); ft_putstr_fd(g_errormatch[i].error, 2); - ft_putstr_fd("'", 2); + ft_putstr_fd("'\n", 2); return (1); } i++; diff --git a/42sh/src/parser/eval_sym.c b/42sh/src/parser/eval_sym.c index b082ed21..4c0fc578 100644 --- a/42sh/src/parser/eval_sym.c +++ b/42sh/src/parser/eval_sym.c @@ -18,6 +18,11 @@ t_stackmatch g_stackmatch[] = {TK_WORD, TK_CASE}, {TK_WORD, WORDLIST}, {TK_WORD, LINEBREAK}, + {TK_WORD, TK_PAREN_OPEN}, + {TK_WORD, TK_LBRACE}, + {TK_WORD, COMPLETE_COMMANDS}, + {TK_WORD, TK_IN}, + {TK_WORD, FOR_WORDLIST}, {TK_ASSIGNEMENT_WORD, CMD_PREFIX}, {TK_IO_NUMBER, REDIRECT_LIST}, {TK_IO_NUMBER, CMD_SUFFIX}, @@ -25,6 +30,9 @@ 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, TK_LBRACE}, + {TK_IO_NUMBER, COMPLETE_COMMANDS}, {TK_IO_NUMBER, TK_BANG}, {TK_IO_NUMBER, SEPARATOR_OP}, {TK_IO_NUMBER, NEWLINE_LIST}, @@ -37,7 +45,10 @@ t_stackmatch g_stackmatch[] = {TK_OR_IF, CMD_SUPERIOR}, {TK_OR_IF, AND_OR}, {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}, @@ -45,6 +56,9 @@ t_stackmatch g_stackmatch[] = {TK_LESS, CMD_WORD}, {TK_LESS, CMD_NAME}, {TK_LESS, LINEBREAK}, + {TK_LESS, TK_PAREN_OPEN}, + {TK_LESS, TK_LBRACE}, + {TK_LESS, COMPLETE_COMMANDS}, {TK_LESS, TK_BANG}, {TK_LESS, SEPARATOR_OP}, {TK_LESS, NEWLINE_LIST}, @@ -58,6 +72,9 @@ t_stackmatch g_stackmatch[] = {TK_GREAT, CMD_WORD}, {TK_GREAT, CMD_NAME}, {TK_GREAT, LINEBREAK}, + {TK_GREAT, TK_PAREN_OPEN}, + {TK_GREAT, TK_LBRACE}, + {TK_GREAT, COMPLETE_COMMANDS}, {TK_GREAT, TK_BANG}, {TK_GREAT, SEPARATOR_OP}, {TK_GREAT, NEWLINE_LIST}, @@ -73,6 +90,9 @@ t_stackmatch g_stackmatch[] = {TK_DLESS, CMD_WORD}, {TK_DLESS, CMD_NAME}, {TK_DLESS, LINEBREAK}, + {TK_DLESS, TK_PAREN_OPEN}, + {TK_DLESS, TK_LBRACE}, + {TK_DLESS, COMPLETE_COMMANDS}, {TK_DLESS, TK_BANG}, {TK_DLESS, SEPARATOR_OP}, {TK_DLESS, NEWLINE_LIST}, @@ -87,6 +107,10 @@ t_stackmatch g_stackmatch[] = {TK_DLESSDASH, CMD_WORD}, {TK_DLESSDASH, CMD_NAME}, {TK_DLESSDASH, LINEBREAK}, + {TK_DLESSDASH, TK_PAREN_OPEN}, + {TK_DLESSDASH, TK_LBRACE}, + {TK_DLESSDASH, COMPLETE_COMMANDS}, + {TK_DLESSDASH, TK_BANG}, {TK_DLESSDASH, TK_BANG}, {TK_DLESSDASH, SEPARATOR_OP}, {TK_DLESSDASH, NEWLINE_LIST}, @@ -101,6 +125,10 @@ t_stackmatch g_stackmatch[] = {TK_DGREAT, CMD_WORD}, {TK_DGREAT, CMD_NAME}, {TK_DGREAT, LINEBREAK}, + {TK_DGREAT, TK_PAREN_OPEN}, + {TK_DGREAT, TK_LBRACE}, + {TK_DGREAT, COMPLETE_COMMANDS}, + {TK_DGREAT, TK_BANG}, {TK_DGREAT, TK_BANG}, {TK_DGREAT, SEPARATOR_OP}, {TK_DGREAT, NEWLINE_LIST}, @@ -115,6 +143,10 @@ t_stackmatch g_stackmatch[] = {TK_LESSAND, CMD_WORD}, {TK_LESSAND, CMD_NAME}, {TK_LESSAND, LINEBREAK}, + {TK_LESSAND, TK_PAREN_OPEN}, + {TK_LESSAND, TK_LBRACE}, + {TK_LESSAND, COMPLETE_COMMANDS}, + {TK_LESSAND, TK_BANG}, {TK_LESSAND, TK_BANG}, {TK_LESSAND, SEPARATOR_OP}, {TK_LESSAND, NEWLINE_LIST}, @@ -129,6 +161,10 @@ t_stackmatch g_stackmatch[] = {TK_GREATAND, CMD_WORD}, {TK_GREATAND, CMD_NAME}, {TK_GREATAND, LINEBREAK}, + {TK_GREATAND, TK_PAREN_OPEN}, + {TK_GREATAND, TK_LBRACE}, + {TK_GREATAND, COMPLETE_COMMANDS}, + {TK_LESSAND, TK_BANG}, {TK_GREATAND, TK_BANG}, {TK_GREATAND, SEPARATOR_OP}, {TK_GREATAND, NEWLINE_LIST}, @@ -143,6 +179,10 @@ t_stackmatch g_stackmatch[] = {TK_LESSGREAT, CMD_WORD}, {TK_LESSGREAT, CMD_NAME}, {TK_LESSGREAT, LINEBREAK}, + {TK_LESSGREAT, TK_PAREN_OPEN}, + {TK_LESSGREAT, TK_LBRACE}, + {TK_LESSGREAT, COMPLETE_COMMANDS}, + {TK_LESSGREAT, TK_BANG}, {TK_LESSGREAT, TK_BANG}, {TK_LESSGREAT, SEPARATOR_OP}, {TK_LESSGREAT, NEWLINE_LIST}, @@ -157,6 +197,10 @@ t_stackmatch g_stackmatch[] = {TK_CLOBBER, CMD_WORD}, {TK_CLOBBER, CMD_NAME}, {TK_CLOBBER, LINEBREAK}, + {TK_CLOBBER, TK_PAREN_OPEN}, + {TK_CLOBBER, TK_LBRACE}, + {TK_CLOBBER, COMPLETE_COMMANDS}, + {TK_CLOBBER, TK_BANG}, {TK_CLOBBER, TK_BANG}, {TK_CLOBBER, SEPARATOR_OP}, {TK_CLOBBER, NEWLINE_LIST}, @@ -165,6 +209,10 @@ t_stackmatch g_stackmatch[] = {TK_CLOBBER, AND_OR_MAJOR}, {TK_IF, LINEBREAK}, + {TK_IF, TK_PAREN_OPEN}, + {TK_IF, TK_LBRACE}, + {TK_IF, TK_PAREN_CLOSE}, + {TK_IF, COMPLETE_COMMANDS}, {TK_IF, TK_BANG}, {TK_IF, SEPARATOR_OP}, {TK_IF, NEWLINE_LIST}, @@ -174,9 +222,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}, @@ -199,49 +250,134 @@ t_stackmatch g_stackmatch[] = {TK_DONE, COMPOUND_LIST}, {TK_DONE, END_COMMAND}, {TK_CASE, LINEBREAK}, + {TK_CASE, TK_PAREN_OPEN}, + {TK_CASE, TK_LBRACE}, + {TK_CASE, COMPLETE_COMMANDS}, {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_ESAC, CASE_LIST}, + {TK_IN, TK_WORD}, + {TK_IN, NAME}, {TK_ESAC, CASE_LIST_NS}, {TK_ESAC, LINEBREAK}, + {TK_ESAC, TK_IN}, {TK_WHILE, LINEBREAK}, + {TK_WHILE, TK_PAREN_OPEN}, + {TK_WHILE, TK_LBRACE}, + {TK_WHILE, COMPLETE_COMMANDS}, {TK_WHILE, TK_BANG}, {TK_WHILE, SEPARATOR_OP}, {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, TK_PAREN_OPEN}, + {TK_UNTIL, TK_LBRACE}, + {TK_UNTIL, COMPLETE_COMMANDS}, {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, TK_PAREN_OPEN}, + {TK_FOR, TK_LBRACE}, + {TK_FOR, COMPLETE_COMMANDS}, + {TK_FOR, TK_BANG}, {TK_FOR, TK_BANG}, {TK_FOR, SEPARATOR_OP}, {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, COMPLETE_COMMANDS}, {TK_LBRACE, LINEBREAK}, + {TK_LBRACE, TK_LBRACE}, {TK_LBRACE, TK_BANG}, {TK_LBRACE, SEPARATOR_OP}, {TK_LBRACE, NEWLINE_LIST}, {TK_LBRACE, PIPE_SEMI_SEQUENCE}, + {TK_LBRACE, AND_OR_MAJOR}, + {TK_LBRACE, TK_WHILE}, + {TK_LBRACE, TK_UNTIL}, + {TK_LBRACE, TK_DO}, + {TK_LBRACE, TK_PAREN_CLOSE}, + {TK_LBRACE, TK_LBRACE}, + {TK_LBRACE, TK_IF}, + {TK_LBRACE, TK_ELIF}, + {TK_LBRACE, TK_THEN}, + {TK_LBRACE, TK_ELSE}, + {TK_LBRACE, COMPOUND_LIST}, + {TK_LBRACE, CASE_LIST_NS}, + {TK_LBRACE, COMPLETE_CONDITION}, + {TK_LBRACE, TK_IN}, + {SEQUENTIAL_SEP, NAME}, + {TK_RBRACE, TK_SEMI}, + {TK_RBRACE, END_COMMAND}, + {TK_RBRACE, SEPARATOR_OP}, + {TK_RBRACE, WORD}, + {TK_RBRACE, IN}, + {TK_RBRACE, TK_AND_IF}, + {TK_RBRACE, TK_OR_IF}, + {TK_RBRACE, TK_PIPE}, + {TK_RBRACE, TK_RBRACE}, + {TK_RBRACE, COMPLETE_COMMANDS}, + {TK_RBRACE, CMD_SUPERIOR}, + {TK_RBRACE, PIPE_SEMI_SEQUENCE}, + {TK_RBRACE, CASE_LIST_NS}, + {TK_RBRACE, PROGRAM}, + {TK_RBRACE, TK_PAREN_OPEN}, + {TK_RBRACE, TK_LBRACE}, + {TK_RBRACE, PATTERN_CASE}, + {TK_RBRACE, PATTERN}, {TK_RBRACE, COMPOUND_LIST}, + {TK_RBRACE, FUNC_NAME}, {TK_BANG, LINEBREAK}, + {TK_BANG, TK_PAREN_OPEN}, + {TK_BANG, TK_LBRACE}, + {TK_BANG, COMPLETE_COMMANDS}, + {TK_BANG, SEPARATOR_OP}, {TK_BANG, SEPARATOR_OP}, {TK_BANG, NEWLINE_LIST}, {TK_IN, LINEBREAK}, @@ -252,44 +388,68 @@ t_stackmatch g_stackmatch[] = {TK_SEMI, TERM}, {TK_SEMI, CMD_NAME}, {TK_SEMI, PROGRAM}, + {TK_SEMI, FOR_WORDLIST}, {TK_AMP, LIST}, {TK_AMP, TERM}, {TK_PIPE, PATTERN}, {TK_PIPE, CMD_SUPERIOR}, - {TK_PAREN_OPEN, FNAME}, - {TK_PAREN_OPEN, CASE_LIST}, + {PATTERN_CASE, TK_IN}, + {PATTERN_CASE, CASE_LIST_NS}, + {TK_PAREN_OPEN, COMPLETE_COMMANDS}, {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_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}, + {TK_PAREN_OPEN, CMD_SUPERIOR}, {SEQUENTIAL_SEP, NAME}, {SEQUENTIAL_SEP, IN}, {SEQUENTIAL_SEP, WORDLIST}, {END_COMMAND, PIPE_SEMI_SEQUENCE}, + {END_COMMAND, AND_OR_MAJOR}, + {END_COMMAND, TK_WHILE}, {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}, {END_COMMAND, TK_ELSE}, {END_COMMAND, LINEBREAK}, + {END_COMMAND, TK_PAREN_OPEN}, + {END_COMMAND, TK_LBRACE}, + {END_COMMAND, COMPLETE_COMMANDS}, {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}, + {LINEBREAK, END_COMMAND}, {LINEBREAK, SEPARATOR_OP}, {LINEBREAK, TK_PAREN_CLOSE}, {LINEBREAK, WORD}, @@ -302,8 +462,36 @@ t_stackmatch g_stackmatch[] = {LINEBREAK, CMD_SUPERIOR}, {LINEBREAK, PIPE_SEMI_SEQUENCE}, {LINEBREAK, COMPOUND_LIST}, + {LINEBREAK, CASE_LIST_NS}, {LINEBREAK, PROGRAM}, + {LINEBREAK, TK_PAREN_OPEN}, + {LINEBREAK, TK_LBRACE}, + {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, TK_LBRACE}, + {TK_PAREN_CLOSE, PATTERN_CASE}, + {TK_PAREN_CLOSE, PATTERN}, + {TK_PAREN_CLOSE, COMPOUND_LIST}, + {TK_PAREN_CLOSE, FUNC_NAME}, {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}, {NEWLINE_LIST, TK_WHILE}, {NEWLINE_LIST, TK_UNTIL}, {NEWLINE_LIST, TK_IF}, @@ -317,9 +505,14 @@ 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}, + {NEWLINE_LIST, LINEBREAK}, + {NEWLINE_LIST, TK_PAREN_OPEN}, + {NEWLINE_LIST, TK_LBRACE}, + {HERE_END, TK_DLESS}, {HERE_END, TK_DLESS}, {HERE_END, TK_DLESSDASH}, {IO_HERE, TK_IO_NUMBER}, @@ -330,6 +523,10 @@ t_stackmatch g_stackmatch[] = {IO_HERE, CMD_WORD}, {IO_HERE, CMD_NAME}, {IO_HERE, LINEBREAK}, + {IO_HERE, TK_PAREN_OPEN}, + {IO_HERE, TK_LBRACE}, + {IO_HERE, COMPLETE_COMMANDS}, + {IO_HERE, TK_BANG}, {IO_HERE, TK_BANG}, {IO_HERE, SEPARATOR_OP}, {IO_HERE, NEWLINE_LIST}, @@ -349,6 +546,8 @@ t_stackmatch g_stackmatch[] = {IO_FILE, CMD_WORD}, {IO_FILE, CMD_NAME}, {IO_FILE, LINEBREAK}, + {IO_FILE, COMPLETE_COMMANDS}, + {IO_FILE, TK_BANG}, {IO_FILE, TK_BANG}, {IO_FILE, SEPARATOR_OP}, {IO_FILE, NEWLINE_LIST}, @@ -360,6 +559,10 @@ t_stackmatch g_stackmatch[] = {IO_REDIRECT, CMD_WORD}, {IO_REDIRECT, CMD_NAME}, {IO_REDIRECT, LINEBREAK}, + {IO_REDIRECT, TK_PAREN_OPEN}, + {IO_REDIRECT, TK_LBRACE}, + {IO_REDIRECT, COMPLETE_COMMANDS}, + {IO_REDIRECT, TK_BANG}, {IO_REDIRECT, TK_BANG}, {IO_REDIRECT, SEPARATOR_OP}, {IO_REDIRECT, NEWLINE_LIST}, @@ -369,12 +572,20 @@ t_stackmatch g_stackmatch[] = {CMD_SUFFIX, CMD_NAME}, {CMD_SUFFIX, CMD_SUPERIOR}, {CMD_PREFIX, LINEBREAK}, + {CMD_PREFIX, TK_PAREN_OPEN}, + {CMD_PREFIX, TK_LBRACE}, + {CMD_PREFIX, COMPLETE_COMMANDS}, + {CMD_PREFIX, TK_BANG}, {CMD_PREFIX, TK_BANG}, {CMD_PREFIX, SEPARATOR_OP}, {CMD_PREFIX, NEWLINE_LIST}, {CMD_PREFIX, PIPE_SEMI_SEQUENCE}, {CMD_WORD, CMD_PREFIX}, + {CMD_NAME, COMPLETE_COMMANDS}, {CMD_NAME, LINEBREAK}, + {CMD_NAME, TK_PAREN_OPEN}, + {CMD_NAME, TK_LBRACE}, + {CMD_NAME, TK_BANG}, {CMD_NAME, TK_BANG}, {CMD_NAME, SEPARATOR_OP}, {CMD_NAME, NEWLINE_LIST}, @@ -383,23 +594,31 @@ 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, LINEBREAK}, + {CMD_SUPERIOR, TK_PAREN_OPEN}, + {CMD_SUPERIOR, TK_LBRACE}, + {CMD_SUPERIOR, COMPLETE_COMMANDS}, + {CMD_SUPERIOR, TK_BANG}, {CMD_SUPERIOR, TK_BANG}, {CMD_SUPERIOR, SEPARATOR_OP}, {CMD_SUPERIOR, NEWLINE_LIST}, @@ -410,13 +629,19 @@ 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, TK_PAREN_OPEN}, + {SIMPLE_COMMAND, TK_LBRACE}, + {SIMPLE_COMMAND, COMPLETE_COMMANDS}, + {SIMPLE_COMMAND, TK_BANG}, {SIMPLE_COMMAND, TK_BANG}, {SIMPLE_COMMAND, SEPARATOR_OP}, {SIMPLE_COMMAND, NEWLINE_LIST}, @@ -429,32 +654,56 @@ t_stackmatch g_stackmatch[] = {LOOP, TK_WHILE}, {LOOP, TK_UNTIL}, {CONDITION, LINEBREAK}, + {CONDITION, TK_PAREN_OPEN}, + {CONDITION, TK_LBRACE}, + {CONDITION, COMPLETE_COMMANDS}, {CONDITION, COMPOUND_LIST}, + {CONDITION, CASE_LIST_NS}, {CONDITION, COMPLETE_CONDITION}, {COMPLETE_CONDITION, LINEBREAK}, + {COMPLETE_CONDITION, TK_PAREN_OPEN}, + {COMPLETE_CONDITION, TK_LBRACE}, + {COMPLETE_CONDITION, COMPLETE_COMMANDS}, + {COMPLETE_CONDITION, COMPLETE_CONDITION}, {COMPLETE_CONDITION, COMPLETE_CONDITION}, {BRACE_GROUP, LINEBREAK}, + {BRACE_GROUP, TK_PAREN_OPEN}, + {BRACE_GROUP, TK_LBRACE}, + {BRACE_GROUP, COMPLETE_COMMANDS}, + {BRACE_GROUP, TK_BANG}, {BRACE_GROUP, TK_BANG}, {BRACE_GROUP, SEPARATOR_OP}, {BRACE_GROUP, NEWLINE_LIST}, {BRACE_GROUP, PIPE_SEMI_SEQUENCE}, {FNAME, LINEBREAK}, + {FNAME, TK_PAREN_OPEN}, + {FNAME, TK_LBRACE}, + {FNAME, COMPLETE_COMMANDS}, + {FNAME, TK_BANG}, {FNAME, TK_BANG}, {FNAME, SEPARATOR_OP}, {FNAME, NEWLINE_LIST}, {FNAME, PIPE_SEMI_SEQUENCE}, {FUNCTION_BODY, FUNC}, {FUNCTION_DEFINITION, LINEBREAK}, + {FUNCTION_DEFINITION, TK_PAREN_OPEN}, + {FUNCTION_DEFINITION, TK_LBRACE}, + {FUNCTION_DEFINITION, COMPLETE_COMMANDS}, + {FUNCTION_DEFINITION, TK_BANG}, {FUNCTION_DEFINITION, TK_BANG}, {FUNCTION_DEFINITION, SEPARATOR_OP}, {FUNCTION_DEFINITION, NEWLINE_LIST}, {FUNCTION_DEFINITION, PIPE_SEMI_SEQUENCE}, {UNTIL_CLAUSE, LINEBREAK}, + {UNTIL_CLAUSE, TK_PAREN_OPEN}, + {UNTIL_CLAUSE, TK_LBRACE}, + {UNTIL_CLAUSE, COMPLETE_COMMANDS}, {UNTIL_CLAUSE, TK_BANG}, {UNTIL_CLAUSE, SEPARATOR_OP}, {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}, @@ -462,13 +711,17 @@ 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}, + {UNTIL_CLAUSE, AND_OR_MAJOR}, {WHILE_CLAUSE, LINEBREAK}, + {WHILE_CLAUSE, COMPLETE_COMMANDS}, {WHILE_CLAUSE, TK_BANG}, {WHILE_CLAUSE, SEPARATOR_OP}, {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}, @@ -476,15 +729,21 @@ 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}, + {WHILE_CLAUSE, AND_OR_MAJOR}, // {ELSE_PART, COMPOUND_LIST}, // {ELSE_PART, COMPLETE_CONDITION}, {IF_CLAUSE, LINEBREAK}, + {IF_CLAUSE, TK_PAREN_OPEN}, + {IF_CLAUSE, TK_LBRACE}, + {IF_CLAUSE, COMPLETE_COMMANDS}, {IF_CLAUSE, TK_BANG}, {IF_CLAUSE, SEPARATOR_OP}, {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}, @@ -492,33 +751,86 @@ 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}, - - {PATTERN, TK_PAREN_OPEN}, + {IF_CLAUSE, AND_OR_MAJOR}, + {BRACE_CLAUSE, LINEBREAK}, + {BRACE_CLAUSE, TK_PAREN_OPEN}, + {BRACE_CLAUSE, TK_LBRACE}, + {BRACE_CLAUSE, COMPLETE_COMMANDS}, + {BRACE_CLAUSE, TK_BANG}, + {BRACE_CLAUSE, SEPARATOR_OP}, + {BRACE_CLAUSE, NEWLINE_LIST}, + {BRACE_CLAUSE, PIPE_SEMI_SEQUENCE}, + {BRACE_CLAUSE, TK_DO}, + {BRACE_CLAUSE, TK_PAREN_CLOSE}, + {BRACE_CLAUSE, TK_WHILE}, + {BRACE_CLAUSE, TK_UNTIL}, + {BRACE_CLAUSE, TK_IF}, + {BRACE_CLAUSE, TK_ELIF}, + {BRACE_CLAUSE, TK_THEN}, + {BRACE_CLAUSE, TK_ELSE}, + {BRACE_CLAUSE, COMPOUND_LIST}, + {BRACE_CLAUSE, CASE_LIST_NS}, + {BRACE_CLAUSE, COMPLETE_COMMAND}, + {BRACE_CLAUSE, COMPLETE_CONDITION}, + {BRACE_CLAUSE, AND_OR_MAJOR}, + {PATTERN, PATTERN_CASE}, {PATTERN, CASE_LIST}, - {PATTERN_CASE, CASE_LIST}, - {CASE_ITEM, CASE_LIST}, - {CASE_ITEM, LINEBREAK}, - {CASE_ITEM_NS, CASE_LIST}, - {CASE_ITEM_NS, LINEBREAK}, - {CASE_LIST, LINEBREAK}, + {PATTERN, TK_IN}, {CASE_LIST_NS, LINEBREAK}, {CASE_CLAUSE, LINEBREAK}, + {CASE_CLAUSE, TK_PAREN_OPEN}, + {CASE_CLAUSE, TK_LBRACE}, + {CASE_CLAUSE, COMPLETE_COMMANDS}, {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_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, TK_LBRACE}, + {FOR_CLAUSE, COMPLETE_COMMANDS}, + {FOR_CLAUSE, TK_BANG}, {FOR_CLAUSE, TK_BANG}, {FOR_CLAUSE, SEPARATOR_OP}, {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}, + {FOR_CLAUSE, TK_ELIF}, + {FOR_CLAUSE, TK_THEN}, + {FOR_CLAUSE, TK_ELSE}, + {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}, + {COMPOUND_LIST, TK_PAREN_CLOSE}, {COMPOUND_LIST, TK_LBRACE}, {COMPOUND_LIST, TK_WHILE}, {COMPOUND_LIST, TK_UNTIL}, @@ -529,18 +841,41 @@ t_stackmatch g_stackmatch[] = {COMPOUND_LIST, TK_ELSE}, {COMPOUND_LIST, COMPOUND_LIST}, {COMPOUND_LIST, COMPLETE_CONDITION}, + {CLOSE_LIST, PATTERN_CASE}, + {CLOSE_LIST, FUNC_NAME}, {SUBSHELL, LINEBREAK}, + {SUBSHELL, COMPLETE_COMMANDS}, {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, TK_LBRACE}, + {COMPOUND_COMMAND, COMPLETE_COMMANDS}, + {COMPOUND_COMMAND, TK_BANG}, {COMPOUND_COMMAND, TK_BANG}, {COMPOUND_COMMAND, SEPARATOR_OP}, {COMPOUND_COMMAND, NEWLINE_LIST}, {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}, @@ -548,16 +883,23 @@ 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}, + {COMPOUND_COMMAND, AND_OR_MAJOR}, {COMMAND, TK_WHILE}, {COMMAND, TK_UNTIL}, {COMMAND, LINEBREAK}, + {COMMAND, TK_PAREN_OPEN}, + {COMMAND, TK_LBRACE}, + {COMMAND, COMPLETE_COMMANDS}, {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}, @@ -566,17 +908,26 @@ 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, TK_LBRACE}, + {AND_OR_MINOR, COMPLETE_COMMANDS}, {AND_OR_MINOR, AND_OR_MAJOR}, {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, TK_PAREN_OPEN}, + {PIPE_SEQUENCE, TK_LBRACE}, + {PIPE_SEQUENCE, COMPLETE_COMMANDS}, + {PIPE_SEQUENCE, TK_BANG}, {PIPE_SEQUENCE, TK_BANG}, {PIPE_SEQUENCE, SEPARATOR_OP}, {PIPE_SEQUENCE, NEWLINE_LIST}, @@ -584,13 +935,19 @@ 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, TK_PAREN_OPEN}, + {PIPE_SEMI_SEQUENCE, TK_LBRACE}, + {PIPE_SEMI_SEQUENCE, COMPLETE_COMMANDS}, + {PIPE_SEMI_SEQUENCE, TK_BANG}, {PIPE_SEMI_SEQUENCE, TK_BANG}, {PIPE_SEMI_SEQUENCE, SEPARATOR_OP}, {PIPE_SEMI_SEQUENCE, NEWLINE_LIST}, @@ -598,19 +955,30 @@ 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, TK_PAREN_OPEN}, + {PIPELINE, TK_LBRACE}, + {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, TK_LBRACE}, + {AND_OR_MAJOR, COMPLETE_COMMANDS}, + {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}, @@ -618,15 +986,22 @@ 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, TK_PAREN_OPEN}, + {AND_OR, TK_LBRACE}, + {AND_OR, COMPLETE_COMMANDS}, + {AND_OR, SEPARATOR_OP}, {AND_OR, SEPARATOR_OP}, {AND_OR, NEWLINE_LIST}, {LIST, LINEBREAK}, + {LIST, COMPLETE_COMMANDS}, {LIST, NEWLINE_LIST}, {COMPLETE_COMMAND, LINEBREAK}, + {COMPLETE_COMMAND, COMPLETE_COMMANDS}, {COMPLETE_COMMAND, NEWLINE_LIST}, - {COMPLETE_COMMANDS, LINEBREAK}, + {COMPLETE_COMMANDS, COMPLETE_COMMANDS}, {0, 0}, }; diff --git a/42sh/src/parser/ft_parse.c b/42sh/src/parser/ft_parse.c index 35ff1972..01f978b8 100644 --- a/42sh/src/parser/ft_parse.c +++ b/42sh/src/parser/ft_parse.c @@ -6,7 +6,6 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/11/30 17:14:58 by jhalford #+# #+# */ -/* Updated: 2017/02/21 20:09:19 by jhalford ### ########.fr */ /* */ /* ************************************************************************** */ @@ -15,30 +14,37 @@ static void insert_linebreak(t_list **lst) { t_token *token; + token = (*lst)->content; token->type = LINEBREAK; } static int end_instruction(t_sym sym) { - if (sym == CMD_SUPERIOR || sym == PIPE_SEMI_SEQUENCE) + if (sym == CMD_SUPERIOR || sym == PIPE_SEMI_SEQUENCE + || sym == COMPLETE_COMMANDS || sym == END_COMMAND) return (1); return (0); } int ft_parse(t_btree **ast, t_list **token, t_parser *parser) { + (void)ast; + if (parser->state == SUCCESS || parser->state == ERROR) + parser_init(parser); while (*token) { produce_sym(*parser->stack, parser->new_sym, token); DG("new sym %s", read_state(*parser->new_sym)); if (eval_sym(*parser->stack, *parser->new_sym)) - parser->state = ERROR; + return ((parser->state = ERROR)); else { aggregate_sym(&parser->stack, parser->new_sym, &parser->state); push_stack(++parser->stack, *parser->new_sym); } + ft_read_stack(parser->stack); + DG("\n"); if (*parser->stack == PROGRAM) parser->state = SUCCESS; else @@ -46,11 +52,11 @@ int ft_parse(t_btree **ast, t_list **token, t_parser *parser) build_tree(ast, token); btree_print(STDBUG, *ast, &ft_putast); if ((end_instruction(*parser->stack) && !(*token)->next)) - /* || *parser->stack == PROGRAM) */ insert_linebreak(token); else ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free); } - ft_read_stack(parser->stack); + 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 306c9db1..4a2cbad4 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/20 22:37:22 by jhalford ### ########.fr */ +/* Updated: 2017/02/25 13:54:08 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -33,29 +33,40 @@ 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}, {TK_WORD, PIPE_SEMI_SEQUENCE, CMD_NAME}, {TK_WORD, SEPARATOR_OP, CMD_NAME}, - {TK_WORD, IN, WORDLIST}, + {TK_WORD, TK_PAREN_OPEN, CMD_NAME}, + {TK_WORD, TK_LBRACE, 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_LBRACE, 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_LBRACE, FNAME}, {TK_NAME, TK_BANG, FNAME}, {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}, {TK_NEWLINE, TK_IF, NEWLINE_LIST}, @@ -66,11 +77,17 @@ 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, TK_LBRACE, 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}, + {TK_NEWLINE, FOR_WORDLIST, NEWLINE_LIST}, + {TK_NEWLINE, SEQUENTIAL_SEP, NEWLINE_LIST}, + {TK_SEMI, CMD_SUPERIOR, SEPARATOR_OP}, {TK_SEMI, CMD_SUPERIOR, SEPARATOR_OP}, {TK_SEMI, TERM, SEPARATOR_OP}, {TK_SEMI, LIST, SEPARATOR_OP}, @@ -88,8 +105,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) @@ -97,7 +114,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++; diff --git a/42sh/src/parser/read_stack.c b/42sh/src/parser/read_stack.c index 95f5c3a1..ebb6e4d8 100644 --- a/42sh/src/parser/read_stack.c +++ b/42sh/src/parser/read_stack.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 15:32:10 by ariard #+# #+# */ -/* Updated: 2017/02/20 22:38:48 by jhalford ### ########.fr */ +/* Updated: 2017/02/25 00:15:00 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,6 +14,46 @@ char *read_state(t_sym current) { + if (current == BRACE_CLAUSE) + return ("BRACE_CLAUSE"); + if (current == FUNC_NAME) + return ("FUNC_NAME"); + if (current == TK_LBRACE) + return ("TK_LBRACE"); + if (current == TK_RBRACE) + return ("TK_RBRACE"); + if (current == TK_ASSIGNEMENT_WORD) + return ("TK_ASSIGNEMENT_WORD"); + 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) + return ("TK_PAREN_CLOSE"); + if (current == FOR_WORDLIST) + return ("FOR_WORDLIST"); + if (current == FOR_CLAUSE) + return ("FOR_CLAUSE"); + if (current == TK_NAME) + return ("TK_NAME"); + if (current == TK_FOR) + return ("FOR"); + if (current == NAME) + return ("NAME"); + if (current == 0) + return ("NULL"); + if (current == PATTERN) + return ("PATTERN"); + if (current == TK_CASE) + return ("TK_CASE"); + if (current == TK_IN) + return ("TK_IN"); + if (current == TK_ESAC) + return ("TK_ESAC"); if (current == UNTIL_CLAUSE) return ("UNTIL_CLAUSE"); if (current == TK_UNTIL) @@ -161,10 +201,8 @@ char *read_state(t_sym current) int ft_read_stack(t_sym *stack) { + DG("read stack :"); while (*stack) - { - ft_putstr(read_state(*stack--)); - ft_putchar(10); - } + DG("%s", read_state(*stack--)); return (0); } diff --git a/42sh/src/parser/tree_wrapper.c b/42sh/src/parser/tree_wrapper.c index 505f2050..ac2d3d5b 100644 --- a/42sh/src/parser/tree_wrapper.c +++ b/42sh/src/parser/tree_wrapper.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/15 18:57:44 by ariard #+# #+# */ -/* Updated: 2017/02/19 16:34:17 by ariard ### ########.fr */ +/* Updated: 2017/02/25 19:10:34 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -31,6 +31,9 @@ int gen_node(t_btree **ast) ((t_astnode *)(*ast)->item)->nest = 0; ((t_astnode *)(*ast)->item)->full = 0; ((t_astnode *)(*ast)->item)->type = 0; + ((t_astnode *)(*ast)->item)->pattern = 0; } return (0); } + +