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 
grammar neeeded
This commit is contained in:
ariard@student.42.fr 2017-02-12 17:30:47 +01:00
commit 80a5a8b1e2
8 changed files with 310 additions and 15 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
42sh/grammar/rules
View file

@ -55,6 +55,12 @@ io_file - compound_command : VALID - AGGREGATION k = 0, new = io_redirect
io_redirect - redirect_list : VALID - NOTHING io_redirect - redirect_list : VALID - NOTHING
io_redirect - compound_command : VALID - AGGREGATION k = 0, new = redirect_list io_redirect - compound_command : VALID - AGGREGATION k = 0, new = redirect_list
io_redirect - cmd_suffix : VALID - NOTHING
io_redirect - cmd_prefix : VALID - NOTHING
io_redirect - cmd_word : VALID - NOTHING
io_redirect - cmd_name : VALID - NOTHING
// si transparence continuer remontee, // si transparence continuer remontee,
// si dernier membre aurait pu aussi constitue membre actuel, ne rien fiare, ainsi que transparence // si dernier membre aurait pu aussi constitue membre actuel, ne rien fiare, ainsi que transparence

29
42sh/includes/parser.h
View file

@ -22,7 +22,7 @@
enum e_sym enum e_sym
{ {
EMPTY = 1, LINEBREAK = 1,
TK_LESS, TK_LESS,
TK_GREAT, TK_GREAT,
TK_DLESS, TK_DLESS,
@ -51,6 +51,18 @@ enum e_sym
TK_N_WORD, TK_N_WORD,
TK_Q_WORD, TK_Q_WORD,
TK_DQ_WORD, TK_DQ_WORD,
TK_ASSIGNEMENT_WORD = 50,
TK_BANG,
TK_NAME,
TK_FOR,
TK_IO_NUMBER,
TK_DLESSDASH,
TK_LESSGREAT,
TK_CASE,
TK_LBRACE,
TK_IN,
TK_CASE,
TK_ESAC,
PROGRAM = 100, PROGRAM = 100,
COMPLETE_COMMANDS, COMPLETE_COMMANDS,
LIST, LIST,
@ -91,7 +103,6 @@ enum e_sym
IO_HERE, IO_HERE,
HERE_END, HERE_END,
NEWLINE_LIST, NEWLINE_LIST,
LINEBREAK,
SEPARATOR_OP, SEPARATOR_OP,
SEPARATOR, SEPARATOR,
SEQUENTIAL_SEP, SEQUENTIAL_SEP,
@ -106,7 +117,7 @@ enum e_sym
| WHILE_CLAUSE | UNTIL_CLAUSE | FUNCTION_DEFINITION | FUNCTION_BODY | FNAME\ | WHILE_CLAUSE | UNTIL_CLAUSE | FUNCTION_DEFINITION | FUNCTION_BODY | FNAME\
| BRACE_GROUP | DO_GROUP | SIMPLE_COMMAND | CMD_NAME | CMD_WORD | CMD_PREFIX\ | BRACE_GROUP | DO_GROUP | SIMPLE_COMMAND | CMD_NAME | CMD_WORD | CMD_PREFIX\
| CMD_SUFFIX | REDIRECT_LIST | IO_REDIRECT | IO_FILE | FILENAME | IO_HERE\ | CMD_SUFFIX | REDIRECT_LIST | IO_REDIRECT | IO_FILE | FILENAME | IO_HERE\
| HERE_END | NEWLINE_LIST | LINEBREAK | SEPARATOR_OP | SEPARATOR | SEQUENTIAL_SEP | HERE_END | NEWLINE_LIST | SEPARATOR_OP | SEPARATOR | SEQUENTIAL_SEP
}; };
typedef unsigned long long int t_sym; typedef unsigned long long int t_sym;
@ -168,6 +179,17 @@ typedef unsigned long long int t_sym;
//#define ALL_SYM -1UL //#define ALL_SYM -1UL
*/ */
struct s_aggrematch
{
t_sym under;
t_sym top;
t_sym new_sym;
};
typedef struct s_aggrematch t_aggrematch;
extern t_aggrematch g_aggrematch[];
struct s_prodmatch struct s_prodmatch
{ {
t_type token; t_type token;
@ -179,7 +201,6 @@ typedef struct s_prodmatch t_prodmatch;
extern t_prodmatch g_prodmatch[]; extern t_prodmatch g_prodmatch[];
struct s_stackmatch struct s_stackmatch
{ {
t_sym under; t_sym under;

2
42sh/sample/stack.sh
View file

@ -1 +1 @@
ls > file1 > file2 ls

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

@ -12,7 +12,37 @@
#include "parser.h" #include "parser.h"
//descente recursive pour multi aggregation t_aggrematch g_aggrematch[] =
{
{CMD_SUFFIX, TK_WORD, CMD_SUFFIX},
{TK_PIPE, TK_WORD, PATTERN},
{WORDLIST, TK_WORD, WORDLIST},
{CMD_PREFIX, TK_ASSIGNEMENT_WORD, CMD_PREFIX},
{ELSE_PART, TK_FI, IF_CLAUSE},
{COMPOUND_LIST, TK_FI, IF_CLAUSE},
{COMPOUND_LIST, TK_DONE, DO_GROUP},
{COMPOUND_LIST, TK_RBRACE, BRACE_GROUP},
{TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, 2},
//watch this
{SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, 1},
{LINEBREAK, TK_SEMI, SEPARATOR_OP, 1},
//prediction one
{LINEBREAK, TK_PAREN_CLOSE, TK_ESAC, CASE_ITEM_NS, tant que pattern ou '('},
{NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, ALL, tant que newline},
{NEWLINE_LIST, NAME, SEPARATOR_SEP, ALL, 0},
{NEWlINE_LIST, IN, SEPARATOR_SEP, ALL, 0},
{NEWLINE_LIST, WORDLIST, SEPARATOR_SEP, ALL, 0},
{NEWLINE_LIST, TERM, SEPARATOR, ALL, 0},
{NEWLINE_LIST, COMPOUND_LIST, SEPARATOR, ALL, 0},
{0, 0, 0},
int aggregate_sym(t_sym **stack, t_sym *new_sym) int aggregate_sym(t_sym **stack, t_sym *new_sym)
{ {

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

@ -14,9 +14,216 @@
t_stackmatch g_stackmatch[] = t_stackmatch g_stackmatch[] =
{ {
{EMPTY, CMD_NAME}, {CMD_SUFFIX, TK_WORD},
{TK_GREAT, CMD_NAME}, {TK_PIPE, TK_WORD},
{CMD_NAME, TK_GREAT}, {CASE, TK_WORD},
{WORDLIST, TK_WORD},
{CMD_PREFIX, TK_ASSIGNEMENT_WORD},
{REDIRECT_LIST, TK_IO_NUMBER},
{CMD_SUFFIX, TK_IO_NUMBER},
{CMD_PREFIX, TK_IO_NUMBER},
{CMD_NAME, TK_IO_NUMBER},
{CMD_WORD, TK_IO_NUMBER},
{LINEBREAK, TK_IO_NUMBER},
{TK_BANG, TK_IO_NUMBER},
{SEPARATOR_OP, TK_IO_NUMBER},
{NEWLINE_LIST, TK_IO_NUMBER},
{TK_AND_IF, AND_OR},
{TK_OR_IF, AND_OR},
{TK_DSEMI, LINEBREAK},
{TK_DSEMI, COMPOUND_LIST},
{TK_DLESS, TK_IO_NUMBER},
{TK_DLESS, REDIRECT_LIST},
{TK_DLESS, CMD_SUFFIX},
{TK_DLESS, CMD_PREFIX},
{TK_DLESS, CMD_WORD},
{TK_DLESS, CMD_NAME},
{TK_DLESS, LINEBREAK},
{TK_DLESS, TK_BANG},
{TK_DLESS, SEPARATOR_OP},
{TK_DLESS, NEWLINE_LIST},
{TK_DLESSDASH, TK_IO_NUMBER},
{TK_DLESSDASH, REDIRECT_LIST},
{TK_DLESSDASH, CMD_SUFFIX},
{TK_DLESSDASH, CMD_PREFIX},
{TK_DLESSDASH, CMD_WORD},
{TK_DLESSDASH, CMD_NAME},
{TK_DLESSDASH, LINEBREAK},
{TK_DLESSDASH, TK_BANG},
{TK_DLESSDASH, SEPARATOR_OP},
{TK_DLESSDASH, NEWLINE_LIST},
{TK_DGREAT, TK_IO_NUMBER},
{TK_DGREAT, REDIRECT_LIST},
{TK_DGREAT, CMD_SUFFIX},
{TK_DGREAT, CMD_PREFIX},
{TK_DGREAT, CMD_WORD},
{TK_DGREAT, CMD_NAME},
{TK_DGREAT, LINEBREAK},
{TK_DGREAT, TK_BANG},
{TK_DGREAT, SEPARATOR_OP},
{TK_DGREAT, NEWLINE_LIST},
{TK_LESSAND, TK_IO_NUMBER},
{TK_LESSAND, REDIRECT_LIST},
{TK_LESSAND, CMD_SUFFIX},
{TK_LESSAND, CMD_PREFIX},
{TK_LESSAND, CMD_WORD},
{TK_LESSAND, CMD_NAME},
{TK_LESSAND, LINEBREAK},
{TK_LESSAND, TK_BANG},
{TK_LESSAND, SEPARATOR_OP},
{TK_LESSAND, NEWLINE_LIST},
{TK_GREATAND, TK_IO_NUMBER},
{TK_GREATAND, REDIRECT_LIST},
{TK_GREATAND, CMD_SUFFIX},
{TK_GREATAND, CMD_PREFIX},
{TK_GREATAND, CMD_WORD},
{TK_GREATAND, CMD_NAME},
{TK_GREATAND, LINEBREAK},
{TK_GREATAND, TK_BANG},
{TK_GREATAND, SEPARATOR_OP},
{TK_GREATAND, NEWLINE_LIST},
{TK_LESSGREAT, TK_IO_NUMBER},
{TK_LESSGREAT, REDIRECT_LIST},
{TK_LESSGREAT, CMD_SUFFIX},
{TK_LESSGREAT, CMD_PREFIX},
{TK_LESSGREAT, CMD_WORD},
{TK_LESSGREAT, CMD_NAME},
{TK_LESSGREAT, LINEBREAK},
{TK_LESSGREAT, TK_BANG},
{TK_LESSGREAT, SEPARATOR_OP},
{TK_LESSGREAT, NEWLINE_LIST},
{TK_CLOBBER, TK_IO_NUMBER},
{TK_CLOBBER, REDIRECT_LIST},
{TK_CLOBBER, CMD_SUFFIX},
{TK_CLOBBER, CMD_PREFIX},
{TK_CLOBBER, CMD_WORD},
{TK_CLOBBER, CMD_NAME},
{TK_CLOBBER, LINEBREAK},
{TK_CLOBBER, TK_BANG},
{TK_CLOBBER, SEPARATOR_OP},
{TK_CLOBBER, NEWLINE_LIST},
{TK_IF, LINEBREAK},
{TK_IF, TK_BANG},
{TK_IF, SEPARATOR_OP},
{TK_IF, NEWLINE_LIST},
{TK_THEN, COMPOUND_LIST},
{TK_ELSE, COMPOUND_LIST},
{TK_ELIF, COMPOUND_LIST},
{TK_FI, ELSE_PART},
{TK_FI, COMPOUND_LIST},
{TK_DO, COMPOUND_LIST},
{TK_DO, NAME},
{TK_DO, SEQUENTIAL_SEP},
{TK_DONE, COMPOUND_LIST},
{TK_CASE, LINEBREAK},
{TK_CASE, TK_BANG},
{TK_CASE, NEWLINE_LIST},
{TK_CASE, SEPARATOR_OP},
{TK_ESAC, CASE_LIST},
{TK_ESAC, CASE_LIST_NS},
{TK_ESAC, LINEBREAK},
{TK_WHILE, LINEBREAK},
{TK_WHILE, TK_BANG},
{TK_WHILE, SEPARATOR_OP},
{TK_WHILE, NEWLINE_LIST},
{TK_UNTIL, LINEBREAK},
{TK_UNTIL, TK_BANG},
{TK_UNTIL, SEPARATOR_OP},
{TK_UNTIL, NEWLINE_LIST},
{TK_FOR, LINEBREAK},
{TK_FOR, TK_BANG},
{TK_FOR, SEPARATOR_OP},
{TK_FOR, NEWLINE_LIST},
{TK_LBRACE, LINEBREAK},
{TK_LBRACE, TK_BANG},
{TK_LBRACE, SEPARATOR_OP},
{TK_LBRACE, NEWLINE_LIST},
{TK_RBRACE, COMPOUND_LIST},
{TK_BANG, LINEBREAK},
{TK_BANG, SEPARATOR_OP},
{TK_BANG, NEWLINE_LIST},
{TK_IN, LINEBREAK},
{TK_SEMI, NAME},
{TK_SEMI, IN},
{TK_SEMI, WORDLIST},
{TK_SEMI, LIST},
{TK_SEMI, TERM},
{TK_AMP, LIST},
{TK_AMP, TERM},
{TK_PIPE, PATTERN},
{TK_PIPE, PIPE_SEQUENCE},
{TK_PAREN_OPEN, FNAME},
{TK_PAREN_OPEN, CASE_LIST},
{TK_PAREN_OPEN, LINEBREAK},
{TK_PAREN_OPEN, TK_BANG},
{TK_PAREN_OPEN, SEPARATOR_OP},
{TK_PAREN_OPEN, NEWLINE_LIST},
{TK_PAREN_CLOSE, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, PATTERN},
{TK_PAREN_CLOSE, COMPOUND_LIST},
{SEQUENTIAL_SEP, NAME},
{SEQUENTIAL_SEP, IN},
{SEQUENTIAL_SEP, WORDLIST},
{SEPARATOR, TERM},
{SEPARATOR, COMPOUND_LIST},
{SEPARATOR_OP, LIST},
{SEPARATOR_OP, TERM},
{SEPARATOR_OP, COMPOUND_LIST},
{LINEBREAK, TK_SEMI},
{LINEBREAK, TK_PAREN_CLOSE},
{LINEBREAK, WORD},
{LINEBREAK, IN},
{LINEBREAK, TK_AND_IF},
{LINEBREAK, TK_OR_IF},
{LINEBREAK, TK_PIPE},
{LINEBREAK, LINEBREAK},
{LINEBREAK, COMPLETECOMMANDS},
{NEWLINE_LIST, NEWLINE_LIST},
{NEWLINE_LIST, NAME},
{NEWLINE_LIST, IN},
{NEWLINE_LIST, WORDLIST},
{NEWLINE_LIST, TERM},
{NEWLINE_LIST, COMPOUND_LIST},
{NEWLINE_LIST, COMPLETE_COMMANDS},
{0, 0}, {0, 0},
}; };

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

@ -22,7 +22,7 @@ int ft_parse(t_btree **ast, t_list **token)
state = UNDEFINED; state = UNDEFINED;
new_sym = ft_memalloc(sizeof(t_sym)); new_sym = ft_memalloc(sizeof(t_sym));
stack = ft_memalloc(sizeof(t_sym) * 1000); stack = ft_memalloc(sizeof(t_sym) * 1000);
push_stack(stack, EMPTY); push_stack(stack, LINEBREAK);
while (*token) while (*token)
{ {
produce_sym(*stack, new_sym, token); produce_sym(*stack, new_sym, token);

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

@ -14,9 +14,37 @@
t_prodmatch g_prodmatch[] = t_prodmatch g_prodmatch[] =
{ {
{TK_N_WORD, EMPTY, CMD_NAME}, {TK_WORD, TK_DLESS, HERE_END},
{TK_GREAT, ALL, TK_GREAT}, {TK_WORD, TK_DLESSDASH, HERE_END},
{TK_N_WORD, ALL, CMD_NAME}, {TK_WORD, TK_LESS, FILENAME},
{TK_WORD, TK_LESSAND, FILENAME},
{TK_WORD, TK_GREAT, FILENAME},
{TK_WORD, TK_GREATAND, FILENAME},
{TK_WORD, TK_DGREAT, FILENAME},
{TK_WORD, TK_LESSGREAT, FILENAME},
{TK_WORD, TK_CLOBBER, FILENAME},
{TK_WORD, CMD_WORD, CMD_SUFFIX},
{TK_WORD, CMD_NAME, CMD_SUFFIX},
{TK_WORD, LINEBREAK, CMD_NAME},
{TK_WORD, NEWLINE_LIST, CMD_NAME},
{TK_WORD, IN, WORDLIST},
{{TK_WORD, CASE_LIST, PATTERN},
{TK_WORD, TK_PAREN_OPEN, PATTERN},
{TK_ASSIGNEMENT_WORD, LINEBREAK, 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_BANG, FNAME},
{TK_NAME, SEPARATOR_OP, FNAME},
{TK_NAME, NEWLINE_LIST, FNAME},
{TK_NAME, TK_FOR, NAME},
{TK_NEWLINE, COMPLETE_COMMANDS, NEWLINE_LIST},
{TK_NEWLINE, LINEBREAK, NEWLINE_LIST},
{0, 0, 0}, {0, 0, 0},
}; };
@ -27,6 +55,7 @@ int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst)
token = (*lst)->content; token = (*lst)->content;
i = 0; i = 0;
*new_sym = NULL;
while (g_prodmatch[i].new_sym) while (g_prodmatch[i].new_sym)
{ {
if (token->type == g_prodmatch[i].token if (token->type == g_prodmatch[i].token
@ -34,5 +63,7 @@ int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst)
*new_sym = g_prodmatch[i].new_sym; *new_sym = g_prodmatch[i].new_sym;
i++; i++;
} }
if (!*new_sym)
*new_sym = token->type;
return (0); return (0);
} }

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

@ -36,8 +36,8 @@ char *read_state(t_sym current)
return ("SIMPLE_COMMAND"); return ("SIMPLE_COMMAND");
if (current == PROGRAM) if (current == PROGRAM)
return ("PROGRAM"); return ("PROGRAM");
*/ if (current == EMPTY) */ if (current == LINEBREAK)
return ("EMPTY"); return ("LINEBREAK");
if (current != 0) if (current != 0)
return ("NON-DEFINED"); return ("NON-DEFINED");
if (current == 0) if (current == 0)