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_list *stack;
t_sym *new_sym;
t_list *heredoc_queue;
};
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 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_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> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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 */
/* */
/* ************************************************************************** */
@ -176,6 +176,7 @@ enum e_sym
LOOP,
FUNC,
PIPE_SEMI_SEQUENCE,
PIPE_CLOSE_SEQUENCE,
CMD_SUPERIOR,
SEQUENCE,
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;
ft_lstdel(&parser->stack, NULL);
btree_del(ast, &ast_free);
ft_lstdel(&data_singleton()->heredoc_queue, &redir_free);
return (0);
}

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

@ -6,7 +6,7 @@
/* By: jhalford <jhalford@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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;
while (1)
{
if ((ret = readline(fd, get_lexer_stack(lexer) ||
parser.state == UNDEFINED || lexer.state == HEREDOC, &str)))
{
@ -53,10 +52,9 @@ int handle_instruction(int fd)
return (1);
if (ft_parse(&ast, &token, &parser))
continue ;
DG();
lexer.state = (data_singleton()->heredoc_queue) ? HEREDOC : 0;
if (data_singleton()->heredoc_queue)
DG("still in HEREDOC");
if (parser.state == ERROR)
error_syntax(&token, &parser, &ast);
lexer.state = data_singleton()->heredoc_queue ? HEREDOC : 0;
if (lexer.state)
continue;
else if (parser.state == SUCCESS)
@ -66,8 +64,6 @@ int handle_instruction(int fd)
ft_add_str_in_history(lexer.str);
return (error_syntax(&token, &parser, &ast));
}
else if (parser.state == ERROR)
error_syntax(&token, &parser, &ast);
}
DG("Before execution:");
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> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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;
redir.type = token->type;
redir.heredoc_data = NULL;
redir.word = NULL;
ft_lsteadd(&node->data.cmd.redir, ft_lstnew(&redir, sizeof(redir)));
if (token->type == TK_DLESS)
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_DSEMI, CMD_SUPERIOR, PIPE_SEQUENCE, CMD_SUPERIOR},
{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, CASE_LIST_NS, PATTERN_CASE, 0},
{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_PIPE, CMD_SUPERIOR, SEQUENCE, CMD_SUPERIOR},
{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, COMPOUND_LIST, 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, CMD_SUPERIOR, 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},
{CLOSE_FUNC, CMD_SUPERIOR, FUNC_NAME, CMD_SUPERIOR},
{TK_RBRACE, COMPOUND_LIST, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, CMD_SUPERIOR, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, PIPE_SEMI_SEQUENCE, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, PIPE_CLOSE_SEQUENCE, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, COMPOUND_LIST, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, CMD_SUPERIOR, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, PIPE_SEMI_SEQUENCE, BRACE_CLAUSE, TK_LBRACE},
{TK_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
{TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
//watch this
@ -62,11 +64,13 @@ t_aggrematch g_aggrematch[] =
{SEPARATOR_OP, COMPOUND_LIST, SEPARATOR, 0},
{SEPARATOR_OP, CASE_LIST_NS, SEPARATOR, 0},
{SEPARATOR_OP, PIPE_SEMI_SEQUENCE, SEPARATOR, 0},
{SEPARATOR_OP, PIPE_CLOSE_SEQUENCE, SEPARATOR, 0},
{SEPARATOR, MATH_SUP, CMD_SUPERIOR, MATH_SUP},
{SEPARATOR, CMD_SUPERIOR, END_COMMAND, CMD_SUPERIOR},
{SEPARATOR, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
{SEPARATOR, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{SEPARATOR, PIPE_CLOSE_SEQUENCE, PIPE_SEQUENCE, PIPE_CLOSE_SEQUENCE},
{LINEBREAK, MATH_SUP, CMD_SUPERIOR, MATH_SUP},
{LINEBREAK, SEPARATOR_OP, SEPARATOR, SEPARATOR_OP},
{LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, TK_SEMI},
@ -76,6 +80,7 @@ t_aggrematch g_aggrematch[] =
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
{LINEBREAK, CMD_SUPERIOR, SEPARATOR_OP, 0},
{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, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{NEWLINE_LIST, MATH_SUP, CMD_SUPERIOR, MATH_SUP},
@ -124,6 +129,7 @@ t_aggrematch g_aggrematch[] =
{IO_HERE, ALL, IO_REDIRECT, 0},
{IO_REDIRECT, CMD_SUPERIOR, CMD_SUPERIOR, CMD_SUPERIOR},
{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
@ -143,6 +149,7 @@ t_aggrematch g_aggrematch[] =
{CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, CMD_NAME},
{CMD_SUFFIX, CMD_SUPERIOR, CMD_SUPERIOR, CMD_SUPERIOR},
{CMD_SUFFIX, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE},
{CMD_SUFFIX, PIPE_CLOSE_SEQUENCE, PIPE_CLOSE_SEQUENCE, PIPE_CLOSE_SEQUENCE},
//to abstract
{CMD_PREFIX, LINEBREAK, 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, TK_PIPE, 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_SUPERIOR, SEQUENCE, PIPE_SEMI_SEQUENCE, SEQUENCE},
{SIMPLE_COMMAND, ALL, COMMAND, 0},
@ -209,8 +215,9 @@ t_aggrematch g_aggrematch[] =
{SUBSHELL, ALL, COMPOUND_COMMAND, 0},
{BRACE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{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_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},
@ -218,7 +225,6 @@ t_aggrematch g_aggrematch[] =
{AND_OR_MINOR, AND_OR_MAJOR, AND_OR_MAJOR, 0},
{AND_OR_MINOR, TK_BANG, AND_OR_MAJOR, 0},
{COMMAND, SEQUENCE, PIPE_SEMI_SEQUENCE, 0},
// {COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE},
// watch
{COMMAND, COMPOUND_LIST, 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, AND_OR_MAJOR, 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, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{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, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{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_UNTIL, PIPELINE, 0},
{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);
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))
{

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

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

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;
if (pop_heredoc(&parser->heredoc_queue, token))
if (pop_heredoc(token))
return (0);
while (*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))
return ((parser->state = ERROR));
else

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

@ -6,13 +6,13 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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"
int pop_heredoc(t_list **heredoc_queue, t_list **lst)
int pop_heredoc(t_list **lst)
{
t_token *token;
t_list *temp;
@ -20,21 +20,20 @@ int pop_heredoc(t_list **heredoc_queue, t_list **lst)
t_redir *head;
temp = NULL;
if (!heredoc_queue && !*heredoc_queue)
return (0);
token = (*lst)->content;
if (token->type == HEREDOCDATA)
if (token->type == HEREDOCDATA && data_singleton()->heredoc_queue)
{
head = data_singleton()->heredoc_queue->content;
temp = data_singleton()->heredoc_queue;
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;
free(temp);
data_singleton()->heredoc_queue = temp2;
}
else
else if (token)
head->heredoc_data = ft_strjoin(head->heredoc_data, token->data);
ft_lstdel(lst, &token_free);
return (1);

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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;
push_stack(&parser->stack, TERMINUS);
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> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* 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, CMD_SUPERIOR, LINEBREAK},
{TK_NEWLINE, PIPE_SEMI_SEQUENCE, LINEBREAK},
{TK_NEWLINE, PIPE_CLOSE_SEQUENCE, LINEBREAK},
{TK_NEWLINE, SEQUENCE, LINEBREAK},
{TK_NEWLINE, CASE_LIST_NS, NEWLINE_LIST},
{TK_NEWLINE, COMPOUND_LIST, NEWLINE_LIST},
@ -101,10 +102,12 @@ t_prodmatch g_prodmatch[] =
{TK_SEMI, CMD_SUPERIOR, SEPARATOR_OP},
{TK_SEMI, LIST, SEPARATOR_OP},
{TK_SEMI, PIPE_SEMI_SEQUENCE, SEPARATOR_OP},
{TK_SEMI, PIPE_CLOSE_SEQUENCE, SEPARATOR_OP},
{TK_AMP, MATH_SUP, SEPARATOR_OP},
{TK_AMP, CMD_SUPERIOR, SEPARATOR_OP},
{TK_AMP, LIST, SEPARATOR_OP},
{TK_AMP, PIPE_SEMI_SEQUENCE, SEPARATOR_OP},
{TK_AMP, PIPE_CLOSE_SEQUENCE, SEPARATOR_OP},
{0, 0, 0},
};