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

Merge branch 'pda' of https://github.com/jzck/minishell into pda

Browse source 
"work last night"
This commit is contained in:
ariard@student.42.fr 2017-02-15 18:31:49 +01:00
commit fc37e7999a
15 changed files with 230 additions and 162 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

1
42sh/Makefile
View file

@ -175,7 +175,6 @@ parser/eval_sym.c\
parser/aggregate_sym.c\ parser/aggregate_sym.c\
parser/pop_stack.c\ parser/pop_stack.c\
parser/push_stack.c\ parser/push_stack.c\
parser/superflous_sym.c\
parser/error_syntax.c\ parser/error_syntax.c\
parser/get_instruction.c\ parser/get_instruction.c\
parser/get_sub_instruction.c\ parser/get_sub_instruction.c\

0
42sh/file1 Normal file
View file

0
42sh/file2 Normal file
View file

0
42sh/file3 Normal file
View file

0
42sh/file4 Normal file
View file

17
42sh/includes/parser.h
View file

@ -114,14 +114,13 @@ enum e_sym
LOOP, LOOP,
FUNC, FUNC,
PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE,
PATTERN_CASE,
CMD_SUPERIOR,
ALL = 200, ALL = 200,
}; };
typedef int t_sym; typedef int t_sym;
# define REDIR (TK_IO_NUMBER | TK_LESS | TK_LESSAND | TK_GREATAND | TK_DGREAT\
| TK_LESSGREAT | TK_CLOBBER | TK_DLESS | TK_DLESSDASH | TK_WORD)
/* /*
typedef unsigned long long int t_sym; typedef unsigned long long int t_sym;
@ -179,9 +178,7 @@ typedef unsigned long long int t_sym;
//#define ALL_SYM -1UL //#define ALL_SYM -1UL
*/ */
# define MATCH_STACK(x, y) (x == y || x == ALL) # define MATCH_STACK(x, y) (x == y || y == ALL)
# define MATCH_NXT_TOKEN(x, y) (x == y || y == ALL || x == 0 || x &~ REDIR)
typedef int t_parstate; typedef int t_parstate;
@ -190,8 +187,7 @@ struct s_aggrematch
t_sym top; t_sym top;
t_sym under; t_sym under;
t_sym new_sym; t_sym new_sym;
t_type next_token; int erase_sym;
t_sym erase_sym;
}; };
typedef struct s_aggrematch t_aggrematch; typedef struct s_aggrematch t_aggrematch;
@ -222,8 +218,7 @@ extern t_stackmatch g_stackmatch[];
int ft_parse(t_btree **ast, t_list **token); int ft_parse(t_btree **ast, t_list **token);
int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst); int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst);
int eval_sym(t_sym stack, t_sym new_sym); int eval_sym(t_sym stack, t_sym new_sym);
int aggregate_sym(t_sym **stack, t_sym *new_sym, int aggregate_sym(t_sym **stack, t_sym *new_sym, t_parstate *state);
t_parstate *state, t_list *next_token);
int push_stack(t_sym *stack, t_sym new_sym); int push_stack(t_sym *stack, t_sym new_sym);
int pop_stack(t_sym **stack, t_sym erase_sym); int pop_stack(t_sym **stack, t_sym erase_sym);
@ -231,7 +226,7 @@ int pop_stack(t_sym **stack, t_sym erase_sym);
int error_syntax(t_list **token); int error_syntax(t_list **token);
int ft_read_stack(t_sym *stack); int ft_read_stack(t_sym *stack);
char *read_state(t_sym current); char *read_state(t_sym current);
#define UNDEFINED (1 << 0) #define UNDEFINED (1 << 0)
#define ERROR (1 << 1) #define ERROR (1 << 1)

3
42sh/sample/multiredir Normal file
View file

@ -0,0 +1,3 @@
cat < file1 < file2 > file3 > file4

2
42sh/sample/stack.sh
View file

@ -1 +1 @@
ls ls | cat | cat > file1

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

@ -14,135 +14,148 @@
t_aggrematch g_aggrematch[] = t_aggrematch g_aggrematch[] =
{ {
{TK_WORD, CMD_SUFFIX, CMD_SUFFIX, ALL, 0}, {TK_WORD, CMD_SUFFIX, CMD_SUFFIX, 0},
{TK_WORD, TK_PIPE, PATTERN, ALL, 0}, {TK_WORD, TK_PIPE, PATTERN, 0},
{TK_WORD, WORDLIST, WORDLIST, ALL, 0}, {TK_WORD, WORDLIST, WORDLIST, 0},
{TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, ALL, 0}, {TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, 0},
{TK_FI, ELSE_PART, IF_CLAUSE, ALL, IF}, {TK_PIPE, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR},
{TK_FI, COMPOUND_LIST, IF_CLAUSE, ALL, IF}, {TK_FI, ELSE_PART, IF_CLAUSE, IF},
{TK_DONE, COMPOUND_LIST, DO_GROUP, ALL, DO}, {TK_FI, COMPOUND_LIST, IF_CLAUSE, IF},
{TK_DONE, COMPOUND_LIST, DO_GROUP, DO},
//Esac ? //Esac ?
{TK_ESAC, CASE_LIST, CASE_CLAUSE, ALL, TK_CASE}, {TK_ESAC, CASE_LIST, CASE_CLAUSE, TK_CASE},
{TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, ALL, TK_CASE}, {TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, TK_CASE},
{TK_ESAC, LINEBREAK, CASE_CLAUSE, ALL, TK_CASE}, {TK_ESAC, LINEBREAK, CASE_CLAUSE, TK_CASE},
{TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, ALL, TK_LBRACE}, {TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, TK_LBRACE},
{TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, ALL, TK_PAREN_OPEN}, {TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, TK_PAREN_OPEN},
//watch this //watch this
{SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, ALL, 0}, {SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, 0},
{LINEBREAK, SEPARATOR_OP, SEPARATOR, ALL, SEPARATOR_OP}, {LINEBREAK, SEPARATOR_OP, SEPARATOR, SEPARATOR_OP},
{LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, ALL, TK_SEMI}, {LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, TK_SEMI},
{LINEBREAK, TK_PAREN_CLOSE, TK_ESAC, CASE_ITEM_NS, PATTERN_CASE},
{LINEBREAK, TK_PAREN_CLOSE, FUNC, ALL, FNAME},
{LINEBREAK, TK_DSEMI, CASE_ITEM, ALL, PATTERN_CASE},
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, LINEBREAK},
{LINEBREAK, TK_PIPE, PIPE_SEMI_SEQUENCE, ALL, PIPE_SEQUENCE},
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, LINEBREAK},
{NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, ALL, NEWLINE},
{NEWLINE_LIST, NAME, SEQUENTIAL_SEP, ALL, 0},
{NEWLINE_LIST, IN, SEQUENTIAL_SEP, ALL, 0},
{NEWLINE_LIST, WORDLIST, SEQUENTIAL_SEP, ALL, 0},
{NEWLINE_LIST, TERM, SEPARATOR, ALL, 0},
{NEWLINE_LIST, COMPOUND_LIST, SEPARATOR, ALL, 0},
{IO_HERE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER},
{FILENAME, TK_LESS, IO_FILE, ALL, TK_LESS},
{FILENAME, TK_LESSAND, IO_FILE, ALL, TK_LESSAND},
{FILENAME, TK_GREAT, IO_FILE, ALL, TK_GREAT},
{FILENAME, TK_GREATAND, IO_FILE, ALL, TK_GREATAND},
{FILENAME, TK_DGREAT, IO_FILE, ALL, TK_DGREAT},
{FILENAME, TK_LESSGREAT, IO_FILE, ALL, TK_LESSGREAT},
{FILENAME, TK_CLOBBER, IO_FILE, ALL, TK_CLOBBER},
{IO_FILE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER},
{IO_REDIRECT, COMPOUND_COMMAND, REDIRECT_LIST, ALL, REDIRECT_LIST},
{IO_REDIRECT, CMD_SUFFIX, CMD_SUFFIX, ALL, CMD_SUFFIX},
{IO_REDIRECT, CMD_NAME, CMD_SUFFIX, ALL, 0},
{IO_REDIRECT, CMD_WORD, CMD_SUFFIX, ALL, 0},
{IO_REDIRECT, CMD_PREFIX, CMD_PREFIX, ALL, CMD_PREFIX},
{IO_REDIRECT, LINEBREAK, CMD_PREFIX, ALL, 0},
{IO_REDIRECT, TK_BANG, CMD_PREFIX, ALL, 0},
{IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, ALL, 0},
{IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, ALL, 0},
{REDIRECT_LIST, COMPOUND_COMMAND, COMPOUND_COMMAND, ALL, COMPOUND_COMMAND},
{CMD_SUFFIX, CMD_WORD, SIMPLE_COMMAND, ALL, CMD_PREFIX},
{CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, ALL, CMD_NAME},
{CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, TK_WORD, 0},
{CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, TK_WORD, 0},
{CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, TK_WORD, 0},
{CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, TK_WORD, 0},
{CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, ALL_SEPARATOR, CMD_PREFIX},
//to check
{CMD_NAME, LINEBREAK, SIMPLE_COMMAND, SUFFIX_NAME, 0},
{CMD_NAME, TK_BANG, SIMPLE_COMMAND, SUFFIX_NAME, 0},
{CMD_NAME, SEPARATOR_OP, SIMPLE_COMMAND, SUFFIX_NAME, 0},
{CMD_NAME, NEWLINE_LIST, SIMPLE_COMMAND, SUFFIX_NAME, 0},
{CMD_NAME, PIPE_SEMI_SEQUENCE, SIMPLE_COMMAND, SUFFIX_NAME, 0},
{SIMPLE_COMMAND, ALL, COMMAND, ALL, 0}, //to abstract TK_ESAC
{DO_GROUP, NAME, FOR_CLAUSE, ALL, TK_FOR}, {LINEBREAK, TK_PAREN_CLOSE, CASE_ITEM_NS, PATTERN_CASE},
{DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, ALL, TK_FOR}, {LINEBREAK, TK_PAREN_CLOSE, FUNC, FNAME},
{DO_GROUP, COMPOUND_LIST, LOOP, ALL, COMPOUND_LIST}, //paren open
{LOOP, WHILE, WHILE_CLAUSE, ALL, WHILE}, {LINEBREAK, TK_DSEMI, CASE_ITEM, PATTERN_CASE},
{LOOP, TK_UNTIL, UNTIL_CLAUSE, ALL, TK_UNTIL}, {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
{BRACE_GROUP, ALL, COMPOUND_COMMAND, ALL, 0}, {LINEBREAK, TK_PIPE, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE},
{FUNCTION_BODY, FUNC, FUNCTION_DEFINITION, ALL, 0}, {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
{FUNCTION_DEFINITION, ALL, COMMAND, ALL, 0}, {LINEBREAK, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR},
{UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, {LINEBREAK, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{WHILE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, {NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, NEWLINE},
{ELSE_PART, COMPOUND_LIST, ELSE_PART, ALL, TK_ELIF}, {NEWLINE_LIST, NAME, SEQUENTIAL_SEP, 0},
{IF_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, {NEWLINE_LIST, IN, SEQUENTIAL_SEP, 0},
{CASE_ITEM, CASE_LIST, CASE_LIST, ALL, CASE_LIST}, {NEWLINE_LIST, WORDLIST, SEQUENTIAL_SEP, 0},
{CASE_ITEM, LINEBREAK, CASE_LIST, ALL, CASE_LIST}, {NEWLINE_LIST, TERM, SEPARATOR, 0},
{CASE_ITEM_NS, CASE_LIST, CASE_LIST_NS, ALL, CASE_LIST}, {NEWLINE_LIST, COMPOUND_LIST, SEPARATOR, 0},
{CASE_ITEM_NS, LINEBREAK, CASE_LIST_NS, ALL, CASE_LIST},
{CASE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, //to check
{FOR_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, {IO_HERE, TK_IO_NUMBER, IO_REDIRECT, TK_IO_NUMBER},
{TERM, LINEBREAK, COMPOUND_LIST, ALL, LINEBREAK}, {IO_HERE, ALL, IO_REDIRECT, 0},
{COMPOUND_LIST, TK_ELSE, ELSE_PART, ALL, TK_ELSE}, {FILENAME, TK_LESS, IO_FILE, TK_LESS},
{COMPOUND_LIST, TK_THEN, ELSE_PART, ALL, TK_ELIF}, {FILENAME, TK_LESSAND, IO_FILE, TK_LESSAND},
{SUBSHELL, ALL, COMPOUND_COMMAND, ALL, 0}, {FILENAME, TK_GREAT, IO_FILE, TK_GREAT},
{COMPOUND_COMMAND, ALL, COMMAND, ALL, 0}, {FILENAME, TK_GREATAND, IO_FILE, TK_GREATAND},
{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, ALL, PIPE_SEMI_SEQUENCE}, {FILENAME, TK_DGREAT, IO_FILE, TK_DGREAT},
{COMMAND, TK_BANG, PIPE_SEQUENCE, ALL, 0}, {FILENAME, TK_LESSGREAT, IO_FILE, TK_LESSGREAT},
{COMMAND, SEPARATOR_OP, PIPE_SEQUENCE, ALL, 0}, {FILENAME, TK_CLOBBER, IO_FILE, TK_CLOBBER},
{COMMAND, NEWLINE_LIST, PIPE_SEQUENCE, ALL, 0},
{COMMAND, LINEBREAK, PIPE_SEQUENCE, ALL, 0}, //to check
{PIPE_SEQUENCE, TK_BANG, PIPELINE, ALL, TK_BANG}, {IO_FILE, TK_IO_NUMBER, IO_REDIRECT, TK_IO_NUMBER},
{PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, ALL, 0}, {IO_FILE, ALL, IO_REDIRECT, 0},
{PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, ALL, 0}, {IO_REDIRECT, CMD_SUPERIOR, CMD_SUPERIOR, CMD_SUPERIOR},
{PIPE_SEQUENCE, LINEBREAK, PIPELINE, ALL_SEPARATOR, 0}, {IO_REDIRECT, COMPOUND_COMMAND, REDIRECT_LIST, REDIRECT_LIST},
{PIPELINE, LINEBREAK, AND_OR, ALL, 0},
// {PIPELINE, LINEBREAK, AND_OR, ALL, AND_OR}, //to check
{PIPELINE, SEPARATOR_OP, AND_OR, ALL, 0}, {IO_REDIRECT, CMD_SUFFIX, CMD_SUFFIX, CMD_SUFFIX},
{AND_OR, SEPARATOR_OP, LIST, ALL, LIST}, {IO_REDIRECT, CMD_NAME, CMD_SUFFIX, 0},
{AND_OR, NEWLINE_LIST, LIST, ALL, 0}, {IO_REDIRECT, CMD_WORD, CMD_SUFFIX, 0},
{AND_OR, LINEBREAK, LIST, ALL, 0}, {IO_REDIRECT, CMD_PREFIX, CMD_PREFIX, CMD_PREFIX},
{LIST, NEWLINE_LIST, COMPLETE_COMMAND, ALL, 0}, {IO_REDIRECT, LINEBREAK, CMD_PREFIX, 0},
{LIST, LINEBREAK, COMPLETE_COMMAND, ALL, 0}, {IO_REDIRECT, TK_BANG, CMD_PREFIX, 0},
{COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, ALL, COMPLETE_COMMANDS}, {IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, 0},
{COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, ALL, 0}, {IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, 0},
{REDIRECT_LIST, COMPOUND_COMMAND, COMPOUND_COMMAND, COMPOUND_COMMAND},
{CMD_SUFFIX, CMD_WORD, SIMPLE_COMMAND, CMD_PREFIX},
{CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, CMD_NAME},
//to abstract
{CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, 0},
{CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, 0},
{CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, 0},
{CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, CMD_PREFIX},
//to check
{CMD_NAME, LINEBREAK, CMD_SUPERIOR, 0},
{CMD_NAME, TK_BANG, CMD_SUPERIOR, 0},
{CMD_NAME, SEPARATOR_OP, CMD_SUPERIOR, 0},
{CMD_NAME, NEWLINE_LIST, CMD_SUPERIOR, 0},
{CMD_NAME, TK_PIPE, CMD_SUPERIOR, 0},
{CMD_NAME, PIPE_SEMI_SEQUENCE, CMD_SUPERIOR, 0},
{SIMPLE_COMMAND, ALL, COMMAND, 0},
{DO_GROUP, NAME, FOR_CLAUSE, TK_FOR},
{DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, TK_FOR},
{DO_GROUP, COMPOUND_LIST, LOOP, COMPOUND_LIST},
{LOOP, WHILE, WHILE_CLAUSE, WHILE},
{LOOP, TK_UNTIL, UNTIL_CLAUSE, TK_UNTIL},
{BRACE_GROUP, ALL, COMPOUND_COMMAND, 0},
{FUNCTION_BODY, FUNC, FUNCTION_DEFINITION, 0},
{FUNCTION_DEFINITION, ALL, COMMAND, 0},
{UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{WHILE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{ELSE_PART, COMPOUND_LIST, ELSE_PART, TK_ELIF},
{IF_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{PATTERN, TK_PAREN_OPEN, PATTERN_CASE, TK_PAREN_OPEN},
{PATTERN, CASE_LIST, PATTERN_CASE, 0},
{CASE_ITEM, CASE_LIST, CASE_LIST, CASE_LIST},
{CASE_ITEM, LINEBREAK, CASE_LIST, CASE_LIST},
{CASE_ITEM_NS, CASE_LIST, CASE_LIST_NS, CASE_LIST},
{CASE_ITEM_NS, LINEBREAK, CASE_LIST_NS, CASE_LIST},
{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_THEN, ELSE_PART, TK_ELIF},
{SUBSHELL, ALL, COMPOUND_COMMAND, 0},
{COMPOUND_COMMAND, ALL, COMMAND, 0},
{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{COMMAND, TK_BANG, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, SEPARATOR_OP, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, NEWLINE_LIST, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, 0},
{PIPE_SEQUENCE, TK_BANG, PIPELINE, TK_BANG},
{PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, 0},
{PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, 0},
{PIPE_SEQUENCE, LINEBREAK, PIPELINE, 0},
{PIPELINE, LINEBREAK, AND_OR, 0},
// {PIPELINE, LINEBREAK, AND_OR, AND_OR},
{PIPELINE, SEPARATOR_OP, AND_OR, 0},
{AND_OR, SEPARATOR_OP, LIST, LIST},
{AND_OR, NEWLINE_LIST, LIST, 0},
{AND_OR, LINEBREAK, LIST, 0},
{LIST, NEWLINE_LIST, COMPLETE_COMMAND, 0},
{LIST, LINEBREAK, COMPLETE_COMMAND, 0},
{COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, COMPLETE_COMMANDS},
{COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, 0},
{COMPLETE_COMMANDS, LINEBREAK, PROGRAM, LINEBREAK},
// voir decoupe separateur au lexer // voir decoupe separateur au lexer
{COMPLETE_COMMANDS, LINEBREAK, PROGRAM, ALL_SEPARATOR, 0}, {0, 0, 0, 0},
{0, 0, 0, 0, 0},
}; };
int aggregate_sym(t_sym **stack, t_sym *new_sym, int aggregate_sym(t_sym **stack, t_sym *new_sym, t_parstate *state)
t_parstate *state, t_list *next_token)
{ {
int i; int i;
int next;
t_token *token;
i = 0; i = 0;
next = 0; DG("aggregate head %s && sym %s",
if (next_token) read_state(**stack), read_state(*new_sym));
if ((token = next_token->content))
next = token->type;
DG("aggregate head %s && sym %s && next %s",
read_state(**stack), read_state(*new_sym), read_state(next));
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(**stack, g_aggrematch[i].under) && MATCH_STACK(**stack, g_aggrematch[i].under))
&& MATCH_NXT_TOKEN(next, g_aggrematch[i].next_token))
{ {
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;
@ -153,7 +166,7 @@ int aggregate_sym(t_sym **stack, t_sym *new_sym,
} }
if (eval_sym(**stack, *new_sym)) if (eval_sym(**stack, *new_sym))
return ((*state = ERROR)); return ((*state = ERROR));
aggregate_sym(stack, new_sym, state, next_token); aggregate_sym(stack, new_sym, state);
return (0); return (0);
} }
i++; i++;

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

@ -12,9 +12,22 @@
#include "parser.h" #include "parser.h"
int error_syntax(t_list **lst) int error_syntax(t_list **lst)
{ {
(void)lst; t_token *token;
ft_putstr_fd("syntax error near unexepected token ';'", 2);
token = (*lst)->content;
if (token->type == TK_SEMI)
ft_putstr_fd("syntax error near unexepected token ';'", 2);
else if (token->type == TK_WORD)
ft_putstr_fd("syntax error near unexepected token 'word'", 2);
else if (token->type == TK_GREAT)
ft_putstr_fd("syntax error near unexepected token '>'", 2);
else if (token->type == TK_NEWLINE)
ft_putstr_fd("syntax error near unexepected token 'newline'", 2);
else if (token->type == TK_LESS)
ft_putstr_fd("syntax error near unexepected token '<'", 2);
else
ft_putstr_fd("grammar error, notify ariard", 2);
return (1); return (1);
} }

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

@ -30,10 +30,37 @@ 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, CMD_SUPERIOR},
{TK_AND_IF, AND_OR}, {TK_AND_IF, AND_OR},
{TK_OR_IF, AND_OR}, {TK_OR_IF, AND_OR},
{TK_DSEMI, LINEBREAK}, {TK_DSEMI, LINEBREAK},
{TK_DSEMI, COMPOUND_LIST}, {TK_DSEMI, COMPOUND_LIST},
{TK_LESS, TK_IO_NUMBER},
{TK_LESS, REDIRECT_LIST},
{TK_LESS, CMD_SUFFIX},
{TK_LESS, CMD_PREFIX},
{TK_LESS, CMD_WORD},
{TK_LESS, CMD_NAME},
{TK_LESS, LINEBREAK},
{TK_LESS, TK_BANG},
{TK_LESS, SEPARATOR_OP},
{TK_LESS, NEWLINE_LIST},
{TK_LESS, PIPE_SEMI_SEQUENCE},
{TK_LESS, CMD_SUPERIOR},
{TK_GREAT, TK_IO_NUMBER},
{TK_GREAT, REDIRECT_LIST},
{TK_GREAT, CMD_SUFFIX},
{TK_GREAT, CMD_PREFIX},
{TK_GREAT, CMD_WORD},
{TK_GREAT, CMD_NAME},
{TK_GREAT, LINEBREAK},
{TK_GREAT, TK_BANG},
{TK_GREAT, SEPARATOR_OP},
{TK_GREAT, NEWLINE_LIST},
{TK_GREAT, PIPE_SEMI_SEQUENCE},
//duplicate and extend
{TK_GREAT, CMD_SUPERIOR},
{TK_DLESS, TK_IO_NUMBER}, {TK_DLESS, TK_IO_NUMBER},
{TK_DLESS, REDIRECT_LIST}, {TK_DLESS, REDIRECT_LIST},
{TK_DLESS, CMD_SUFFIX}, {TK_DLESS, CMD_SUFFIX},
@ -45,6 +72,8 @@ 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, CMD_SUPERIOR},
{TK_DLESSDASH, TK_IO_NUMBER}, {TK_DLESSDASH, TK_IO_NUMBER},
{TK_DLESSDASH, REDIRECT_LIST}, {TK_DLESSDASH, REDIRECT_LIST},
{TK_DLESSDASH, CMD_SUFFIX}, {TK_DLESSDASH, CMD_SUFFIX},
@ -56,6 +85,8 @@ 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, CMD_SUPERIOR},
{TK_DGREAT, TK_IO_NUMBER}, {TK_DGREAT, TK_IO_NUMBER},
{TK_DGREAT, REDIRECT_LIST}, {TK_DGREAT, REDIRECT_LIST},
{TK_DGREAT, CMD_SUFFIX}, {TK_DGREAT, CMD_SUFFIX},
@ -67,6 +98,8 @@ 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, CMD_SUPERIOR},
{TK_LESSAND, TK_IO_NUMBER}, {TK_LESSAND, TK_IO_NUMBER},
{TK_LESSAND, REDIRECT_LIST}, {TK_LESSAND, REDIRECT_LIST},
{TK_LESSAND, CMD_SUFFIX}, {TK_LESSAND, CMD_SUFFIX},
@ -78,6 +111,8 @@ 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, CMD_SUPERIOR},
{TK_GREATAND, TK_IO_NUMBER}, {TK_GREATAND, TK_IO_NUMBER},
{TK_GREATAND, REDIRECT_LIST}, {TK_GREATAND, REDIRECT_LIST},
{TK_GREATAND, CMD_SUFFIX}, {TK_GREATAND, CMD_SUFFIX},
@ -89,6 +124,8 @@ 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, CMD_SUPERIOR},
{TK_LESSGREAT, TK_IO_NUMBER}, {TK_LESSGREAT, TK_IO_NUMBER},
{TK_LESSGREAT, REDIRECT_LIST}, {TK_LESSGREAT, REDIRECT_LIST},
{TK_LESSGREAT, CMD_SUFFIX}, {TK_LESSGREAT, CMD_SUFFIX},
@ -100,6 +137,8 @@ t_stackmatch g_stackmatch[] =
{TK_LESSGREAT, SEPARATOR_OP}, {TK_LESSGREAT, SEPARATOR_OP},
{TK_LESSGREAT, NEWLINE_LIST}, {TK_LESSGREAT, NEWLINE_LIST},
{TK_LESSGREAT, PIPE_SEMI_SEQUENCE}, {TK_LESSGREAT, PIPE_SEMI_SEQUENCE},
{TK_LESSGREAT, CMD_SUPERIOR},
{TK_CLOBBER, TK_IO_NUMBER}, {TK_CLOBBER, TK_IO_NUMBER},
{TK_CLOBBER, REDIRECT_LIST}, {TK_CLOBBER, REDIRECT_LIST},
{TK_CLOBBER, CMD_SUFFIX}, {TK_CLOBBER, CMD_SUFFIX},
@ -111,6 +150,8 @@ t_stackmatch g_stackmatch[] =
{TK_CLOBBER, SEPARATOR_OP}, {TK_CLOBBER, SEPARATOR_OP},
{TK_CLOBBER, NEWLINE_LIST}, {TK_CLOBBER, NEWLINE_LIST},
{TK_CLOBBER, PIPE_SEMI_SEQUENCE}, {TK_CLOBBER, PIPE_SEMI_SEQUENCE},
{TK_CLOBBER, CMD_SUPERIOR},
{TK_IF, LINEBREAK}, {TK_IF, LINEBREAK},
{TK_IF, TK_BANG}, {TK_IF, TK_BANG},
{TK_IF, SEPARATOR_OP}, {TK_IF, SEPARATOR_OP},
@ -168,7 +209,7 @@ t_stackmatch g_stackmatch[] =
{TK_AMP, LIST}, {TK_AMP, LIST},
{TK_AMP, TERM}, {TK_AMP, TERM},
{TK_PIPE, PATTERN}, {TK_PIPE, PATTERN},
{TK_PIPE, PIPE_SEQUENCE}, {TK_PIPE, CMD_SUPERIOR},
{TK_PAREN_OPEN, FNAME}, {TK_PAREN_OPEN, FNAME},
{TK_PAREN_OPEN, CASE_LIST}, {TK_PAREN_OPEN, CASE_LIST},
{TK_PAREN_OPEN, LINEBREAK}, {TK_PAREN_OPEN, LINEBREAK},
@ -197,6 +238,8 @@ t_stackmatch g_stackmatch[] =
{LINEBREAK, TK_PIPE}, {LINEBREAK, TK_PIPE},
{LINEBREAK, LINEBREAK}, {LINEBREAK, LINEBREAK},
{LINEBREAK, COMPLETE_COMMANDS}, {LINEBREAK, COMPLETE_COMMANDS},
{LINEBREAK, CMD_SUPERIOR},
{LINEBREAK, PIPE_SEMI_SEQUENCE},
{NEWLINE_LIST, NEWLINE_LIST}, {NEWLINE_LIST, NEWLINE_LIST},
{NEWLINE_LIST, NAME}, {NEWLINE_LIST, NAME},
{NEWLINE_LIST, IN}, {NEWLINE_LIST, IN},
@ -207,6 +250,7 @@ t_stackmatch g_stackmatch[] =
{HERE_END, TK_DLESS}, {HERE_END, TK_DLESS},
{HERE_END, TK_DLESSDASH}, {HERE_END, TK_DLESSDASH},
{IO_HERE, TK_IO_NUMBER}, {IO_HERE, TK_IO_NUMBER},
{IO_HERE, CMD_SUPERIOR},
{IO_HERE, REDIRECT_LIST}, {IO_HERE, REDIRECT_LIST},
{IO_HERE, CMD_SUFFIX}, {IO_HERE, CMD_SUFFIX},
{IO_HERE, CMD_PREFIX}, {IO_HERE, CMD_PREFIX},
@ -225,6 +269,7 @@ t_stackmatch g_stackmatch[] =
{FILENAME, TK_LESSGREAT}, {FILENAME, TK_LESSGREAT},
{FILENAME, TK_CLOBBER}, {FILENAME, TK_CLOBBER},
{IO_FILE, TK_IO_NUMBER}, {IO_FILE, TK_IO_NUMBER},
{IO_FILE, CMD_SUPERIOR},
{IO_FILE, REDIRECT_LIST}, {IO_FILE, REDIRECT_LIST},
{IO_FILE, CMD_SUFFIX}, {IO_FILE, CMD_SUFFIX},
{IO_FILE, CMD_PREFIX}, {IO_FILE, CMD_PREFIX},
@ -236,6 +281,7 @@ t_stackmatch g_stackmatch[] =
{IO_FILE, NEWLINE_LIST}, {IO_FILE, NEWLINE_LIST},
{IO_FILE, PIPE_SEMI_SEQUENCE}, {IO_FILE, PIPE_SEMI_SEQUENCE},
{IO_REDIRECT, REDIRECT_LIST}, {IO_REDIRECT, REDIRECT_LIST},
{IO_REDIRECT, CMD_SUPERIOR},
{IO_REDIRECT, CMD_SUFFIX}, {IO_REDIRECT, CMD_SUFFIX},
{IO_REDIRECT, CMD_PREFIX}, {IO_REDIRECT, CMD_PREFIX},
{IO_REDIRECT, CMD_WORD}, {IO_REDIRECT, CMD_WORD},
@ -259,6 +305,14 @@ t_stackmatch g_stackmatch[] =
{CMD_NAME, SEPARATOR_OP}, {CMD_NAME, SEPARATOR_OP},
{CMD_NAME, NEWLINE_LIST}, {CMD_NAME, NEWLINE_LIST},
{CMD_NAME, PIPE_SEMI_SEQUENCE}, {CMD_NAME, PIPE_SEMI_SEQUENCE},
{CMD_SUPERIOR, LINEBREAK,},
{CMD_SUPERIOR, TK_BANG},
{CMD_SUPERIOR, SEPARATOR_OP},
{CMD_SUPERIOR, NEWLINE_LIST},
{CMD_SUPERIOR, TK_PIPE},
{CMD_SUPERIOR, PIPE_SEMI_SEQUENCE},
{SIMPLE_COMMAND, LINEBREAK}, {SIMPLE_COMMAND, LINEBREAK},
{SIMPLE_COMMAND, TK_BANG}, {SIMPLE_COMMAND, TK_BANG},
{SIMPLE_COMMAND, SEPARATOR_OP}, {SIMPLE_COMMAND, SEPARATOR_OP},
@ -303,6 +357,7 @@ t_stackmatch g_stackmatch[] =
{IF_CLAUSE, PIPE_SEMI_SEQUENCE}, {IF_CLAUSE, PIPE_SEMI_SEQUENCE},
{PATTERN, TK_PAREN_OPEN}, {PATTERN, TK_PAREN_OPEN},
{PATTERN, CASE_LIST}, {PATTERN, CASE_LIST},
{PATTERN_CASE, CASE_LIST},
{CASE_ITEM, CASE_LIST}, {CASE_ITEM, CASE_LIST},
{CASE_ITEM, LINEBREAK}, {CASE_ITEM, LINEBREAK},
{CASE_ITEM_NS, CASE_LIST}, {CASE_ITEM_NS, CASE_LIST},

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

@ -18,7 +18,6 @@ int ft_parse(t_btree **ast, t_list **token)
t_sym *stack; t_sym *stack;
t_parstate state; t_parstate state;
//to delete //to delete
t_token *content;
(void)ast; (void)ast;
state = UNDEFINED; state = UNDEFINED;
@ -27,14 +26,13 @@ int ft_parse(t_btree **ast, t_list **token)
push_stack(stack, LINEBREAK); push_stack(stack, LINEBREAK);
while (*token) while (*token)
{ {
content = (*token)->content;
produce_sym(*stack, new_sym, token); produce_sym(*stack, new_sym, token);
DG("new sym %s", read_state(*new_sym)); DG("new sym %s", read_state(*new_sym));
if (eval_sym(*stack, *new_sym)) if (eval_sym(*stack, *new_sym))
state = ERROR; state = ERROR;
else else
{ {
aggregate_sym(&stack, new_sym, &state, (*token)->next); aggregate_sym(&stack, new_sym, &state);
push_stack(++stack, *new_sym); push_stack(++stack, *new_sym);
} }
ft_putstr("\n"); ft_putstr("\n");
@ -46,10 +44,7 @@ int ft_parse(t_btree **ast, t_list **token)
if (state == SUCCESS) if (state == SUCCESS)
ft_putstr("success"); ft_putstr("success");
// build_tree(token, ast); // build_tree(token, ast);
if (*stack == TK_PIPE) ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free);
content->type = LINEBREAK;
else
ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free);
} }
return (0); return (0);
} }

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

@ -26,6 +26,7 @@ t_prodmatch g_prodmatch[] =
{TK_N_WORD, CMD_WORD, CMD_SUFFIX}, {TK_N_WORD, CMD_WORD, CMD_SUFFIX},
{TK_N_WORD, CMD_NAME, CMD_SUFFIX}, {TK_N_WORD, CMD_NAME, CMD_SUFFIX},
{TK_N_WORD, LINEBREAK, CMD_NAME}, {TK_N_WORD, LINEBREAK, CMD_NAME},
{TK_N_WORD, TK_PIPE, CMD_NAME},
{TK_N_WORD, NEWLINE_LIST, CMD_NAME}, {TK_N_WORD, NEWLINE_LIST, CMD_NAME},
{TK_N_WORD, TK_BANG, CMD_NAME}, {TK_N_WORD, TK_BANG, CMD_NAME},
@ -45,6 +46,8 @@ t_prodmatch g_prodmatch[] =
{TK_NAME, TK_FOR, NAME}, {TK_NAME, TK_FOR, NAME},
{TK_NEWLINE, COMPLETE_COMMANDS, NEWLINE_LIST}, {TK_NEWLINE, COMPLETE_COMMANDS, NEWLINE_LIST},
{TK_NEWLINE, LINEBREAK, NEWLINE_LIST}, {TK_NEWLINE, LINEBREAK, NEWLINE_LIST},
{TK_NEWLINE, CMD_SUPERIOR, LINEBREAK},
{TK_NEWLINE, PIPE_SEMI_SEQUENCE, LINEBREAK},
{TK_SEMI, TERM, SEPARATOR_OP}, {TK_SEMI, TERM, SEPARATOR_OP},
{TK_SEMI, LIST, SEPARATOR_OP}, {TK_SEMI, LIST, SEPARATOR_OP},
{TK_SEMI, COMPOUND_LIST, SEPARATOR_OP}, {TK_SEMI, COMPOUND_LIST, SEPARATOR_OP},

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

@ -14,6 +14,18 @@
char *read_state(t_sym current) char *read_state(t_sym current)
{ {
if (current == CMD_SUPERIOR)
return ("CMD_SUPERIOR");
if (current == TK_IO_NUMBER)
return ("IO_NUMBER");
if (current == CMD_SUFFIX)
return ("CMD_SUFFIX");
if (current == CMD_PREFIX)
return ("CMD_PREFIX");
if (current == IO_REDIRECT)
return ("IO_REDIRECT");
if (current == IO_FILE)
return ("IO_FILE");
if (current == PIPE_SEMI_SEQUENCE) if (current == PIPE_SEMI_SEQUENCE)
return ("PIPE_SEMI_SEQUENCE"); return ("PIPE_SEMI_SEQUENCE");
if (current == TK_PIPE) if (current == TK_PIPE)

20
42sh/src/parser/superflous_sym.c
View file

@ -1,20 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* superflous_sym.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 17:47:33 by ariard #+# #+# */
/* Updated: 2017/02/09 19:25:30 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser.h"
int superflous_sym(t_sym stack, t_sym new_sym)
{
if (stack == new_sym)
return (1);
return (0);
}