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

grammar moar beton

Browse source
This commit is contained in:
Antoine Riard 2017-03-10 19:04:14 +01:00
parent 63ed4b64f4
commit 488d7bf800
7 changed files with 220 additions and 21 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
42sh/src/parser/add_case.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/04 20:42:13 by ariard #+# #+# */
/* Updated: 2017/03/10 17:34:11 by ariard ### ########.fr */
/* Updated: 2017/03/10 18:10:47 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/parser/add_condition.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/10 17:06:16 by ariard #+# #+# */
/* Updated: 2017/03/10 18:06:27 by ariard ### ########.fr */
/* Updated: 2017/03/10 18:10:42 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/parser/add_sep.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/15 19:12:07 by ariard #+# #+# */
/* Updated: 2017/03/10 18:05:35 by ariard ### ########.fr */
/* Updated: 2017/03/10 18:10:55 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

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

@ -1,4 +1,4 @@
/* ************************************************************************** */ /* */
/* ************************************************************************** */
/* ::: :::::::: */
/* aggregate_sym.c :+: :+: :+: */
/* +:+ +:+ +:+ */
@ -11,6 +11,11 @@
#include "minishell.h"
/*
* In case of grammar error, manange it
*
*/
t_aggrematch g_aggrematch[] =
{
{TK_WORD, CMD_SUFFIX, CMD_SUFFIX, 0},
@ -134,8 +139,6 @@ t_aggrematch g_aggrematch[] =
{IO_REDIRECT, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE},
{IO_REDIRECT, PIPE_CLOSE_SEQUENCE, PIPE_CLOSE_SEQUENCE, PIPE_CLOSE_SEQUENCE},
{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},
@ -147,6 +150,15 @@ t_aggrematch g_aggrematch[] =
{IO_REDIRECT, TK_BANG, CMD_PREFIX, TK_BANG},
{IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, 0},
{IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, 0},
{IO_REDIRECT, TK_WHILE, CMD_PREFIX, 0},
{IO_REDIRECT, TK_UNTIL, CMD_PREFIX, 0},
{IO_REDIRECT, TK_DO, CMD_PREFIX, 0},
{IO_REDIRECT, TK_THEN, CMD_PREFIX, TK_BANG},
{IO_REDIRECT, TK_IF, CMD_PREFIX, 0},
{IO_REDIRECT, TK_ELIF, CMD_PREFIX, 0},
{IO_REDIRECT, TK_ELSE, CMD_PREFIX, 0},
{IO_REDIRECT, TK_PAREN_CLOSE, 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},
@ -161,6 +173,19 @@ t_aggrematch g_aggrematch[] =
{CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, TK_BANG},
{CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, 0},
{CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_WHILE, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_UNTIL,SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_DO, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_THEN, SIMPLE_COMMAND, TK_BANG},
{CMD_PREFIX, TK_IF, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_ELIF, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_ELSE, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_PAREN_CLOSE, SIMPLE_COMMAND, 0},
{CMD_PREFIX, COMPLETE_CONDITION, SIMPLE_COMMAND, 0},
{CMD_PREFIX, CONDITION, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_PIPE, SIMPLE_COMMAND, 0},
{CMD_PREFIX, SEQUENCE, SIMPLE_COMMAND, 0},
{CMD_PREFIX, COMPOUND_LIST, SIMPLE_COMMAND, 0},
{CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, CMD_PREFIX},
//to check
@ -182,6 +207,7 @@ t_aggrematch g_aggrematch[] =
{CMD_NAME, COMPOUND_LIST, CMD_SUPERIOR, 0},
{CMD_NAME, CASE_LIST_NS, CMD_SUPERIOR, 0},
{CMD_NAME, COMPLETE_CONDITION, CMD_SUPERIOR, 0},
{CMD_NAME, CONDITION, CMD_SUPERIOR, 0},
{CMD_NAME, TK_PIPE, CMD_SUPERIOR, 0},
{CMD_NAME, SEQUENCE, CMD_SUPERIOR, 0},
{CMD_NAME, AND_OR_MAJOR, CMD_SUPERIOR, 0},
@ -199,18 +225,15 @@ t_aggrematch g_aggrematch[] =
{LOOP, TK_UNTIL, UNTIL_CLAUSE, TK_UNTIL},
{UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{WHILE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
// {ELSE_PART, COMPOUND_LIST, ELSE_PART, TK_ELIF},
// {ELSE_PART, COMPLETE_CONDITION, IF_CLAUSE, COMPLETE_CONDITION},
{IF_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{CASE_LIST_NS, TK_IN, TK_IN, TK_IN},
{CASE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{FOR_CLAUSE, ALL, COMPOUND_COMMAND, 0},
// {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, CONDITION, CONDITION, CONDITION},
{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},
@ -249,6 +272,7 @@ t_aggrematch g_aggrematch[] =
{COMMAND, COMPLETE_COMMANDS, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, COMPLETE_CONDITION, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, CONDITION, PIPE_SEMI_SEQUENCE, 0},
{COMPOUND_COMMAND, SEQUENCE, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, COMPOUND_LIST, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, CASE_LIST_NS, PIPE_CLOSE_SEQUENCE, 0},
@ -270,6 +294,7 @@ t_aggrematch g_aggrematch[] =
{COMPOUND_COMMAND, COMPLETE_COMMANDS, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, AND_OR_MAJOR, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, COMPLETE_CONDITION, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, CONDITION, PIPE_CLOSE_SEQUENCE, 0},
{END_COMMAND, SEQUENCE, PIPE_SEQUENCE, SEQUENCE},
{END_COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{END_COMMAND, AND_OR_MAJOR, LIST, AND_OR_MAJOR},
@ -288,6 +313,7 @@ t_aggrematch g_aggrematch[] =
{END_COMMAND, TK_THEN, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_ELSE, PIPE_SEQUENCE, 0},
{END_COMMAND, COMPLETE_CONDITION, PIPE_SEQUENCE, 0},
{END_COMMAND, CONDITION, PIPE_SEQUENCE, 0},
{END_COMMAND, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
{END_COMMAND, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{PIPE_SEMI_SEQUENCE, SEQUENCE, PIPE_SEMI_SEQUENCE, SEQUENCE},
@ -311,6 +337,7 @@ t_aggrematch g_aggrematch[] =
{PIPE_SEQUENCE, COMPOUND_LIST, PIPELINE, 0},
{PIPE_SEQUENCE, CASE_LIST_NS, PIPELINE, 0},
{PIPE_SEQUENCE, COMPLETE_CONDITION, PIPELINE, 0},
{PIPE_SEQUENCE, CONDITION, PIPELINE, 0},
{PIPELINE, TK_WHILE, AND_OR, 0},
{PIPELINE, TK_UNTIL, AND_OR, 0},
{PIPELINE, TK_DO, AND_OR, 0},
@ -330,6 +357,7 @@ t_aggrematch g_aggrematch[] =
// {PIPELINE, LINEBREAK, AND_OR, AND_OR},
{PIPELINE, SEPARATOR_OP, AND_OR, 0},
{PIPELINE, COMPLETE_CONDITION, AND_OR, 0},
{PIPELINE, 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},
@ -345,6 +373,7 @@ t_aggrematch g_aggrematch[] =
{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, CONDITION, COMPOUND_LIST, 0},
{AND_OR, SEPARATOR_OP, LIST, LIST},
{AND_OR, NEWLINE_LIST, LIST, 0},
{AND_OR, LINEBREAK, LIST, 0},
@ -370,21 +399,21 @@ int aggregate_sym(t_list **stack, t_sym *new_sym, t_parstate *state)
return (1);
i = 0;
head = (*stack)->content;
// DG("aggregate head %s && sym %s",
// read_state(*head), read_state(*new_sym));
DG("aggregate head %s && sym %s",
read_state(*head), read_state(*new_sym));
while (g_aggrematch[i].top)
{
if (*new_sym == g_aggrematch[i].top
&& MATCH_STACK(*head, 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);
head = (*stack)->content;
// DG("stack after pop: %s", read_state(*head));
DG("stack after pop: %s", read_state(*head));
}
if (eval_sym(stack, *new_sym))
{

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

@ -10,7 +10,7 @@
/* ************************************************************************** */
#include "minishell.h"
t_stackmatch g_stackmatch[] =
{
{TK_WORD, CMD_SUFFIX},
@ -41,15 +41,26 @@ t_stackmatch g_stackmatch[] =
{TK_IO_NUMBER, PIPE_SEMI_SEQUENCE},
{TK_IO_NUMBER, PIPE_CLOSE_SEQUENCE},
{TK_IO_NUMBER, SEQUENCE},
// watch!
{TK_IO_NUMBER, CMD_SUPERIOR},
{TK_IO_NUMBER, AND_OR_MAJOR},
{TK_IO_NUMBER, TK_WHILE},
{TK_IO_NUMBER, TK_UNTIL},
{TK_IO_NUMBER, TK_IF},
{TK_IO_NUMBER, TK_DO},
{TK_IO_NUMBER, TK_ELIF},
{TK_IO_NUMBER, TK_THEN},
{TK_IO_NUMBER, TK_PAREN_CLOSE},
{TK_IO_NUMBER, COMPLETE_CONDITION},
{TK_IO_NUMBER, CONDITION},
{TK_IO_NUMBER, COMPOUND_LIST},
{TK_AND_IF, AND_OR},
{TK_AND_IF, CMD_SUPERIOR},
{TK_AND_IF, PIPE_SEMI_SEQUENCE},
{TK_AND_IF, COMPOUND_LIST},
{TK_OR_IF, AND_OR},
{TK_OR_IF, CMD_SUPERIOR},
{TK_OR_IF, PIPE_SEMI_SEQUENCE},
{TK_OR_IF, COMPOUND_LIST},
{TK_DSEMI, LINEBREAK},
{TK_DSEMI, TK_BANG},
{TK_DSEMI, COMPLETE_COMMANDS},
@ -76,6 +87,18 @@ t_stackmatch g_stackmatch[] =
{TK_LESS, PIPE_SEMI_SEQUENCE},
{TK_LESS, PIPE_CLOSE_SEQUENCE},
{TK_LESS, SEQUENCE},
{TK_LESS, CMD_SUPERIOR},
{TK_LESS, AND_OR_MAJOR},
{TK_LESS, TK_WHILE},
{TK_LESS, TK_UNTIL},
{TK_LESS, TK_IF},
{TK_LESS, TK_DO},
{TK_LESS, TK_ELIF},
{TK_LESS, TK_THEN},
{TK_LESS, TK_PAREN_CLOSE},
{TK_LESS, COMPLETE_CONDITION},
{TK_LESS, CONDITION},
{TK_LESS, COMPOUND_LIST},
// watch !
{TK_LESS, CMD_SUPERIOR},
{TK_LESS, AND_OR_MAJOR},
@ -95,6 +118,18 @@ t_stackmatch g_stackmatch[] =
{TK_GREAT, PIPE_SEMI_SEQUENCE},
{TK_GREAT, PIPE_CLOSE_SEQUENCE},
{TK_GREAT, SEQUENCE},
{TK_GREAT, CMD_SUPERIOR},
{TK_GREAT, AND_OR_MAJOR},
{TK_GREAT, TK_WHILE},
{TK_GREAT, TK_UNTIL},
{TK_GREAT, TK_IF},
{TK_GREAT, TK_DO},
{TK_GREAT, TK_ELIF},
{TK_GREAT, TK_THEN},
{TK_GREAT, TK_PAREN_CLOSE},
{TK_GREAT, COMPLETE_CONDITION},
{TK_GREAT, CONDITION},
{TK_GREAT, COMPOUND_LIST},
// watch !
//duplicate and extend
{TK_GREAT, CMD_SUPERIOR},
@ -116,6 +151,18 @@ t_stackmatch g_stackmatch[] =
{TK_DLESS, PIPE_SEMI_SEQUENCE},
{TK_DLESS, PIPE_CLOSE_SEQUENCE},
{TK_DLESS, SEQUENCE},
{TK_DLESS, CMD_SUPERIOR},
{TK_DLESS, AND_OR_MAJOR},
{TK_DLESS, TK_WHILE},
{TK_DLESS, TK_UNTIL},
{TK_DLESS, TK_IF},
{TK_DLESS, TK_DO},
{TK_DLESS, TK_ELIF},
{TK_DLESS, TK_THEN},
{TK_DLESS, TK_PAREN_CLOSE},
{TK_DLESS, COMPLETE_CONDITION},
{TK_DLESS, CONDITION},
{TK_DLESS, COMPOUND_LIST},
// watch !
{TK_DLESS, CMD_SUPERIOR},
{TK_DLESS, AND_OR_MAJOR},
@ -136,6 +183,18 @@ t_stackmatch g_stackmatch[] =
{TK_DGREAT, PIPE_SEMI_SEQUENCE},
{TK_DGREAT, PIPE_CLOSE_SEQUENCE},
{TK_DGREAT, SEQUENCE},
{TK_DGREAT, CMD_SUPERIOR},
{TK_DGREAT, AND_OR_MAJOR},
{TK_DGREAT, TK_WHILE},
{TK_DGREAT, TK_UNTIL},
{TK_DGREAT, TK_IF},
{TK_DGREAT, TK_DO},
{TK_DGREAT, TK_ELIF},
{TK_DGREAT, TK_THEN},
{TK_DGREAT, TK_PAREN_CLOSE},
{TK_DGREAT, COMPLETE_CONDITION},
{TK_DGREAT, CONDITION},
{TK_DGREAT, COMPOUND_LIST},
// watch !
{TK_DGREAT, CMD_SUPERIOR},
{TK_DGREAT, AND_OR_MAJOR},
@ -156,6 +215,18 @@ t_stackmatch g_stackmatch[] =
{TK_LESSAND, PIPE_SEMI_SEQUENCE},
{TK_LESSAND, PIPE_CLOSE_SEQUENCE},
{TK_LESSAND, SEQUENCE},
{TK_LESSAND, CMD_SUPERIOR},
{TK_LESSAND, AND_OR_MAJOR},
{TK_LESSAND, TK_WHILE},
{TK_LESSAND, TK_UNTIL},
{TK_LESSAND, TK_IF},
{TK_LESSAND, TK_DO},
{TK_LESSAND, TK_ELIF},
{TK_LESSAND, TK_THEN},
{TK_LESSAND, TK_PAREN_CLOSE},
{TK_LESSAND, COMPLETE_CONDITION},
{TK_LESSAND, CONDITION},
{TK_LESSAND, COMPOUND_LIST},
// watch !
{TK_LESSAND, CMD_SUPERIOR},
{TK_LESSAND, AND_OR_MAJOR},
@ -176,6 +247,18 @@ t_stackmatch g_stackmatch[] =
{TK_GREATAND, PIPE_SEMI_SEQUENCE},
{TK_GREATAND, PIPE_CLOSE_SEQUENCE},
{TK_GREATAND, SEQUENCE},
{TK_GREATAND, CMD_SUPERIOR},
{TK_GREATAND, AND_OR_MAJOR},
{TK_GREATAND, TK_WHILE},
{TK_GREATAND, TK_UNTIL},
{TK_GREATAND, TK_IF},
{TK_GREATAND, TK_DO},
{TK_GREATAND, TK_ELIF},
{TK_GREATAND, TK_THEN},
{TK_GREATAND, TK_PAREN_CLOSE},
{TK_GREATAND, COMPLETE_CONDITION},
{TK_GREATAND, CONDITION},
{TK_GREATAND, COMPOUND_LIST},
// watch !
{TK_GREATAND, CMD_SUPERIOR},
{TK_GREATAND, AND_OR_MAJOR},
@ -200,6 +283,7 @@ t_stackmatch g_stackmatch[] =
{TK_IF, TK_THEN},
{TK_IF, TK_PAREN_CLOSE},
{TK_IF, COMPLETE_CONDITION},
{TK_IF, CONDITION},
{TK_IF, COMPOUND_LIST},
{TK_IF, CASE_LIST_NS},
{TK_THEN, CONDITION},
@ -238,6 +322,7 @@ t_stackmatch g_stackmatch[] =
{TK_CASE, TK_ELIF},
{TK_CASE, TK_ELSE},
{TK_CASE, COMPLETE_CONDITION},
{TK_CASE, CONDITION},
{TK_CASE, CASE_LIST_NS},
{TK_CASE, COMPOUND_LIST},
{TK_CASE, NEWLINE_LIST},
@ -270,6 +355,7 @@ t_stackmatch g_stackmatch[] =
{TK_WHILE, TK_PAREN_CLOSE},
{TK_WHILE, TK_THEN},
{TK_WHILE, COMPLETE_CONDITION},
{TK_WHILE, CONDITION},
{TK_UNTIL, LINEBREAK},
{TK_UNTIL, TK_PAREN_OPEN},
{TK_UNTIL, TK_LBRACE},
@ -291,6 +377,7 @@ t_stackmatch g_stackmatch[] =
{TK_UNTIL, TK_THEN},
{TK_UNTIL, TK_PAREN_CLOSE},
{TK_UNTIL, COMPLETE_CONDITION},
{TK_UNTIL, CONDITION},
{TK_FOR, LINEBREAK},
{TK_FOR, TK_BANG},
{TK_FOR, TK_PAREN_OPEN},
@ -312,6 +399,7 @@ t_stackmatch g_stackmatch[] =
{TK_FOR, TK_ELSE},
{TK_FOR, TK_PAREN_CLOSE},
{TK_FOR, COMPLETE_CONDITION},
{TK_FOR, CONDITION},
{TK_LBRACE, COMPLETE_COMMANDS},
{TK_LBRACE, LINEBREAK},
{TK_LBRACE, TK_BANG},
@ -334,6 +422,7 @@ t_stackmatch g_stackmatch[] =
{TK_LBRACE, COMPOUND_LIST},
{TK_LBRACE, CASE_LIST_NS},
{TK_LBRACE, COMPLETE_CONDITION},
{TK_LBRACE, CONDITION},
{TK_LBRACE, TK_IN},
{TK_LBRACE, TK_PIPE},
{TK_RBRACE, TK_SEMI},
@ -402,6 +491,7 @@ t_stackmatch g_stackmatch[] =
{TK_PAREN_OPEN, COMPOUND_LIST},
{TK_PAREN_OPEN, CASE_LIST_NS},
{TK_PAREN_OPEN, COMPLETE_CONDITION},
{TK_PAREN_OPEN, CONDITION},
{TK_PAREN_OPEN, TK_IN},
{TK_PAREN_OPEN, CMD_SUPERIOR},
{OPEN_FUNC, CMD_SUPERIOR},
@ -429,6 +519,7 @@ t_stackmatch g_stackmatch[] =
{END_COMMAND, COMPOUND_LIST},
{END_COMMAND, CASE_LIST_NS},
{END_COMMAND, COMPLETE_CONDITION},
{END_COMMAND, CONDITION},
{SEPARATOR, MATH_SUP},
{SEPARATOR, CMD_SUPERIOR},
{SEPARATOR, TERM},
@ -560,6 +651,18 @@ t_stackmatch g_stackmatch[] =
{IO_HERE, PIPE_SEMI_SEQUENCE},
{IO_HERE, PIPE_CLOSE_SEQUENCE},
{IO_HERE, SEQUENCE},
{IO_HERE, CMD_SUPERIOR},
{IO_HERE, AND_OR_MAJOR},
{IO_HERE, TK_WHILE},
{IO_HERE, TK_UNTIL},
{IO_HERE, TK_IF},
{IO_HERE, TK_DO},
{IO_HERE, TK_ELIF},
{IO_HERE, TK_THEN},
{IO_HERE, TK_PAREN_CLOSE},
{IO_HERE, COMPLETE_CONDITION},
{IO_HERE, CONDITION},
{IO_HERE, COMPOUND_LIST},
// watch !
{FILENAME, TK_LESS},
{FILENAME, TK_LESSAND},
@ -583,6 +686,18 @@ t_stackmatch g_stackmatch[] =
{IO_FILE, PIPE_SEMI_SEQUENCE},
{IO_FILE, PIPE_CLOSE_SEQUENCE},
{IO_FILE, SEQUENCE},
{IO_FILE, CMD_SUPERIOR},
{IO_FILE, AND_OR_MAJOR},
{IO_FILE, TK_WHILE},
{IO_FILE, TK_UNTIL},
{IO_FILE, TK_IF},
{IO_FILE, TK_DO},
{IO_FILE, TK_ELIF},
{IO_FILE, TK_THEN},
{IO_FILE, TK_PAREN_CLOSE},
{IO_FILE, COMPLETE_CONDITION},
{IO_FILE, CONDITION},
{IO_FILE, COMPOUND_LIST},
// watch !
{IO_REDIRECT, REDIRECT_LIST},
{IO_REDIRECT, CMD_SUPERIOR},
@ -600,6 +715,18 @@ t_stackmatch g_stackmatch[] =
{IO_REDIRECT, PIPE_SEMI_SEQUENCE},
{IO_REDIRECT, PIPE_CLOSE_SEQUENCE},
{IO_REDIRECT, SEQUENCE},
{IO_REDIRECT, CMD_SUPERIOR},
{IO_REDIRECT, AND_OR_MAJOR},
{IO_REDIRECT, TK_WHILE},
{IO_REDIRECT, TK_UNTIL},
{IO_REDIRECT, TK_IF},
{IO_REDIRECT, TK_DO},
{IO_REDIRECT, TK_ELIF},
{IO_REDIRECT, TK_THEN},
{IO_REDIRECT, TK_PAREN_CLOSE},
{IO_REDIRECT, COMPLETE_CONDITION},
{IO_REDIRECT, CONDITION},
{IO_REDIRECT, COMPOUND_LIST},
// watch !/
{REDIRECT_LIST, COMPOUND_COMMAND},
{CMD_SUFFIX, CMD_WORD},
@ -615,6 +742,18 @@ t_stackmatch g_stackmatch[] =
{CMD_PREFIX, SEPARATOR_OP},
{CMD_PREFIX, NEWLINE_LIST},
{CMD_PREFIX, SEQUENCE},
{CMD_PREFIX, CMD_SUPERIOR},
{CMD_PREFIX, AND_OR_MAJOR},
{CMD_PREFIX, TK_WHILE},
{CMD_PREFIX, TK_UNTIL},
{CMD_PREFIX, TK_IF},
{CMD_PREFIX, TK_DO},
{CMD_PREFIX, TK_ELIF},
{CMD_PREFIX, TK_THEN},
{CMD_PREFIX, TK_PAREN_CLOSE},
{CMD_PREFIX, COMPLETE_CONDITION},
{CMD_PREFIX, CONDITION},
{CMD_PREFIX, COMPOUND_LIST},
// watch !
{CMD_WORD, CMD_PREFIX},
{CMD_NAME, COMPLETE_COMMANDS},
@ -625,6 +764,10 @@ t_stackmatch g_stackmatch[] =
{CMD_NAME, SEPARATOR_OP},
{CMD_NAME, NEWLINE_LIST},
{CMD_NAME, SEQUENCE},
{CMD_NAME, CMD_SUPERIOR},
{CMD_NAME, AND_OR_MAJOR},
{CMD_NAME, CONDITION},
{CMD_NAME, COMPOUND_LIST},
// watch !
{CMD_NAME, AND_OR_MAJOR},
{CMD_NAME, TK_WHILE},
@ -639,6 +782,7 @@ t_stackmatch g_stackmatch[] =
{CMD_NAME, COMPOUND_LIST},
{CMD_NAME, CASE_LIST_NS},
{CMD_NAME, COMPLETE_CONDITION},
{CMD_NAME, CONDITION},
{CMD_SUPERIOR, TK_WHILE},
{CMD_SUPERIOR, FUNC_NAME},
@ -652,6 +796,7 @@ t_stackmatch g_stackmatch[] =
{CMD_SUPERIOR, COMPOUND_LIST},
{CMD_SUPERIOR, CASE_LIST_NS},
{CMD_SUPERIOR, COMPLETE_CONDITION},
{CMD_SUPERIOR, CONDITION},
{CMD_SUPERIOR, LINEBREAK},
{CMD_SUPERIOR, TK_PAREN_OPEN},
{CMD_SUPERIOR, TK_LBRACE},
@ -690,6 +835,7 @@ t_stackmatch g_stackmatch[] =
{SIMPLE_COMMAND, COMPOUND_LIST},
{SIMPLE_COMMAND, CASE_LIST_NS},
{SIMPLE_COMMAND, COMPLETE_CONDITION},
{SIMPLE_COMMAND, CONDITION},
{SIMPLE_COMMAND, LINEBREAK},
{SIMPLE_COMMAND, TK_PAREN_OPEN},
{SIMPLE_COMMAND, TK_LBRACE},
@ -768,6 +914,7 @@ t_stackmatch g_stackmatch[] =
{UNTIL_CLAUSE, COMPOUND_LIST},
{UNTIL_CLAUSE, CASE_LIST_NS},
{UNTIL_CLAUSE, COMPLETE_CONDITION},
{UNTIL_CLAUSE, CONDITION},
{UNTIL_CLAUSE, AND_OR_MAJOR},
{WHILE_CLAUSE, LINEBREAK},
{WHILE_CLAUSE, COMPLETE_COMMANDS},
@ -789,9 +936,8 @@ t_stackmatch g_stackmatch[] =
{WHILE_CLAUSE, COMPOUND_LIST},
{WHILE_CLAUSE, CASE_LIST_NS},
{WHILE_CLAUSE, COMPLETE_CONDITION},
{WHILE_CLAUSE, CONDITION},
{WHILE_CLAUSE, AND_OR_MAJOR},
// {ELSE_PART, COMPOUND_LIST},
// {ELSE_PART, COMPLETE_CONDITION},
{IF_CLAUSE, LINEBREAK},
{IF_CLAUSE, TK_BANG},
{IF_CLAUSE, TK_PAREN_OPEN},
@ -814,6 +960,7 @@ t_stackmatch g_stackmatch[] =
{IF_CLAUSE, CASE_LIST_NS},
{IF_CLAUSE, COMPLETE_COMMAND},
{IF_CLAUSE, COMPLETE_CONDITION},
{IF_CLAUSE, CONDITION},
{IF_CLAUSE, AND_OR_MAJOR},
{BRACE_CLAUSE, LINEBREAK},
{BRACE_CLAUSE, TK_PAREN_OPEN},
@ -837,6 +984,7 @@ t_stackmatch g_stackmatch[] =
{BRACE_CLAUSE, CASE_LIST_NS},
{BRACE_CLAUSE, COMPLETE_COMMAND},
{BRACE_CLAUSE, COMPLETE_CONDITION},
{BRACE_CLAUSE, CONDITION},
{BRACE_CLAUSE, AND_OR_MAJOR},
{PATTERN, PATTERN_CASE},
{PATTERN, CASE_LIST},
@ -865,6 +1013,7 @@ t_stackmatch g_stackmatch[] =
{CASE_CLAUSE, COMPOUND_LIST},
{CASE_CLAUSE, CASE_LIST_NS},
{CASE_CLAUSE, COMPLETE_CONDITION},
{CASE_CLAUSE, CONDITION},
{CASE_CLAUSE, AND_OR_MAJOR},
{WORDLIST, IN},
@ -892,6 +1041,7 @@ t_stackmatch g_stackmatch[] =
{FOR_CLAUSE, COMPOUND_LIST},
{FOR_CLAUSE, CASE_LIST_NS},
{FOR_CLAUSE, COMPLETE_CONDITION},
{FOR_CLAUSE, CONDITION},
{FOR_CLAUSE, AND_OR_MAJOR},
{COMPOUND_LIST, TK_DO},
{COMPOUND_LIST, TK_PAREN_CLOSE},
@ -906,6 +1056,7 @@ t_stackmatch g_stackmatch[] =
{COMPOUND_LIST, TK_ELSE},
{COMPOUND_LIST, COMPOUND_LIST},
{COMPOUND_LIST, COMPLETE_CONDITION},
{COMPOUND_LIST, CONDITION},
{CLOSE_LIST, PATTERN},
{CLOSE_LIST, FUNC_NAME},
{SUBSHELL, LINEBREAK},
@ -930,6 +1081,7 @@ t_stackmatch g_stackmatch[] =
{SUBSHELL, COMPOUND_LIST},
{SUBSHELL, CASE_LIST_NS},
{SUBSHELL, COMPLETE_CONDITION},
{SUBSHELL, CONDITION},
{SUBSHELL, AND_OR_MAJOR},
{COMPOUND_COMMAND, LINEBREAK},
{COMPOUND_COMMAND, TK_PAREN_OPEN},
@ -953,6 +1105,7 @@ t_stackmatch g_stackmatch[] =
{COMPOUND_COMMAND, COMPOUND_LIST},
{COMPOUND_COMMAND, CASE_LIST_NS},
{COMPOUND_COMMAND, COMPLETE_CONDITION},
{COMPOUND_COMMAND, CONDITION},
{COMPOUND_COMMAND, AND_OR_MAJOR},
{COMMAND, TK_WHILE},
{COMMAND, TK_UNTIL},
@ -970,6 +1123,7 @@ t_stackmatch g_stackmatch[] =
{COMMAND, COMPOUND_LIST},
{COMMAND, CASE_LIST_NS},
{COMMAND, COMPLETE_CONDITION},
{COMMAND, CONDITION},
{COMMAND, SEPARATOR_OP},
{COMMAND, NEWLINE_LIST},
{COMMAND, SEQUENCE},
@ -994,6 +1148,7 @@ t_stackmatch g_stackmatch[] =
{PIPE_SEQUENCE, COMPOUND_LIST},
{PIPE_SEQUENCE, CASE_LIST_NS},
{PIPE_SEQUENCE, COMPLETE_CONDITION},
{PIPE_SEQUENCE, CONDITION},
{PIPE_SEQUENCE, LINEBREAK},
{PIPE_SEQUENCE, TK_BANG},
{PIPE_SEQUENCE, TK_PAREN_OPEN},
@ -1013,6 +1168,7 @@ t_stackmatch g_stackmatch[] =
{TK_BANG, COMPOUND_LIST},
{TK_BANG, CASE_LIST_NS},
{TK_BANG, COMPLETE_CONDITION},
{TK_BANG, CONDITION},
{TK_BANG, LINEBREAK},
{TK_BANG, TK_PAREN_OPEN},
{TK_BANG, TK_LBRACE},
@ -1031,6 +1187,7 @@ t_stackmatch g_stackmatch[] =
{PIPE_SEMI_SEQUENCE, COMPOUND_LIST},
{PIPE_SEMI_SEQUENCE, CASE_LIST_NS},
{PIPE_SEMI_SEQUENCE, COMPLETE_CONDITION},
{PIPE_SEMI_SEQUENCE, CONDITION},
{PIPE_SEMI_SEQUENCE, LINEBREAK},
{PIPE_SEMI_SEQUENCE, TK_BANG},
{PIPE_SEMI_SEQUENCE, TK_PAREN_OPEN},
@ -1051,6 +1208,7 @@ t_stackmatch g_stackmatch[] =
{PIPE_CLOSE_SEQUENCE, COMPOUND_LIST},
{PIPE_CLOSE_SEQUENCE, CASE_LIST_NS},
{PIPE_CLOSE_SEQUENCE, COMPLETE_CONDITION},
{PIPE_CLOSE_SEQUENCE, CONDITION},
{PIPE_CLOSE_SEQUENCE, LINEBREAK},
{PIPE_CLOSE_SEQUENCE, TK_BANG},
{PIPE_CLOSE_SEQUENCE, TK_PAREN_OPEN},
@ -1073,6 +1231,7 @@ t_stackmatch g_stackmatch[] =
{SEQUENCE, COMPOUND_LIST},
{SEQUENCE, CASE_LIST_NS},
{SEQUENCE, COMPLETE_CONDITION},
{SEQUENCE, CONDITION},
{SEQUENCE, LINEBREAK},
{SEQUENCE, TK_PAREN_OPEN},
{SEQUENCE, TK_LBRACE},
@ -1093,6 +1252,7 @@ t_stackmatch g_stackmatch[] =
{PIPELINE, COMPOUND_LIST},
{PIPELINE, CASE_LIST_NS},
{PIPELINE, COMPLETE_CONDITION},
{PIPELINE, CONDITION},
{PIPELINE, LINEBREAK},
{PIPELINE, TK_BANG},
{PIPELINE, TK_PAREN_OPEN},
@ -1120,6 +1280,7 @@ t_stackmatch g_stackmatch[] =
{AND_OR, COMPOUND_LIST},
{AND_OR, CASE_LIST_NS},
{AND_OR, COMPLETE_CONDITION},
{AND_OR, CONDITION},
{AND_OR, LINEBREAK},
{AND_OR, TK_BANG},
{AND_OR, TK_PAREN_OPEN},
@ -1147,7 +1308,7 @@ int eval_sym(t_list **stack, t_sym new_sym)
if (!*stack)
return (1);
head = (*stack)->content;
// DG("eval head %s && sym %s", read_state(*head), read_state(new_sym));
DG("eval head %s && sym %s", read_state(*head), read_state(new_sym));
i = 0;
while (g_stackmatch[i].top)
{

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

@ -55,7 +55,7 @@ int ft_parse(t_btree **ast, t_list **token, t_parser *parser)
else
parser->state = UNDEFINED;
build_tree(ast, token);
btree_print(STDBUG, *ast, &ft_putast);
// btree_print(STDBUG, *ast, &ft_putast);
if ((end_instruction(&parser->stack) && !(*token)->next))
insert_linebreak(token);
else

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 17:58:34 by ariard #+# #+# */
/* Updated: 2017/03/09 18:14:07 by ariard ### ########.fr */
/* Updated: 2017/03/10 18:46:59 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -44,6 +44,7 @@ t_prodmatch g_prodmatch[] =
{TK_WORD, COMPOUND_LIST, CMD_NAME},
{TK_WORD, CASE_LIST_NS, CMD_NAME},
{TK_WORD, COMPLETE_CONDITION, CMD_NAME},
{TK_WORD, CONDITION, CMD_NAME},
{TK_WORD, NEWLINE_LIST, CMD_NAME},
{TK_WORD, TK_BANG, CMD_NAME},
{TK_WORD, SEQUENCE, CMD_NAME},
@ -59,6 +60,13 @@ t_prodmatch g_prodmatch[] =
{TK_ASSIGNEMENT_WORD, TK_LBRACE, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_BANG, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, SEPARATOR_OP, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_WHILE, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_UNTIL, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_FOR, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_IF, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_FI, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_ELIF, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_ELSE, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, NEWLINE_LIST, CMD_PREFIX},
{TK_NAME, TK_BANG, FNAME},
{TK_NAME, LINEBREAK, FNAME},
@ -76,6 +84,7 @@ t_prodmatch g_prodmatch[] =
{TK_NEWLINE, TK_IN, NEWLINE_LIST},
{TK_NEWLINE, TK_WHILE, NEWLINE_LIST},
{TK_NEWLINE, TK_UNTIL, NEWLINE_LIST},
{TK_NEWLINE, TK_FOR, NEWLINE_LIST},
{TK_NEWLINE, TK_IF, NEWLINE_LIST},
{TK_NEWLINE, TK_FI, NEWLINE_LIST},
{TK_NEWLINE, TK_ELIF, NEWLINE_LIST},