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

subshell et case ok

Browse source
This commit is contained in:
ariard@student.42.fr 2017-02-24 19:30:20 +01:00
parent d50a0d1b13
commit 0461285d95
17 changed files with 228 additions and 56 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
42sh/Makefile
View file

@ -6,7 +6,7 @@
# By: wescande <wescande@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2016/08/29 21:32:58 by wescande #+# #+# #
# Updated: 2017/02/21 21:32:36 by ariard ### ########.fr #
# Updated: 2017/02/24 18:49:55 by ariard ### ########.fr #
# #
# **************************************************************************** #
@ -225,6 +225,7 @@ main/shell_get_avdata.c\
main/shell_get_opts.c\
main/shell_init.c\
parser/add_cmd.c\
parser/add_subshell.c\
parser/add_condition.c\
parser/add_file.c\
parser/add_loop.c\

7
42sh/includes/parser.h
View file

@ -44,7 +44,6 @@ enum e_sym
TK_PAREN_OPEN,
TK_PAREN_CLOSE,
TK_BQUOTE,
TK_SUBSHELL,
TK_NEWLINE,
TK_WHILE,
TK_DO,
@ -63,6 +62,7 @@ enum e_sym
TK_IO_NUMBER,
TK_DLESSDASH,
TK_LESSGREAT,
TK_SUBSHELL,
TK_CASE,
TK_IN,
TK_ESAC,
@ -119,7 +119,6 @@ enum e_sym
LOOP,
FUNC,
PIPE_SEMI_SEQUENCE,
PATTERN_CASE,
CMD_SUPERIOR,
AND_OR_MAJOR,
AND_OR_MINOR,
@ -127,6 +126,7 @@ enum e_sym
CONDITION,
COMPLETE_CONDITION,
FOR_WORDLIST,
PATTERN_CASE,
ALL = 200,
};
@ -220,10 +220,13 @@ int add_branch(t_btree **ast, t_list **lst);
int add_case_cmd(t_btree **ast, t_list **lst);
int add_case_sep(t_btree **ast, t_list **lst);
int add_pattern(t_btree **ast, t_list **lst);
int add_subshell_cmd(t_btree **ast, t_list **lst);
int add_subshell_sep(t_btree **ast, t_list **lst);
int isloop(t_btree **ast, t_list **lst);
int isdir(t_btree **ast);
int iscase(t_btree **ast, t_list **lst);
int iscondition(t_btree **ast, t_list **lst);
int issubshell(t_btree **ast, t_list **lst);
int join_ast(t_btree **ast, t_btree **new_node);
int gen_node(t_btree **ast);

1
42sh/sample/case/case.sh
View file

@ -3,5 +3,4 @@ case $rental in
("yolo") echo bonjour
esac ;;
("van") echo yolo ;;
("bicycle") echo hola ;;
esac

1
42sh/sample/subshell/subshell01.sh Normal file
View file

@ -0,0 +1 @@
(ls | cat && pwd)

4
42sh/src/lexer/lexer_sep.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/30 16:29:57 by jhalford #+# #+# */
/* Updated: 2017/02/20 20:54:07 by ariard ### ########.fr */
/* Updated: 2017/02/24 19:14:57 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -39,6 +39,6 @@ int lexer_sep(t_list **alst, t_lexer *lexer)
token->type = cn == '|' ? TK_OR_IF : TK_PIPE;
token->type = (c == ';') ? TK_SEMI : token->type;
token->type = (c == ';') && (cn == ';') ? TK_DSEMI : token->type;
lexer->pos += 1 + (token->type & (TK_AND_IF | TK_OR_IF) ? 1 : 0);
lexer->pos += 1 + (token->type & (TK_AND_IF | TK_OR_IF | TK_DSEMI) ? 1 : 0);
return (lexer_lex(&(*alst)->next, lexer));
}

4
42sh/src/main/ft_putast.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/14 18:18:04 by jhalford #+# #+# */
/* Updated: 2017/02/24 16:24:19 by ariard ### ########.fr */
/* Updated: 2017/02/24 19:06:19 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,6 +16,8 @@ char *ft_putast(void *nodein)
{
t_astnode *node;
node = nodein;
if (node->type == SUBSHELL)
return ("SUBSHELL");
if (node->type == TK_NAME)
return ("TK_NAME");
if (node->type == TK_FOR)

2
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/02/24 16:17:54 by ariard ### ########.fr */
/* Updated: 2017/02/24 18:39:09 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/15 20:49:15 by ariard #+# #+# */
/* Updated: 2017/02/24 16:29:21 by ariard ### ########.fr */
/* Updated: 2017/02/24 19:29:04 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -21,6 +21,8 @@ int add_cmd(t_btree **ast, t_list **lst)
DG("add cmd");
if (!*ast)
gen_node(ast);
else if ((token = (*lst)->content)->type == TK_IN)
return (0);
else if (isdir(ast))
return (add_file(ast, lst));
else if (isloop(ast, lst) == 3)
@ -37,11 +39,12 @@ int add_cmd(t_btree **ast, t_list **lst)
return (add_case_cmd(ast, lst));
else if (iscase(ast, lst) == 3)
return (add_branch(ast, lst));
else if ((node = (*ast)->item)->type != TK_DO && node->type != TK_THEN
&& node->type != TK_PAREN_CLOSE && node->type != TK_ESAC)
else if (issubshell(ast, lst))
return (add_subshell_cmd(ast, lst));
else if ((node = (*ast)->item)->type != TK_DO && node->type != TK_THEN
&& node->type != TK_PAREN_CLOSE)
return (add_cmd(&(*ast)->right, lst));
my_tab = NULL;
token = (*lst)->content;
node = (*ast)->item;
node->type = token->type;
if (token->type == TK_WORD)

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 22:17:14 by ariard #+# #+# */
/* Updated: 2017/02/24 16:28:27 by ariard ### ########.fr */
/* Updated: 2017/02/24 18:47:29 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

4
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/02/24 16:08:47 by ariard ### ########.fr */
/* Updated: 2017/02/24 18:54:09 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -25,6 +25,8 @@ int add_sep(t_btree **ast, t_list **lst)
return (add_condition_sep(ast, lst));
else if (iscase(ast, lst) == 2)
return (add_case_sep(ast, lst));
else if (issubshell(ast, lst))
return (add_subshell_sep(ast, lst));
if (!*ast)
gen_node(ast);
token = (*lst)->content;

48
42sh/src/parser/add_subshell.c Normal file
View file

@ -0,0 +1,48 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* add_subshell.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/24 18:41:50 by ariard #+# #+# */
/* Updated: 2017/02/24 19:16:06 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser.h"
int issubshell(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
node = NULL;
token = (*lst)->content;
DG("test loop");
if (*ast)
{
node = (*ast)->item;
if (node->type == SUBSHELL && node->full == 0)
return (1);
}
return (0);
}
int add_subshell_cmd(t_btree **ast, t_list **lst)
{
t_token *token;
t_astnode *node;
DG("add subshell");
token = (*lst)->content;
node = (*ast)->item;
if (token->type == TK_PAREN_CLOSE && node->type == SUBSHELL)
return ((node->full = 1));
return (add_cmd(&(*ast)->right, lst));
}
int add_subshell_sep(t_btree **ast, t_list **lst)
{
return (add_sep(&(*ast)->right, lst));
}

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 17:39:18 by ariard #+# #+# */
/* Updated: 2017/02/21 20:40:31 by ariard ### ########.fr */
/* Updated: 2017/02/24 18:25:45 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -20,6 +20,8 @@ t_aggrematch g_aggrematch[] =
{TK_WORD, FOR_WORDLIST, FOR_WORDLIST, FOR_WORDLIST},
{TK_SEMI, FOR_WORDLIST, SEQUENTIAL_SEP, 0},
{TK_DSEMI, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{TK_PAREN_OPEN, TK_IN, PATTERN_CASE, 0},
{TK_PAREN_OPEN, CASE_LIST_NS, PATTERN_CASE, 0},
{TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, 0},
{TK_PIPE, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR},
{TK_FI, ELSE_PART, IF_CLAUSE, TK_IF},
@ -34,6 +36,9 @@ t_aggrematch g_aggrematch[] =
{TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, TK_CASE},
{TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, TK_LBRACE},
{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_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
{TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
//watch this
@ -49,11 +54,8 @@ t_aggrematch g_aggrematch[] =
{LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, TK_SEMI},
//to abstract TK_ESAC
{LINEBREAK, TK_PAREN_CLOSE, CASE_ITEM_NS, PATTERN_CASE},
{LINEBREAK, TK_PAREN_CLOSE, FUNC, FNAME},
//paren open
{LINEBREAK, TK_DSEMI, CASE_ITEM, PATTERN_CASE},
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
{LINEBREAK, TK_PIPE, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE},
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
{LINEBREAK, CMD_SUPERIOR, SEPARATOR_OP, 0},
@ -108,6 +110,7 @@ t_aggrematch g_aggrematch[] =
{IO_REDIRECT, CMD_WORD, CMD_SUFFIX, 0},
{IO_REDIRECT, CMD_PREFIX, CMD_PREFIX, CMD_PREFIX},
{IO_REDIRECT, LINEBREAK, CMD_PREFIX, 0},
{IO_REDIRECT, TK_PAREN_OPEN, CMD_PREFIX, 0},
{IO_REDIRECT, COMPLETE_COMMANDS, CMD_PREFIX, 0},
{IO_REDIRECT, TK_BANG, CMD_PREFIX, 0},
{IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, 0},
@ -118,6 +121,7 @@ t_aggrematch g_aggrematch[] =
{CMD_SUFFIX, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR},
//to abstract
{CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_PAREN_OPEN, SIMPLE_COMMAND, 0},
{CMD_PREFIX, COMPLETE_COMMANDS, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, 0},
{CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, 0},
@ -126,6 +130,7 @@ t_aggrematch g_aggrematch[] =
{CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, CMD_PREFIX},
//to check
{CMD_NAME, LINEBREAK, CMD_SUPERIOR, 0},
{CMD_NAME, TK_PAREN_OPEN, CMD_SUPERIOR, 0},
{CMD_NAME, COMPLETE_COMMANDS, CMD_SUPERIOR, 0},
{CMD_NAME, TK_BANG, CMD_SUPERIOR, 0},
{CMD_NAME, SEPARATOR_OP, CMD_SUPERIOR, 0},
@ -160,15 +165,13 @@ t_aggrematch g_aggrematch[] =
// {ELSE_PART, COMPOUND_LIST, ELSE_PART, TK_ELIF},
// {ELSE_PART, COMPLETE_CONDITION, IF_CLAUSE, COMPLETE_CONDITION},
{IF_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{PATTERN, CASE_LIST, PATTERN_CASE, 0},
{CASE_LIST_NS, TK_IN, TK_IN, TK_IN},
{CASE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{FOR_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{TERM, LINEBREAK, COMPOUND_LIST, LINEBREAK},
// {COMPOUND_LIST, TK_ELSE, ELSE_PART, TK_ELSE},
{COMPOUND_LIST, TK_IF, CONDITION, TK_IF},
{COMPOUND_LIST, TK_THEN, CONDITION, TK_THEN},
{COMPOUND_LIST, TK_PAREN_CLOSE, CASE_LIST_NS, TK_PAREN_OPEN},
{COMPOUND_LIST, TK_PAREN_CLOSE, CASE_LIST_NS, PATTERN_CASE},
{COMPOUND_LIST, COMPLETE_CONDITION, COMPLETE_CONDITION, COMPLETE_CONDITION},
// {COMPOUND_LIST, TK_THEN, ELSE_PART, TK_ELIF},
{COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
@ -177,6 +180,7 @@ t_aggrematch g_aggrematch[] =
{COMPOUND_COMMAND, ALL, COMMAND, 0},
{AND_OR_MINOR, PIPE_SEMI_SEQUENCE, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE},
{AND_OR_MINOR, LINEBREAK, AND_OR_MAJOR, 0},
{AND_OR_MINOR, TK_PAREN_OPEN, AND_OR_MAJOR, 0},
{AND_OR_MINOR, COMPLETE_COMMANDS, AND_OR_MAJOR, 0},
{AND_OR_MINOR, AND_OR_MAJOR, AND_OR_MAJOR, 0},
{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE},
@ -194,9 +198,9 @@ t_aggrematch g_aggrematch[] =
{COMMAND, SEPARATOR_OP, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, NEWLINE_LIST, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_PAREN_OPEN, 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},
{END_COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{END_COMMAND, AND_OR_MAJOR, LIST, AND_OR_MAJOR},
@ -204,6 +208,7 @@ t_aggrematch g_aggrematch[] =
{END_COMMAND, TK_WHILE, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_UNTIL, PIPE_SEQUENCE, 0},
{END_COMMAND, LINEBREAK, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_PAREN_OPEN, PIPE_SEQUENCE, 0},
{END_COMMAND, COMPLETE_COMMANDS, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_DO, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_PAREN_CLOSE, PIPE_SEQUENCE, 0},
@ -220,6 +225,7 @@ t_aggrematch g_aggrematch[] =
{PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, 0},
{PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, 0},
{PIPE_SEQUENCE, LINEBREAK, PIPELINE, 0},
{PIPE_SEQUENCE, TK_PAREN_OPEN, PIPELINE, 0},
{PIPE_SEQUENCE, COMPLETE_COMMANDS, PIPELINE, 0},
{PIPE_SEQUENCE, AND_OR_MAJOR, PIPELINE, 0},
{PIPE_SEQUENCE, TK_DO, PIPELINE, 0},
@ -243,6 +249,7 @@ t_aggrematch g_aggrematch[] =
{PIPELINE, COMPOUND_LIST, AND_OR, 0},
{PIPELINE, CASE_LIST_NS, AND_OR, 0},
{PIPELINE, LINEBREAK, AND_OR, 0},
{PIPELINE, TK_PAREN_OPEN, AND_OR, 0},
{PIPELINE, COMPLETE_COMMANDS, AND_OR, 0},
// {PIPELINE, LINEBREAK, AND_OR, AND_OR},
{PIPELINE, SEPARATOR_OP, AND_OR, 0},
@ -263,12 +270,15 @@ t_aggrematch g_aggrematch[] =
{AND_OR, SEPARATOR_OP, LIST, LIST},
{AND_OR, NEWLINE_LIST, LIST, 0},
{AND_OR, LINEBREAK, LIST, 0},
{AND_OR, TK_PAREN_OPEN, LIST, 0},
{AND_OR, COMPLETE_COMMANDS, LIST, 0},
{LIST, NEWLINE_LIST, COMPLETE_COMMAND, 0},
{LIST, LINEBREAK, COMPLETE_COMMAND, 0},
{LIST, TK_PAREN_OPEN, LIST, 0},
{LIST, COMPLETE_COMMANDS, COMPLETE_COMMAND, 0},
{COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, COMPLETE_COMMANDS},
{COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, 0},
{COMPLETE_COMMAND, TK_PAREN_OPEN, COMPLETE_COMMANDS, 0},
{COMPLETE_COMMAND, COMPLETE_COMMANDS, COMPLETE_COMMANDS, 0},
{COMPLETE_COMMANDS, COMPLETE_COMMANDS, COMPLETE_COMMANDS, COMPLETE_COMMANDS},
{0, 0, 0, 0},
@ -279,20 +289,20 @@ int aggregate_sym(t_sym **stack, t_sym *new_sym, t_parstate *state)
int i;
i = 0;
// DG("aggregate head %s && sym %s",
// read_state(**stack), read_state(*new_sym));
DG("aggregate head %s && sym %s",
read_state(**stack), read_state(*new_sym));
while (g_aggrematch[i].top)
{
if (*new_sym == g_aggrematch[i].top
&& MATCH_STACK(**stack, g_aggrematch[i].under))
{
// 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);
// DG("stack after pop: %s", read_state(**stack));
DG("stack after pop: %s", read_state(**stack));
}
if (eval_sym(**stack, *new_sym))
return ((*state = ERROR));

16
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/02/24 16:24:44 by ariard ### ########.fr */
/* Updated: 2017/02/24 19:27:32 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -33,17 +33,20 @@ t_treematch g_treematch[] =
{TK_NEWLINE, &add_sep},
{TK_CASE, &add_cmd},
{TK_ESAC, &add_cmd},
{TK_IN, &add_cmd},
{TK_DSEMI, &add_cmd},
{TK_PAREN_OPEN, &add_cmd},
{TK_PAREN_CLOSE, &add_cmd},
{TK_FOR, &add_cmd},
{SUBSHELL, &add_cmd},
{0, NULL},
};
static int isseparator(int type, int cache)
static int isseparator(t_token *token, int cache)
{
if (type == TK_NEWLINE && (cache == TK_WHILE || cache == TK_DO
if (token->type == TK_NEWLINE && (cache == TK_WHILE || cache == TK_DO
|| cache == TK_NEWLINE || cache == TK_THEN || cache == TK_IN
|| cache == TK_WORD))
|| cache == TK_WORD || cache == TK_DSEMI))
return (0);
return (1);
}
@ -58,10 +61,11 @@ int build_tree(t_btree **ast, t_list **lst)
token = (*lst)->content;
//check bug de cache case ?
// cache = token->type;
if (token->type == TK_PAREN_OPEN && cache != TK_IN && cache != TK_DSEMI)
token->type = SUBSHELL;
while (g_treematch[i].type)
{
if (g_treematch[i].type == token->type
&& isseparator(token->type, cache))
if ((isseparator(token, cache) && g_treematch[i].type == token->type))
{
DG("func TK : '%s' TK : '%s'",

3
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/02/21 19:27:59 by jhalford ### ########.fr */
/* Updated: 2017/02/24 19:12:35 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,6 +16,7 @@ t_errormatch g_errormatch[] =
{
{TK_NEWLINE, "newline"},
{TK_SEMI, ";"},
{TK_DSEMI, ";;"},
{TK_PIPE, "|"},
{TK_AMP, "&"},
{TK_LESS, "<"},

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

@ -18,6 +18,7 @@ t_stackmatch g_stackmatch[] =
{TK_WORD, TK_CASE},
{TK_WORD, WORDLIST},
{TK_WORD, LINEBREAK},
{TK_WORD, TK_PAREN_OPEN},
{TK_WORD, COMPLETE_COMMANDS},
{TK_WORD, TK_IN},
{TK_WORD, FOR_WORDLIST},
@ -28,6 +29,7 @@ t_stackmatch g_stackmatch[] =
{TK_IO_NUMBER, CMD_NAME},
{TK_IO_NUMBER, CMD_WORD},
{TK_IO_NUMBER, LINEBREAK},
{TK_IO_NUMBER, TK_PAREN_OPEN},
{TK_IO_NUMBER, COMPLETE_COMMANDS},
{TK_IO_NUMBER, TK_BANG},
{TK_IO_NUMBER, SEPARATOR_OP},
@ -52,6 +54,7 @@ t_stackmatch g_stackmatch[] =
{TK_LESS, CMD_WORD},
{TK_LESS, CMD_NAME},
{TK_LESS, LINEBREAK},
{TK_LESS, TK_PAREN_OPEN},
{TK_LESS, COMPLETE_COMMANDS},
{TK_LESS, TK_BANG},
{TK_LESS, SEPARATOR_OP},
@ -66,6 +69,7 @@ t_stackmatch g_stackmatch[] =
{TK_GREAT, CMD_WORD},
{TK_GREAT, CMD_NAME},
{TK_GREAT, LINEBREAK},
{TK_GREAT, TK_PAREN_OPEN},
{TK_GREAT, COMPLETE_COMMANDS},
{TK_GREAT, TK_BANG},
{TK_GREAT, SEPARATOR_OP},
@ -82,6 +86,7 @@ t_stackmatch g_stackmatch[] =
{TK_DLESS, CMD_WORD},
{TK_DLESS, CMD_NAME},
{TK_DLESS, LINEBREAK},
{TK_DLESS, TK_PAREN_OPEN},
{TK_DLESS, COMPLETE_COMMANDS},
{TK_DLESS, TK_BANG},
{TK_DLESS, SEPARATOR_OP},
@ -97,6 +102,7 @@ t_stackmatch g_stackmatch[] =
{TK_DLESSDASH, CMD_WORD},
{TK_DLESSDASH, CMD_NAME},
{TK_DLESSDASH, LINEBREAK},
{TK_DLESSDASH, TK_PAREN_OPEN},
{TK_DLESSDASH, COMPLETE_COMMANDS},
{TK_DLESSDASH, TK_BANG},
{TK_DLESSDASH, TK_BANG},
@ -113,6 +119,7 @@ t_stackmatch g_stackmatch[] =
{TK_DGREAT, CMD_WORD},
{TK_DGREAT, CMD_NAME},
{TK_DGREAT, LINEBREAK},
{TK_DGREAT, TK_PAREN_OPEN},
{TK_DGREAT, COMPLETE_COMMANDS},
{TK_DGREAT, TK_BANG},
{TK_DGREAT, TK_BANG},
@ -129,6 +136,7 @@ t_stackmatch g_stackmatch[] =
{TK_LESSAND, CMD_WORD},
{TK_LESSAND, CMD_NAME},
{TK_LESSAND, LINEBREAK},
{TK_LESSAND, TK_PAREN_OPEN},
{TK_LESSAND, COMPLETE_COMMANDS},
{TK_LESSAND, TK_BANG},
{TK_LESSAND, TK_BANG},
@ -145,6 +153,7 @@ t_stackmatch g_stackmatch[] =
{TK_GREATAND, CMD_WORD},
{TK_GREATAND, CMD_NAME},
{TK_GREATAND, LINEBREAK},
{TK_GREATAND, TK_PAREN_OPEN},
{TK_GREATAND, COMPLETE_COMMANDS},
{TK_LESSAND, TK_BANG},
{TK_GREATAND, TK_BANG},
@ -161,6 +170,7 @@ t_stackmatch g_stackmatch[] =
{TK_LESSGREAT, CMD_WORD},
{TK_LESSGREAT, CMD_NAME},
{TK_LESSGREAT, LINEBREAK},
{TK_LESSGREAT, TK_PAREN_OPEN},
{TK_LESSGREAT, COMPLETE_COMMANDS},
{TK_LESSGREAT, TK_BANG},
{TK_LESSGREAT, TK_BANG},
@ -177,6 +187,7 @@ t_stackmatch g_stackmatch[] =
{TK_CLOBBER, CMD_WORD},
{TK_CLOBBER, CMD_NAME},
{TK_CLOBBER, LINEBREAK},
{TK_CLOBBER, TK_PAREN_OPEN},
{TK_CLOBBER, COMPLETE_COMMANDS},
{TK_CLOBBER, TK_BANG},
{TK_CLOBBER, TK_BANG},
@ -187,6 +198,7 @@ t_stackmatch g_stackmatch[] =
{TK_CLOBBER, AND_OR_MAJOR},
{TK_IF, LINEBREAK},
{TK_IF, TK_PAREN_OPEN},
{TK_IF, TK_PAREN_CLOSE},
{TK_IF, COMPLETE_COMMANDS},
{TK_IF, TK_BANG},
@ -226,6 +238,7 @@ t_stackmatch g_stackmatch[] =
{TK_DONE, COMPOUND_LIST},
{TK_DONE, END_COMMAND},
{TK_CASE, LINEBREAK},
{TK_CASE, TK_PAREN_OPEN},
{TK_CASE, COMPLETE_COMMANDS},
{TK_CASE, TK_BANG},
{TK_CASE, TK_DO},
@ -248,6 +261,7 @@ t_stackmatch g_stackmatch[] =
{TK_ESAC, LINEBREAK},
{TK_ESAC, TK_IN},
{TK_WHILE, LINEBREAK},
{TK_WHILE, TK_PAREN_OPEN},
{TK_WHILE, COMPLETE_COMMANDS},
{TK_WHILE, TK_BANG},
{TK_WHILE, SEPARATOR_OP},
@ -265,6 +279,7 @@ t_stackmatch g_stackmatch[] =
{TK_WHILE, TK_THEN},
{TK_WHILE, COMPLETE_CONDITION},
{TK_UNTIL, LINEBREAK},
{TK_UNTIL, TK_PAREN_OPEN},
{TK_UNTIL, COMPLETE_COMMANDS},
{TK_UNTIL, TK_BANG},
{TK_UNTIL, SEPARATOR_OP},
@ -282,6 +297,7 @@ t_stackmatch g_stackmatch[] =
{TK_UNTIL, TK_PAREN_CLOSE},
{TK_UNTIL, COMPLETE_CONDITION},
{TK_FOR, LINEBREAK},
{TK_FOR, TK_PAREN_OPEN},
{TK_FOR, COMPLETE_COMMANDS},
{TK_FOR, TK_BANG},
{TK_FOR, TK_BANG},
@ -300,6 +316,7 @@ t_stackmatch g_stackmatch[] =
{TK_FOR, TK_PAREN_CLOSE},
{TK_FOR, COMPLETE_CONDITION},
{TK_LBRACE, LINEBREAK},
{TK_LBRACE, TK_PAREN_OPEN},
{TK_LBRACE, COMPLETE_COMMANDS},
{TK_LBRACE, TK_BANG},
{TK_LBRACE, SEPARATOR_OP},
@ -308,6 +325,7 @@ t_stackmatch g_stackmatch[] =
{TK_RBRACE, COMPOUND_LIST},
{TK_RBRACE, CASE_LIST_NS},
{TK_BANG, LINEBREAK},
{TK_BANG, TK_PAREN_OPEN},
{TK_BANG, COMPLETE_COMMANDS},
{TK_BANG, SEPARATOR_OP},
{TK_BANG, SEPARATOR_OP},
@ -325,20 +343,29 @@ t_stackmatch g_stackmatch[] =
{TK_AMP, TERM},
{TK_PIPE, PATTERN},
{TK_PIPE, CMD_SUPERIOR},
{TK_PAREN_OPEN, FNAME},
{TK_PAREN_OPEN, CASE_LIST_NS},
{TK_PAREN_OPEN, TK_IN},
{TK_PAREN_OPEN, CASE_LIST},
{TK_PAREN_OPEN, LINEBREAK},
{PATTERN_CASE, TK_IN},
{PATTERN_CASE, CASE_LIST_NS},
{TK_PAREN_OPEN, COMPLETE_COMMANDS},
{TK_PAREN_OPEN, TK_BANG},
{TK_PAREN_OPEN, LINEBREAK},
{TK_PAREN_OPEN, TK_PAREN_OPEN},
{TK_PAREN_OPEN, TK_BANG},
{TK_PAREN_OPEN, SEPARATOR_OP},
{TK_PAREN_OPEN, NEWLINE_LIST},
{TK_PAREN_OPEN, PIPE_SEMI_SEQUENCE},
{TK_PAREN_CLOSE, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, PATTERN},
{TK_PAREN_CLOSE, COMPOUND_LIST},
{TK_PAREN_OPEN, AND_OR_MAJOR},
{TK_PAREN_OPEN, TK_WHILE},
{TK_PAREN_OPEN, TK_UNTIL},
{TK_PAREN_OPEN, TK_DO},
{TK_PAREN_OPEN, TK_PAREN_CLOSE},
{TK_PAREN_OPEN, TK_PAREN_OPEN},
{TK_PAREN_OPEN, TK_IF},
{TK_PAREN_OPEN, TK_ELIF},
{TK_PAREN_OPEN, TK_THEN},
{TK_PAREN_OPEN, TK_ELSE},
{TK_PAREN_OPEN, COMPOUND_LIST},
{TK_PAREN_OPEN, CASE_LIST_NS},
{TK_PAREN_OPEN, COMPLETE_CONDITION},
{TK_PAREN_OPEN, TK_IN},
{SEQUENTIAL_SEP, NAME},
{SEQUENTIAL_SEP, IN},
{SEQUENTIAL_SEP, WORDLIST},
@ -354,6 +381,7 @@ t_stackmatch g_stackmatch[] =
{END_COMMAND, TK_ELIF},
{END_COMMAND, TK_ELSE},
{END_COMMAND, LINEBREAK},
{END_COMMAND, TK_PAREN_OPEN},
{END_COMMAND, COMPLETE_COMMANDS},
{END_COMMAND, COMPOUND_LIST},
{END_COMMAND, CASE_LIST_NS},
@ -372,7 +400,6 @@ t_stackmatch g_stackmatch[] =
{LINEBREAK, TK_SEMI},
{LINEBREAK, END_COMMAND},
{LINEBREAK, SEPARATOR_OP},
{LINEBREAK, SEPARATOR_OP},
{LINEBREAK, TK_PAREN_CLOSE},
{LINEBREAK, WORD},
{LINEBREAK, IN},
@ -386,6 +413,25 @@ t_stackmatch g_stackmatch[] =
{LINEBREAK, COMPOUND_LIST},
{LINEBREAK, CASE_LIST_NS},
{LINEBREAK, PROGRAM},
{LINEBREAK, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, TK_SEMI},
{TK_PAREN_CLOSE, END_COMMAND},
{TK_PAREN_CLOSE, SEPARATOR_OP},
{TK_PAREN_CLOSE, WORD},
{TK_PAREN_CLOSE, IN},
{TK_PAREN_CLOSE, TK_AND_IF},
{TK_PAREN_CLOSE, TK_OR_IF},
{TK_PAREN_CLOSE, TK_PIPE},
{TK_PAREN_CLOSE, TK_PAREN_CLOSE},
{TK_PAREN_CLOSE, COMPLETE_COMMANDS},
{TK_PAREN_CLOSE, CMD_SUPERIOR},
{TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE},
{TK_PAREN_CLOSE, CASE_LIST_NS},
{TK_PAREN_CLOSE, PROGRAM},
{TK_PAREN_CLOSE, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, PATTERN_CASE},
{TK_PAREN_CLOSE, PATTERN},
{TK_PAREN_CLOSE, COMPOUND_LIST},
{NEWLINE_LIST, TK_DO},
{NEWLINE_LIST, CASE_LIST_NS},
{NEWLINE_LIST, TK_PAREN_CLOSE},
@ -410,6 +456,7 @@ t_stackmatch g_stackmatch[] =
{NEWLINE_LIST, COMPLETE_CONDITION},
{NEWLINE_LIST, CONDITION},
{NEWLINE_LIST, LINEBREAK},
{NEWLINE_LIST, TK_PAREN_OPEN},
{HERE_END, TK_DLESS},
{HERE_END, TK_DLESS},
{HERE_END, TK_DLESSDASH},
@ -421,6 +468,7 @@ t_stackmatch g_stackmatch[] =
{IO_HERE, CMD_WORD},
{IO_HERE, CMD_NAME},
{IO_HERE, LINEBREAK},
{IO_HERE, TK_PAREN_OPEN},
{IO_HERE, COMPLETE_COMMANDS},
{IO_HERE, TK_BANG},
{IO_HERE, TK_BANG},
@ -455,6 +503,7 @@ t_stackmatch g_stackmatch[] =
{IO_REDIRECT, CMD_WORD},
{IO_REDIRECT, CMD_NAME},
{IO_REDIRECT, LINEBREAK},
{IO_REDIRECT, TK_PAREN_OPEN},
{IO_REDIRECT, COMPLETE_COMMANDS},
{IO_REDIRECT, TK_BANG},
{IO_REDIRECT, TK_BANG},
@ -466,6 +515,7 @@ t_stackmatch g_stackmatch[] =
{CMD_SUFFIX, CMD_NAME},
{CMD_SUFFIX, CMD_SUPERIOR},
{CMD_PREFIX, LINEBREAK},
{CMD_PREFIX, TK_PAREN_OPEN},
{CMD_PREFIX, COMPLETE_COMMANDS},
{CMD_PREFIX, TK_BANG},
{CMD_PREFIX, TK_BANG},
@ -475,6 +525,7 @@ t_stackmatch g_stackmatch[] =
{CMD_WORD, CMD_PREFIX},
{CMD_NAME, COMPLETE_COMMANDS},
{CMD_NAME, LINEBREAK},
{CMD_NAME, TK_PAREN_OPEN},
{CMD_NAME, TK_BANG},
{CMD_NAME, TK_BANG},
{CMD_NAME, SEPARATOR_OP},
@ -485,6 +536,7 @@ t_stackmatch g_stackmatch[] =
{CMD_NAME, TK_UNTIL},
{CMD_NAME, TK_DO},
{CMD_NAME, TK_PAREN_CLOSE},
{CMD_NAME, TK_PAREN_OPEN},
{CMD_NAME, TK_IF},
{CMD_NAME, TK_ELIF},
{CMD_NAME, TK_THEN},
@ -505,6 +557,7 @@ t_stackmatch g_stackmatch[] =
{CMD_SUPERIOR, CASE_LIST_NS},
{CMD_SUPERIOR, COMPLETE_CONDITION},
{CMD_SUPERIOR, LINEBREAK},
{CMD_SUPERIOR, TK_PAREN_OPEN},
{CMD_SUPERIOR, COMPLETE_COMMANDS},
{CMD_SUPERIOR, TK_BANG},
{CMD_SUPERIOR, TK_BANG},
@ -526,6 +579,7 @@ t_stackmatch g_stackmatch[] =
{SIMPLE_COMMAND, CASE_LIST_NS},
{SIMPLE_COMMAND, COMPLETE_CONDITION},
{SIMPLE_COMMAND, LINEBREAK},
{SIMPLE_COMMAND, TK_PAREN_OPEN},
{SIMPLE_COMMAND, COMPLETE_COMMANDS},
{SIMPLE_COMMAND, TK_BANG},
{SIMPLE_COMMAND, TK_BANG},
@ -540,15 +594,18 @@ t_stackmatch g_stackmatch[] =
{LOOP, TK_WHILE},
{LOOP, TK_UNTIL},
{CONDITION, LINEBREAK},
{CONDITION, TK_PAREN_OPEN},
{CONDITION, COMPLETE_COMMANDS},
{CONDITION, COMPOUND_LIST},
{CONDITION, CASE_LIST_NS},
{CONDITION, COMPLETE_CONDITION},
{COMPLETE_CONDITION, LINEBREAK},
{COMPLETE_CONDITION, TK_PAREN_OPEN},
{COMPLETE_CONDITION, COMPLETE_COMMANDS},
{COMPLETE_CONDITION, COMPLETE_CONDITION},
{COMPLETE_CONDITION, COMPLETE_CONDITION},
{BRACE_GROUP, LINEBREAK},
{BRACE_GROUP, TK_PAREN_OPEN},
{BRACE_GROUP, COMPLETE_COMMANDS},
{BRACE_GROUP, TK_BANG},
{BRACE_GROUP, TK_BANG},
@ -556,6 +613,7 @@ t_stackmatch g_stackmatch[] =
{BRACE_GROUP, NEWLINE_LIST},
{BRACE_GROUP, PIPE_SEMI_SEQUENCE},
{FNAME, LINEBREAK},
{FNAME, TK_PAREN_OPEN},
{FNAME, COMPLETE_COMMANDS},
{FNAME, TK_BANG},
{FNAME, TK_BANG},
@ -564,6 +622,7 @@ t_stackmatch g_stackmatch[] =
{FNAME, PIPE_SEMI_SEQUENCE},
{FUNCTION_BODY, FUNC},
{FUNCTION_DEFINITION, LINEBREAK},
{FUNCTION_DEFINITION, TK_PAREN_OPEN},
{FUNCTION_DEFINITION, COMPLETE_COMMANDS},
{FUNCTION_DEFINITION, TK_BANG},
{FUNCTION_DEFINITION, TK_BANG},
@ -571,9 +630,9 @@ t_stackmatch g_stackmatch[] =
{FUNCTION_DEFINITION, NEWLINE_LIST},
{FUNCTION_DEFINITION, PIPE_SEMI_SEQUENCE},
{UNTIL_CLAUSE, LINEBREAK},
{UNTIL_CLAUSE, TK_PAREN_OPEN},
{UNTIL_CLAUSE, COMPLETE_COMMANDS},
{UNTIL_CLAUSE, TK_BANG},
{UNTIL_CLAUSE, TK_BANG},
{UNTIL_CLAUSE, SEPARATOR_OP},
{UNTIL_CLAUSE, NEWLINE_LIST},
{UNTIL_CLAUSE, PIPE_SEMI_SEQUENCE},
@ -588,7 +647,9 @@ t_stackmatch g_stackmatch[] =
{UNTIL_CLAUSE, COMPOUND_LIST},
{UNTIL_CLAUSE, CASE_LIST_NS},
{UNTIL_CLAUSE, COMPLETE_CONDITION},
{UNTIL_CLAUSE, AND_OR_MAJOR},
{WHILE_CLAUSE, LINEBREAK},
{WHILE_CLAUSE, TK_PAREN_OPEN},
{WHILE_CLAUSE, COMPLETE_COMMANDS},
{WHILE_CLAUSE, TK_BANG},
{WHILE_CLAUSE, SEPARATOR_OP},
@ -605,9 +666,11 @@ t_stackmatch g_stackmatch[] =
{WHILE_CLAUSE, COMPOUND_LIST},
{WHILE_CLAUSE, CASE_LIST_NS},
{WHILE_CLAUSE, COMPLETE_CONDITION},
{WHILE_CLAUSE, AND_OR_MAJOR},
// {ELSE_PART, COMPOUND_LIST},
// {ELSE_PART, COMPLETE_CONDITION},
{IF_CLAUSE, LINEBREAK},
{IF_CLAUSE, TK_PAREN_OPEN},
{IF_CLAUSE, COMPLETE_COMMANDS},
{IF_CLAUSE, TK_BANG},
{IF_CLAUSE, SEPARATOR_OP},
@ -625,13 +688,14 @@ t_stackmatch g_stackmatch[] =
{IF_CLAUSE, CASE_LIST_NS},
{IF_CLAUSE, COMPLETE_COMMAND},
{IF_CLAUSE, COMPLETE_CONDITION},
{IF_CLAUSE, AND_OR_MAJOR},
{PATTERN, TK_PAREN_OPEN},
{PATTERN, PATTERN_CASE},
{PATTERN, CASE_LIST},
{PATTERN, TK_IN},
{PATTERN_CASE, CASE_LIST},
{CASE_LIST_NS, LINEBREAK},
{CASE_CLAUSE, LINEBREAK},
{CASE_CLAUSE, TK_PAREN_OPEN},
{CASE_CLAUSE, COMPLETE_COMMANDS},
{CASE_CLAUSE, TK_BANG},
{CASE_CLAUSE, SEPARATOR_OP},
@ -648,13 +712,15 @@ t_stackmatch g_stackmatch[] =
{CASE_CLAUSE, TK_ELSE},
{CASE_CLAUSE, COMPOUND_LIST},
{CASE_CLAUSE, CASE_LIST_NS},
{CASE_CLAUSE, COMPLETE_COMMAND},
{CASE_CLAUSE, COMPLETE_CONDITION},
{CASE_CLAUSE, AND_OR_MAJOR},
{WORDLIST, IN},
{IN, LINEBREAK},
{NAME, TK_FOR},
{FOR_WORDLIST, NAME},
{FOR_CLAUSE, LINEBREAK},
{FOR_CLAUSE, TK_PAREN_OPEN},
{FOR_CLAUSE, COMPLETE_COMMANDS},
{FOR_CLAUSE, TK_BANG},
{FOR_CLAUSE, TK_BANG},
@ -672,6 +738,7 @@ t_stackmatch g_stackmatch[] =
{FOR_CLAUSE, COMPOUND_LIST},
{FOR_CLAUSE, CASE_LIST_NS},
{FOR_CLAUSE, COMPLETE_CONDITION},
{FOR_CLAUSE, AND_OR_MAJOR},
{TERM, LINEBREAK},
{TERM, COMPLETE_COMMANDS},
{COMPOUND_LIST, TK_DO},
@ -689,11 +756,26 @@ t_stackmatch g_stackmatch[] =
{SUBSHELL, LINEBREAK},
{SUBSHELL, COMPLETE_COMMANDS},
{SUBSHELL, TK_BANG},
{SUBSHELL, TK_BANG},
{SUBSHELL, SEPARATOR_OP},
{SUBSHELL, NEWLINE_LIST},
{SUBSHELL, PIPE_SEMI_SEQUENCE},
{SUBSHELL, SEPARATOR_OP},
{SUBSHELL, NEWLINE_LIST},
{SUBSHELL, PIPE_SEMI_SEQUENCE},
{SUBSHELL, TK_DO},
{SUBSHELL, TK_PAREN_CLOSE},
{SUBSHELL, TK_WHILE},
{SUBSHELL, TK_UNTIL},
{SUBSHELL, TK_IF},
{SUBSHELL, TK_ELIF},
{SUBSHELL, TK_THEN},
{SUBSHELL, TK_ELSE},
{SUBSHELL, COMPOUND_LIST},
{SUBSHELL, CASE_LIST_NS},
{SUBSHELL, COMPLETE_CONDITION},
{SUBSHELL, AND_OR_MAJOR},
{COMPOUND_COMMAND, LINEBREAK},
{COMPOUND_COMMAND, TK_PAREN_OPEN},
{COMPOUND_COMMAND, COMPLETE_COMMANDS},
{COMPOUND_COMMAND, TK_BANG},
{COMPOUND_COMMAND, TK_BANG},
@ -712,9 +794,11 @@ t_stackmatch g_stackmatch[] =
{COMPOUND_COMMAND, COMPOUND_LIST},
{COMPOUND_COMMAND, CASE_LIST_NS},
{COMPOUND_COMMAND, COMPLETE_CONDITION},
{COMPOUND_COMMAND, AND_OR_MAJOR},
{COMMAND, TK_WHILE},
{COMMAND, TK_UNTIL},
{COMMAND, LINEBREAK},
{COMMAND, TK_PAREN_OPEN},
{COMMAND, COMPLETE_COMMANDS},
{COMMAND, TK_DO},
{COMMAND, TK_PAREN_CLOSE},
@ -732,9 +816,9 @@ t_stackmatch g_stackmatch[] =
{COMMAND, AND_OR_MAJOR},
{AND_OR_MINOR, PIPE_SEMI_SEQUENCE},
{AND_OR_MINOR, LINEBREAK},
{AND_OR_MINOR, TK_PAREN_OPEN},
{AND_OR_MINOR, COMPLETE_COMMANDS},
{AND_OR_MINOR, AND_OR_MAJOR},
{AND_OR_MINOR, AND_OR_MAJOR},
{PIPE_SEQUENCE, TK_WHILE},
{PIPE_SEQUENCE, TK_UNTIL},
{PIPE_SEQUENCE, TK_DO},
@ -747,6 +831,7 @@ t_stackmatch g_stackmatch[] =
{PIPE_SEQUENCE, CASE_LIST_NS},
{PIPE_SEQUENCE, COMPLETE_CONDITION},
{PIPE_SEQUENCE, LINEBREAK},
{PIPE_SEQUENCE, TK_PAREN_OPEN},
{PIPE_SEQUENCE, COMPLETE_COMMANDS},
{PIPE_SEQUENCE, TK_BANG},
{PIPE_SEQUENCE, TK_BANG},
@ -765,6 +850,7 @@ t_stackmatch g_stackmatch[] =
{PIPE_SEMI_SEQUENCE, CASE_LIST_NS},
{PIPE_SEMI_SEQUENCE, COMPLETE_CONDITION},
{PIPE_SEMI_SEQUENCE, LINEBREAK},
{PIPE_SEMI_SEQUENCE, TK_PAREN_OPEN},
{PIPE_SEMI_SEQUENCE, COMPLETE_COMMANDS},
{PIPE_SEMI_SEQUENCE, TK_BANG},
{PIPE_SEMI_SEQUENCE, TK_BANG},
@ -783,12 +869,14 @@ t_stackmatch g_stackmatch[] =
{PIPELINE, CASE_LIST_NS},
{PIPELINE, COMPLETE_CONDITION},
{PIPELINE, LINEBREAK},
{PIPELINE, TK_PAREN_OPEN},
{PIPELINE, COMPLETE_COMMANDS},
{PIPELINE, SEPARATOR_OP},
{PIPELINE, SEPARATOR_OP},
{PIPELINE, NEWLINE_LIST},
{PIPELINE, AND_OR_MAJOR},
{AND_OR_MAJOR, LINEBREAK},
{AND_OR_MAJOR, TK_PAREN_OPEN},
{AND_OR_MAJOR, COMPLETE_COMMANDS},
{AND_OR_MAJOR, AND_OR_MAJOR},
{AND_OR_MAJOR, AND_OR_MAJOR},
@ -804,17 +892,21 @@ t_stackmatch g_stackmatch[] =
{AND_OR, CASE_LIST_NS},
{AND_OR, COMPLETE_CONDITION},
{AND_OR, LINEBREAK},
{AND_OR, TK_PAREN_OPEN},
{AND_OR, COMPLETE_COMMANDS},
{AND_OR, SEPARATOR_OP},
{AND_OR, SEPARATOR_OP},
{AND_OR, NEWLINE_LIST},
{LIST, LINEBREAK},
{LIST, TK_PAREN_OPEN},
{LIST, COMPLETE_COMMANDS},
{LIST, NEWLINE_LIST},
{COMPLETE_COMMAND, LINEBREAK},
{COMPLETE_COMMAND, TK_PAREN_OPEN},
{COMPLETE_COMMAND, COMPLETE_COMMANDS},
{COMPLETE_COMMAND, NEWLINE_LIST},
{COMPLETE_COMMANDS, LINEBREAK},
{COMPLETE_COMMANDS, TK_PAREN_OPEN},
{COMPLETE_COMMANDS, COMPLETE_COMMANDS},
{0, 0},
};
@ -823,7 +915,7 @@ int eval_sym(t_sym stack, t_sym new_sym)
{
int i;
// DG("eval head %s && sym %s", read_state(stack), read_state(new_sym));
DG("eval head %s && sym %s", read_state(stack), read_state(new_sym));
i = 0;
while (g_stackmatch[i].top)
{

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

@ -43,7 +43,7 @@ int ft_parse(t_btree **ast, t_list **token, t_parser *parser)
aggregate_sym(&parser->stack, parser->new_sym, &parser->state);
push_stack(++parser->stack, *parser->new_sym);
}
// ft_read_stack(parser->stack);
ft_read_stack(parser->stack);
DG("\n");
if (*parser->stack == PROGRAM)
parser->state = SUCCESS;
@ -56,5 +56,7 @@ int ft_parse(t_btree **ast, t_list **token, t_parser *parser)
else
ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free);
}
if (parser->state == SUCCESS)
DG("sucessful parsing");
return (0);
}

14
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/02/21 22:21:41 by ariard ### ########.fr */
/* Updated: 2017/02/24 18:25:47 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -45,14 +45,17 @@ t_prodmatch g_prodmatch[] =
{TK_WORD, TK_BANG, CMD_NAME},
{TK_WORD, PIPE_SEMI_SEQUENCE, CMD_NAME},
{TK_WORD, SEPARATOR_OP, CMD_NAME},
{TK_WORD, TK_PAREN_OPEN, CMD_NAME},
{TK_WORD, CASE_LIST, PATTERN},
{TK_WORD, TK_PAREN_OPEN, PATTERN},
{TK_WORD, PATTERN_CASE, PATTERN},
{TK_WORD, COMPLETE_COMMANDS, CMD_NAME},
{TK_ASSIGNEMENT_WORD, LINEBREAK, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_PAREN_OPEN, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_BANG, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, SEPARATOR_OP, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, NEWLINE_LIST, CMD_PREFIX},
{TK_NAME, LINEBREAK, FNAME},
{TK_NAME, TK_PAREN_OPEN, FNAME},
{TK_NAME, TK_BANG, FNAME},
{TK_NAME, SEPARATOR_OP, FNAME},
{TK_NAME, NEWLINE_LIST, FNAME},
@ -71,6 +74,7 @@ t_prodmatch g_prodmatch[] =
{TK_NEWLINE, CMD_NAME, NEWLINE_LIST},
{TK_NEWLINE, COMPLETE_COMMANDS, NEWLINE_LIST},
{TK_NEWLINE, LINEBREAK, NEWLINE_LIST},
{TK_NEWLINE, TK_PAREN_OPEN, NEWLINE_LIST},
{TK_NEWLINE, CMD_SUPERIOR, LINEBREAK},
{TK_NEWLINE, PIPE_SEMI_SEQUENCE, LINEBREAK},
{TK_NEWLINE, CASE_LIST_NS, NEWLINE_LIST},
@ -97,8 +101,8 @@ int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst)
int i;
token = (*lst)->content;
// DG("produce stack : %s && token : %s", read_state(stack),
// read_state(token->type));
DG("produce stack : %s && token : %s", read_state(stack),
read_state(token->type));
i = 0;
*new_sym = 0;
while (g_prodmatch[i].new_sym)
@ -106,7 +110,7 @@ int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst)
if (token->type == g_prodmatch[i].token
&& stack == g_prodmatch[i].stack)
{
// DG("MATCH : %s", read_state(g_prodmatch[i].new_sym));
DG("MATCH : %s", read_state(g_prodmatch[i].new_sym));
*new_sym = g_prodmatch[i].new_sym;
}
i++;