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

correction aggregation + gestion erreur de syntax - heredoc en meme temps

Browse source
This commit is contained in:
Antoine Riard 2017-03-09 18:39:53 +01:00
parent 70372a4d85
commit 8eb20e36aa
16 changed files with 139 additions and 38 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

30
42sh/error Normal file
View file

@ -0,0 +1,30 @@
42sh
Makefile
STDBUG
TESTSHELL
donovan_segaults_06-02
error
includes
libft
objs
pdf
sample
src
test_framework.sh
testmake
update_makefile.sh
42sh
Makefile
STDBUG
TESTSHELL
donovan_segaults_06-02
error
includes
libft
objs
pdf
sample
src
test_framework.sh
testmake
update_makefile.sh

0
42sh/file3 Normal file
View file

3
42sh/includes/parser.h
View file

@ -30,7 +30,6 @@ struct s_parser
t_parstate state; t_parstate state;
t_list *stack; t_list *stack;
t_sym *new_sym; t_sym *new_sym;
t_list *heredoc_queue;
}; };
struct s_aggrematch struct s_aggrematch
@ -75,7 +74,7 @@ int aggregate_sym(t_list **stack, t_sym *new_sym, t_parstate *state);
int push_stack(t_list **stack, t_sym new_sym); int push_stack(t_list **stack, t_sym new_sym);
int pop_stack(t_list **stack, t_sym erase_sym); int pop_stack(t_list **stack, t_sym erase_sym);
int pop_heredoc(t_list **heredoc_queue, t_list **lst); int pop_heredoc(t_list **lst);
int error_syntax(t_list **token, t_parser *parser, t_btree **ast); int error_syntax(t_list **token, t_parser *parser, t_btree **ast);
int error_EOF(t_list **token, t_parser *parser, t_btree **ast); int error_EOF(t_list **token, t_parser *parser, t_btree **ast);

3
42sh/includes/types.h
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */ /* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/13 17:11:48 by jhalford #+# #+# */ /* Created: 2016/12/13 17:11:48 by jhalford #+# #+# */
/* Updated: 2017/03/09 15:16:47 by ariard ### ########.fr */ /* Updated: 2017/03/09 17:58:18 by ariard ### ########.fr */
/* Updated: 2017/03/07 18:35:11 by jhalford ### ########.fr */ /* Updated: 2017/03/07 18:35:11 by jhalford ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -176,6 +176,7 @@ enum e_sym
LOOP, LOOP,
FUNC, FUNC,
PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE,
PIPE_CLOSE_SEQUENCE,
CMD_SUPERIOR, CMD_SUPERIOR,
SEQUENCE, SEQUENCE,
AND_OR_MAJOR, AND_OR_MAJOR,

0
42sh/ret2 Normal file
View file

1
42sh/src/main/instruction_free.c
View file

@ -6,5 +6,6 @@ int instruction_free(t_list **token, t_parser *parser, t_btree **ast)
token = NULL; token = NULL;
ft_lstdel(&parser->stack, NULL); ft_lstdel(&parser->stack, NULL);
btree_del(ast, &ast_free); btree_del(ast, &ast_free);
ft_lstdel(&data_singleton()->heredoc_queue, &redir_free);
return (0); return (0);
} }

12
42sh/src/main/main.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jhalford@student.42.fr> +#+ +:+ +#+ */ /* By: jhalford <jhalford@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/06 18:40:58 by jhalford #+# #+# */ /* Created: 2016/12/06 18:40:58 by jhalford #+# #+# */
/* Updated: 2017/03/09 16:03:50 by ariard ### ########.fr */ /* Updated: 2017/03/09 17:37:38 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -28,7 +28,6 @@ int handle_instruction(int fd)
ast = NULL; ast = NULL;
while (1) while (1)
{ {
if ((ret = readline(fd, get_lexer_stack(lexer) || if ((ret = readline(fd, get_lexer_stack(lexer) ||
parser.state == UNDEFINED || lexer.state == HEREDOC, &str))) parser.state == UNDEFINED || lexer.state == HEREDOC, &str)))
{ {
@ -53,10 +52,9 @@ int handle_instruction(int fd)
return (1); return (1);
if (ft_parse(&ast, &token, &parser)) if (ft_parse(&ast, &token, &parser))
continue ; continue ;
DG(); if (parser.state == ERROR)
lexer.state = (data_singleton()->heredoc_queue) ? HEREDOC : 0; error_syntax(&token, &parser, &ast);
if (data_singleton()->heredoc_queue) lexer.state = data_singleton()->heredoc_queue ? HEREDOC : 0;
DG("still in HEREDOC");
if (lexer.state) if (lexer.state)
continue; continue;
else if (parser.state == SUCCESS) else if (parser.state == SUCCESS)
@ -66,8 +64,6 @@ int handle_instruction(int fd)
ft_add_str_in_history(lexer.str); ft_add_str_in_history(lexer.str);
return (error_syntax(&token, &parser, &ast)); return (error_syntax(&token, &parser, &ast));
} }
else if (parser.state == ERROR)
error_syntax(&token, &parser, &ast);
} }
DG("Before execution:"); DG("Before execution:");
btree_print(STDBUG, ast, &ft_putast); btree_print(STDBUG, ast, &ft_putast);

3
42sh/src/parser/add_redir.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 16:39:05 by ariard #+# #+# */ /* Created: 2017/02/17 16:39:05 by ariard #+# #+# */
/* Updated: 2017/03/08 22:11:07 by ariard ### ########.fr */ /* Updated: 2017/03/09 18:29:45 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -97,6 +97,7 @@ int add_redir_type(t_btree **ast, t_list **lst)
|| token->type == TK_LESSAND) ? STDIN : STDOUT; || token->type == TK_LESSAND) ? STDIN : STDOUT;
redir.type = token->type; redir.type = token->type;
redir.heredoc_data = NULL; redir.heredoc_data = NULL;
redir.word = NULL;
ft_lsteadd(&node->data.cmd.redir, ft_lstnew(&redir, sizeof(redir))); ft_lsteadd(&node->data.cmd.redir, ft_lstnew(&redir, sizeof(redir)));
if (token->type == TK_DLESS) if (token->type == TK_DLESS)
ft_lsteadd(&data_singleton()->heredoc_queue, ft_lstnew(&redir, sizeof(redir))); ft_lsteadd(&data_singleton()->heredoc_queue, ft_lstnew(&redir, sizeof(redir)));

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

@ -21,6 +21,7 @@ t_aggrematch g_aggrematch[] =
{TK_SEMI, FOR_WORDLIST, SEQUENTIAL_SEP, 0}, {TK_SEMI, FOR_WORDLIST, SEQUENTIAL_SEP, 0},
{TK_DSEMI, CMD_SUPERIOR, PIPE_SEQUENCE, CMD_SUPERIOR}, {TK_DSEMI, CMD_SUPERIOR, PIPE_SEQUENCE, CMD_SUPERIOR},
{TK_DSEMI, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE}, {TK_DSEMI, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{TK_DSEMI, PIPE_CLOSE_SEQUENCE, PIPE_SEQUENCE, PIPE_CLOSE_SEQUENCE},
{TK_PAREN_OPEN, TK_IN, PATTERN_CASE, 0}, {TK_PAREN_OPEN, TK_IN, PATTERN_CASE, 0},
{TK_PAREN_OPEN, CASE_LIST_NS, PATTERN_CASE, 0}, {TK_PAREN_OPEN, CASE_LIST_NS, PATTERN_CASE, 0},
{TK_PAREN_OPEN, TK_PAREN_OPEN, MATH, TK_PAREN_OPEN}, {TK_PAREN_OPEN, TK_PAREN_OPEN, MATH, TK_PAREN_OPEN},
@ -28,7 +29,7 @@ t_aggrematch g_aggrematch[] =
{TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, 0}, {TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, 0},
{TK_PIPE, CMD_SUPERIOR, SEQUENCE, CMD_SUPERIOR}, {TK_PIPE, CMD_SUPERIOR, SEQUENCE, CMD_SUPERIOR},
{TK_PIPE, PIPE_SEMI_SEQUENCE, SEQUENCE, PIPE_SEMI_SEQUENCE}, {TK_PIPE, PIPE_SEMI_SEQUENCE, SEQUENCE, PIPE_SEMI_SEQUENCE},
// {TK_PIPE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE}, {TK_PIPE, PIPE_CLOSE_SEQUENCE, SEQUENCE, PIPE_CLOSE_SEQUENCE},
{TK_FI, ELSE_PART, IF_CLAUSE, TK_IF}, {TK_FI, ELSE_PART, IF_CLAUSE, TK_IF},
{TK_FI, COMPOUND_LIST, IF_CLAUSE, COMPLETE_CONDITION}, {TK_FI, COMPOUND_LIST, IF_CLAUSE, COMPLETE_CONDITION},
{TK_FI, COMPLETE_CONDITION, IF_CLAUSE, COMPLETE_CONDITION}, {TK_FI, COMPLETE_CONDITION, IF_CLAUSE, COMPLETE_CONDITION},
@ -45,15 +46,16 @@ t_aggrematch g_aggrematch[] =
{TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, TK_PAREN_OPEN}, {TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, CMD_SUPERIOR, SUBSHELL, TK_PAREN_OPEN}, {TK_PAREN_CLOSE, CMD_SUPERIOR, SUBSHELL, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE, SUBSHELL, TK_PAREN_OPEN}, {TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE, SUBSHELL, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, PIPE_CLOSE_SEQUENCE, SUBSHELL, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, OPEN_FUNC, CLOSE_FUNC, OPEN_FUNC}, {TK_PAREN_CLOSE, OPEN_FUNC, CLOSE_FUNC, OPEN_FUNC},
{CLOSE_FUNC, CMD_SUPERIOR, FUNC_NAME, CMD_SUPERIOR}, {CLOSE_FUNC, CMD_SUPERIOR, FUNC_NAME, CMD_SUPERIOR},
{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_RBRACE, PIPE_SEMI_SEQUENCE, BRACE_CLAUSE, TK_LBRACE}, {TK_RBRACE, PIPE_SEMI_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_RBRACE, PIPE_SEMI_SEQUENCE, BRACE_CLAUSE, TK_LBRACE},
{TK_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR}, {TK_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
{TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR}, {TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
//watch this //watch this
@ -62,11 +64,13 @@ t_aggrematch g_aggrematch[] =
{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},
{SEPARATOR_OP, PIPE_SEMI_SEQUENCE, SEPARATOR, 0}, {SEPARATOR_OP, PIPE_SEMI_SEQUENCE, SEPARATOR, 0},
{SEPARATOR_OP, PIPE_CLOSE_SEQUENCE, SEPARATOR, 0},
{SEPARATOR, MATH_SUP, CMD_SUPERIOR, MATH_SUP}, {SEPARATOR, MATH_SUP, CMD_SUPERIOR, MATH_SUP},
{SEPARATOR, CMD_SUPERIOR, END_COMMAND, CMD_SUPERIOR}, {SEPARATOR, CMD_SUPERIOR, END_COMMAND, CMD_SUPERIOR},
{SEPARATOR, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS}, {SEPARATOR, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST}, {SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
{SEPARATOR, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE}, {SEPARATOR, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{SEPARATOR, PIPE_CLOSE_SEQUENCE, PIPE_SEQUENCE, PIPE_CLOSE_SEQUENCE},
{LINEBREAK, MATH_SUP, CMD_SUPERIOR, MATH_SUP}, {LINEBREAK, MATH_SUP, CMD_SUPERIOR, MATH_SUP},
{LINEBREAK, SEPARATOR_OP, SEPARATOR, SEPARATOR_OP}, {LINEBREAK, SEPARATOR_OP, SEPARATOR, SEPARATOR_OP},
{LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, TK_SEMI}, {LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, TK_SEMI},
@ -76,6 +80,7 @@ t_aggrematch g_aggrematch[] =
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK}, {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
{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, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST}, {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, MATH_SUP, CMD_SUPERIOR, MATH_SUP}, {NEWLINE_LIST, MATH_SUP, CMD_SUPERIOR, MATH_SUP},
@ -124,6 +129,7 @@ t_aggrematch g_aggrematch[] =
{IO_HERE, ALL, IO_REDIRECT, 0}, {IO_HERE, ALL, IO_REDIRECT, 0},
{IO_REDIRECT, CMD_SUPERIOR, CMD_SUPERIOR, CMD_SUPERIOR}, {IO_REDIRECT, CMD_SUPERIOR, CMD_SUPERIOR, CMD_SUPERIOR},
{IO_REDIRECT, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE}, {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}, {IO_REDIRECT, COMPOUND_COMMAND, REDIRECT_LIST, REDIRECT_LIST},
//to check //to check
@ -143,6 +149,7 @@ t_aggrematch g_aggrematch[] =
{CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, CMD_NAME}, {CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, CMD_NAME},
{CMD_SUFFIX, CMD_SUPERIOR, CMD_SUPERIOR, CMD_SUPERIOR}, {CMD_SUFFIX, CMD_SUPERIOR, CMD_SUPERIOR, CMD_SUPERIOR},
{CMD_SUFFIX, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE}, {CMD_SUFFIX, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE},
{CMD_SUFFIX, PIPE_CLOSE_SEQUENCE, PIPE_CLOSE_SEQUENCE, PIPE_CLOSE_SEQUENCE},
//to abstract //to abstract
{CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, 0}, {CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_PAREN_OPEN, SIMPLE_COMMAND, 0}, {CMD_PREFIX, TK_PAREN_OPEN, SIMPLE_COMMAND, 0},
@ -174,7 +181,6 @@ t_aggrematch g_aggrematch[] =
{CMD_NAME, COMPLETE_CONDITION, CMD_SUPERIOR, 0}, {CMD_NAME, COMPLETE_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, PIPE_SEMI_SEQUENCE, CMD_SUPERIOR, 0},
{CMD_NAME, AND_OR_MAJOR, CMD_SUPERIOR, 0}, {CMD_NAME, AND_OR_MAJOR, 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},
@ -209,8 +215,9 @@ 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},
{COMPOUND_COMMAND, ALL, COMMAND, 0}, // {COMPOUND_COMMAND, ALL, COMMAND, 0},
{AND_OR_MINOR, PIPE_SEMI_SEQUENCE, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE}, {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, LINEBREAK, AND_OR_MAJOR, 0},
{AND_OR_MINOR, TK_PAREN_OPEN, 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, TK_LBRACE, AND_OR_MAJOR, 0},
@ -218,7 +225,6 @@ t_aggrematch g_aggrematch[] =
{AND_OR_MINOR, AND_OR_MAJOR, AND_OR_MAJOR, 0}, {AND_OR_MINOR, AND_OR_MAJOR, AND_OR_MAJOR, 0},
{AND_OR_MINOR, TK_BANG, AND_OR_MAJOR, 0}, {AND_OR_MINOR, TK_BANG, AND_OR_MAJOR, 0},
{COMMAND, SEQUENCE, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, SEQUENCE, PIPE_SEMI_SEQUENCE, 0},
// {COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE},
// watch // watch
{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},
@ -240,6 +246,27 @@ t_aggrematch g_aggrematch[] =
{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_MAJOR, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, COMPLETE_CONDITION, PIPE_SEMI_SEQUENCE, 0}, {COMMAND, COMPLETE_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},
{COMPOUND_COMMAND, TK_WHILE, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_UNTIL, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_DO, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_PAREN_CLOSE, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_IF, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_THEN, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_ELIF, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_ELSE, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_BANG, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, SEPARATOR_OP, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, NEWLINE_LIST, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, LINEBREAK, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_BANG, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_PAREN_OPEN, PIPE_CLOSE_SEQUENCE, 0},
{COMPOUND_COMMAND, TK_LBRACE, PIPE_CLOSE_SEQUENCE, 0},
{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},
{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, LIST, AND_OR_MAJOR}, {END_COMMAND, AND_OR_MAJOR, LIST, AND_OR_MAJOR},
@ -261,6 +288,7 @@ t_aggrematch g_aggrematch[] =
{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},
{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_SEQUENCE, TK_WHILE, PIPELINE, 0}, {PIPE_SEQUENCE, TK_WHILE, PIPELINE, 0},
{PIPE_SEQUENCE, TK_UNTIL, PIPELINE, 0}, {PIPE_SEQUENCE, TK_UNTIL, PIPELINE, 0},
{PIPE_SEQUENCE, TK_BANG, PIPELINE, TK_BANG}, {PIPE_SEQUENCE, TK_BANG, PIPELINE, TK_BANG},
@ -339,21 +367,21 @@ int aggregate_sym(t_list **stack, t_sym *new_sym, t_parstate *state)
return (1); return (1);
i = 0; i = 0;
head = (*stack)->content; head = (*stack)->content;
DG("aggregate head %s && sym %s", // DG("aggregate head %s && sym %s",
read_state(*head), read_state(*new_sym)); // read_state(*head), read_state(*new_sym));
while (g_aggrematch[i].top) while (g_aggrematch[i].top)
{ {
if (*new_sym == g_aggrematch[i].top if (*new_sym == g_aggrematch[i].top
&& MATCH_STACK(*head, g_aggrematch[i].under)) && 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; *new_sym = g_aggrematch[i].new_sym;
if (g_aggrematch[i].erase_sym) if (g_aggrematch[i].erase_sym)
{ {
pop_stack(stack, g_aggrematch[i].erase_sym); pop_stack(stack, g_aggrematch[i].erase_sym);
head = (*stack)->content; 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)) if (eval_sym(stack, *new_sym))
{ {

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/15 18:32:59 by ariard #+# #+# */ /* Created: 2017/02/15 18:32:59 by ariard #+# #+# */
/* Updated: 2017/03/07 19:32:15 by ariard ### ########.fr */ /* Updated: 2017/03/09 18:33:05 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -20,6 +20,8 @@ t_treematch g_treematch[] =
{TK_SEMI, &add_sep}, {TK_SEMI, &add_sep},
{TK_GREAT, &add_cmd}, {TK_GREAT, &add_cmd},
{TK_LESS, &add_cmd}, {TK_LESS, &add_cmd},
{TK_GREATAND, &add_cmd},
{TK_LESSAND, &add_cmd},
{TK_DGREAT, &add_cmd}, {TK_DGREAT, &add_cmd},
{TK_DLESS, &add_cmd}, {TK_DLESS, &add_cmd},
{TK_IO_NUMBER, &add_cmd}, {TK_IO_NUMBER, &add_cmd},

5
42sh/src/parser/error_syntax.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 20:15:35 by ariard #+# #+# */ /* Created: 2017/02/09 20:15:35 by ariard #+# #+# */
/* Updated: 2017/03/09 15:44:56 by ariard ### ########.fr */ /* Updated: 2017/03/09 16:37:14 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -58,9 +58,10 @@ int error_syntax(t_list **lst, t_parser *parser,
t_token *token; t_token *token;
int i; int i;
if (!*lst)
return (0);
token = (*lst)->content; token = (*lst)->content;
i = 0; i = 0;
while (g_errormatch[i].token) while (g_errormatch[i].token)
{ {
if (g_errormatch[i].token == token->type) if (g_errormatch[i].token == token->type)

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

@ -40,6 +40,7 @@ t_stackmatch g_stackmatch[] =
{TK_IO_NUMBER, SEPARATOR_OP}, {TK_IO_NUMBER, SEPARATOR_OP},
{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, SEQUENCE}, {TK_IO_NUMBER, SEQUENCE},
// watch! // watch!
{TK_IO_NUMBER, CMD_SUPERIOR}, {TK_IO_NUMBER, CMD_SUPERIOR},
@ -56,6 +57,7 @@ t_stackmatch g_stackmatch[] =
{TK_DSEMI, CASE_LIST_NS}, {TK_DSEMI, CASE_LIST_NS},
{TK_DSEMI, CMD_SUPERIOR}, {TK_DSEMI, CMD_SUPERIOR},
{TK_DSEMI, PIPE_SEMI_SEQUENCE}, {TK_DSEMI, PIPE_SEMI_SEQUENCE},
{TK_DSEMI, PIPE_CLOSE_SEQUENCE},
{TK_DSEMI, SEQUENCE}, {TK_DSEMI, SEQUENCE},
// watch! // watch!
{TK_LESS, TK_IO_NUMBER}, {TK_LESS, TK_IO_NUMBER},
@ -73,6 +75,7 @@ t_stackmatch g_stackmatch[] =
{TK_LESS, SEPARATOR_OP}, {TK_LESS, SEPARATOR_OP},
{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, SEQUENCE}, {TK_LESS, SEQUENCE},
// watch ! // watch !
{TK_LESS, CMD_SUPERIOR}, {TK_LESS, CMD_SUPERIOR},
@ -92,6 +95,7 @@ t_stackmatch g_stackmatch[] =
{TK_GREAT, SEPARATOR_OP}, {TK_GREAT, SEPARATOR_OP},
{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, SEQUENCE}, {TK_GREAT, SEQUENCE},
// watch ! // watch !
//duplicate and extend //duplicate and extend
@ -113,6 +117,7 @@ t_stackmatch g_stackmatch[] =
{TK_DLESS, SEPARATOR_OP}, {TK_DLESS, SEPARATOR_OP},
{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, SEQUENCE}, {TK_DLESS, SEQUENCE},
// watch ! // watch !
{TK_DLESS, CMD_SUPERIOR}, {TK_DLESS, CMD_SUPERIOR},
@ -134,6 +139,7 @@ t_stackmatch g_stackmatch[] =
{TK_DLESSDASH, SEPARATOR_OP}, {TK_DLESSDASH, SEPARATOR_OP},
{TK_DLESSDASH, NEWLINE_LIST}, {TK_DLESSDASH, NEWLINE_LIST},
{TK_DLESSDASH, PIPE_SEMI_SEQUENCE}, {TK_DLESSDASH, PIPE_SEMI_SEQUENCE},
{TK_DLESSDASH, PIPE_CLOSE_SEQUENCE},
{TK_DLESSDASH, SEQUENCE}, {TK_DLESSDASH, SEQUENCE},
// watch ! // watch !
{TK_DLESSDASH, CMD_SUPERIOR}, {TK_DLESSDASH, CMD_SUPERIOR},
@ -155,6 +161,7 @@ t_stackmatch g_stackmatch[] =
{TK_DGREAT, SEPARATOR_OP}, {TK_DGREAT, SEPARATOR_OP},
{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, SEQUENCE}, {TK_DGREAT, SEQUENCE},
// watch ! // watch !
{TK_DGREAT, CMD_SUPERIOR}, {TK_DGREAT, CMD_SUPERIOR},
@ -176,6 +183,7 @@ t_stackmatch g_stackmatch[] =
{TK_LESSAND, SEPARATOR_OP}, {TK_LESSAND, SEPARATOR_OP},
{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, SEQUENCE}, {TK_LESSAND, SEQUENCE},
// watch ! // watch !
{TK_LESSAND, CMD_SUPERIOR}, {TK_LESSAND, CMD_SUPERIOR},
@ -197,6 +205,7 @@ t_stackmatch g_stackmatch[] =
{TK_GREATAND, SEPARATOR_OP}, {TK_GREATAND, SEPARATOR_OP},
{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, SEQUENCE}, {TK_GREATAND, SEQUENCE},
// watch ! // watch !
{TK_GREATAND, CMD_SUPERIOR}, {TK_GREATAND, CMD_SUPERIOR},
@ -365,6 +374,7 @@ t_stackmatch g_stackmatch[] =
{TK_LBRACE, CASE_LIST_NS}, {TK_LBRACE, CASE_LIST_NS},
{TK_LBRACE, COMPLETE_CONDITION}, {TK_LBRACE, COMPLETE_CONDITION},
{TK_LBRACE, TK_IN}, {TK_LBRACE, TK_IN},
{TK_LBRACE, TK_PIPE},
{TK_RBRACE, TK_SEMI}, {TK_RBRACE, TK_SEMI},
{TK_RBRACE, END_COMMAND}, {TK_RBRACE, END_COMMAND},
{TK_RBRACE, SEPARATOR_OP}, {TK_RBRACE, SEPARATOR_OP},
@ -372,11 +382,11 @@ t_stackmatch g_stackmatch[] =
{TK_RBRACE, IN}, {TK_RBRACE, IN},
{TK_RBRACE, TK_AND_IF}, {TK_RBRACE, TK_AND_IF},
{TK_RBRACE, TK_OR_IF}, {TK_RBRACE, TK_OR_IF},
{TK_RBRACE, TK_PIPE},
{TK_RBRACE, TK_RBRACE}, {TK_RBRACE, TK_RBRACE},
{TK_RBRACE, COMPLETE_COMMANDS}, {TK_RBRACE, COMPLETE_COMMANDS},
{TK_RBRACE, CMD_SUPERIOR}, {TK_RBRACE, CMD_SUPERIOR},
{TK_RBRACE, PIPE_SEMI_SEQUENCE}, {TK_RBRACE, PIPE_SEMI_SEQUENCE},
{TK_RBRACE, PIPE_CLOSE_SEQUENCE},
{TK_RBRACE, CASE_LIST_NS}, {TK_RBRACE, CASE_LIST_NS},
{TK_RBRACE, PROGRAM}, {TK_RBRACE, PROGRAM},
{TK_RBRACE, TK_PAREN_OPEN}, {TK_RBRACE, TK_PAREN_OPEN},
@ -405,6 +415,7 @@ t_stackmatch g_stackmatch[] =
{TK_PIPE, PATTERN}, {TK_PIPE, PATTERN},
{TK_PIPE, CMD_SUPERIOR}, {TK_PIPE, CMD_SUPERIOR},
{TK_PIPE, PIPE_SEMI_SEQUENCE}, {TK_PIPE, PIPE_SEMI_SEQUENCE},
{TK_PIPE, PIPE_CLOSE_SEQUENCE},
{PATTERN_CASE, TK_IN}, {PATTERN_CASE, TK_IN},
{PATTERN_CASE, CASE_LIST_NS}, {PATTERN_CASE, CASE_LIST_NS},
{TK_PAREN_OPEN, COMPLETE_COMMANDS}, {TK_PAREN_OPEN, COMPLETE_COMMANDS},
@ -462,6 +473,7 @@ t_stackmatch g_stackmatch[] =
{SEPARATOR, COMPOUND_LIST}, {SEPARATOR, COMPOUND_LIST},
{SEPARATOR, CASE_LIST_NS}, {SEPARATOR, CASE_LIST_NS},
{SEPARATOR, PIPE_SEMI_SEQUENCE}, {SEPARATOR, PIPE_SEMI_SEQUENCE},
{SEPARATOR, PIPE_CLOSE_SEQUENCE},
{SEPARATOR_OP, MATH_SUP}, {SEPARATOR_OP, MATH_SUP},
{SEPARATOR_OP, CMD_SUPERIOR}, {SEPARATOR_OP, CMD_SUPERIOR},
{SEPARATOR_OP, LIST}, {SEPARATOR_OP, LIST},
@ -469,6 +481,7 @@ t_stackmatch g_stackmatch[] =
{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},
{SEPARATOR_OP, PIPE_CLOSE_SEQUENCE},
{LINEBREAK, MATH_SUP}, {LINEBREAK, MATH_SUP},
{LINEBREAK, TK_SEMI}, {LINEBREAK, TK_SEMI},
{LINEBREAK, END_COMMAND}, {LINEBREAK, END_COMMAND},
@ -484,6 +497,7 @@ t_stackmatch g_stackmatch[] =
{LINEBREAK, COMPLETE_COMMANDS}, {LINEBREAK, COMPLETE_COMMANDS},
{LINEBREAK, CMD_SUPERIOR}, {LINEBREAK, CMD_SUPERIOR},
{LINEBREAK, PIPE_SEMI_SEQUENCE}, {LINEBREAK, PIPE_SEMI_SEQUENCE},
{LINEBREAK, PIPE_CLOSE_SEQUENCE},
{LINEBREAK, COMPOUND_LIST}, {LINEBREAK, COMPOUND_LIST},
{LINEBREAK, CASE_LIST_NS}, {LINEBREAK, CASE_LIST_NS},
{LINEBREAK, PROGRAM}, {LINEBREAK, PROGRAM},
@ -502,6 +516,7 @@ t_stackmatch g_stackmatch[] =
{TK_PAREN_CLOSE, COMPLETE_COMMANDS}, {TK_PAREN_CLOSE, COMPLETE_COMMANDS},
{TK_PAREN_CLOSE, CMD_SUPERIOR}, {TK_PAREN_CLOSE, CMD_SUPERIOR},
{TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE}, {TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE},
{TK_PAREN_CLOSE, PIPE_CLOSE_SEQUENCE},
{TK_PAREN_CLOSE, CASE_LIST_NS}, {TK_PAREN_CLOSE, CASE_LIST_NS},
{TK_PAREN_CLOSE, PROGRAM}, {TK_PAREN_CLOSE, PROGRAM},
{TK_PAREN_CLOSE, TK_LBRACE}, {TK_PAREN_CLOSE, TK_LBRACE},
@ -524,6 +539,7 @@ t_stackmatch g_stackmatch[] =
{TK_RBRACE, COMPLETE_COMMANDS}, {TK_RBRACE, COMPLETE_COMMANDS},
{TK_RBRACE, CMD_SUPERIOR}, {TK_RBRACE, CMD_SUPERIOR},
{TK_RBRACE, PIPE_SEMI_SEQUENCE}, {TK_RBRACE, PIPE_SEMI_SEQUENCE},
{TK_RBRACE, PIPE_CLOSE_SEQUENCE},
{TK_RBRACE, CASE_LIST_NS}, {TK_RBRACE, CASE_LIST_NS},
{TK_RBRACE, PROGRAM}, {TK_RBRACE, PROGRAM},
{TK_RBRACE, TK_LBRACE}, {TK_RBRACE, TK_LBRACE},
@ -580,6 +596,7 @@ t_stackmatch g_stackmatch[] =
{IO_HERE, SEPARATOR_OP}, {IO_HERE, SEPARATOR_OP},
{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, SEQUENCE}, {IO_HERE, SEQUENCE},
// watch ! // watch !
{FILENAME, TK_LESS}, {FILENAME, TK_LESS},
@ -602,6 +619,7 @@ t_stackmatch g_stackmatch[] =
{IO_FILE, SEPARATOR_OP}, {IO_FILE, SEPARATOR_OP},
{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, SEQUENCE}, {IO_FILE, SEQUENCE},
// watch ! // watch !
{IO_REDIRECT, REDIRECT_LIST}, {IO_REDIRECT, REDIRECT_LIST},
@ -618,6 +636,7 @@ t_stackmatch g_stackmatch[] =
{IO_REDIRECT, SEPARATOR_OP}, {IO_REDIRECT, SEPARATOR_OP},
{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, SEQUENCE}, {IO_REDIRECT, SEQUENCE},
// watch !/ // watch !/
{REDIRECT_LIST, COMPOUND_COMMAND}, {REDIRECT_LIST, COMPOUND_COMMAND},
@ -625,6 +644,7 @@ t_stackmatch g_stackmatch[] =
{CMD_SUFFIX, CMD_NAME}, {CMD_SUFFIX, CMD_NAME},
{CMD_SUFFIX, CMD_SUPERIOR}, {CMD_SUFFIX, CMD_SUPERIOR},
{CMD_SUFFIX, PIPE_SEMI_SEQUENCE}, {CMD_SUFFIX, PIPE_SEMI_SEQUENCE},
{CMD_SUFFIX, PIPE_CLOSE_SEQUENCE},
{CMD_PREFIX, LINEBREAK}, {CMD_PREFIX, LINEBREAK},
{CMD_PREFIX, TK_PAREN_OPEN}, {CMD_PREFIX, TK_PAREN_OPEN},
{CMD_PREFIX, TK_LBRACE}, {CMD_PREFIX, TK_LBRACE},
@ -1064,7 +1084,28 @@ t_stackmatch g_stackmatch[] =
{PIPE_SEMI_SEQUENCE, NEWLINE_LIST}, {PIPE_SEMI_SEQUENCE, NEWLINE_LIST},
{PIPE_SEMI_SEQUENCE, AND_OR_MAJOR}, {PIPE_SEMI_SEQUENCE, AND_OR_MAJOR},
{PIPE_SEMI_SEQUENCE, SEQUENCE}, {PIPE_SEMI_SEQUENCE, SEQUENCE},
{PIPE_CLOSE_SEQUENCE, TK_WHILE},
{PIPE_CLOSE_SEQUENCE, TK_UNTIL},
{PIPE_CLOSE_SEQUENCE, TK_DO},
{PIPE_CLOSE_SEQUENCE, TK_PAREN_CLOSE},
{PIPE_CLOSE_SEQUENCE, TK_IF},
{PIPE_CLOSE_SEQUENCE, TK_ELIF},
{PIPE_CLOSE_SEQUENCE, TK_THEN},
{PIPE_CLOSE_SEQUENCE, TK_ELSE},
{PIPE_CLOSE_SEQUENCE, COMPOUND_LIST},
{PIPE_CLOSE_SEQUENCE, CASE_LIST_NS},
{PIPE_CLOSE_SEQUENCE, COMPLETE_CONDITION},
{PIPE_CLOSE_SEQUENCE, LINEBREAK},
{PIPE_CLOSE_SEQUENCE, TK_BANG},
{PIPE_CLOSE_SEQUENCE, TK_PAREN_OPEN},
{PIPE_CLOSE_SEQUENCE, TK_LBRACE},
{PIPE_CLOSE_SEQUENCE, COMPLETE_COMMANDS},
{PIPE_CLOSE_SEQUENCE, SEPARATOR_OP},
{PIPE_CLOSE_SEQUENCE, NEWLINE_LIST},
{PIPE_CLOSE_SEQUENCE, AND_OR_MAJOR},
{PIPE_CLOSE_SEQUENCE, SEQUENCE},
{SEQUENCE, PIPE_SEMI_SEQUENCE}, {SEQUENCE, PIPE_SEMI_SEQUENCE},
{SEQUENCE, PIPE_CLOSE_SEQUENCE},
{SEQUENCE, TK_WHILE}, {SEQUENCE, TK_WHILE},
{SEQUENCE, TK_UNTIL}, {SEQUENCE, TK_UNTIL},
{SEQUENCE, TK_DO}, {SEQUENCE, TK_DO},
@ -1150,7 +1191,7 @@ int eval_sym(t_list **stack, t_sym new_sym)
if (!*stack) if (!*stack)
return (1); return (1);
head = (*stack)->content; 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; i = 0;
while (g_stackmatch[i].top) while (g_stackmatch[i].top)
{ {

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

@ -34,12 +34,12 @@ int ft_parse(t_btree **ast, t_list **token, t_parser *parser)
{ {
t_sym *head; t_sym *head;
if (pop_heredoc(&parser->heredoc_queue, token)) if (pop_heredoc(token))
return (0); return (0);
while (*token) while (*token)
{ {
produce_sym(&parser->stack, parser->new_sym, token); produce_sym(&parser->stack, parser->new_sym, token);
DG("new sym %s", read_state(*parser->new_sym)); // DG("new sym %s", read_state(*parser->new_sym));
if (eval_sym(&parser->stack, *parser->new_sym)) if (eval_sym(&parser->stack, *parser->new_sym))
return ((parser->state = ERROR)); return ((parser->state = ERROR));
else else

13
42sh/src/parser/heredoc_parser.c
View file

@ -6,13 +6,13 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/03/08 16:21:05 by ariard #+# #+# */ /* Created: 2017/03/08 16:21:05 by ariard #+# #+# */
/* Updated: 2017/03/08 23:18:29 by ariard ### ########.fr */ /* Updated: 2017/03/09 17:34:31 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "minishell.h" #include "minishell.h"
int pop_heredoc(t_list **heredoc_queue, t_list **lst) int pop_heredoc(t_list **lst)
{ {
t_token *token; t_token *token;
t_list *temp; t_list *temp;
@ -20,21 +20,20 @@ int pop_heredoc(t_list **heredoc_queue, t_list **lst)
t_redir *head; t_redir *head;
temp = NULL; temp = NULL;
if (!heredoc_queue && !*heredoc_queue)
return (0);
token = (*lst)->content; token = (*lst)->content;
if (token->type == HEREDOCDATA) if (token->type == HEREDOCDATA && data_singleton()->heredoc_queue)
{ {
head = data_singleton()->heredoc_queue->content; head = data_singleton()->heredoc_queue->content;
temp = data_singleton()->heredoc_queue; temp = data_singleton()->heredoc_queue;
DG("compare %s with %s", (char *)token->data, head->word); DG("compare %s with %s", (char *)token->data, head->word);
if (head && ft_strcmp((char *)token->data, head->word) == 0) if (head && token && ft_strcmp((char *)token->data, head->word) == 0)
{ {
DG();
temp2 = temp->next; temp2 = temp->next;
free(temp); free(temp);
data_singleton()->heredoc_queue = temp2; data_singleton()->heredoc_queue = temp2;
} }
else else if (token)
head->heredoc_data = ft_strjoin(head->heredoc_data, token->data); head->heredoc_data = ft_strjoin(head->heredoc_data, token->data);
ft_lstdel(lst, &token_free); ft_lstdel(lst, &token_free);
return (1); return (1);

3
42sh/src/parser/parser_init.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/21 16:14:04 by ariard #+# #+# */ /* Created: 2017/02/21 16:14:04 by ariard #+# #+# */
/* Updated: 2017/03/08 21:56:56 by ariard ### ########.fr */ /* Updated: 2017/03/09 16:49:14 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -19,5 +19,4 @@ void parser_init(t_parser *parser)
parser->stack = NULL; parser->stack = NULL;
push_stack(&parser->stack, TERMINUS); push_stack(&parser->stack, TERMINUS);
push_stack(&parser->stack, LINEBREAK); push_stack(&parser->stack, LINEBREAK);
parser->heredoc_queue = NULL;
} }

5
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/08 18:00:22 by ariard ### ########.fr */ /* Updated: 2017/03/09 18:14:07 by ariard ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -89,6 +89,7 @@ t_prodmatch g_prodmatch[] =
{TK_NEWLINE, TK_LBRACE, NEWLINE_LIST}, {TK_NEWLINE, TK_LBRACE, NEWLINE_LIST},
{TK_NEWLINE, CMD_SUPERIOR, LINEBREAK}, {TK_NEWLINE, CMD_SUPERIOR, LINEBREAK},
{TK_NEWLINE, PIPE_SEMI_SEQUENCE, LINEBREAK}, {TK_NEWLINE, PIPE_SEMI_SEQUENCE, LINEBREAK},
{TK_NEWLINE, PIPE_CLOSE_SEQUENCE, LINEBREAK},
{TK_NEWLINE, SEQUENCE, LINEBREAK}, {TK_NEWLINE, SEQUENCE, LINEBREAK},
{TK_NEWLINE, CASE_LIST_NS, NEWLINE_LIST}, {TK_NEWLINE, CASE_LIST_NS, NEWLINE_LIST},
{TK_NEWLINE, COMPOUND_LIST, NEWLINE_LIST}, {TK_NEWLINE, COMPOUND_LIST, NEWLINE_LIST},
@ -101,10 +102,12 @@ t_prodmatch g_prodmatch[] =
{TK_SEMI, CMD_SUPERIOR, SEPARATOR_OP}, {TK_SEMI, CMD_SUPERIOR, SEPARATOR_OP},
{TK_SEMI, LIST, SEPARATOR_OP}, {TK_SEMI, LIST, SEPARATOR_OP},
{TK_SEMI, PIPE_SEMI_SEQUENCE, SEPARATOR_OP}, {TK_SEMI, PIPE_SEMI_SEQUENCE, SEPARATOR_OP},
{TK_SEMI, PIPE_CLOSE_SEQUENCE, SEPARATOR_OP},
{TK_AMP, MATH_SUP, SEPARATOR_OP}, {TK_AMP, MATH_SUP, SEPARATOR_OP},
{TK_AMP, CMD_SUPERIOR, SEPARATOR_OP}, {TK_AMP, CMD_SUPERIOR, SEPARATOR_OP},
{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},
{0, 0, 0}, {0, 0, 0},
}; };