jack/42-archive
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge branch 'master' of github.com:jzck/42sh

Browse source
This commit is contained in:
wescande 2017-03-29 15:00:42 +02:00
commit 52b25360ea
7 changed files with 78 additions and 106 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
42sh/includes/types.h
View file

@ -6,7 +6,7 @@
/* By: jhalford <jhalford@student.42.fr> +#+ +:+ +#+ */ /* By: jhalford <jhalford@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/13 17:11:48 by jhalford #+# #+# */ /* Created: 2016/12/13 17:11:48 by jhalford #+# #+# */
/* Updated: 2017/03/24 17:10:56 by ariard ### ########.fr */ /* Updated: 2017/03/29 13:59:26 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -182,8 +182,6 @@ enum e_sym
PIPE_CLOSE_SEQUENCE, PIPE_CLOSE_SEQUENCE,
CMD_SUPERIOR, CMD_SUPERIOR,
SEQUENCE, SEQUENCE,
AND_OR_MAJOR,
AND_OR_MINOR,
END_COMMAND, END_COMMAND,
CONDITION, CONDITION,
COMPLETE_CONDITION, COMPLETE_CONDITION,

8
42sh/src/completion/c_match_glob.c
View file

@ -6,7 +6,7 @@
/* By: gwojda <gwojda@student.42.fr> +#+ +:+ +#+ */ /* By: gwojda <gwojda@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/08 17:20:01 by gwojda #+# #+# */ /* Created: 2017/03/08 17:20:01 by gwojda #+# #+# */
/* Updated: 2017/03/23 00:06:08 by gwojda ### ########.fr */ /* Updated: 2017/03/29 13:47:10 by gwojda ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -55,11 +55,11 @@ static int c_glob_pos(char *str, size_t pos)
pos = data_singleton()->line.pos; pos = data_singleton()->line.pos;
if (!str) if (!str)
return (-1); return (-1);
if (pos && str[pos] == ' ') if (pos && (str[pos] == ' ' || str[pos] == ';'))
--pos; --pos;
while (pos && str[pos] != ' ') while (pos && str[pos] != ' ' && str[pos] != ';')
--pos; --pos;
if (str[pos] == ' ') if (str[pos] == ' ' || str[pos] == ';')
++pos; ++pos;
return (pos); return (pos);
} }

35
42sh/src/parser/aggregate_sym.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/11 15:58:38 by ariard #+# #+# */ /* Created: 2017/03/11 15:58:38 by ariard #+# #+# */
/* Updated: 2017/03/29 13:42:08 by ariard ### ########.fr */ /* Updated: 2017/03/29 14:30:32 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -51,12 +51,6 @@ static t_aggrematch g_aggrematch[] =
{TK_RBRACE, PIPE_CLOSE_SEQUENCE, BRACE_CLAUSE, TK_LBRACE}, {TK_RBRACE, PIPE_CLOSE_SEQUENCE, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, COMPOUND_LIST, BRACE_CLAUSE, TK_LBRACE}, {TK_RBRACE, COMPOUND_LIST, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, CMD_SUPERIOR, BRACE_CLAUSE, TK_LBRACE}, {TK_RBRACE, CMD_SUPERIOR, BRACE_CLAUSE, TK_LBRACE},
{TK_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
{TK_AND_IF, PIPE_CLOSE_SEQUENCE, AND_OR_MINOR, PIPE_CLOSE_SEQUENCE},
{TK_AND_IF, PIPE_SEMI_SEQUENCE, AND_OR_MINOR, PIPE_SEMI_SEQUENCE},
{TK_OR_IF, PIPE_SEMI_SEQUENCE, AND_OR_MINOR, PIPE_SEMI_SEQUENCE},
{TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
{TK_OR_IF, PIPE_CLOSE_SEQUENCE, AND_OR_MINOR, PIPE_CLOSE_SEQUENCE},
{SEPARATOR_OP, CMD_SUPERIOR, SEPARATOR, 0}, {SEPARATOR_OP, CMD_SUPERIOR, SEPARATOR, 0},
{SEPARATOR_OP, COMPOUND_LIST, SEPARATOR, 0}, {SEPARATOR_OP, COMPOUND_LIST, SEPARATOR, 0},
{SEPARATOR_OP, CASE_LIST_NS, SEPARATOR, 0}, {SEPARATOR_OP, CASE_LIST_NS, SEPARATOR, 0},
@ -74,7 +68,7 @@ static t_aggrematch g_aggrematch[] =
{LINEBREAK, CMD_SUPERIOR, SEPARATOR_OP, 0}, {LINEBREAK, CMD_SUPERIOR, SEPARATOR_OP, 0},
{LINEBREAK, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE}, {LINEBREAK, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{LINEBREAK, PIPE_CLOSE_SEQUENCE, PIPE_SEQUENCE, PIPE_CLOSE_SEQUENCE}, {LINEBREAK, PIPE_CLOSE_SEQUENCE, PIPE_SEQUENCE, PIPE_CLOSE_SEQUENCE},
{LINEBREAK, COMPOUND_LIST, PROGRAM, LINEBREAK}, {LINEBREAK, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
{LINEBREAK, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS}, {LINEBREAK, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{NEWLINE_LIST, CMD_NAME, CMD_SUPERIOR, CMD_NAME}, {NEWLINE_LIST, CMD_NAME, CMD_SUPERIOR, CMD_NAME},
{NEWLINE_LIST, SEQUENTIAL_SEP, SEQUENTIAL_SEP, SEQUENTIAL_SEP}, {NEWLINE_LIST, SEQUENTIAL_SEP, SEQUENTIAL_SEP, SEQUENTIAL_SEP},
@ -103,6 +97,7 @@ static t_aggrematch g_aggrematch[] =
{NEWLINE_LIST, CASE_LIST_NS, SEPARATOR, 0}, {NEWLINE_LIST, CASE_LIST_NS, SEPARATOR, 0},
{NEWLINE_LIST, COMPLETE_CONDITION, COMPLETE_CONDITION, COMPLETE_CONDITION}, {NEWLINE_LIST, COMPLETE_CONDITION, COMPLETE_CONDITION, COMPLETE_CONDITION},
{NEWLINE_LIST, CONDITION, CONDITION, CONDITION}, {NEWLINE_LIST, CONDITION, CONDITION, CONDITION},
{NEWLINE_LIST, AND_OR, AND_OR, AND_OR},
{NEWLINE_LIST, COMPLETE_COMMANDS, LINEBREAK, 0}, {NEWLINE_LIST, COMPLETE_COMMANDS, LINEBREAK, 0},
{NEWLINE_LIST, LINEBREAK, PROGRAM, LINEBREAK}, {NEWLINE_LIST, LINEBREAK, PROGRAM, LINEBREAK},
{NEWLINE_LIST, FOR_WORDLIST, SEQUENTIAL_SEP, 0}, {NEWLINE_LIST, FOR_WORDLIST, SEQUENTIAL_SEP, 0},
@ -195,7 +190,7 @@ static t_aggrematch g_aggrematch[] =
{CMD_NAME, CONDITION, CMD_SUPERIOR, 0}, {CMD_NAME, CONDITION, CMD_SUPERIOR, 0},
{CMD_NAME, TK_PIPE, CMD_SUPERIOR, 0}, {CMD_NAME, TK_PIPE, CMD_SUPERIOR, 0},
{CMD_NAME, SEQUENCE, CMD_SUPERIOR, 0}, {CMD_NAME, SEQUENCE, CMD_SUPERIOR, 0},
{CMD_NAME, AND_OR_MAJOR, CMD_SUPERIOR, 0}, {CMD_NAME, AND_OR, CMD_SUPERIOR, 0},
{CMD_SUPERIOR, SEQUENCE, PIPE_SEMI_SEQUENCE, SEQUENCE}, {CMD_SUPERIOR, SEQUENCE, PIPE_SEMI_SEQUENCE, SEQUENCE},
{SIMPLE_COMMAND, ALL, COMMAND, 0}, {SIMPLE_COMMAND, ALL, COMMAND, 0},
{DO_GROUP, NAME, FOR_CLAUSE, TK_FOR}, {DO_GROUP, NAME, FOR_CLAUSE, TK_FOR},
@ -226,16 +221,6 @@ static t_aggrematch g_aggrematch[] =
{SUBSHELL, ALL, COMPOUND_COMMAND, 0}, {SUBSHELL, ALL, COMPOUND_COMMAND, 0},
{BRACE_CLAUSE, ALL, COMPOUND_COMMAND, 0}, {BRACE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{COMPOUND_COMMAND, FUNC_NAME, COMMAND, FUNC_NAME}, {COMPOUND_COMMAND, FUNC_NAME, COMMAND, FUNC_NAME},
{AND_OR_MINOR, PIPE_SEMI_SEQUENCE, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE},
{AND_OR_MINOR, PIPE_CLOSE_SEQUENCE, AND_OR_MAJOR, PIPE_CLOSE_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, CMD_SUPERIOR, AND_OR_MAJOR, 0},
{AND_OR_MINOR, COMPOUND_LIST, AND_OR_MAJOR, 0},
{AND_OR_MINOR, COMPLETE_COMMANDS, AND_OR_MAJOR, 0},
{AND_OR_MINOR, AND_OR_MAJOR, AND_OR_MAJOR, 0},
{AND_OR_MINOR, TK_BANG, AND_OR_MAJOR, TK_BANG},
{COMMAND, SEQUENCE, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, SEQUENCE, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, COMPOUND_LIST, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, COMPOUND_LIST, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, CASE_LIST_NS, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, CASE_LIST_NS, PIPE_SEMI_SEQUENCE, 0},
@ -255,7 +240,7 @@ static t_aggrematch g_aggrematch[] =
{COMMAND, TK_PAREN_OPEN, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, TK_PAREN_OPEN, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_LBRACE, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, TK_LBRACE, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, COMPLETE_COMMANDS, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, COMPLETE_COMMANDS, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, AND_OR, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, COMPLETE_CONDITION, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, COMPLETE_CONDITION, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, CONDITION, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, CONDITION, PIPE_SEMI_SEQUENCE, 0},
{COMPOUND_COMMAND, SEQUENCE, PIPE_CLOSE_SEQUENCE, 0}, {COMPOUND_COMMAND, SEQUENCE, PIPE_CLOSE_SEQUENCE, 0},
@ -277,12 +262,11 @@ static t_aggrematch g_aggrematch[] =
{COMPOUND_COMMAND, TK_PAREN_OPEN, PIPE_CLOSE_SEQUENCE, 0}, {COMPOUND_COMMAND, TK_PAREN_OPEN, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_LBRACE, PIPE_CLOSE_SEQUENCE, 0}, {COMPOUND_COMMAND, TK_LBRACE, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, COMPLETE_COMMANDS, PIPE_CLOSE_SEQUENCE, 0}, {COMPOUND_COMMAND, COMPLETE_COMMANDS, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, AND_OR_MAJOR, PIPE_CLOSE_SEQUENCE, 0}, {COMPOUND_COMMAND, AND_OR, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, COMPLETE_CONDITION, PIPE_CLOSE_SEQUENCE, 0}, {COMPOUND_COMMAND, COMPLETE_CONDITION, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, CONDITION, PIPE_CLOSE_SEQUENCE, 0}, {COMPOUND_COMMAND, CONDITION, PIPE_CLOSE_SEQUENCE, 0},
{END_COMMAND, SEQUENCE, PIPE_SEQUENCE, SEQUENCE}, {END_COMMAND, SEQUENCE, PIPE_SEQUENCE, SEQUENCE},
{END_COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE}, {END_COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{END_COMMAND, AND_OR_MAJOR, COMPOUND_LIST, AND_OR_MAJOR},
{END_COMMAND, TK_WHILE, PIPE_SEQUENCE, 0}, {END_COMMAND, TK_WHILE, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_WHILE, PIPE_SEQUENCE, 0}, {END_COMMAND, TK_WHILE, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_UNTIL, PIPE_SEQUENCE, 0}, {END_COMMAND, TK_UNTIL, PIPE_SEQUENCE, 0},
@ -301,6 +285,7 @@ static t_aggrematch g_aggrematch[] =
{END_COMMAND, CONDITION, PIPE_SEQUENCE, 0}, {END_COMMAND, CONDITION, PIPE_SEQUENCE, 0},
{END_COMMAND, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST}, {END_COMMAND, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
{END_COMMAND, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS}, {END_COMMAND, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{END_COMMAND, AND_OR, COMPLETE_COMMANDS, 0},
{PIPE_SEMI_SEQUENCE, SEQUENCE, PIPE_SEMI_SEQUENCE, SEQUENCE}, {PIPE_SEMI_SEQUENCE, SEQUENCE, PIPE_SEMI_SEQUENCE, SEQUENCE},
{PIPE_CLOSE_SEQUENCE, SEQUENCE, PIPE_CLOSE_SEQUENCE, SEQUENCE}, {PIPE_CLOSE_SEQUENCE, SEQUENCE, PIPE_CLOSE_SEQUENCE, SEQUENCE},
{PIPE_SEQUENCE, TK_WHILE, PIPELINE, 0}, {PIPE_SEQUENCE, TK_WHILE, PIPELINE, 0},
@ -312,7 +297,7 @@ static t_aggrematch g_aggrematch[] =
{PIPE_SEQUENCE, TK_PAREN_OPEN, PIPELINE, 0}, {PIPE_SEQUENCE, TK_PAREN_OPEN, PIPELINE, 0},
{PIPE_SEQUENCE, TK_LBRACE, PIPELINE, 0}, {PIPE_SEQUENCE, TK_LBRACE, PIPELINE, 0},
{PIPE_SEQUENCE, COMPLETE_COMMANDS, PIPELINE, 0}, {PIPE_SEQUENCE, COMPLETE_COMMANDS, PIPELINE, 0},
{PIPE_SEQUENCE, AND_OR_MAJOR, PIPELINE, 0}, {PIPE_SEQUENCE, AND_OR, PIPELINE, 0},
{PIPE_SEQUENCE, TK_DO, PIPELINE, 0}, {PIPE_SEQUENCE, TK_DO, PIPELINE, 0},
{PIPE_SEQUENCE, TK_PAREN_CLOSE, PIPELINE, 0}, {PIPE_SEQUENCE, TK_PAREN_CLOSE, PIPELINE, 0},
{PIPE_SEQUENCE, TK_IF, PIPELINE, 0}, {PIPE_SEQUENCE, TK_IF, PIPELINE, 0},
@ -342,8 +327,8 @@ static t_aggrematch g_aggrematch[] =
{PIPELINE, SEPARATOR_OP, AND_OR, 0}, {PIPELINE, SEPARATOR_OP, AND_OR, 0},
{PIPELINE, COMPLETE_CONDITION, AND_OR, 0}, {PIPELINE, COMPLETE_CONDITION, AND_OR, 0},
{PIPELINE, CONDITION, AND_OR, 0}, {PIPELINE, CONDITION, AND_OR, 0},
{PIPELINE, AND_OR_MAJOR, AND_OR, AND_OR_MAJOR}, {PIPELINE, AND_OR, AND_OR, AND_OR},
{AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR}, {AND_OR, AND_OR, AND_OR, AND_OR},
{AND_OR, TK_DO, COMPOUND_LIST, 0}, {AND_OR, TK_DO, COMPOUND_LIST, 0},
{AND_OR, TK_PAREN_CLOSE, COMPOUND_LIST, 0}, {AND_OR, TK_PAREN_CLOSE, COMPOUND_LIST, 0},
{AND_OR, TK_WHILE, COMPOUND_LIST, 0}, {AND_OR, TK_WHILE, COMPOUND_LIST, 0},

118
42sh/src/parser/eval_sym.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/11 16:11:21 by ariard #+# #+# */ /* Created: 2017/03/11 16:11:21 by ariard #+# #+# */
/* Updated: 2017/03/29 13:42:14 by ariard ### ########.fr */ /* Updated: 2017/03/29 14:32:14 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -16,6 +16,7 @@ static t_stackmatch g_stackmatch[] =
{ {
{TK_WORD, CMD_SUFFIX}, {TK_WORD, CMD_SUFFIX},
{TK_WORD, TK_PIPE}, {TK_WORD, TK_PIPE},
{TK_WORD, AND_OR},
{TK_WORD, TK_CASE}, {TK_WORD, TK_CASE},
{TK_WORD, WORDLIST}, {TK_WORD, WORDLIST},
{TK_WORD, LINEBREAK}, {TK_WORD, LINEBREAK},
@ -37,12 +38,12 @@ static t_stackmatch g_stackmatch[] =
{TK_IO_NUMBER, TK_LBRACE}, {TK_IO_NUMBER, TK_LBRACE},
{TK_IO_NUMBER, COMPLETE_COMMANDS}, {TK_IO_NUMBER, COMPLETE_COMMANDS},
{TK_IO_NUMBER, SEPARATOR_OP}, {TK_IO_NUMBER, SEPARATOR_OP},
{TK_IO_NUMBER, AND_OR},
{TK_IO_NUMBER, NEWLINE_LIST}, {TK_IO_NUMBER, NEWLINE_LIST},
{TK_IO_NUMBER, PIPE_SEMI_SEQUENCE}, {TK_IO_NUMBER, PIPE_SEMI_SEQUENCE},
{TK_IO_NUMBER, PIPE_CLOSE_SEQUENCE}, {TK_IO_NUMBER, PIPE_CLOSE_SEQUENCE},
{TK_IO_NUMBER, SEQUENCE}, {TK_IO_NUMBER, SEQUENCE},
{TK_IO_NUMBER, CMD_SUPERIOR}, {TK_IO_NUMBER, CMD_SUPERIOR},
{TK_IO_NUMBER, AND_OR_MAJOR},
{TK_IO_NUMBER, TK_WHILE}, {TK_IO_NUMBER, TK_WHILE},
{TK_IO_NUMBER, TK_UNTIL}, {TK_IO_NUMBER, TK_UNTIL},
{TK_IO_NUMBER, TK_IF}, {TK_IO_NUMBER, TK_IF},
@ -83,12 +84,12 @@ static t_stackmatch g_stackmatch[] =
{TK_LESS, COMPLETE_COMMANDS}, {TK_LESS, COMPLETE_COMMANDS},
{TK_LESS, TK_BANG}, {TK_LESS, TK_BANG},
{TK_LESS, SEPARATOR_OP}, {TK_LESS, SEPARATOR_OP},
{TK_LESS, AND_OR},
{TK_LESS, NEWLINE_LIST}, {TK_LESS, NEWLINE_LIST},
{TK_LESS, PIPE_SEMI_SEQUENCE}, {TK_LESS, PIPE_SEMI_SEQUENCE},
{TK_LESS, PIPE_CLOSE_SEQUENCE}, {TK_LESS, PIPE_CLOSE_SEQUENCE},
{TK_LESS, SEQUENCE}, {TK_LESS, SEQUENCE},
{TK_LESS, CMD_SUPERIOR}, {TK_LESS, CMD_SUPERIOR},
{TK_LESS, AND_OR_MAJOR},
{TK_LESS, TK_WHILE}, {TK_LESS, TK_WHILE},
{TK_LESS, TK_UNTIL}, {TK_LESS, TK_UNTIL},
{TK_LESS, TK_IF}, {TK_LESS, TK_IF},
@ -100,7 +101,6 @@ static t_stackmatch g_stackmatch[] =
{TK_LESS, CONDITION}, {TK_LESS, CONDITION},
{TK_LESS, COMPOUND_LIST}, {TK_LESS, COMPOUND_LIST},
{TK_LESS, CMD_SUPERIOR}, {TK_LESS, CMD_SUPERIOR},
{TK_LESS, AND_OR_MAJOR},
{TK_GREAT, TK_IO_NUMBER}, {TK_GREAT, TK_IO_NUMBER},
{TK_GREAT, REDIRECT_LIST}, {TK_GREAT, REDIRECT_LIST},
{TK_GREAT, CMD_SUFFIX}, {TK_GREAT, CMD_SUFFIX},
@ -113,12 +113,12 @@ static t_stackmatch g_stackmatch[] =
{TK_GREAT, TK_LBRACE}, {TK_GREAT, TK_LBRACE},
{TK_GREAT, COMPLETE_COMMANDS}, {TK_GREAT, COMPLETE_COMMANDS},
{TK_GREAT, SEPARATOR_OP}, {TK_GREAT, SEPARATOR_OP},
{TK_GREAT, AND_OR},
{TK_GREAT, NEWLINE_LIST}, {TK_GREAT, NEWLINE_LIST},
{TK_GREAT, PIPE_SEMI_SEQUENCE}, {TK_GREAT, PIPE_SEMI_SEQUENCE},
{TK_GREAT, PIPE_CLOSE_SEQUENCE}, {TK_GREAT, PIPE_CLOSE_SEQUENCE},
{TK_GREAT, SEQUENCE}, {TK_GREAT, SEQUENCE},
{TK_GREAT, CMD_SUPERIOR}, {TK_GREAT, CMD_SUPERIOR},
{TK_GREAT, AND_OR_MAJOR},
{TK_GREAT, TK_WHILE}, {TK_GREAT, TK_WHILE},
{TK_GREAT, TK_UNTIL}, {TK_GREAT, TK_UNTIL},
{TK_GREAT, TK_IF}, {TK_GREAT, TK_IF},
@ -130,7 +130,6 @@ static t_stackmatch g_stackmatch[] =
{TK_GREAT, CONDITION}, {TK_GREAT, CONDITION},
{TK_GREAT, COMPOUND_LIST}, {TK_GREAT, COMPOUND_LIST},
{TK_GREAT, CMD_SUPERIOR}, {TK_GREAT, CMD_SUPERIOR},
{TK_GREAT, AND_OR_MAJOR},
{TK_DLESS, TK_IO_NUMBER}, {TK_DLESS, TK_IO_NUMBER},
{TK_DLESS, REDIRECT_LIST}, {TK_DLESS, REDIRECT_LIST},
{TK_DLESS, CMD_SUFFIX}, {TK_DLESS, CMD_SUFFIX},
@ -143,12 +142,12 @@ static t_stackmatch g_stackmatch[] =
{TK_DLESS, COMPLETE_COMMANDS}, {TK_DLESS, COMPLETE_COMMANDS},
{TK_DLESS, TK_BANG}, {TK_DLESS, TK_BANG},
{TK_DLESS, SEPARATOR_OP}, {TK_DLESS, SEPARATOR_OP},
{TK_DLESS, AND_OR},
{TK_DLESS, NEWLINE_LIST}, {TK_DLESS, NEWLINE_LIST},
{TK_DLESS, PIPE_SEMI_SEQUENCE}, {TK_DLESS, PIPE_SEMI_SEQUENCE},
{TK_DLESS, PIPE_CLOSE_SEQUENCE}, {TK_DLESS, PIPE_CLOSE_SEQUENCE},
{TK_DLESS, SEQUENCE}, {TK_DLESS, SEQUENCE},
{TK_DLESS, CMD_SUPERIOR}, {TK_DLESS, CMD_SUPERIOR},
{TK_DLESS, AND_OR_MAJOR},
{TK_DLESS, TK_WHILE}, {TK_DLESS, TK_WHILE},
{TK_DLESS, TK_UNTIL}, {TK_DLESS, TK_UNTIL},
{TK_DLESS, TK_IF}, {TK_DLESS, TK_IF},
@ -160,7 +159,6 @@ static t_stackmatch g_stackmatch[] =
{TK_DLESS, CONDITION}, {TK_DLESS, CONDITION},
{TK_DLESS, COMPOUND_LIST}, {TK_DLESS, COMPOUND_LIST},
{TK_DLESS, CMD_SUPERIOR}, {TK_DLESS, CMD_SUPERIOR},
{TK_DLESS, AND_OR_MAJOR},
{TK_DGREAT, TK_IO_NUMBER}, {TK_DGREAT, TK_IO_NUMBER},
{TK_DGREAT, REDIRECT_LIST}, {TK_DGREAT, REDIRECT_LIST},
{TK_DGREAT, CMD_SUFFIX}, {TK_DGREAT, CMD_SUFFIX},
@ -173,12 +171,12 @@ static t_stackmatch g_stackmatch[] =
{TK_DGREAT, TK_LBRACE}, {TK_DGREAT, TK_LBRACE},
{TK_DGREAT, COMPLETE_COMMANDS}, {TK_DGREAT, COMPLETE_COMMANDS},
{TK_DGREAT, SEPARATOR_OP}, {TK_DGREAT, SEPARATOR_OP},
{TK_DGREAT, AND_OR},
{TK_DGREAT, NEWLINE_LIST}, {TK_DGREAT, NEWLINE_LIST},
{TK_DGREAT, PIPE_SEMI_SEQUENCE}, {TK_DGREAT, PIPE_SEMI_SEQUENCE},
{TK_DGREAT, PIPE_CLOSE_SEQUENCE}, {TK_DGREAT, PIPE_CLOSE_SEQUENCE},
{TK_DGREAT, SEQUENCE}, {TK_DGREAT, SEQUENCE},
{TK_DGREAT, CMD_SUPERIOR}, {TK_DGREAT, CMD_SUPERIOR},
{TK_DGREAT, AND_OR_MAJOR},
{TK_DGREAT, TK_WHILE}, {TK_DGREAT, TK_WHILE},
{TK_DGREAT, TK_UNTIL}, {TK_DGREAT, TK_UNTIL},
{TK_DGREAT, TK_IF}, {TK_DGREAT, TK_IF},
@ -190,7 +188,6 @@ static t_stackmatch g_stackmatch[] =
{TK_DGREAT, CONDITION}, {TK_DGREAT, CONDITION},
{TK_DGREAT, COMPOUND_LIST}, {TK_DGREAT, COMPOUND_LIST},
{TK_DGREAT, CMD_SUPERIOR}, {TK_DGREAT, CMD_SUPERIOR},
{TK_DGREAT, AND_OR_MAJOR},
{TK_LESSAND, TK_IO_NUMBER}, {TK_LESSAND, TK_IO_NUMBER},
{TK_LESSAND, REDIRECT_LIST}, {TK_LESSAND, REDIRECT_LIST},
{TK_LESSAND, CMD_SUFFIX}, {TK_LESSAND, CMD_SUFFIX},
@ -203,12 +200,12 @@ static t_stackmatch g_stackmatch[] =
{TK_LESSAND, TK_LBRACE}, {TK_LESSAND, TK_LBRACE},
{TK_LESSAND, COMPLETE_COMMANDS}, {TK_LESSAND, COMPLETE_COMMANDS},
{TK_LESSAND, SEPARATOR_OP}, {TK_LESSAND, SEPARATOR_OP},
{TK_LESSAND, AND_OR},
{TK_LESSAND, NEWLINE_LIST}, {TK_LESSAND, NEWLINE_LIST},
{TK_LESSAND, PIPE_SEMI_SEQUENCE}, {TK_LESSAND, PIPE_SEMI_SEQUENCE},
{TK_LESSAND, PIPE_CLOSE_SEQUENCE}, {TK_LESSAND, PIPE_CLOSE_SEQUENCE},
{TK_LESSAND, SEQUENCE}, {TK_LESSAND, SEQUENCE},
{TK_LESSAND, CMD_SUPERIOR}, {TK_LESSAND, CMD_SUPERIOR},
{TK_LESSAND, AND_OR_MAJOR},
{TK_LESSAND, TK_WHILE}, {TK_LESSAND, TK_WHILE},
{TK_LESSAND, TK_UNTIL}, {TK_LESSAND, TK_UNTIL},
{TK_LESSAND, TK_IF}, {TK_LESSAND, TK_IF},
@ -220,7 +217,6 @@ static t_stackmatch g_stackmatch[] =
{TK_LESSAND, CONDITION}, {TK_LESSAND, CONDITION},
{TK_LESSAND, COMPOUND_LIST}, {TK_LESSAND, COMPOUND_LIST},
{TK_LESSAND, CMD_SUPERIOR}, {TK_LESSAND, CMD_SUPERIOR},
{TK_LESSAND, AND_OR_MAJOR},
{TK_GREATAND, TK_IO_NUMBER}, {TK_GREATAND, TK_IO_NUMBER},
{TK_GREATAND, REDIRECT_LIST}, {TK_GREATAND, REDIRECT_LIST},
{TK_GREATAND, CMD_SUFFIX}, {TK_GREATAND, CMD_SUFFIX},
@ -233,12 +229,12 @@ static t_stackmatch g_stackmatch[] =
{TK_GREATAND, TK_LBRACE}, {TK_GREATAND, TK_LBRACE},
{TK_GREATAND, COMPLETE_COMMANDS}, {TK_GREATAND, COMPLETE_COMMANDS},
{TK_GREATAND, SEPARATOR_OP}, {TK_GREATAND, SEPARATOR_OP},
{TK_GREATAND, AND_OR},
{TK_GREATAND, NEWLINE_LIST}, {TK_GREATAND, NEWLINE_LIST},
{TK_GREATAND, PIPE_SEMI_SEQUENCE}, {TK_GREATAND, PIPE_SEMI_SEQUENCE},
{TK_GREATAND, PIPE_CLOSE_SEQUENCE}, {TK_GREATAND, PIPE_CLOSE_SEQUENCE},
{TK_GREATAND, SEQUENCE}, {TK_GREATAND, SEQUENCE},
{TK_GREATAND, CMD_SUPERIOR}, {TK_GREATAND, CMD_SUPERIOR},
{TK_GREATAND, AND_OR_MAJOR},
{TK_GREATAND, TK_WHILE}, {TK_GREATAND, TK_WHILE},
{TK_GREATAND, TK_UNTIL}, {TK_GREATAND, TK_UNTIL},
{TK_GREATAND, TK_IF}, {TK_GREATAND, TK_IF},
@ -250,7 +246,6 @@ static t_stackmatch g_stackmatch[] =
{TK_GREATAND, CONDITION}, {TK_GREATAND, CONDITION},
{TK_GREATAND, COMPOUND_LIST}, {TK_GREATAND, COMPOUND_LIST},
{TK_GREATAND, CMD_SUPERIOR}, {TK_GREATAND, CMD_SUPERIOR},
{TK_GREATAND, AND_OR_MAJOR},
{TK_IF, LINEBREAK}, {TK_IF, LINEBREAK},
{TK_IF, TK_BANG}, {TK_IF, TK_BANG},
{TK_IF, TK_PAREN_OPEN}, {TK_IF, TK_PAREN_OPEN},
@ -258,6 +253,7 @@ static t_stackmatch g_stackmatch[] =
{TK_IF, FUNC_NAME}, {TK_IF, FUNC_NAME},
{TK_IF, COMPLETE_COMMANDS}, {TK_IF, COMPLETE_COMMANDS},
{TK_IF, SEPARATOR_OP}, {TK_IF, SEPARATOR_OP},
{TK_IF, AND_OR},
{TK_IF, NEWLINE_LIST}, {TK_IF, NEWLINE_LIST},
{TK_IF, SEQUENCE}, {TK_IF, SEQUENCE},
{TK_IF, TK_WHILE}, {TK_IF, TK_WHILE},
@ -315,6 +311,7 @@ static t_stackmatch g_stackmatch[] =
{TK_CASE, COMPOUND_LIST}, {TK_CASE, COMPOUND_LIST},
{TK_CASE, NEWLINE_LIST}, {TK_CASE, NEWLINE_LIST},
{TK_CASE, SEPARATOR_OP}, {TK_CASE, SEPARATOR_OP},
{TK_CASE, AND_OR},
{TK_CASE, SEQUENCE}, {TK_CASE, SEQUENCE},
{TK_IN, TK_WORD}, {TK_IN, TK_WORD},
{TK_IN, NAME}, {TK_IN, NAME},
@ -328,6 +325,7 @@ static t_stackmatch g_stackmatch[] =
{TK_WHILE, COMPLETE_COMMANDS}, {TK_WHILE, COMPLETE_COMMANDS},
{TK_WHILE, TK_BANG}, {TK_WHILE, TK_BANG},
{TK_WHILE, SEPARATOR_OP}, {TK_WHILE, SEPARATOR_OP},
{TK_WHILE, AND_OR},
{TK_WHILE, NEWLINE_LIST}, {TK_WHILE, NEWLINE_LIST},
{TK_WHILE, SEQUENCE}, {TK_WHILE, SEQUENCE},
{TK_WHILE, TK_DO}, {TK_WHILE, TK_DO},
@ -350,6 +348,7 @@ static t_stackmatch g_stackmatch[] =
{TK_UNTIL, COMPLETE_COMMANDS}, {TK_UNTIL, COMPLETE_COMMANDS},
{TK_UNTIL, TK_BANG}, {TK_UNTIL, TK_BANG},
{TK_UNTIL, SEPARATOR_OP}, {TK_UNTIL, SEPARATOR_OP},
{TK_UNTIL, AND_OR},
{TK_UNTIL, NEWLINE_LIST}, {TK_UNTIL, NEWLINE_LIST},
{TK_UNTIL, SEQUENCE}, {TK_UNTIL, SEQUENCE},
{TK_UNTIL, TK_DO}, {TK_UNTIL, TK_DO},
@ -372,6 +371,7 @@ static t_stackmatch g_stackmatch[] =
{FUNC_NAME, FUNC_NAME}, {FUNC_NAME, FUNC_NAME},
{FUNC_NAME, COMPLETE_COMMANDS}, {FUNC_NAME, COMPLETE_COMMANDS},
{FUNC_NAME, SEPARATOR_OP}, {FUNC_NAME, SEPARATOR_OP},
{FUNC_NAME, AND_OR},
{FUNC_NAME, NEWLINE_LIST}, {FUNC_NAME, NEWLINE_LIST},
{FUNC_NAME, SEQUENCE}, {FUNC_NAME, SEQUENCE},
{FUNC_NAME, TK_WHILE}, {FUNC_NAME, TK_WHILE},
@ -394,6 +394,7 @@ static t_stackmatch g_stackmatch[] =
{TK_FOR, FUNC_NAME}, {TK_FOR, FUNC_NAME},
{TK_FOR, COMPLETE_COMMANDS}, {TK_FOR, COMPLETE_COMMANDS},
{TK_FOR, SEPARATOR_OP}, {TK_FOR, SEPARATOR_OP},
{TK_FOR, AND_OR},
{TK_FOR, NEWLINE_LIST}, {TK_FOR, NEWLINE_LIST},
{TK_FOR, SEQUENCE}, {TK_FOR, SEQUENCE},
{TK_FOR, TK_DO}, {TK_FOR, TK_DO},
@ -415,9 +416,9 @@ static t_stackmatch g_stackmatch[] =
{TK_LBRACE, TK_LBRACE}, {TK_LBRACE, TK_LBRACE},
{TK_LBRACE, TK_PAREN_OPEN}, {TK_LBRACE, TK_PAREN_OPEN},
{TK_LBRACE, SEPARATOR_OP}, {TK_LBRACE, SEPARATOR_OP},
{TK_LBRACE, AND_OR},
{TK_LBRACE, NEWLINE_LIST}, {TK_LBRACE, NEWLINE_LIST},
{TK_LBRACE, SEQUENCE}, {TK_LBRACE, SEQUENCE},
{TK_LBRACE, AND_OR_MAJOR},
{TK_LBRACE, TK_WHILE}, {TK_LBRACE, TK_WHILE},
{TK_LBRACE, FUNC_NAME}, {TK_LBRACE, FUNC_NAME},
{TK_LBRACE, TK_UNTIL}, {TK_LBRACE, TK_UNTIL},
@ -433,9 +434,11 @@ static t_stackmatch g_stackmatch[] =
{TK_LBRACE, CONDITION}, {TK_LBRACE, CONDITION},
{TK_LBRACE, TK_IN}, {TK_LBRACE, TK_IN},
{TK_LBRACE, TK_PIPE}, {TK_LBRACE, TK_PIPE},
{TK_LBRACE, AND_OR},
{TK_RBRACE, TK_SEMI}, {TK_RBRACE, TK_SEMI},
{TK_RBRACE, END_COMMAND}, {TK_RBRACE, END_COMMAND},
{TK_RBRACE, SEPARATOR_OP}, {TK_RBRACE, SEPARATOR_OP},
{TK_RBRACE, AND_OR},
{TK_RBRACE, WORD}, {TK_RBRACE, WORD},
{TK_RBRACE, IN}, {TK_RBRACE, IN},
{TK_RBRACE, TK_AND_IF}, {TK_RBRACE, TK_AND_IF},
@ -458,6 +461,7 @@ static t_stackmatch g_stackmatch[] =
{TK_BANG, TK_LBRACE}, {TK_BANG, TK_LBRACE},
{TK_BANG, COMPLETE_COMMANDS}, {TK_BANG, COMPLETE_COMMANDS},
{TK_BANG, SEPARATOR_OP}, {TK_BANG, SEPARATOR_OP},
{TK_BANG, AND_OR},
{TK_BANG, NEWLINE_LIST}, {TK_BANG, NEWLINE_LIST},
{TK_IN, LINEBREAK}, {TK_IN, LINEBREAK},
{TK_SEMI, NAME}, {TK_SEMI, NAME},
@ -481,10 +485,10 @@ static t_stackmatch g_stackmatch[] =
{TK_PAREN_OPEN, TK_BANG}, {TK_PAREN_OPEN, TK_BANG},
{TK_PAREN_OPEN, TK_PAREN_OPEN}, {TK_PAREN_OPEN, TK_PAREN_OPEN},
{TK_PAREN_OPEN, SEPARATOR_OP}, {TK_PAREN_OPEN, SEPARATOR_OP},
{TK_PAREN_OPEN, AND_OR},
{TK_PAREN_OPEN, NEWLINE_LIST}, {TK_PAREN_OPEN, NEWLINE_LIST},
{TK_PAREN_OPEN, SEQUENCE}, {TK_PAREN_OPEN, SEQUENCE},
{TK_PAREN_OPEN, FUNC_NAME}, {TK_PAREN_OPEN, FUNC_NAME},
{TK_PAREN_OPEN, AND_OR_MAJOR},
{TK_PAREN_OPEN, TK_WHILE}, {TK_PAREN_OPEN, TK_WHILE},
{TK_PAREN_OPEN, TK_LBRACE}, {TK_PAREN_OPEN, TK_LBRACE},
{TK_PAREN_OPEN, FUNC_NAME}, {TK_PAREN_OPEN, FUNC_NAME},
@ -508,7 +512,6 @@ static t_stackmatch g_stackmatch[] =
{SEQUENTIAL_SEP, FOR_WORDLIST}, {SEQUENTIAL_SEP, FOR_WORDLIST},
{END_COMMAND, SEQUENCE}, {END_COMMAND, SEQUENCE},
{END_COMMAND, PIPE_SEMI_SEQUENCE}, {END_COMMAND, PIPE_SEMI_SEQUENCE},
{END_COMMAND, AND_OR_MAJOR},
{END_COMMAND, TK_WHILE}, {END_COMMAND, TK_WHILE},
{END_COMMAND, FUNC_NAME}, {END_COMMAND, FUNC_NAME},
{END_COMMAND, TK_UNTIL}, {END_COMMAND, TK_UNTIL},
@ -527,6 +530,7 @@ static t_stackmatch g_stackmatch[] =
{END_COMMAND, CASE_LIST_NS}, {END_COMMAND, CASE_LIST_NS},
{END_COMMAND, COMPLETE_CONDITION}, {END_COMMAND, COMPLETE_CONDITION},
{END_COMMAND, CONDITION}, {END_COMMAND, CONDITION},
{END_COMMAND, AND_OR},
{SEPARATOR, CMD_SUPERIOR}, {SEPARATOR, CMD_SUPERIOR},
{SEPARATOR, TERM}, {SEPARATOR, TERM},
{SEPARATOR, COMPOUND_LIST}, {SEPARATOR, COMPOUND_LIST},
@ -535,7 +539,6 @@ static t_stackmatch g_stackmatch[] =
{SEPARATOR, PIPE_CLOSE_SEQUENCE}, {SEPARATOR, PIPE_CLOSE_SEQUENCE},
{SEPARATOR_OP, CMD_SUPERIOR}, {SEPARATOR_OP, CMD_SUPERIOR},
{SEPARATOR_OP, LIST}, {SEPARATOR_OP, LIST},
{SEPARATOR_OP, TERM},
{SEPARATOR_OP, CASE_LIST_NS}, {SEPARATOR_OP, CASE_LIST_NS},
{SEPARATOR_OP, COMPOUND_LIST}, {SEPARATOR_OP, COMPOUND_LIST},
{SEPARATOR_OP, PIPE_SEMI_SEQUENCE}, {SEPARATOR_OP, PIPE_SEMI_SEQUENCE},
@ -543,12 +546,12 @@ static t_stackmatch g_stackmatch[] =
{LINEBREAK, TK_SEMI}, {LINEBREAK, TK_SEMI},
{LINEBREAK, END_COMMAND}, {LINEBREAK, END_COMMAND},
{LINEBREAK, SEPARATOR_OP}, {LINEBREAK, SEPARATOR_OP},
{LINEBREAK, AND_OR},
{LINEBREAK, TK_PAREN_CLOSE}, {LINEBREAK, TK_PAREN_CLOSE},
{LINEBREAK, WORD}, {LINEBREAK, WORD},
{LINEBREAK, IN}, {LINEBREAK, IN},
{LINEBREAK, TK_AND_IF},
{LINEBREAK, TK_OR_IF},
{LINEBREAK, TK_PIPE}, {LINEBREAK, TK_PIPE},
{LINEBREAK, AND_OR},
{LINEBREAK, LINEBREAK}, {LINEBREAK, LINEBREAK},
{LINEBREAK, TK_BANG}, {LINEBREAK, TK_BANG},
{LINEBREAK, COMPLETE_COMMANDS}, {LINEBREAK, COMPLETE_COMMANDS},
@ -563,6 +566,7 @@ static t_stackmatch g_stackmatch[] =
{TK_PAREN_CLOSE, TK_SEMI}, {TK_PAREN_CLOSE, TK_SEMI},
{TK_PAREN_CLOSE, END_COMMAND}, {TK_PAREN_CLOSE, END_COMMAND},
{TK_PAREN_CLOSE, SEPARATOR_OP}, {TK_PAREN_CLOSE, SEPARATOR_OP},
{TK_PAREN_CLOSE, AND_OR},
{TK_PAREN_CLOSE, WORD}, {TK_PAREN_CLOSE, WORD},
{TK_PAREN_CLOSE, IN}, {TK_PAREN_CLOSE, IN},
{TK_PAREN_CLOSE, TK_PIPE}, {TK_PAREN_CLOSE, TK_PIPE},
@ -582,6 +586,7 @@ static t_stackmatch g_stackmatch[] =
{TK_RBRACE, TK_SEMI}, {TK_RBRACE, TK_SEMI},
{TK_RBRACE, END_COMMAND}, {TK_RBRACE, END_COMMAND},
{TK_RBRACE, SEPARATOR_OP}, {TK_RBRACE, SEPARATOR_OP},
{TK_RBRACE, AND_OR},
{TK_RBRACE, WORD}, {TK_RBRACE, WORD},
{TK_RBRACE, IN}, {TK_RBRACE, IN},
{TK_RBRACE, TK_PIPE}, {TK_RBRACE, TK_PIPE},
@ -614,6 +619,7 @@ static t_stackmatch g_stackmatch[] =
{NEWLINE_LIST, TK_ELSE}, {NEWLINE_LIST, TK_ELSE},
{NEWLINE_LIST, CMD_NAME}, {NEWLINE_LIST, CMD_NAME},
{NEWLINE_LIST, NEWLINE_LIST}, {NEWLINE_LIST, NEWLINE_LIST},
{NEWLINE_LIST, AND_OR},
{NEWLINE_LIST, NAME}, {NEWLINE_LIST, NAME},
{NEWLINE_LIST, IN}, {NEWLINE_LIST, IN},
{NEWLINE_LIST, WORDLIST}, {NEWLINE_LIST, WORDLIST},
@ -645,12 +651,12 @@ static t_stackmatch g_stackmatch[] =
{IO_HERE, TK_LBRACE}, {IO_HERE, TK_LBRACE},
{IO_HERE, COMPLETE_COMMANDS}, {IO_HERE, COMPLETE_COMMANDS},
{IO_HERE, SEPARATOR_OP}, {IO_HERE, SEPARATOR_OP},
{IO_HERE, AND_OR},
{IO_HERE, NEWLINE_LIST}, {IO_HERE, NEWLINE_LIST},
{IO_HERE, PIPE_SEMI_SEQUENCE}, {IO_HERE, PIPE_SEMI_SEQUENCE},
{IO_HERE, PIPE_CLOSE_SEQUENCE}, {IO_HERE, PIPE_CLOSE_SEQUENCE},
{IO_HERE, SEQUENCE}, {IO_HERE, SEQUENCE},
{IO_HERE, CMD_SUPERIOR}, {IO_HERE, CMD_SUPERIOR},
{IO_HERE, AND_OR_MAJOR},
{IO_HERE, TK_WHILE}, {IO_HERE, TK_WHILE},
{IO_HERE, TK_UNTIL}, {IO_HERE, TK_UNTIL},
{IO_HERE, TK_IF}, {IO_HERE, TK_IF},
@ -679,12 +685,12 @@ static t_stackmatch g_stackmatch[] =
{IO_FILE, TK_BANG}, {IO_FILE, TK_BANG},
{IO_FILE, COMPLETE_COMMANDS}, {IO_FILE, COMPLETE_COMMANDS},
{IO_FILE, SEPARATOR_OP}, {IO_FILE, SEPARATOR_OP},
{IO_FILE, AND_OR},
{IO_FILE, NEWLINE_LIST}, {IO_FILE, NEWLINE_LIST},
{IO_FILE, PIPE_SEMI_SEQUENCE}, {IO_FILE, PIPE_SEMI_SEQUENCE},
{IO_FILE, PIPE_CLOSE_SEQUENCE}, {IO_FILE, PIPE_CLOSE_SEQUENCE},
{IO_FILE, SEQUENCE}, {IO_FILE, SEQUENCE},
{IO_FILE, CMD_SUPERIOR}, {IO_FILE, CMD_SUPERIOR},
{IO_FILE, AND_OR_MAJOR},
{IO_FILE, TK_WHILE}, {IO_FILE, TK_WHILE},
{IO_FILE, TK_UNTIL}, {IO_FILE, TK_UNTIL},
{IO_FILE, TK_IF}, {IO_FILE, TK_IF},
@ -707,12 +713,12 @@ static t_stackmatch g_stackmatch[] =
{IO_REDIRECT, TK_LBRACE}, {IO_REDIRECT, TK_LBRACE},
{IO_REDIRECT, COMPLETE_COMMANDS}, {IO_REDIRECT, COMPLETE_COMMANDS},
{IO_REDIRECT, SEPARATOR_OP}, {IO_REDIRECT, SEPARATOR_OP},
{IO_REDIRECT, AND_OR},
{IO_REDIRECT, NEWLINE_LIST}, {IO_REDIRECT, NEWLINE_LIST},
{IO_REDIRECT, PIPE_SEMI_SEQUENCE}, {IO_REDIRECT, PIPE_SEMI_SEQUENCE},
{IO_REDIRECT, PIPE_CLOSE_SEQUENCE}, {IO_REDIRECT, PIPE_CLOSE_SEQUENCE},
{IO_REDIRECT, SEQUENCE}, {IO_REDIRECT, SEQUENCE},
{IO_REDIRECT, CMD_SUPERIOR}, {IO_REDIRECT, CMD_SUPERIOR},
{IO_REDIRECT, AND_OR_MAJOR},
{IO_REDIRECT, TK_WHILE}, {IO_REDIRECT, TK_WHILE},
{IO_REDIRECT, TK_UNTIL}, {IO_REDIRECT, TK_UNTIL},
{IO_REDIRECT, TK_IF}, {IO_REDIRECT, TK_IF},
@ -735,10 +741,10 @@ static t_stackmatch g_stackmatch[] =
{CMD_PREFIX, COMPLETE_COMMANDS}, {CMD_PREFIX, COMPLETE_COMMANDS},
{CMD_PREFIX, TK_BANG}, {CMD_PREFIX, TK_BANG},
{CMD_PREFIX, SEPARATOR_OP}, {CMD_PREFIX, SEPARATOR_OP},
{CMD_PREFIX, AND_OR},
{CMD_PREFIX, NEWLINE_LIST}, {CMD_PREFIX, NEWLINE_LIST},
{CMD_PREFIX, SEQUENCE}, {CMD_PREFIX, SEQUENCE},
{CMD_PREFIX, CMD_SUPERIOR}, {CMD_PREFIX, CMD_SUPERIOR},
{CMD_PREFIX, AND_OR_MAJOR},
{CMD_PREFIX, TK_WHILE}, {CMD_PREFIX, TK_WHILE},
{CMD_PREFIX, TK_UNTIL}, {CMD_PREFIX, TK_UNTIL},
{CMD_PREFIX, TK_IF}, {CMD_PREFIX, TK_IF},
@ -756,13 +762,12 @@ static t_stackmatch g_stackmatch[] =
{CMD_NAME, TK_LBRACE}, {CMD_NAME, TK_LBRACE},
{CMD_NAME, TK_BANG}, {CMD_NAME, TK_BANG},
{CMD_NAME, SEPARATOR_OP}, {CMD_NAME, SEPARATOR_OP},
{CMD_NAME, AND_OR},
{CMD_NAME, NEWLINE_LIST}, {CMD_NAME, NEWLINE_LIST},
{CMD_NAME, SEQUENCE}, {CMD_NAME, SEQUENCE},
{CMD_NAME, CMD_SUPERIOR}, {CMD_NAME, CMD_SUPERIOR},
{CMD_NAME, AND_OR_MAJOR},
{CMD_NAME, CONDITION}, {CMD_NAME, CONDITION},
{CMD_NAME, COMPOUND_LIST}, {CMD_NAME, COMPOUND_LIST},
{CMD_NAME, AND_OR_MAJOR},
{CMD_NAME, TK_WHILE}, {CMD_NAME, TK_WHILE},
{CMD_NAME, FUNC_NAME}, {CMD_NAME, FUNC_NAME},
{CMD_NAME, TK_UNTIL}, {CMD_NAME, TK_UNTIL},
@ -795,10 +800,10 @@ static t_stackmatch g_stackmatch[] =
{CMD_SUPERIOR, COMPLETE_COMMANDS}, {CMD_SUPERIOR, COMPLETE_COMMANDS},
{CMD_SUPERIOR, TK_BANG}, {CMD_SUPERIOR, TK_BANG},
{CMD_SUPERIOR, SEPARATOR_OP}, {CMD_SUPERIOR, SEPARATOR_OP},
{CMD_SUPERIOR, AND_OR},
{CMD_SUPERIOR, NEWLINE_LIST}, {CMD_SUPERIOR, NEWLINE_LIST},
{CMD_SUPERIOR, TK_PIPE}, {CMD_SUPERIOR, TK_PIPE},
{CMD_SUPERIOR, SEQUENCE}, {CMD_SUPERIOR, SEQUENCE},
{CMD_SUPERIOR, AND_OR_MAJOR},
{CLOSE_FUNC, CMD_SUPERIOR}, {CLOSE_FUNC, CMD_SUPERIOR},
{CLOSE_FUNC, OPEN_FUNC}, {CLOSE_FUNC, OPEN_FUNC},
{SIMPLE_COMMAND, TK_WHILE}, {SIMPLE_COMMAND, TK_WHILE},
@ -819,9 +824,9 @@ static t_stackmatch g_stackmatch[] =
{SIMPLE_COMMAND, COMPLETE_COMMANDS}, {SIMPLE_COMMAND, COMPLETE_COMMANDS},
{SIMPLE_COMMAND, TK_BANG}, {SIMPLE_COMMAND, TK_BANG},
{SIMPLE_COMMAND, SEPARATOR_OP}, {SIMPLE_COMMAND, SEPARATOR_OP},
{SIMPLE_COMMAND, AND_OR},
{SIMPLE_COMMAND, NEWLINE_LIST}, {SIMPLE_COMMAND, NEWLINE_LIST},
{SIMPLE_COMMAND, SEQUENCE}, {SIMPLE_COMMAND, SEQUENCE},
{SIMPLE_COMMAND, AND_OR_MAJOR},
{DO_GROUP, CMD_SUPERIOR}, {DO_GROUP, CMD_SUPERIOR},
{DO_GROUP, COMPOUND_LIST}, {DO_GROUP, COMPOUND_LIST},
{DO_GROUP, NAME}, {DO_GROUP, NAME},
@ -854,8 +859,8 @@ static t_stackmatch g_stackmatch[] =
{COMPLETE_CONDITION, CASE_LIST_NS}, {COMPLETE_CONDITION, CASE_LIST_NS},
{COMPLETE_CONDITION, TK_BANG}, {COMPLETE_CONDITION, TK_BANG},
{COMPLETE_CONDITION, SEPARATOR_OP}, {COMPLETE_CONDITION, SEPARATOR_OP},
{COMPLETE_CONDITION, AND_OR},
{COMPLETE_CONDITION, NEWLINE_LIST}, {COMPLETE_CONDITION, NEWLINE_LIST},
{COMPLETE_CONDITION, AND_OR_MAJOR},
{COMPLETE_CONDITION, CASE_LIST_NS}, {COMPLETE_CONDITION, CASE_LIST_NS},
{COMPLETE_CONDITION, FUNC_NAME}, {COMPLETE_CONDITION, FUNC_NAME},
{FNAME, LINEBREAK}, {FNAME, LINEBREAK},
@ -864,6 +869,7 @@ static t_stackmatch g_stackmatch[] =
{FNAME, COMPLETE_COMMANDS}, {FNAME, COMPLETE_COMMANDS},
{FNAME, TK_BANG}, {FNAME, TK_BANG},
{FNAME, SEPARATOR_OP}, {FNAME, SEPARATOR_OP},
{FNAME, AND_OR},
{FNAME, NEWLINE_LIST}, {FNAME, NEWLINE_LIST},
{FNAME, SEQUENCE}, {FNAME, SEQUENCE},
{FUNCTION_BODY, FUNC}, {FUNCTION_BODY, FUNC},
@ -874,6 +880,7 @@ static t_stackmatch g_stackmatch[] =
{FUNCTION_DEFINITION, COMPLETE_COMMANDS}, {FUNCTION_DEFINITION, COMPLETE_COMMANDS},
{FUNCTION_DEFINITION, TK_BANG}, {FUNCTION_DEFINITION, TK_BANG},
{FUNCTION_DEFINITION, SEPARATOR_OP}, {FUNCTION_DEFINITION, SEPARATOR_OP},
{FUNCTION_DEFINITION, AND_OR},
{FUNCTION_DEFINITION, NEWLINE_LIST}, {FUNCTION_DEFINITION, NEWLINE_LIST},
{FUNCTION_DEFINITION, SEQUENCE}, {FUNCTION_DEFINITION, SEQUENCE},
{UNTIL_CLAUSE, LINEBREAK}, {UNTIL_CLAUSE, LINEBREAK},
@ -883,6 +890,7 @@ static t_stackmatch g_stackmatch[] =
{UNTIL_CLAUSE, COMPLETE_COMMANDS}, {UNTIL_CLAUSE, COMPLETE_COMMANDS},
{UNTIL_CLAUSE, TK_BANG}, {UNTIL_CLAUSE, TK_BANG},
{UNTIL_CLAUSE, SEPARATOR_OP}, {UNTIL_CLAUSE, SEPARATOR_OP},
{UNTIL_CLAUSE, AND_OR},
{UNTIL_CLAUSE, NEWLINE_LIST}, {UNTIL_CLAUSE, NEWLINE_LIST},
{UNTIL_CLAUSE, SEQUENCE}, {UNTIL_CLAUSE, SEQUENCE},
{UNTIL_CLAUSE, TK_DO}, {UNTIL_CLAUSE, TK_DO},
@ -898,11 +906,11 @@ static t_stackmatch g_stackmatch[] =
{UNTIL_CLAUSE, CASE_LIST_NS}, {UNTIL_CLAUSE, CASE_LIST_NS},
{UNTIL_CLAUSE, COMPLETE_CONDITION}, {UNTIL_CLAUSE, COMPLETE_CONDITION},
{UNTIL_CLAUSE, CONDITION}, {UNTIL_CLAUSE, CONDITION},
{UNTIL_CLAUSE, AND_OR_MAJOR},
{WHILE_CLAUSE, LINEBREAK}, {WHILE_CLAUSE, LINEBREAK},
{WHILE_CLAUSE, COMPLETE_COMMANDS}, {WHILE_CLAUSE, COMPLETE_COMMANDS},
{WHILE_CLAUSE, TK_BANG}, {WHILE_CLAUSE, TK_BANG},
{WHILE_CLAUSE, SEPARATOR_OP}, {WHILE_CLAUSE, SEPARATOR_OP},
{WHILE_CLAUSE, AND_OR},
{WHILE_CLAUSE, NEWLINE_LIST}, {WHILE_CLAUSE, NEWLINE_LIST},
{WHILE_CLAUSE, SEQUENCE}, {WHILE_CLAUSE, SEQUENCE},
{WHILE_CLAUSE, TK_DO}, {WHILE_CLAUSE, TK_DO},
@ -920,7 +928,6 @@ static t_stackmatch g_stackmatch[] =
{WHILE_CLAUSE, CASE_LIST_NS}, {WHILE_CLAUSE, CASE_LIST_NS},
{WHILE_CLAUSE, COMPLETE_CONDITION}, {WHILE_CLAUSE, COMPLETE_CONDITION},
{WHILE_CLAUSE, CONDITION}, {WHILE_CLAUSE, CONDITION},
{WHILE_CLAUSE, AND_OR_MAJOR},
{IF_CLAUSE, LINEBREAK}, {IF_CLAUSE, LINEBREAK},
{IF_CLAUSE, TK_BANG}, {IF_CLAUSE, TK_BANG},
{IF_CLAUSE, TK_PAREN_OPEN}, {IF_CLAUSE, TK_PAREN_OPEN},
@ -928,6 +935,7 @@ static t_stackmatch g_stackmatch[] =
{IF_CLAUSE, FUNC_NAME}, {IF_CLAUSE, FUNC_NAME},
{IF_CLAUSE, COMPLETE_COMMANDS}, {IF_CLAUSE, COMPLETE_COMMANDS},
{IF_CLAUSE, SEPARATOR_OP}, {IF_CLAUSE, SEPARATOR_OP},
{IF_CLAUSE, AND_OR},
{IF_CLAUSE, NEWLINE_LIST}, {IF_CLAUSE, NEWLINE_LIST},
{IF_CLAUSE, SEQUENCE}, {IF_CLAUSE, SEQUENCE},
{IF_CLAUSE, TK_DO}, {IF_CLAUSE, TK_DO},
@ -944,7 +952,6 @@ static t_stackmatch g_stackmatch[] =
{IF_CLAUSE, COMPLETE_COMMAND}, {IF_CLAUSE, COMPLETE_COMMAND},
{IF_CLAUSE, COMPLETE_CONDITION}, {IF_CLAUSE, COMPLETE_CONDITION},
{IF_CLAUSE, CONDITION}, {IF_CLAUSE, CONDITION},
{IF_CLAUSE, AND_OR_MAJOR},
{BRACE_CLAUSE, LINEBREAK}, {BRACE_CLAUSE, LINEBREAK},
{BRACE_CLAUSE, TK_PAREN_OPEN}, {BRACE_CLAUSE, TK_PAREN_OPEN},
{BRACE_CLAUSE, TK_LBRACE}, {BRACE_CLAUSE, TK_LBRACE},
@ -952,6 +959,7 @@ static t_stackmatch g_stackmatch[] =
{BRACE_CLAUSE, COMPLETE_COMMANDS}, {BRACE_CLAUSE, COMPLETE_COMMANDS},
{BRACE_CLAUSE, TK_BANG}, {BRACE_CLAUSE, TK_BANG},
{BRACE_CLAUSE, SEPARATOR_OP}, {BRACE_CLAUSE, SEPARATOR_OP},
{BRACE_CLAUSE, AND_OR},
{BRACE_CLAUSE, NEWLINE_LIST}, {BRACE_CLAUSE, NEWLINE_LIST},
{BRACE_CLAUSE, SEQUENCE}, {BRACE_CLAUSE, SEQUENCE},
{BRACE_CLAUSE, TK_DO}, {BRACE_CLAUSE, TK_DO},
@ -968,7 +976,6 @@ static t_stackmatch g_stackmatch[] =
{BRACE_CLAUSE, COMPLETE_COMMAND}, {BRACE_CLAUSE, COMPLETE_COMMAND},
{BRACE_CLAUSE, COMPLETE_CONDITION}, {BRACE_CLAUSE, COMPLETE_CONDITION},
{BRACE_CLAUSE, CONDITION}, {BRACE_CLAUSE, CONDITION},
{BRACE_CLAUSE, AND_OR_MAJOR},
{PATTERN, PATTERN_CASE}, {PATTERN, PATTERN_CASE},
{PATTERN, CASE_LIST}, {PATTERN, CASE_LIST},
{PATTERN, TK_IN}, {PATTERN, TK_IN},
@ -981,6 +988,7 @@ static t_stackmatch g_stackmatch[] =
{CASE_CLAUSE, FUNC_NAME}, {CASE_CLAUSE, FUNC_NAME},
{CASE_CLAUSE, COMPLETE_COMMANDS}, {CASE_CLAUSE, COMPLETE_COMMANDS},
{CASE_CLAUSE, SEPARATOR_OP}, {CASE_CLAUSE, SEPARATOR_OP},
{CASE_CLAUSE, AND_OR},
{CASE_CLAUSE, NEWLINE_LIST}, {CASE_CLAUSE, NEWLINE_LIST},
{CASE_CLAUSE, SEQUENCE}, {CASE_CLAUSE, SEQUENCE},
{CASE_CLAUSE, TK_PAREN_CLOSE}, {CASE_CLAUSE, TK_PAREN_CLOSE},
@ -997,7 +1005,6 @@ static t_stackmatch g_stackmatch[] =
{CASE_CLAUSE, CASE_LIST_NS}, {CASE_CLAUSE, CASE_LIST_NS},
{CASE_CLAUSE, COMPLETE_CONDITION}, {CASE_CLAUSE, COMPLETE_CONDITION},
{CASE_CLAUSE, CONDITION}, {CASE_CLAUSE, CONDITION},
{CASE_CLAUSE, AND_OR_MAJOR},
{WORDLIST, IN}, {WORDLIST, IN},
{IN, LINEBREAK}, {IN, LINEBREAK},
{NAME, TK_FOR}, {NAME, TK_FOR},
@ -1009,6 +1016,7 @@ static t_stackmatch g_stackmatch[] =
{FOR_CLAUSE, FUNC_NAME}, {FOR_CLAUSE, FUNC_NAME},
{FOR_CLAUSE, COMPLETE_COMMANDS}, {FOR_CLAUSE, COMPLETE_COMMANDS},
{FOR_CLAUSE, SEPARATOR_OP}, {FOR_CLAUSE, SEPARATOR_OP},
{FOR_CLAUSE, AND_OR},
{FOR_CLAUSE, NEWLINE_LIST}, {FOR_CLAUSE, NEWLINE_LIST},
{FOR_CLAUSE, SEQUENCE}, {FOR_CLAUSE, SEQUENCE},
{FOR_CLAUSE, TK_DO}, {FOR_CLAUSE, TK_DO},
@ -1024,7 +1032,6 @@ static t_stackmatch g_stackmatch[] =
{FOR_CLAUSE, CASE_LIST_NS}, {FOR_CLAUSE, CASE_LIST_NS},
{FOR_CLAUSE, COMPLETE_CONDITION}, {FOR_CLAUSE, COMPLETE_CONDITION},
{FOR_CLAUSE, CONDITION}, {FOR_CLAUSE, CONDITION},
{FOR_CLAUSE, AND_OR_MAJOR},
{COMPOUND_LIST, TK_DO}, {COMPOUND_LIST, TK_DO},
{COMPOUND_LIST, TK_PAREN_CLOSE}, {COMPOUND_LIST, TK_PAREN_CLOSE},
{COMPOUND_LIST, TK_LBRACE}, {COMPOUND_LIST, TK_LBRACE},
@ -1045,11 +1052,13 @@ static t_stackmatch g_stackmatch[] =
{SUBSHELL, COMPLETE_COMMANDS}, {SUBSHELL, COMPLETE_COMMANDS},
{SUBSHELL, TK_BANG}, {SUBSHELL, TK_BANG},
{SUBSHELL, SEPARATOR_OP}, {SUBSHELL, SEPARATOR_OP},
{SUBSHELL, AND_OR},
{SUBSHELL, NEWLINE_LIST}, {SUBSHELL, NEWLINE_LIST},
{SUBSHELL, SEQUENCE}, {SUBSHELL, SEQUENCE},
{SUBSHELL, TK_LBRACE}, {SUBSHELL, TK_LBRACE},
{SUBSHELL, TK_PAREN_OPEN}, {SUBSHELL, TK_PAREN_OPEN},
{SUBSHELL, SEPARATOR_OP}, {SUBSHELL, SEPARATOR_OP},
{SUBSHELL, AND_OR},
{SUBSHELL, NEWLINE_LIST}, {SUBSHELL, NEWLINE_LIST},
{SUBSHELL, TK_DO}, {SUBSHELL, TK_DO},
{SUBSHELL, TK_PAREN_CLOSE}, {SUBSHELL, TK_PAREN_CLOSE},
@ -1064,13 +1073,13 @@ static t_stackmatch g_stackmatch[] =
{SUBSHELL, CASE_LIST_NS}, {SUBSHELL, CASE_LIST_NS},
{SUBSHELL, COMPLETE_CONDITION}, {SUBSHELL, COMPLETE_CONDITION},
{SUBSHELL, CONDITION}, {SUBSHELL, CONDITION},
{SUBSHELL, AND_OR_MAJOR},
{COMPOUND_COMMAND, LINEBREAK}, {COMPOUND_COMMAND, LINEBREAK},
{COMPOUND_COMMAND, TK_PAREN_OPEN}, {COMPOUND_COMMAND, TK_PAREN_OPEN},
{COMPOUND_COMMAND, TK_LBRACE}, {COMPOUND_COMMAND, TK_LBRACE},
{COMPOUND_COMMAND, COMPLETE_COMMANDS}, {COMPOUND_COMMAND, COMPLETE_COMMANDS},
{COMPOUND_COMMAND, TK_BANG}, {COMPOUND_COMMAND, TK_BANG},
{COMPOUND_COMMAND, SEPARATOR_OP}, {COMPOUND_COMMAND, SEPARATOR_OP},
{COMPOUND_COMMAND, AND_OR},
{COMPOUND_COMMAND, NEWLINE_LIST}, {COMPOUND_COMMAND, NEWLINE_LIST},
{COMPOUND_COMMAND, SEQUENCE}, {COMPOUND_COMMAND, SEQUENCE},
{COMPOUND_COMMAND, FUNC}, {COMPOUND_COMMAND, FUNC},
@ -1087,7 +1096,6 @@ static t_stackmatch g_stackmatch[] =
{COMPOUND_COMMAND, CASE_LIST_NS}, {COMPOUND_COMMAND, CASE_LIST_NS},
{COMPOUND_COMMAND, COMPLETE_CONDITION}, {COMPOUND_COMMAND, COMPLETE_CONDITION},
{COMPOUND_COMMAND, CONDITION}, {COMPOUND_COMMAND, CONDITION},
{COMPOUND_COMMAND, AND_OR_MAJOR},
{COMMAND, TK_WHILE}, {COMMAND, TK_WHILE},
{COMMAND, TK_UNTIL}, {COMMAND, TK_UNTIL},
{COMMAND, LINEBREAK}, {COMMAND, LINEBREAK},
@ -1106,18 +1114,9 @@ static t_stackmatch g_stackmatch[] =
{COMMAND, COMPLETE_CONDITION}, {COMMAND, COMPLETE_CONDITION},
{COMMAND, CONDITION}, {COMMAND, CONDITION},
{COMMAND, SEPARATOR_OP}, {COMMAND, SEPARATOR_OP},
{COMMAND, AND_OR},
{COMMAND, NEWLINE_LIST}, {COMMAND, NEWLINE_LIST},
{COMMAND, SEQUENCE}, {COMMAND, SEQUENCE},
{COMMAND, AND_OR_MAJOR},
{AND_OR_MINOR, SEQUENCE},
{AND_OR_MINOR, LINEBREAK},
{AND_OR_MINOR, TK_BANG},
{AND_OR_MINOR, TK_PAREN_OPEN},
{AND_OR_MINOR, TK_LBRACE},
{AND_OR_MINOR, CMD_SUPERIOR},
{AND_OR_MINOR, COMPOUND_LIST},
{AND_OR_MINOR, COMPLETE_COMMANDS},
{AND_OR_MINOR, AND_OR_MAJOR},
{PIPE_SEQUENCE, TK_WHILE}, {PIPE_SEQUENCE, TK_WHILE},
{PIPE_SEQUENCE, FUNC_NAME}, {PIPE_SEQUENCE, FUNC_NAME},
{PIPE_SEQUENCE, TK_UNTIL}, {PIPE_SEQUENCE, TK_UNTIL},
@ -1137,8 +1136,8 @@ static t_stackmatch g_stackmatch[] =
{PIPE_SEQUENCE, TK_LBRACE}, {PIPE_SEQUENCE, TK_LBRACE},
{PIPE_SEQUENCE, COMPLETE_COMMANDS}, {PIPE_SEQUENCE, COMPLETE_COMMANDS},
{PIPE_SEQUENCE, SEPARATOR_OP}, {PIPE_SEQUENCE, SEPARATOR_OP},
{PIPE_SEQUENCE, AND_OR},
{PIPE_SEQUENCE, NEWLINE_LIST}, {PIPE_SEQUENCE, NEWLINE_LIST},
{PIPE_SEQUENCE, AND_OR_MAJOR},
{TK_BANG, TK_WHILE}, {TK_BANG, TK_WHILE},
{TK_BANG, TK_UNTIL}, {TK_BANG, TK_UNTIL},
{TK_BANG, TK_DO}, {TK_BANG, TK_DO},
@ -1156,8 +1155,8 @@ static t_stackmatch g_stackmatch[] =
{TK_BANG, TK_LBRACE}, {TK_BANG, TK_LBRACE},
{TK_BANG, COMPLETE_COMMANDS}, {TK_BANG, COMPLETE_COMMANDS},
{TK_BANG, SEPARATOR_OP}, {TK_BANG, SEPARATOR_OP},
{TK_BANG, AND_OR},
{TK_BANG, NEWLINE_LIST}, {TK_BANG, NEWLINE_LIST},
{TK_BANG, AND_OR_MAJOR},
{PIPE_SEMI_SEQUENCE, TK_WHILE}, {PIPE_SEMI_SEQUENCE, TK_WHILE},
{PIPE_SEMI_SEQUENCE, TK_UNTIL}, {PIPE_SEMI_SEQUENCE, TK_UNTIL},
{PIPE_SEMI_SEQUENCE, TK_DO}, {PIPE_SEMI_SEQUENCE, TK_DO},
@ -1176,8 +1175,8 @@ static t_stackmatch g_stackmatch[] =
{PIPE_SEMI_SEQUENCE, TK_LBRACE}, {PIPE_SEMI_SEQUENCE, TK_LBRACE},
{PIPE_SEMI_SEQUENCE, COMPLETE_COMMANDS}, {PIPE_SEMI_SEQUENCE, COMPLETE_COMMANDS},
{PIPE_SEMI_SEQUENCE, SEPARATOR_OP}, {PIPE_SEMI_SEQUENCE, SEPARATOR_OP},
{PIPE_SEMI_SEQUENCE, AND_OR},
{PIPE_SEMI_SEQUENCE, NEWLINE_LIST}, {PIPE_SEMI_SEQUENCE, NEWLINE_LIST},
{PIPE_SEMI_SEQUENCE, AND_OR_MAJOR},
{PIPE_SEMI_SEQUENCE, SEQUENCE}, {PIPE_SEMI_SEQUENCE, SEQUENCE},
{PIPE_CLOSE_SEQUENCE, TK_WHILE}, {PIPE_CLOSE_SEQUENCE, TK_WHILE},
{PIPE_CLOSE_SEQUENCE, TK_UNTIL}, {PIPE_CLOSE_SEQUENCE, TK_UNTIL},
@ -1197,8 +1196,8 @@ static t_stackmatch g_stackmatch[] =
{PIPE_CLOSE_SEQUENCE, TK_LBRACE}, {PIPE_CLOSE_SEQUENCE, TK_LBRACE},
{PIPE_CLOSE_SEQUENCE, COMPLETE_COMMANDS}, {PIPE_CLOSE_SEQUENCE, COMPLETE_COMMANDS},
{PIPE_CLOSE_SEQUENCE, SEPARATOR_OP}, {PIPE_CLOSE_SEQUENCE, SEPARATOR_OP},
{PIPE_CLOSE_SEQUENCE, AND_OR},
{PIPE_CLOSE_SEQUENCE, NEWLINE_LIST}, {PIPE_CLOSE_SEQUENCE, NEWLINE_LIST},
{PIPE_CLOSE_SEQUENCE, AND_OR_MAJOR},
{PIPE_CLOSE_SEQUENCE, SEQUENCE}, {PIPE_CLOSE_SEQUENCE, SEQUENCE},
{SEQUENCE, PIPE_SEMI_SEQUENCE}, {SEQUENCE, PIPE_SEMI_SEQUENCE},
{SEQUENCE, PIPE_CLOSE_SEQUENCE}, {SEQUENCE, PIPE_CLOSE_SEQUENCE},
@ -1220,8 +1219,8 @@ static t_stackmatch g_stackmatch[] =
{SEQUENCE, COMPLETE_COMMANDS}, {SEQUENCE, COMPLETE_COMMANDS},
{SEQUENCE, TK_BANG}, {SEQUENCE, TK_BANG},
{SEQUENCE, SEPARATOR_OP}, {SEQUENCE, SEPARATOR_OP},
{SEQUENCE, AND_OR},
{SEQUENCE, NEWLINE_LIST}, {SEQUENCE, NEWLINE_LIST},
{SEQUENCE, AND_OR_MAJOR},
{SEQUENCE, SEQUENCE}, {SEQUENCE, SEQUENCE},
{PIPELINE, TK_WHILE}, {PIPELINE, TK_WHILE},
{PIPELINE, TK_UNTIL}, {PIPELINE, TK_UNTIL},
@ -1241,16 +1240,8 @@ static t_stackmatch g_stackmatch[] =
{PIPELINE, TK_LBRACE}, {PIPELINE, TK_LBRACE},
{PIPELINE, COMPLETE_COMMANDS}, {PIPELINE, COMPLETE_COMMANDS},
{PIPELINE, SEPARATOR_OP}, {PIPELINE, SEPARATOR_OP},
{PIPELINE, SEPARATOR_OP}, {PIPELINE, AND_OR},
{PIPELINE, NEWLINE_LIST}, {PIPELINE, NEWLINE_LIST},
{PIPELINE, AND_OR_MAJOR},
{AND_OR_MAJOR, LINEBREAK},
{AND_OR_MAJOR, TK_BANG},
{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_DO},
{AND_OR, TK_PAREN_CLOSE}, {AND_OR, TK_PAREN_CLOSE},
{AND_OR, TK_WHILE}, {AND_OR, TK_WHILE},
@ -1259,7 +1250,9 @@ static t_stackmatch g_stackmatch[] =
{AND_OR, TK_ELIF}, {AND_OR, TK_ELIF},
{AND_OR, TK_THEN}, {AND_OR, TK_THEN},
{AND_OR, TK_ELSE}, {AND_OR, TK_ELSE},
{AND_OR, CMD_SUPERIOR},
{AND_OR, COMPOUND_LIST}, {AND_OR, COMPOUND_LIST},
{AND_OR, PIPE_SEMI_SEQUENCE},
{AND_OR, CASE_LIST_NS}, {AND_OR, CASE_LIST_NS},
{AND_OR, COMPLETE_CONDITION}, {AND_OR, COMPLETE_CONDITION},
{AND_OR, CONDITION}, {AND_OR, CONDITION},
@ -1268,8 +1261,6 @@ static t_stackmatch g_stackmatch[] =
{AND_OR, TK_PAREN_OPEN}, {AND_OR, TK_PAREN_OPEN},
{AND_OR, TK_LBRACE}, {AND_OR, TK_LBRACE},
{AND_OR, COMPLETE_COMMANDS}, {AND_OR, COMPLETE_COMMANDS},
{AND_OR, SEPARATOR_OP},
{AND_OR, SEPARATOR_OP},
{AND_OR, NEWLINE_LIST}, {AND_OR, NEWLINE_LIST},
{LIST, LINEBREAK}, {LIST, LINEBREAK},
{LIST, COMPLETE_COMMANDS}, {LIST, COMPLETE_COMMANDS},
@ -1291,6 +1282,7 @@ int eval_sym(t_list **stack, t_sym new_sym)
return (1); return (1);
head = (*stack)->content; head = (*stack)->content;
i = 0; i = 0;
DG("eval %s &7 %s", read_state(*head), read_state(new_sym));
while (g_stackmatch[i].top) while (g_stackmatch[i].top)
{ {
if (new_sym == g_stackmatch[i].top && *head == g_stackmatch[i].under) if (new_sym == g_stackmatch[i].top && *head == g_stackmatch[i].under)

4
42sh/src/parser/ft_parse.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/11 16:17:38 by ariard #+# #+# */ /* Created: 2017/03/11 16:17:38 by ariard #+# #+# */
/* Updated: 2017/03/29 13:41:44 by ariard ### ########.fr */ /* Updated: 2017/03/29 14:27:02 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -26,7 +26,6 @@ static int end_instruction(t_list **stack)
head = (*stack)->content; head = (*stack)->content;
if (*head == CMD_SUPERIOR || *head == PIPE_SEMI_SEQUENCE if (*head == CMD_SUPERIOR || *head == PIPE_SEMI_SEQUENCE
|| *head == COMPOUND_LIST
|| *head == COMPLETE_COMMANDS || *head == END_COMMAND) || *head == COMPLETE_COMMANDS || *head == END_COMMAND)
return (1); return (1);
return (0); return (0);
@ -41,6 +40,7 @@ int ft_parse(t_btree **ast, t_list **token, t_parser *parser)
while (parser && token && *token) while (parser && token && *token)
{ {
produce_sym(&parser->stack, parser->new_sym, token); produce_sym(&parser->stack, parser->new_sym, token);
DG("produce sym %s", read_state(*parser->new_sym));
if (parser->new_sym && eval_sym(&parser->stack, *parser->new_sym)) if (parser->new_sym && eval_sym(&parser->stack, *parser->new_sym))
return ((parser->state = ERROR)); return ((parser->state = ERROR));
if (aggregate_sym(&parser->stack, parser->new_sym, &parser->state)) if (aggregate_sym(&parser->stack, parser->new_sym, &parser->state))

9
42sh/src/parser/produce_sym.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 17:58:34 by ariard #+# #+# */ /* Created: 2017/02/09 17:58:34 by ariard #+# #+# */
/* Updated: 2017/03/27 17:22:10 by ariard ### ########.fr */ /* Updated: 2017/03/29 14:31:14 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -31,7 +31,6 @@ static t_prodmatch g_prodmatch[] =
{TK_WORD, TK_BANG, CMD_NAME}, {TK_WORD, TK_BANG, CMD_NAME},
{TK_WORD, TK_PIPE, CMD_NAME}, {TK_WORD, TK_PIPE, CMD_NAME},
{TK_WORD, AND_OR, CMD_NAME}, {TK_WORD, AND_OR, CMD_NAME},
{TK_WORD, AND_OR_MAJOR, CMD_NAME},
{TK_WORD, TK_PAREN_CLOSE, CMD_NAME}, {TK_WORD, TK_PAREN_CLOSE, CMD_NAME},
{TK_WORD, TK_WHILE, CMD_NAME}, {TK_WORD, TK_WHILE, CMD_NAME},
{TK_WORD, TK_UNTIL, CMD_NAME}, {TK_WORD, TK_UNTIL, CMD_NAME},
@ -75,7 +74,6 @@ static t_prodmatch g_prodmatch[] =
{TK_ASSIGNMENT_WORD, COMPLETE_CONDITION, CMD_PREFIX}, {TK_ASSIGNMENT_WORD, COMPLETE_CONDITION, CMD_PREFIX},
{TK_ASSIGNMENT_WORD, CONDITION, CMD_PREFIX}, {TK_ASSIGNMENT_WORD, CONDITION, CMD_PREFIX},
{TK_ASSIGNMENT_WORD, AND_OR, CMD_PREFIX}, {TK_ASSIGNMENT_WORD, AND_OR, CMD_PREFIX},
{TK_ASSIGNMENT_WORD, AND_OR_MAJOR, CMD_PREFIX},
{TK_ASSIGNMENT_WORD, PIPE_SEMI_SEQUENCE, CMD_SUFFIX}, {TK_ASSIGNMENT_WORD, PIPE_SEMI_SEQUENCE, CMD_SUFFIX},
{TK_ASSIGNMENT_WORD, SEQUENCE, CMD_PREFIX}, {TK_ASSIGNMENT_WORD, SEQUENCE, CMD_PREFIX},
{TK_ASSIGNMENT_WORD, COMPLETE_COMMANDS, CMD_PREFIX}, {TK_ASSIGNMENT_WORD, COMPLETE_COMMANDS, CMD_PREFIX},
@ -119,6 +117,7 @@ static t_prodmatch g_prodmatch[] =
{TK_NEWLINE, CONDITION, NEWLINE_LIST}, {TK_NEWLINE, CONDITION, NEWLINE_LIST},
{TK_NEWLINE, FOR_WORDLIST, NEWLINE_LIST}, {TK_NEWLINE, FOR_WORDLIST, NEWLINE_LIST},
{TK_NEWLINE, SEQUENTIAL_SEP, NEWLINE_LIST}, {TK_NEWLINE, SEQUENTIAL_SEP, NEWLINE_LIST},
{TK_NEWLINE, AND_OR, NEWLINE_LIST},
{TK_NEWLINE, PROGRAM, NEWLINE_LIST}, {TK_NEWLINE, PROGRAM, NEWLINE_LIST},
{TK_SEMI, CMD_SUPERIOR, SEPARATOR_OP}, {TK_SEMI, CMD_SUPERIOR, SEPARATOR_OP},
{TK_SEMI, LIST, SEPARATOR_OP}, {TK_SEMI, LIST, SEPARATOR_OP},
@ -128,6 +127,8 @@ static t_prodmatch g_prodmatch[] =
{TK_AMP, LIST, SEPARATOR_OP}, {TK_AMP, LIST, SEPARATOR_OP},
{TK_AMP, PIPE_SEMI_SEQUENCE, SEPARATOR_OP}, {TK_AMP, PIPE_SEMI_SEQUENCE, SEPARATOR_OP},
{TK_AMP, PIPE_CLOSE_SEQUENCE, SEPARATOR_OP}, {TK_AMP, PIPE_CLOSE_SEQUENCE, SEPARATOR_OP},
{TK_AND_IF, ALL, AND_OR},
{TK_OR_IF, ALL, AND_OR},
{0, 0, 0}, {0, 0, 0},
}; };
@ -146,7 +147,7 @@ int produce_sym(t_list **stack, t_sym *new_sym, t_list **lst)
while (g_prodmatch[i].new_sym) while (g_prodmatch[i].new_sym)
{ {
if (token->type == g_prodmatch[i].token if (token->type == g_prodmatch[i].token
&& *head == g_prodmatch[i].stack) && (*head == g_prodmatch[i].stack || g_prodmatch[i].stack == ALL))
*new_sym = g_prodmatch[i].new_sym; *new_sym = g_prodmatch[i].new_sym;
i++; i++;
} }

6
42sh/src/parser/read_stack.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 15:32:10 by ariard #+# #+# */ /* Created: 2017/02/09 15:32:10 by ariard #+# #+# */
/* Updated: 2017/03/24 17:25:03 by gwojda ### ########.fr */ /* Updated: 2017/03/29 14:15:17 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -130,10 +130,6 @@ char *read_state(t_sym current)
return ("TK_DO"); return ("TK_DO");
if (current == TK_DONE) if (current == TK_DONE)
return ("TK_DONE"); return ("TK_DONE");
if (current == AND_OR_MINOR)
return ("AND_OR_MINOR");
if (current == AND_OR_MAJOR)
return ("AND_OR_MAJOR");
if (current == TK_COMMAND) if (current == TK_COMMAND)
return ("TK_COMMAND"); return ("TK_COMMAND");
if (current == TK_AND_IF) if (current == TK_AND_IF)