diff --git a/42sh/Makefile b/42sh/Makefile index a1eb2f94..2aad4347 100644 --- a/42sh/Makefile +++ b/42sh/Makefile @@ -175,7 +175,6 @@ parser/eval_sym.c\ parser/aggregate_sym.c\ parser/pop_stack.c\ parser/push_stack.c\ -parser/superflous_sym.c\ parser/error_syntax.c\ parser/get_instruction.c\ parser/get_sub_instruction.c\ diff --git a/42sh/file1 b/42sh/file1 new file mode 100644 index 00000000..e69de29b diff --git a/42sh/file2 b/42sh/file2 new file mode 100644 index 00000000..e69de29b diff --git a/42sh/file3 b/42sh/file3 new file mode 100644 index 00000000..e69de29b diff --git a/42sh/file4 b/42sh/file4 new file mode 100644 index 00000000..e69de29b diff --git a/42sh/includes/parser.h b/42sh/includes/parser.h index cc55c791..7d5f20f7 100644 --- a/42sh/includes/parser.h +++ b/42sh/includes/parser.h @@ -114,14 +114,13 @@ enum e_sym LOOP, FUNC, PIPE_SEMI_SEQUENCE, + PATTERN_CASE, + CMD_SUPERIOR, ALL = 200, }; typedef int t_sym; -# define REDIR (TK_IO_NUMBER | TK_LESS | TK_LESSAND | TK_GREATAND | TK_DGREAT\ - | TK_LESSGREAT | TK_CLOBBER | TK_DLESS | TK_DLESSDASH | TK_WORD) - /* typedef unsigned long long int t_sym; @@ -179,9 +178,7 @@ typedef unsigned long long int t_sym; //#define ALL_SYM -1UL */ -# define MATCH_STACK(x, y) (x == y || x == ALL) -# define MATCH_NXT_TOKEN(x, y) (x == y || y == ALL || x == 0 || x &~ REDIR) - +# define MATCH_STACK(x, y) (x == y || y == ALL) typedef int t_parstate; @@ -190,8 +187,7 @@ struct s_aggrematch t_sym top; t_sym under; t_sym new_sym; - t_type next_token; - t_sym erase_sym; + int erase_sym; }; typedef struct s_aggrematch t_aggrematch; @@ -222,8 +218,7 @@ extern t_stackmatch g_stackmatch[]; int ft_parse(t_btree **ast, t_list **token); int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst); int eval_sym(t_sym stack, t_sym new_sym); -int aggregate_sym(t_sym **stack, t_sym *new_sym, - t_parstate *state, t_list *next_token); +int aggregate_sym(t_sym **stack, t_sym *new_sym, t_parstate *state); int push_stack(t_sym *stack, t_sym new_sym); int pop_stack(t_sym **stack, t_sym erase_sym); @@ -231,7 +226,7 @@ int pop_stack(t_sym **stack, t_sym erase_sym); int error_syntax(t_list **token); int ft_read_stack(t_sym *stack); -char *read_state(t_sym current); +char *read_state(t_sym current); #define UNDEFINED (1 << 0) #define ERROR (1 << 1) diff --git a/42sh/sample/multiredir b/42sh/sample/multiredir new file mode 100644 index 00000000..0350bb6f --- /dev/null +++ b/42sh/sample/multiredir @@ -0,0 +1,3 @@ +cat < file1 < file2 > file3 > file4 + + diff --git a/42sh/sample/stack.sh b/42sh/sample/stack.sh index 30cde0b2..1c1823ad 100644 --- a/42sh/sample/stack.sh +++ b/42sh/sample/stack.sh @@ -1 +1 @@ -ls +ls | cat | cat > file1 diff --git a/42sh/src/parser/aggregate_sym.c b/42sh/src/parser/aggregate_sym.c index 59441c34..0b81a7f2 100644 --- a/42sh/src/parser/aggregate_sym.c +++ b/42sh/src/parser/aggregate_sym.c @@ -14,135 +14,148 @@ t_aggrematch g_aggrematch[] = { - {TK_WORD, CMD_SUFFIX, CMD_SUFFIX, ALL, 0}, - {TK_WORD, TK_PIPE, PATTERN, ALL, 0}, - {TK_WORD, WORDLIST, WORDLIST, ALL, 0}, - {TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, ALL, 0}, - {TK_FI, ELSE_PART, IF_CLAUSE, ALL, IF}, - {TK_FI, COMPOUND_LIST, IF_CLAUSE, ALL, IF}, - {TK_DONE, COMPOUND_LIST, DO_GROUP, ALL, DO}, + {TK_WORD, CMD_SUFFIX, CMD_SUFFIX, 0}, + {TK_WORD, TK_PIPE, PATTERN, 0}, + {TK_WORD, WORDLIST, WORDLIST, 0}, + {TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, 0}, + {TK_PIPE, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR}, + {TK_FI, ELSE_PART, IF_CLAUSE, IF}, + {TK_FI, COMPOUND_LIST, IF_CLAUSE, IF}, + {TK_DONE, COMPOUND_LIST, DO_GROUP, DO}, //Esac ? - {TK_ESAC, CASE_LIST, CASE_CLAUSE, ALL, TK_CASE}, - {TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, ALL, TK_CASE}, - {TK_ESAC, LINEBREAK, CASE_CLAUSE, ALL, TK_CASE}, - {TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, ALL, TK_LBRACE}, - {TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, ALL, TK_PAREN_OPEN}, + {TK_ESAC, CASE_LIST, 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}, //watch this - {SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, ALL, 0}, - {LINEBREAK, SEPARATOR_OP, SEPARATOR, ALL, SEPARATOR_OP}, - {LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, ALL, TK_SEMI}, - {LINEBREAK, TK_PAREN_CLOSE, TK_ESAC, CASE_ITEM_NS, PATTERN_CASE}, - {LINEBREAK, TK_PAREN_CLOSE, FUNC, ALL, FNAME}, - {LINEBREAK, TK_DSEMI, CASE_ITEM, ALL, PATTERN_CASE}, - {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, LINEBREAK}, - {LINEBREAK, TK_PIPE, PIPE_SEMI_SEQUENCE, ALL, PIPE_SEQUENCE}, - {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, LINEBREAK}, - {NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, ALL, NEWLINE}, - {NEWLINE_LIST, NAME, SEQUENTIAL_SEP, ALL, 0}, - {NEWLINE_LIST, IN, SEQUENTIAL_SEP, ALL, 0}, - {NEWLINE_LIST, WORDLIST, SEQUENTIAL_SEP, ALL, 0}, - {NEWLINE_LIST, TERM, SEPARATOR, ALL, 0}, - {NEWLINE_LIST, COMPOUND_LIST, SEPARATOR, ALL, 0}, - {IO_HERE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER}, - {FILENAME, TK_LESS, IO_FILE, ALL, TK_LESS}, - {FILENAME, TK_LESSAND, IO_FILE, ALL, TK_LESSAND}, - {FILENAME, TK_GREAT, IO_FILE, ALL, TK_GREAT}, - {FILENAME, TK_GREATAND, IO_FILE, ALL, TK_GREATAND}, - {FILENAME, TK_DGREAT, IO_FILE, ALL, TK_DGREAT}, - {FILENAME, TK_LESSGREAT, IO_FILE, ALL, TK_LESSGREAT}, - {FILENAME, TK_CLOBBER, IO_FILE, ALL, TK_CLOBBER}, - {IO_FILE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER}, - {IO_REDIRECT, COMPOUND_COMMAND, REDIRECT_LIST, ALL, REDIRECT_LIST}, - {IO_REDIRECT, CMD_SUFFIX, CMD_SUFFIX, ALL, CMD_SUFFIX}, - {IO_REDIRECT, CMD_NAME, CMD_SUFFIX, ALL, 0}, - {IO_REDIRECT, CMD_WORD, CMD_SUFFIX, ALL, 0}, - {IO_REDIRECT, CMD_PREFIX, CMD_PREFIX, ALL, CMD_PREFIX}, - {IO_REDIRECT, LINEBREAK, CMD_PREFIX, ALL, 0}, - {IO_REDIRECT, TK_BANG, CMD_PREFIX, ALL, 0}, - {IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, ALL, 0}, - {IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, ALL, 0}, - {REDIRECT_LIST, COMPOUND_COMMAND, COMPOUND_COMMAND, ALL, COMPOUND_COMMAND}, - {CMD_SUFFIX, CMD_WORD, SIMPLE_COMMAND, ALL, CMD_PREFIX}, - {CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, ALL, CMD_NAME}, - {CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, TK_WORD, 0}, - {CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, TK_WORD, 0}, - {CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, TK_WORD, 0}, - {CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, TK_WORD, 0}, - {CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, ALL_SEPARATOR, CMD_PREFIX}, -//to check - {CMD_NAME, LINEBREAK, SIMPLE_COMMAND, SUFFIX_NAME, 0}, - {CMD_NAME, TK_BANG, SIMPLE_COMMAND, SUFFIX_NAME, 0}, - {CMD_NAME, SEPARATOR_OP, SIMPLE_COMMAND, SUFFIX_NAME, 0}, - {CMD_NAME, NEWLINE_LIST, SIMPLE_COMMAND, SUFFIX_NAME, 0}, - {CMD_NAME, PIPE_SEMI_SEQUENCE, SIMPLE_COMMAND, SUFFIX_NAME, 0}, + {SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, 0}, + {LINEBREAK, SEPARATOR_OP, SEPARATOR, SEPARATOR_OP}, + {LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, TK_SEMI}, - {SIMPLE_COMMAND, ALL, COMMAND, ALL, 0}, - {DO_GROUP, NAME, FOR_CLAUSE, ALL, TK_FOR}, - {DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, ALL, TK_FOR}, - {DO_GROUP, COMPOUND_LIST, LOOP, ALL, COMPOUND_LIST}, - {LOOP, WHILE, WHILE_CLAUSE, ALL, WHILE}, - {LOOP, TK_UNTIL, UNTIL_CLAUSE, ALL, TK_UNTIL}, - {BRACE_GROUP, ALL, COMPOUND_COMMAND, ALL, 0}, - {FUNCTION_BODY, FUNC, FUNCTION_DEFINITION, ALL, 0}, - {FUNCTION_DEFINITION, ALL, COMMAND, ALL, 0}, - {UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - {WHILE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - {ELSE_PART, COMPOUND_LIST, ELSE_PART, ALL, TK_ELIF}, - {IF_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - {CASE_ITEM, CASE_LIST, CASE_LIST, ALL, CASE_LIST}, - {CASE_ITEM, LINEBREAK, CASE_LIST, ALL, CASE_LIST}, - {CASE_ITEM_NS, CASE_LIST, CASE_LIST_NS, ALL, CASE_LIST}, - {CASE_ITEM_NS, LINEBREAK, CASE_LIST_NS, ALL, CASE_LIST}, - {CASE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - {FOR_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - {TERM, LINEBREAK, COMPOUND_LIST, ALL, LINEBREAK}, - {COMPOUND_LIST, TK_ELSE, ELSE_PART, ALL, TK_ELSE}, - {COMPOUND_LIST, TK_THEN, ELSE_PART, ALL, TK_ELIF}, - {SUBSHELL, ALL, COMPOUND_COMMAND, ALL, 0}, - {COMPOUND_COMMAND, ALL, COMMAND, ALL, 0}, - {COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, ALL, PIPE_SEMI_SEQUENCE}, - {COMMAND, TK_BANG, PIPE_SEQUENCE, ALL, 0}, - {COMMAND, SEPARATOR_OP, PIPE_SEQUENCE, ALL, 0}, - {COMMAND, NEWLINE_LIST, PIPE_SEQUENCE, ALL, 0}, - {COMMAND, LINEBREAK, PIPE_SEQUENCE, ALL, 0}, - {PIPE_SEQUENCE, TK_BANG, PIPELINE, ALL, TK_BANG}, - {PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, ALL, 0}, - {PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, ALL, 0}, - {PIPE_SEQUENCE, LINEBREAK, PIPELINE, ALL_SEPARATOR, 0}, - {PIPELINE, LINEBREAK, AND_OR, ALL, 0}, -// {PIPELINE, LINEBREAK, AND_OR, ALL, AND_OR}, - {PIPELINE, SEPARATOR_OP, AND_OR, ALL, 0}, - {AND_OR, SEPARATOR_OP, LIST, ALL, LIST}, - {AND_OR, NEWLINE_LIST, LIST, ALL, 0}, - {AND_OR, LINEBREAK, LIST, ALL, 0}, - {LIST, NEWLINE_LIST, COMPLETE_COMMAND, ALL, 0}, - {LIST, LINEBREAK, COMPLETE_COMMAND, ALL, 0}, - {COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, ALL, COMPLETE_COMMANDS}, - {COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, ALL, 0}, +//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, SIMPLE_COMMAND, CMD_SUPERIOR}, + {LINEBREAK, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE}, + {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}, + +//to check + {IO_HERE, TK_IO_NUMBER, IO_REDIRECT, TK_IO_NUMBER}, + {IO_HERE, ALL, IO_REDIRECT, 0}, + {FILENAME, TK_LESS, IO_FILE, TK_LESS}, + {FILENAME, TK_LESSAND, IO_FILE, TK_LESSAND}, + {FILENAME, TK_GREAT, IO_FILE, TK_GREAT}, + {FILENAME, TK_GREATAND, IO_FILE, TK_GREATAND}, + {FILENAME, TK_DGREAT, IO_FILE, TK_DGREAT}, + {FILENAME, TK_LESSGREAT, IO_FILE, TK_LESSGREAT}, + {FILENAME, TK_CLOBBER, IO_FILE, TK_CLOBBER}, + +//to check + {IO_FILE, TK_IO_NUMBER, IO_REDIRECT, TK_IO_NUMBER}, + {IO_FILE, ALL, IO_REDIRECT, 0}, + {IO_REDIRECT, CMD_SUPERIOR, CMD_SUPERIOR, CMD_SUPERIOR}, + {IO_REDIRECT, COMPOUND_COMMAND, REDIRECT_LIST, REDIRECT_LIST}, + +//to check + {IO_REDIRECT, CMD_SUFFIX, CMD_SUFFIX, CMD_SUFFIX}, + {IO_REDIRECT, CMD_NAME, CMD_SUFFIX, 0}, + {IO_REDIRECT, CMD_WORD, CMD_SUFFIX, 0}, + {IO_REDIRECT, CMD_PREFIX, CMD_PREFIX, CMD_PREFIX}, + {IO_REDIRECT, LINEBREAK, CMD_PREFIX, 0}, + {IO_REDIRECT, TK_BANG, CMD_PREFIX, 0}, + {IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, 0}, + {IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, 0}, + {REDIRECT_LIST, COMPOUND_COMMAND, COMPOUND_COMMAND, COMPOUND_COMMAND}, + {CMD_SUFFIX, CMD_WORD, SIMPLE_COMMAND, CMD_PREFIX}, + {CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, CMD_NAME}, + +//to abstract + {CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, 0}, + {CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, 0}, + {CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, 0}, + {CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, 0}, + + {CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, CMD_PREFIX}, +//to check + {CMD_NAME, LINEBREAK, 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_PIPE, CMD_SUPERIOR, 0}, + {CMD_NAME, PIPE_SEMI_SEQUENCE, CMD_SUPERIOR, 0}, + {SIMPLE_COMMAND, ALL, COMMAND, 0}, + {DO_GROUP, NAME, FOR_CLAUSE, TK_FOR}, + {DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, TK_FOR}, + {DO_GROUP, COMPOUND_LIST, LOOP, COMPOUND_LIST}, + {LOOP, WHILE, WHILE_CLAUSE, WHILE}, + {LOOP, TK_UNTIL, UNTIL_CLAUSE, TK_UNTIL}, + {BRACE_GROUP, ALL, COMPOUND_COMMAND, 0}, + {FUNCTION_BODY, FUNC, FUNCTION_DEFINITION, 0}, + {FUNCTION_DEFINITION, ALL, COMMAND, 0}, + {UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, 0}, + {WHILE_CLAUSE, ALL, COMPOUND_COMMAND, 0}, + {ELSE_PART, COMPOUND_LIST, ELSE_PART, TK_ELIF}, + {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_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_THEN, ELSE_PART, TK_ELIF}, + {SUBSHELL, ALL, COMPOUND_COMMAND, 0}, + {COMPOUND_COMMAND, ALL, COMMAND, 0}, + {COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE}, + {COMMAND, TK_BANG, PIPE_SEMI_SEQUENCE, 0}, + {COMMAND, SEPARATOR_OP, PIPE_SEMI_SEQUENCE, 0}, + {COMMAND, NEWLINE_LIST, PIPE_SEMI_SEQUENCE, 0}, + {COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, 0}, + {PIPE_SEQUENCE, TK_BANG, PIPELINE, TK_BANG}, + {PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, 0}, + {PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, 0}, + {PIPE_SEQUENCE, LINEBREAK, PIPELINE, 0}, + {PIPELINE, LINEBREAK, AND_OR, 0}, +// {PIPELINE, LINEBREAK, AND_OR, AND_OR}, + {PIPELINE, SEPARATOR_OP, AND_OR, 0}, + {AND_OR, SEPARATOR_OP, LIST, LIST}, + {AND_OR, NEWLINE_LIST, LIST, 0}, + {AND_OR, LINEBREAK, LIST, 0}, + {LIST, NEWLINE_LIST, COMPLETE_COMMAND, 0}, + {LIST, LINEBREAK, COMPLETE_COMMAND, 0}, + {COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, COMPLETE_COMMANDS}, + {COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, 0}, + {COMPLETE_COMMANDS, LINEBREAK, PROGRAM, LINEBREAK}, // voir decoupe separateur au lexer - {COMPLETE_COMMANDS, LINEBREAK, PROGRAM, ALL_SEPARATOR, 0}, - {0, 0, 0, 0, 0}, + {0, 0, 0, 0}, }; -int aggregate_sym(t_sym **stack, t_sym *new_sym, - t_parstate *state, t_list *next_token) +int aggregate_sym(t_sym **stack, t_sym *new_sym, t_parstate *state) { int i; - int next; - t_token *token; i = 0; - next = 0; - if (next_token) - if ((token = next_token->content)) - next = token->type; - DG("aggregate head %s && sym %s && next %s", - read_state(**stack), read_state(*new_sym), read_state(next)); + 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) - && MATCH_NXT_TOKEN(next, g_aggrematch[i].next_token)) + && MATCH_STACK(**stack, g_aggrematch[i].under)) + { DG("MATCH : %s", read_state(g_aggrematch[i].new_sym)); *new_sym = g_aggrematch[i].new_sym; @@ -153,7 +166,7 @@ int aggregate_sym(t_sym **stack, t_sym *new_sym, } if (eval_sym(**stack, *new_sym)) return ((*state = ERROR)); - aggregate_sym(stack, new_sym, state, next_token); + aggregate_sym(stack, new_sym, state); return (0); } i++; diff --git a/42sh/src/parser/error_syntax.c b/42sh/src/parser/error_syntax.c index c5c668a1..9bacf149 100644 --- a/42sh/src/parser/error_syntax.c +++ b/42sh/src/parser/error_syntax.c @@ -12,9 +12,22 @@ #include "parser.h" -int error_syntax(t_list **lst) -{ - (void)lst; - ft_putstr_fd("syntax error near unexepected token ';'", 2); +int error_syntax(t_list **lst) +{ + t_token *token; + + token = (*lst)->content; + if (token->type == TK_SEMI) + ft_putstr_fd("syntax error near unexepected token ';'", 2); + else if (token->type == TK_WORD) + ft_putstr_fd("syntax error near unexepected token 'word'", 2); + else if (token->type == TK_GREAT) + ft_putstr_fd("syntax error near unexepected token '>'", 2); + else if (token->type == TK_NEWLINE) + ft_putstr_fd("syntax error near unexepected token 'newline'", 2); + else if (token->type == TK_LESS) + ft_putstr_fd("syntax error near unexepected token '<'", 2); + else + ft_putstr_fd("grammar error, notify ariard", 2); return (1); } diff --git a/42sh/src/parser/eval_sym.c b/42sh/src/parser/eval_sym.c index 75d9dc3b..38e9361c 100644 --- a/42sh/src/parser/eval_sym.c +++ b/42sh/src/parser/eval_sym.c @@ -30,10 +30,37 @@ t_stackmatch g_stackmatch[] = {TK_IO_NUMBER, SEPARATOR_OP}, {TK_IO_NUMBER, NEWLINE_LIST}, {TK_IO_NUMBER, PIPE_SEMI_SEQUENCE}, + {TK_IO_NUMBER, CMD_SUPERIOR}, {TK_AND_IF, AND_OR}, {TK_OR_IF, AND_OR}, {TK_DSEMI, LINEBREAK}, {TK_DSEMI, COMPOUND_LIST}, + {TK_LESS, TK_IO_NUMBER}, + {TK_LESS, REDIRECT_LIST}, + {TK_LESS, CMD_SUFFIX}, + {TK_LESS, CMD_PREFIX}, + {TK_LESS, CMD_WORD}, + {TK_LESS, CMD_NAME}, + {TK_LESS, LINEBREAK}, + {TK_LESS, TK_BANG}, + {TK_LESS, SEPARATOR_OP}, + {TK_LESS, NEWLINE_LIST}, + {TK_LESS, PIPE_SEMI_SEQUENCE}, + {TK_LESS, CMD_SUPERIOR}, + {TK_GREAT, TK_IO_NUMBER}, + {TK_GREAT, REDIRECT_LIST}, + {TK_GREAT, CMD_SUFFIX}, + {TK_GREAT, CMD_PREFIX}, + {TK_GREAT, CMD_WORD}, + {TK_GREAT, CMD_NAME}, + {TK_GREAT, LINEBREAK}, + {TK_GREAT, TK_BANG}, + {TK_GREAT, SEPARATOR_OP}, + {TK_GREAT, NEWLINE_LIST}, + {TK_GREAT, PIPE_SEMI_SEQUENCE}, +//duplicate and extend + {TK_GREAT, CMD_SUPERIOR}, + {TK_DLESS, TK_IO_NUMBER}, {TK_DLESS, REDIRECT_LIST}, {TK_DLESS, CMD_SUFFIX}, @@ -45,6 +72,8 @@ t_stackmatch g_stackmatch[] = {TK_DLESS, SEPARATOR_OP}, {TK_DLESS, NEWLINE_LIST}, {TK_DLESS, PIPE_SEMI_SEQUENCE}, + {TK_DLESS, CMD_SUPERIOR}, + {TK_DLESSDASH, TK_IO_NUMBER}, {TK_DLESSDASH, REDIRECT_LIST}, {TK_DLESSDASH, CMD_SUFFIX}, @@ -56,6 +85,8 @@ t_stackmatch g_stackmatch[] = {TK_DLESSDASH, SEPARATOR_OP}, {TK_DLESSDASH, NEWLINE_LIST}, {TK_DLESSDASH, PIPE_SEMI_SEQUENCE}, + {TK_DLESSDASH, CMD_SUPERIOR}, + {TK_DGREAT, TK_IO_NUMBER}, {TK_DGREAT, REDIRECT_LIST}, {TK_DGREAT, CMD_SUFFIX}, @@ -67,6 +98,8 @@ t_stackmatch g_stackmatch[] = {TK_DGREAT, SEPARATOR_OP}, {TK_DGREAT, NEWLINE_LIST}, {TK_DGREAT, PIPE_SEMI_SEQUENCE}, + {TK_DGREAT, CMD_SUPERIOR}, + {TK_LESSAND, TK_IO_NUMBER}, {TK_LESSAND, REDIRECT_LIST}, {TK_LESSAND, CMD_SUFFIX}, @@ -78,6 +111,8 @@ t_stackmatch g_stackmatch[] = {TK_LESSAND, SEPARATOR_OP}, {TK_LESSAND, NEWLINE_LIST}, {TK_LESSAND, PIPE_SEMI_SEQUENCE}, + {TK_LESSAND, CMD_SUPERIOR}, + {TK_GREATAND, TK_IO_NUMBER}, {TK_GREATAND, REDIRECT_LIST}, {TK_GREATAND, CMD_SUFFIX}, @@ -89,6 +124,8 @@ t_stackmatch g_stackmatch[] = {TK_GREATAND, SEPARATOR_OP}, {TK_GREATAND, NEWLINE_LIST}, {TK_GREATAND, PIPE_SEMI_SEQUENCE}, + {TK_GREATAND, CMD_SUPERIOR}, + {TK_LESSGREAT, TK_IO_NUMBER}, {TK_LESSGREAT, REDIRECT_LIST}, {TK_LESSGREAT, CMD_SUFFIX}, @@ -100,6 +137,8 @@ t_stackmatch g_stackmatch[] = {TK_LESSGREAT, SEPARATOR_OP}, {TK_LESSGREAT, NEWLINE_LIST}, {TK_LESSGREAT, PIPE_SEMI_SEQUENCE}, + {TK_LESSGREAT, CMD_SUPERIOR}, + {TK_CLOBBER, TK_IO_NUMBER}, {TK_CLOBBER, REDIRECT_LIST}, {TK_CLOBBER, CMD_SUFFIX}, @@ -111,6 +150,8 @@ t_stackmatch g_stackmatch[] = {TK_CLOBBER, SEPARATOR_OP}, {TK_CLOBBER, NEWLINE_LIST}, {TK_CLOBBER, PIPE_SEMI_SEQUENCE}, + {TK_CLOBBER, CMD_SUPERIOR}, + {TK_IF, LINEBREAK}, {TK_IF, TK_BANG}, {TK_IF, SEPARATOR_OP}, @@ -168,7 +209,7 @@ t_stackmatch g_stackmatch[] = {TK_AMP, LIST}, {TK_AMP, TERM}, {TK_PIPE, PATTERN}, - {TK_PIPE, PIPE_SEQUENCE}, + {TK_PIPE, CMD_SUPERIOR}, {TK_PAREN_OPEN, FNAME}, {TK_PAREN_OPEN, CASE_LIST}, {TK_PAREN_OPEN, LINEBREAK}, @@ -197,6 +238,8 @@ t_stackmatch g_stackmatch[] = {LINEBREAK, TK_PIPE}, {LINEBREAK, LINEBREAK}, {LINEBREAK, COMPLETE_COMMANDS}, + {LINEBREAK, CMD_SUPERIOR}, + {LINEBREAK, PIPE_SEMI_SEQUENCE}, {NEWLINE_LIST, NEWLINE_LIST}, {NEWLINE_LIST, NAME}, {NEWLINE_LIST, IN}, @@ -207,6 +250,7 @@ t_stackmatch g_stackmatch[] = {HERE_END, TK_DLESS}, {HERE_END, TK_DLESSDASH}, {IO_HERE, TK_IO_NUMBER}, + {IO_HERE, CMD_SUPERIOR}, {IO_HERE, REDIRECT_LIST}, {IO_HERE, CMD_SUFFIX}, {IO_HERE, CMD_PREFIX}, @@ -225,6 +269,7 @@ t_stackmatch g_stackmatch[] = {FILENAME, TK_LESSGREAT}, {FILENAME, TK_CLOBBER}, {IO_FILE, TK_IO_NUMBER}, + {IO_FILE, CMD_SUPERIOR}, {IO_FILE, REDIRECT_LIST}, {IO_FILE, CMD_SUFFIX}, {IO_FILE, CMD_PREFIX}, @@ -236,6 +281,7 @@ t_stackmatch g_stackmatch[] = {IO_FILE, NEWLINE_LIST}, {IO_FILE, PIPE_SEMI_SEQUENCE}, {IO_REDIRECT, REDIRECT_LIST}, + {IO_REDIRECT, CMD_SUPERIOR}, {IO_REDIRECT, CMD_SUFFIX}, {IO_REDIRECT, CMD_PREFIX}, {IO_REDIRECT, CMD_WORD}, @@ -259,6 +305,14 @@ t_stackmatch g_stackmatch[] = {CMD_NAME, SEPARATOR_OP}, {CMD_NAME, NEWLINE_LIST}, {CMD_NAME, PIPE_SEMI_SEQUENCE}, + + {CMD_SUPERIOR, LINEBREAK,}, + {CMD_SUPERIOR, TK_BANG}, + {CMD_SUPERIOR, SEPARATOR_OP}, + {CMD_SUPERIOR, NEWLINE_LIST}, + {CMD_SUPERIOR, TK_PIPE}, + {CMD_SUPERIOR, PIPE_SEMI_SEQUENCE}, + {SIMPLE_COMMAND, LINEBREAK}, {SIMPLE_COMMAND, TK_BANG}, {SIMPLE_COMMAND, SEPARATOR_OP}, @@ -303,6 +357,7 @@ t_stackmatch g_stackmatch[] = {IF_CLAUSE, PIPE_SEMI_SEQUENCE}, {PATTERN, TK_PAREN_OPEN}, {PATTERN, CASE_LIST}, + {PATTERN_CASE, CASE_LIST}, {CASE_ITEM, CASE_LIST}, {CASE_ITEM, LINEBREAK}, {CASE_ITEM_NS, CASE_LIST}, diff --git a/42sh/src/parser/ft_parse.c b/42sh/src/parser/ft_parse.c index a774e88f..2ee26cc2 100644 --- a/42sh/src/parser/ft_parse.c +++ b/42sh/src/parser/ft_parse.c @@ -18,7 +18,6 @@ int ft_parse(t_btree **ast, t_list **token) t_sym *stack; t_parstate state; //to delete - t_token *content; (void)ast; state = UNDEFINED; @@ -27,14 +26,13 @@ int ft_parse(t_btree **ast, t_list **token) push_stack(stack, LINEBREAK); while (*token) { - content = (*token)->content; produce_sym(*stack, new_sym, token); DG("new sym %s", read_state(*new_sym)); if (eval_sym(*stack, *new_sym)) state = ERROR; else { - aggregate_sym(&stack, new_sym, &state, (*token)->next); + aggregate_sym(&stack, new_sym, &state); push_stack(++stack, *new_sym); } ft_putstr("\n"); @@ -46,10 +44,7 @@ int ft_parse(t_btree **ast, t_list **token) if (state == SUCCESS) ft_putstr("success"); // build_tree(token, ast); - if (*stack == TK_PIPE) - content->type = LINEBREAK; - else - ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free); + ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free); } return (0); } diff --git a/42sh/src/parser/produce_sym.c b/42sh/src/parser/produce_sym.c index 4ab45e5f..bb95c364 100644 --- a/42sh/src/parser/produce_sym.c +++ b/42sh/src/parser/produce_sym.c @@ -26,6 +26,7 @@ t_prodmatch g_prodmatch[] = {TK_N_WORD, CMD_WORD, CMD_SUFFIX}, {TK_N_WORD, CMD_NAME, CMD_SUFFIX}, {TK_N_WORD, LINEBREAK, CMD_NAME}, + {TK_N_WORD, TK_PIPE, CMD_NAME}, {TK_N_WORD, NEWLINE_LIST, CMD_NAME}, {TK_N_WORD, TK_BANG, CMD_NAME}, @@ -45,6 +46,8 @@ t_prodmatch g_prodmatch[] = {TK_NAME, TK_FOR, NAME}, {TK_NEWLINE, COMPLETE_COMMANDS, NEWLINE_LIST}, {TK_NEWLINE, LINEBREAK, NEWLINE_LIST}, + {TK_NEWLINE, CMD_SUPERIOR, LINEBREAK}, + {TK_NEWLINE, PIPE_SEMI_SEQUENCE, LINEBREAK}, {TK_SEMI, TERM, SEPARATOR_OP}, {TK_SEMI, LIST, SEPARATOR_OP}, {TK_SEMI, COMPOUND_LIST, SEPARATOR_OP}, diff --git a/42sh/src/parser/read_stack.c b/42sh/src/parser/read_stack.c index 31c9bebc..2e9ccf35 100644 --- a/42sh/src/parser/read_stack.c +++ b/42sh/src/parser/read_stack.c @@ -14,6 +14,18 @@ char *read_state(t_sym current) { + if (current == CMD_SUPERIOR) + return ("CMD_SUPERIOR"); + if (current == TK_IO_NUMBER) + return ("IO_NUMBER"); + if (current == CMD_SUFFIX) + return ("CMD_SUFFIX"); + if (current == CMD_PREFIX) + return ("CMD_PREFIX"); + if (current == IO_REDIRECT) + return ("IO_REDIRECT"); + if (current == IO_FILE) + return ("IO_FILE"); if (current == PIPE_SEMI_SEQUENCE) return ("PIPE_SEMI_SEQUENCE"); if (current == TK_PIPE) diff --git a/42sh/src/parser/superflous_sym.c b/42sh/src/parser/superflous_sym.c deleted file mode 100644 index ac7790d2..00000000 --- a/42sh/src/parser/superflous_sym.c +++ /dev/null @@ -1,20 +0,0 @@ -/* ************************************************************************** */ -/* */ -/* ::: :::::::: */ -/* superflous_sym.c :+: :+: :+: */ -/* +:+ +:+ +:+ */ -/* By: ariard +#+ +:+ +#+ */ -/* +#+#+#+#+#+ +#+ */ -/* Created: 2017/02/09 17:47:33 by ariard #+# #+# */ -/* Updated: 2017/02/09 19:25:30 by ariard ### ########.fr */ -/* */ -/* ************************************************************************** */ - -#include "parser.h" - -int superflous_sym(t_sym stack, t_sym new_sym) -{ - if (stack == new_sym) - return (1); - return (0); -}