From fd951302a376dc09c44b8d1d944da793b60756de Mon Sep 17 00:00:00 2001 From: "ariard@student.42.fr" Date: Mon, 13 Feb 2017 23:00:05 +0100 Subject: [PATCH] combinaison pipe et simple ok --- 42sh/includes/.parser.h.swm | Bin 24576 -> 0 bytes 42sh/includes/.parser.h.swn | Bin 20480 -> 20480 bytes 42sh/includes/lexer.h | 2 +- 42sh/includes/parser.h | 44 ++++----- 42sh/sample/stack.sh | 2 +- 42sh/src/parser/aggregate_sym.c | 166 +++++++++++++++----------------- 42sh/src/parser/error_syntax.c | 2 +- 42sh/src/parser/eval_sym.c | 120 +++++------------------ 42sh/src/parser/ft_parse.c | 16 ++- 42sh/src/parser/pop_stack.c | 14 ++- 42sh/src/parser/produce_sym.c | 63 +++++++----- 42sh/src/parser/push_stack.c | 2 +- 42sh/src/parser/read_stack.c | 36 ++++++- 42sh/tofix | 13 +++ 14 files changed, 238 insertions(+), 242 deletions(-) delete mode 100644 42sh/includes/.parser.h.swm create mode 100644 42sh/tofix diff --git a/42sh/includes/.parser.h.swm b/42sh/includes/.parser.h.swm deleted file mode 100644 index ba6e51fc4b06450358bb162c5e2317e829ba649d..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 24576 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 Ov?XZZW@cA`j{gO7SeMiQ diff --git a/42sh/includes/.parser.h.swn b/42sh/includes/.parser.h.swn index 2abcaac7df2b3534f54e4e69c54e7874312065cc..163f04d89d5281e593a7a318388f290b64dcfda1 100644 GIT binary patch delta 1924 zcmZ|PeQXnD9Ki9XWo{fDbQ91hCcC{jw>qI)H5p?Jy6v`gyS}XLoC}&u*$PgijP`&L zkxrw$CE{j{piu*;XjBsAH1lO!Ld*c)5@Hxm7lRrJNQ{Yql0b}puN}faUh=u;x#xNM zd!Bpx+;3o?WniCW!Aj@-9mh8txe2Fh$?$4Vy z3GoctAaIy{>qi|fvA3@yge;6%g;rnfxS;btbxg}mS!H;$X(2AOAKFT)K-(K7k zUDX?lN`auiIq3Gvk|dQ?cBpb~E#2lYGlY7_{|}R$3Om8+aiv&$1u(vxy)?@)XV3XM%2z6J`_ z?+;WMQdz`O;0Y^UTFlus)e{P9zR-=2srBVXUW4BoP?fNvQSrKcjj2M%Ewzp23o(>e z3)TnS>G0Im8|n?JzrJ1xW(FxCw>dRKJU*k#amG5!C0A9|xLh@^#YW3LBi2XkHqJQA zFXr0EG-{^}%VEKhIYJDe4gzDd*%{Qqilezg>_97WVZ$Ubw`1FM{H->_l9g{Wl1rbk zrs|gE8bkG$EYB^^N^%;-L5`QXfNNj-6q63)WtaOSWHw!q85$r<}-Dp8Ma&U%4 zjpH>ug&s7b2m+HV@I&m)Pj=+>AU3 zTp(rrf=Nu^BtF9t9L9dUidQf&LzIdnl`zbFw+QDrjAvmU%Jjh`u1IZJR&N|_ykbp# z-#lSYry)5Sk0hdILP~wmQgxS^ocbd1gdWkOvLjto$h!7uZ$g(Hv1q@p>Fd@+W2t!_ zm!-n+cyg>OrT-$3X6WDC7nQD$Ot%qTrfpLu?`86zENzJOMB~@{^>uwq#A70%$2WBA fQbLQYULB9Fjp*GEr^cEW7`xlzS;mT@k1YQJ^xbi= delta 2350 zcmYk-eQXnD9Ki9Xbz^jFYzB>(5xocj28inhXqZF$^0d9}dRMNk<7IN0Y%&4^TsH{{ zb|eBb0o+#qFeE06iDE>9P$H6msJumEd`oc4 zbG>J9%riLVse7v72|cboGQUA^)Cw_gcx>6=fA@*!rg}!|=1genTezvQ;ZWO|8qeO` zowfJZ?^E?SUUpByQ#{{MJXaUb_4(zs2WqM-D6aJKL)Ubm-N;&%LPXJmCQL^SCgP?~ zi0k+n7jO>8@eba=s~Ev26VeH2~?7=o{ zL^oC-0f|MJg*sH?1kbY>v+?}|AzncQH_C-LhIN>RugZjY2|KX^tMDXNlqG~{B=BPj zekX6A;UGrQ4;u?mi$BTTm&juj&qC#M1>7SaHII36&pZ&%jZH7h)lZ+A_4)dp%$D9} z9;;dSwrVkHOGlbvZL4O=c0)I%W9Z2g#iUFG>_E!09V;=uScsRVrJ2$LhC?mYO(-6A zlIci9U&d`)hILzpQl*}B%PC#Ta+_jAHzbidnSr4dC!JW!aj8n)Ph3fnDPJ%|buwq!De?%HDvGNGnCRT z(+ShU)KxhCYS0QVS7kL!p}SBZ>E_5WliVm2^^}ae#Y7;LlD6tWkK7(Z8nhvusjSyWy&5-JaBeuWvSHdbLC zM0$iMf*=I|C~rO`bDg7+QO(`nrSJYF z`Z|f%p!#2lM==fm(&q(yfMN6^f%&MxZ;bId-o_!i|(S>%T5yKKRV=?BU9vY^g99b_v9{jokBPQb +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/01 12:15:50 by jhalford #+# #+# */ -/* Updated: 2017/02/10 01:43:45 by ariard ### ########.fr */ +/* Updated: 2017/02/13 19:41:57 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/includes/parser.h b/42sh/includes/parser.h index 21d31f66..53701f4e 100644 --- a/42sh/includes/parser.h +++ b/42sh/includes/parser.h @@ -6,7 +6,7 @@ /* By: jhalford +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2016/12/01 12:15:54 by jhalford #+# #+# */ -/* Updated: 2017/02/12 20:35:20 by ariard ### ########.fr */ +/* Updated: 2017/02/13 22:33:39 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -59,11 +59,14 @@ enum e_sym TK_DLESSDASH, TK_LESSGREAT, TK_CASE, - TK_LBRACE, TK_IN, - TK_CASE, TK_ESAC, + TK_CLOBBER, + TK_LBRACE, + TK_RBRACE, + TK_DSEMI, PROGRAM = 100, + COMPLETE_COMMAND, COMPLETE_COMMANDS, LIST, AND_OR, @@ -79,7 +82,9 @@ enum e_sym IN, WORDLIST, CASE_CLAUSE, + CASE_LIST, CASE_LIST_NS, + CASE_ITEM, CASE_ITEM_NS, PATTERN, IF_CLAUSE, @@ -109,21 +114,15 @@ enum e_sym LOOP, FUNC, PIPE_SEMI_SEQUENCE, - ALL = TK_LESS | TK_GREAT | TK_DLESS | TK_DGREAT | TK_LESSAND | TK_GREATAND\ - | TK_SEMI | TK_PIPE | TK_AND_IF | TK_OR_IF | TK_AMP | TK_PAREN_OPEN\ - | TK_PAREN_CLOSE | TK_BQUOTE | TK_SUBSHELL | TK_NEWLINE | TK_WHILE | TK_DO\ - | TK_DONE | TK_IF | TK_THEN | TK_FI | TK_ELIF | TK_ELSE | TK_UNTIL | TK_N_WORD\ - | TK_Q_WORD | TK_DQ_WORD | PROGRAM | COMPLETE_COMMANDS | LIST\ - | AND_OR | PIPELINE | PIPE_SEQUENCE | COMMAND | COMPOUND_COMMAND | SUBSHELL\ - | COMPOUND_LIST | TERM | FOR_CLAUSE | NAME | IN | WORDLIST | CASE_CLAUSE\ - | CASE_LIST_NS | CASE_ITEM_NS | PATTERN | IF_CLAUSE | ELSE_PART\ - | WHILE_CLAUSE | UNTIL_CLAUSE | FUNCTION_DEFINITION | FUNCTION_BODY | FNAME\ - | BRACE_GROUP | DO_GROUP | SIMPLE_COMMAND | CMD_NAME | CMD_WORD | CMD_PREFIX\ - | CMD_SUFFIX | REDIRECT_LIST | IO_REDIRECT | IO_FILE | FILENAME | IO_HERE\ - | HERE_END | NEWLINE_LIST | SEPARATOR_OP | SEPARATOR | SEQUENTIAL_SEP + ALL = 200, + PATTERN_CASE, + ALL_SEPERATOR, }; -typedef unsigned long long int t_sym; +# define PATTERN_CASE (PATTERN | TK_PAREN_OPEN) +# define ALL_SEPARATOR (TK_NEWLINE | TK_SEMI | TK_AMP) + +typedef int t_sym; /* typedef unsigned long long int t_sym; @@ -181,12 +180,15 @@ typedef unsigned long long int t_sym; #define ALL_SYM !0 //#define ALL_SYM -1UL */ +typedef int t_parstate; struct s_aggrematch { - t_sym under; t_sym top; + t_sym under; t_sym new_sym; + t_type next_token; + t_sym erase_sym; }; typedef struct s_aggrematch t_aggrematch; @@ -217,11 +219,11 @@ extern t_stackmatch g_stackmatch[]; int ft_parse(t_btree **ast, t_list **token); int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst); int eval_sym(t_sym stack, t_sym new_sym); -int aggregate_sym(t_sym **stack, t_sym *new_sym); -int superflous_sym(t_sym stack, t_sym new_sym); +int aggregate_sym(t_sym **stack, t_sym *new_sym, + t_parstate *state, t_list *next_token); int push_stack(t_sym *stack, t_sym new_sym); -int pop_stack(t_sym **stack, int k); +int pop_stack(t_sym **stack, t_sym erase_sym); int error_syntax(t_list **token); @@ -232,8 +234,6 @@ char *read_state(t_sym current); #define ERROR (1 << 1) #define SUCCESS (1 << 2) -typedef int t_parstate; - /* * Build AST * diff --git a/42sh/sample/stack.sh b/42sh/sample/stack.sh index 9e2740c6..968d1077 100644 --- a/42sh/sample/stack.sh +++ b/42sh/sample/stack.sh @@ -1 +1 @@ -ls +ls | cat | cat | cat diff --git a/42sh/src/parser/aggregate_sym.c b/42sh/src/parser/aggregate_sym.c index 1bf8c8c6..f4424ef4 100644 --- a/42sh/src/parser/aggregate_sym.c +++ b/42sh/src/parser/aggregate_sym.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 17:39:18 by ariard #+# #+# */ -/* Updated: 2017/02/12 20:53:36 by ariard ### ########.fr */ +/* Updated: 2017/02/13 22:59:11 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -17,54 +17,41 @@ t_aggrematch g_aggrematch[] = {TK_WORD, CMD_SUFFIX, CMD_SUFFIX, ALL, 0}, {TK_WORD, TK_PIPE, PATTERN, ALL, 0}, {TK_WORD, WORDLIST, WORDLIST, ALL, 0}, - {TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, ALL, 0}, - - {TK_FI, ELSE_PART, IF_CLAUSE, ALL, tant que IF}, - {TK_FI, COMPOUND_LIST, IF_CLAUSE, ALL, tant que IF}, - - {TK_DONE, COMPOUND_LIST, DO_GROUP, ALL, tant DO}, - + {TK_FI, ELSE_PART, IF_CLAUSE, ALL, IF}, + {TK_FI, COMPOUND_LIST, IF_CLAUSE, ALL, IF}, + {TK_DONE, COMPOUND_LIST, DO_GROUP, ALL, DO}, //Esac ? - {TK_ESAC, CASE_LIST, CASE_CLAUSE, ALL, tant que CASE}, - {TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, ALL, tant que CASE}, - {TK_ESAC, LINEBREAK, CASE_CLAUSE, ALL, tant que CASE}, - - {TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, ALL tant que LBRACE}, - - {TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, ALL, tant que TK_PAREN_OPEN}, - + {TK_ESAC, CASE_LIST, CASE_CLAUSE, ALL, TK_CASE}, + {TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, ALL, TK_CASE}, + {TK_ESAC, LINEBREAK, CASE_CLAUSE, ALL, TK_CASE}, + {TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, ALL, TK_LBRACE}, + {TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, ALL, TK_PAREN_OPEN}, //watch this {SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, ALL, 0}, - - {LINEBREAK, TK_SEMI, SEPARATOR_OP, ALL, tant que TK_SEMI}, -//do one - {LINEBREAK, TK_PAREN_CLOSE, TK_ESAC, CASE_ITEM_NS, tant que pattern ou '('}, + {LINEBREAK, SEPARATOR_OP, SEPARATOR, ALL, SEPARATOR_OP}, + {LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, ALL, 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, tant que pattern ou '('}, - {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, tant que linebreak}, + {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, 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, 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_LESGREAT, IO_FILE, ALL, TK_LESSGREAT}, + {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}, @@ -74,100 +61,105 @@ t_aggrematch g_aggrematch[] = {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_NEWLINE ou TK_SEMI ou TK_AMP, 0}, - {CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, - {CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, - {CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, - - {CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, - CMD_PREFIX}, - - {CMD_NAME, LINEBREAK, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, - {CMD_NAME, TK_BANG, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, - {CMD_NAME, SEPARATOR_OP, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, - {CMD_NAME, NEWLINE_LIST, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, + {CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, ALL_SEPARATOR, 0}, + {CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, ALL_SEPARATOR, 0}, + {CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, ALL_SEPARATOR, 0}, + {CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, ALL_SEPARATOR, 0}, + {CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, ALL_SEPARATOR, CMD_PREFIX}, +//to check + {CMD_NAME, LINEBREAK, SIMPLE_COMMAND, ALL, 0}, + {CMD_NAME, TK_BANG, SIMPLE_COMMAND, ALL, 0}, + {CMD_NAME, SEPARATOR_OP, SIMPLE_COMMAND, ALL, 0}, + {CMD_NAME, NEWLINE_LIST, SIMPLE_COMMAND, ALL, 0}, + {CMD_NAME, PIPE_SEMI_SEQUENCE, SIMPLE_COMMAND, ALL, 0}, {SIMPLE_COMMAND, ALL, COMMAND, ALL, 0}, - - {DO_GROUP, NAME, FOR_CLAUSE, ALL, FOR}, - {DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, ALL, FOR}, + {DO_GROUP, NAME, FOR_CLAUSE, ALL, TK_FOR}, + {DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, ALL, TK_FOR}, {DO_GROUP, COMPOUND_LIST, LOOP, ALL, COMPOUND_LIST}, - {LOOP, WHILE, WHILE_CLAUSE, ALL, WHILE}, - {LOOP, UNTIL, UNTIL_CLAUSE, ALL, UNTIL}, - + {LOOP, TK_UNTIL, UNTIL_CLAUSE, ALL, TK_UNTIL}, {BRACE_GROUP, ALL, COMPOUND_COMMAND, ALL, 0}, - {FUNCTION_BODY, FUNC, FUNCTION_DEFINITION, ALL, 0}, - {FUNCTION_DEFINITION, ALL, COMMAND, ALL, 0}, - {UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - {WHILE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - - {ELSE_PART, COMPOUND_LIST, ELSE_PART, ALL, ELIF}, - + {ELSE_PART, COMPOUND_LIST, ELSE_PART, ALL, TK_ELIF}, {IF_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - {CASE_ITEM, CASE_LIST, CASE_LIST, ALL, CASE_LIST}, {CASE_ITEM, LINEBREAK, CASE_LIST, ALL, CASE_LIST}, - {CASE_ITEM_NS, CASE_LIST, CASE_LIST_NS, ALL, CASE_LIST}, {CASE_ITEM_NS, LINEBREAK, CASE_LIST_NS, ALL, CASE_LIST}, - {CASE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - {FOR_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, - {TERM, LINEBREAK, COMPOUND_LIST, ALL, LINEBREAK}, - {COMPOUND_LIST, TK_ELSE, ELSE_PART, ALL, TK_ELSE}, {COMPOUND_LIST, TK_THEN, ELSE_PART, ALL, TK_ELIF}, - {SUBSHELL, ALL, COMPOUND_COMMAND, ALL, 0}, - {COMPOUND_COMMAND, ALL, COMMAND, ALL, 0}, - - {COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, ALL, PIPE_SEQUENCE}, - {COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, ALL, PIPE_SEQUENCE}, + {COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, ALL, PIPE_SEMI_SEQUENCE}, {COMMAND, TK_BANG, PIPE_SEQUENCE, ALL, 0}, {COMMAND, SEPARATOR_OP, PIPE_SEQUENCE, ALL, 0}, {COMMAND, NEWLINE_LIST, PIPE_SEQUENCE, ALL, 0}, - + {COMMAND, LINEBREAK, PIPE_SEQUENCE, ALL, 0}, {PIPE_SEQUENCE, TK_BANG, PIPELINE, ALL, TK_BANG}, {PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, ALL, 0}, {PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, ALL, 0}, - - {PIPELINE, LINEBREAK, AND_OR, ALL, AND_OR}, + {PIPE_SEQUENCE, LINEBREAK, PIPELINE, ALL_SEPARATOR, 0}, + {PIPELINE, LINEBREAK, AND_OR, ALL, 0}, +// {PIPELINE, LINEBREAK, AND_OR, ALL, AND_OR}, {PIPELINE, SEPARATOR_OP, AND_OR, ALL, 0}, - {AND_OR, SEPARATOR_OP, LIST, ALL, LIST}, {AND_OR, NEWLINE_LIST, LIST, ALL, 0}, - + {AND_OR, LINEBREAK, LIST, ALL, 0}, {LIST, NEWLINE_LIST, COMPLETE_COMMAND, ALL, 0}, - + {LIST, LINEBREAK, COMPLETE_COMMAND, ALL, 0}, {COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, ALL, COMPLETE_COMMANDS}, {COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, ALL, 0}, - - {0, 0, 0}, -} +// voir decoupe separateur au lexer + {COMPLETE_COMMANDS, LINEBREAK, PROGRAM, ALL_SEPARATOR, 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_list *next_token) { - DG("aggregate head %s && sym %s", read_state(**stack), read_state(*new_sym)); - if (**stack == 0 && *new_sym == CMD_NAME) + int i; + int next; + t_token *token; + + i = 0; + next = 0; + if (next_token) + 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) { - *new_sym = SIMPLE_COMMAND; - aggregate_sym(stack, new_sym); + if (*new_sym == g_aggrematch[i].top && (**stack == g_aggrematch[i].under + || g_aggrematch[i].under == ALL + || g_aggrematch[i].under == ALL_SEPARATOR) + && (next == g_aggrematch[i].next_token || next == 0 + || g_aggrematch[i].next_token == ALL + || (g_aggrematch[i].next_token == ALL_SEPARATOR && next == TK_SEMI))) + { + 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)); + } + if (eval_sym(**stack, *new_sym)) + return ((*state = ERROR)); + aggregate_sym(stack, new_sym, state, next_token); + return (0); + } + i++; } - if (**stack == 0 && *new_sym == SIMPLE_COMMAND) - *new_sym = PROGRAM; return (0); } diff --git a/42sh/src/parser/error_syntax.c b/42sh/src/parser/error_syntax.c index bfbeb805..c5c668a1 100644 --- a/42sh/src/parser/error_syntax.c +++ b/42sh/src/parser/error_syntax.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 20:15:35 by ariard #+# #+# */ -/* Updated: 2017/02/09 20:31:48 by ariard ### ########.fr */ +/* Updated: 2017/02/13 22:09:03 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/parser/eval_sym.c b/42sh/src/parser/eval_sym.c index 3f927208..510970b5 100644 --- a/42sh/src/parser/eval_sym.c +++ b/42sh/src/parser/eval_sym.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 16:26:30 by ariard #+# #+# */ -/* Updated: 2017/02/12 21:08:57 by ariard ### ########.fr */ +/* Updated: 2017/02/13 22:59:09 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,13 +14,12 @@ t_stackmatch g_stackmatch[] = { - {TK_WORD, CMD_SUFFIX}, - {TK_WORD, TK_PIPE}, - {TK_WORD, CASE}, - {TK_WORD, WORDLIST}, - + {TK_N_WORD, CMD_SUFFIX}, + {TK_N_WORD, TK_PIPE}, + {TK_N_WORD, TK_CASE}, + {TK_N_WORD, WORDLIST}, + {TK_N_WORD, LINEBREAK}, {TK_ASSIGNEMENT_WORD, CMD_PREFIX}, - {TK_IO_NUMBER, REDIRECT_LIST}, {TK_IO_NUMBER, CMD_SUFFIX}, {TK_IO_NUMBER, CMD_PREFIX}, @@ -29,16 +28,12 @@ t_stackmatch g_stackmatch[] = {TK_IO_NUMBER, LINEBREAK}, {TK_IO_NUMBER, TK_BANG}, {TK_IO_NUMBER, SEPARATOR_OP}, - {TK_IO_NUMBER, NEWWLINE_LIST}, + {TK_IO_NUMBER, NEWLINE_LIST}, {TK_IO_NUMBER, PIPE_SEMI_SEQUENCE}, - {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}, @@ -50,7 +45,6 @@ t_stackmatch g_stackmatch[] = {TK_DLESS, SEPARATOR_OP}, {TK_DLESS, NEWLINE_LIST}, {TK_DLESS, PIPE_SEMI_SEQUENCE}, - {TK_DLESSDASH, TK_IO_NUMBER}, {TK_DLESSDASH, REDIRECT_LIST}, {TK_DLESSDASH, CMD_SUFFIX}, @@ -62,7 +56,6 @@ t_stackmatch g_stackmatch[] = {TK_DLESSDASH, SEPARATOR_OP}, {TK_DLESSDASH, NEWLINE_LIST}, {TK_DLESSDASH, PIPE_SEMI_SEQUENCE}, - {TK_DGREAT, TK_IO_NUMBER}, {TK_DGREAT, REDIRECT_LIST}, {TK_DGREAT, CMD_SUFFIX}, @@ -74,7 +67,6 @@ t_stackmatch g_stackmatch[] = {TK_DGREAT, SEPARATOR_OP}, {TK_DGREAT, NEWLINE_LIST}, {TK_DGREAT, PIPE_SEMI_SEQUENCE}, - {TK_LESSAND, TK_IO_NUMBER}, {TK_LESSAND, REDIRECT_LIST}, {TK_LESSAND, CMD_SUFFIX}, @@ -86,7 +78,6 @@ t_stackmatch g_stackmatch[] = {TK_LESSAND, SEPARATOR_OP}, {TK_LESSAND, NEWLINE_LIST}, {TK_LESSAND, PIPE_SEMI_SEQUENCE}, - {TK_GREATAND, TK_IO_NUMBER}, {TK_GREATAND, REDIRECT_LIST}, {TK_GREATAND, CMD_SUFFIX}, @@ -98,7 +89,6 @@ t_stackmatch g_stackmatch[] = {TK_GREATAND, SEPARATOR_OP}, {TK_GREATAND, NEWLINE_LIST}, {TK_GREATAND, PIPE_SEMI_SEQUENCE}, - {TK_LESSGREAT, TK_IO_NUMBER}, {TK_LESSGREAT, REDIRECT_LIST}, {TK_LESSGREAT, CMD_SUFFIX}, @@ -110,7 +100,6 @@ t_stackmatch g_stackmatch[] = {TK_LESSGREAT, SEPARATOR_OP}, {TK_LESSGREAT, NEWLINE_LIST}, {TK_LESSGREAT, PIPE_SEMI_SEQUENCE}, - {TK_CLOBBER, TK_IO_NUMBER}, {TK_CLOBBER, REDIRECT_LIST}, {TK_CLOBBER, CMD_SUFFIX}, @@ -122,82 +111,64 @@ t_stackmatch g_stackmatch[] = {TK_CLOBBER, SEPARATOR_OP}, {TK_CLOBBER, NEWLINE_LIST}, {TK_CLOBBER, PIPE_SEMI_SEQUENCE}, - {TK_IF, LINEBREAK}, {TK_IF, TK_BANG}, {TK_IF, SEPARATOR_OP}, {TK_IF, NEWLINE_LIST}, {TK_IF, PIPE_SEMI_SEQUENCE}, - {TK_THEN, COMPOUND_LIST}, - {TK_ELSE, COMPOUND_LIST}, - - {TK_ELIF, 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_CASE, PIPE_SEMI_SEQUENCE}, - {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_WHILE, PIPE_SEMI_SEQUENCE}, - {TK_UNTIL, LINEBREAK}, {TK_UNTIL, TK_BANG}, {TK_UNTIL, SEPARATOR_OP}, {TK_UNTIL, NEWLINE_LIST}, {TK_UNTIL, PIPE_SEMI_SEQUENCE}, - {TK_FOR, LINEBREAK}, {TK_FOR, TK_BANG}, {TK_FOR, SEPARATOR_OP}, {TK_FOR, NEWLINE_LIST}, {TK_FOR, PIPE_SEMI_SEQUENCE}, - {TK_LBRACE, LINEBREAK}, {TK_LBRACE, TK_BANG}, {TK_LBRACE, SEPARATOR_OP}, {TK_LBRACE, NEWLINE_LIST}, {TK_LBRACE, PIPE_SEMI_SEQUENCE}, - {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_SEMI, CMD_NAME}, + {TK_SEMI, PROGRAM}, {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}, @@ -205,23 +176,19 @@ t_stackmatch g_stackmatch[] = {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}, - {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_SEMI}, + {LINEBREAK, SEPARATOR_OP}, {LINEBREAK, TK_PAREN_CLOSE}, {LINEBREAK, WORD}, {LINEBREAK, IN}, @@ -230,7 +197,6 @@ t_stackmatch g_stackmatch[] = {LINEBREAK, TK_PIPE}, {LINEBREAK, LINEBREAK}, {LINEBREAK, COMPLETE_COMMANDS}, - {NEWLINE_LIST, NEWLINE_LIST}, {NEWLINE_LIST, NAME}, {NEWLINE_LIST, IN}, @@ -238,10 +204,8 @@ t_stackmatch g_stackmatch[] = {NEWLINE_LIST, TERM}, {NEWLINE_LIST, COMPOUND_LIST}, {NEWLINE_LIST, COMPLETE_COMMANDS}, - - {HERE_END, DLESS}, - {HERE_END, DLESSDASH}, - + {HERE_END, TK_DLESS}, + {HERE_END, TK_DLESSDASH}, {IO_HERE, TK_IO_NUMBER}, {IO_HERE, REDIRECT_LIST}, {IO_HERE, CMD_SUFFIX}, @@ -253,7 +217,6 @@ t_stackmatch g_stackmatch[] = {IO_HERE, SEPARATOR_OP}, {IO_HERE, NEWLINE_LIST}, {IO_HERE, PIPE_SEMI_SEQUENCE}, - {FILENAME, TK_LESS}, {FILENAME, TK_LESSAND}, {FILENAME, TK_GREAT}, @@ -261,7 +224,6 @@ t_stackmatch g_stackmatch[] = {FILENAME, TK_DGREAT}, {FILENAME, TK_LESSGREAT}, {FILENAME, TK_CLOBBER}, - {IO_FILE, TK_IO_NUMBER}, {IO_FILE, REDIRECT_LIST}, {IO_FILE, CMD_SUFFIX}, @@ -273,7 +235,6 @@ t_stackmatch g_stackmatch[] = {IO_FILE, SEPARATOR_OP}, {IO_FILE, NEWLINE_LIST}, {IO_FILE, PIPE_SEMI_SEQUENCE}, - {IO_REDIRECT, REDIRECT_LIST}, {IO_REDIRECT, CMD_SUFFIX}, {IO_REDIRECT, CMD_PREFIX}, @@ -284,112 +245,84 @@ t_stackmatch g_stackmatch[] = {IO_REDIRECT, SEPARATOR_OP}, {IO_REDIRECT, NEWLINE_LIST}, {IO_REDIRECT, PIPE_SEMI_SEQUENCE}, - - {REDIRECT_LIST, COMPOUND_COMMAND} - + {REDIRECT_LIST, COMPOUND_COMMAND}, {CMD_SUFFIX, CMD_WORD}, {CMD_SUFFIX, CMD_NAME}, - {CMD_PREFIX, LINEBREAK}, {CMD_PREFIX, TK_BANG}, {CMD_PREFIX, SEPARATOR_OP}, {CMD_PREFIX, NEWLINE_LIST}, {CMD_PREFIX, PIPE_SEMI_SEQUENCE}, - {CMD_WORD, CMD_PREFIX}, - {CMD_NAME, LINEBREAK}, {CMD_NAME, TK_BANG}, {CMD_NAME, SEPARATOR_OP}, {CMD_NAME, NEWLINE_LIST}, {CMD_NAME, PIPE_SEMI_SEQUENCE}, - - {SIMPLE_COMMNAND, LINEBREAK}, + {SIMPLE_COMMAND, LINEBREAK}, {SIMPLE_COMMAND, TK_BANG}, {SIMPLE_COMMAND, SEPARATOR_OP}, {SIMPLE_COMMAND, NEWLINE_LIST}, {SIMPLE_COMMAND, PIPE_SEMI_SEQUENCE}, - {DO_GROUP, COMPOUND_LIST}, {DO_GROUP, NAME}, {DO_GROUP, SEQUENTIAL_SEP}, - - {LOOP, WHILE}, - {LOOP, UNTIL}, - + {LOOP, TK_WHILE}, + {LOOP, TK_UNTIL}, {BRACE_GROUP, LINEBREAK}, {BRACE_GROUP, TK_BANG}, {BRACE_GROUP, SEPARATOR_OP}, {BRACE_GROUP, NEWLINE_LIST}, {BRACE_GROUP, PIPE_SEMI_SEQUENCE}, - {FNAME, LINEBREAK}, {FNAME, TK_BANG}, {FNAME, SEPARATOR_OP}, {FNAME, NEWLINE_LIST}, {FNAME, PIPE_SEMI_SEQUENCE}, - {FUNCTION_BODY, FUNC}, - {FUNCTION_DEFINITION, LINEBREAK}, {FUNCTION_DEFINITION, TK_BANG}, {FUNCTION_DEFINITION, SEPARATOR_OP}, {FUNCTION_DEFINITION, NEWLINE_LIST}, {FUNCTION_DEFINITION, PIPE_SEMI_SEQUENCE}, - {UNTIL_CLAUSE, LINEBREAK}, {UNTIL_CLAUSE, TK_BANG}, {UNTIL_CLAUSE, SEPARATOR_OP}, {UNTIL_CLAUSE, NEWLINE_LIST}, {UNTIL_CLAUSE, PIPE_SEMI_SEQUENCE}, - {WHILE_CLAUSE, LINEBREAK}, {WHILE_CLAUSE, TK_BANG}, {WHILE_CLAUSE, SEPARATOR_OP}, {WHILE_CLAUSE, NEWLINE_LIST}, {WHILE_CLAUSE, PIPE_SEMI_SEQUENCE}, - {ELSE_PART, COMPOUND_LIST}, - {IF_CLAUSE, LINEBREAK}, {IF_CLAUSE, TK_BANG}, {IF_CLAUSE, SEPARATOR_OP}, {IF_CLAUSE, NEWLINE_LIST}, {IF_CLAUSE, PIPE_SEMI_SEQUENCE}, - {PATTERN, TK_PAREN_OPEN}, {PATTERN, CASE_LIST}, - {CASE_ITEM, CASE_LIST}, {CASE_ITEM, LINEBREAK}, - {CASE_ITEM_NS, CASE_LIST}, {CASE_ITEM_NS, LINEBREAK}, - {CASE_LIST, LINEBREAK}, - {CASE_LIST_NS, LINEBREAK}, - {CASE_CLAUSE, LINEBREAK}, {CASE_CLAUSE, TK_BANG}, {CASE_CLAUSE, SEPARATOR_OP}, {CASE_CLAUSE, NEWLINE_LIST}, {CASE_CLAUSE, PIPE_SEMI_SEQUENCE}, - {WORDLIST, IN}, - {IN, LINEBREAK}, - - {NAME, FOR}, - + {NAME, TK_FOR}, {FOR_CLAUSE, LINEBREAK}, {FOR_CLAUSE, TK_BANG}, {FOR_CLAUSE, SEPARATOR_OP}, {FOR_CLAUSE, NEWLINE_LIST}, {FOR_CLAUSE, PIPE_SEMI_SEQUENCE}, - {TERM, LINEBREAK}, - {COMPOUND_LIST, TK_DO}, {COMPOUND_LIST, TK_LBRACE}, {COMPOUND_LIST, TK_WHILE}, @@ -397,45 +330,40 @@ t_stackmatch g_stackmatch[] = {COMPOUND_LIST, TK_ELIF}, {COMPOUND_LIST, TK_ELSE}, {COMPOUND_LIST, TK_IF}, - {SUBSHELL, LINEBREAK}, {SUBSHELL, TK_BANG}, {SUBSHELL, SEPARATOR_OP}, {SUBSHELL, NEWLINE_LIST}, {SUBSHELL, PIPE_SEMI_SEQUENCE}, - {COMPOUND_COMMAND, LINEBREAK}, {COMPOUND_COMMAND, TK_BANG}, {COMPOUND_COMMAND, SEPARATOR_OP}, {COMPOUND_COMMAND, NEWLINE_LIST}, {COMPOUND_COMMAND, PIPE_SEMI_SEQUENCE}, {COMPOUND_COMMAND, FUNC}, - {COMMAND, LINEBREAK}, {COMMAND, TK_BANG}, {COMMAND, SEPARATOR_OP}, {COMMAND, NEWLINE_LIST}, {COMMAND, PIPE_SEMI_SEQUENCE}, - {PIPE_SEQUENCE, LINEBREAK}, {PIPE_SEQUENCE, TK_BANG}, {PIPE_SEQUENCE, SEPARATOR_OP}, {PIPE_SEQUENCE, NEWLINE_LIST}, - + {PIPE_SEMI_SEQUENCE, LINEBREAK}, + {PIPE_SEMI_SEQUENCE, TK_BANG}, + {PIPE_SEMI_SEQUENCE, SEPARATOR_OP}, + {PIPE_SEMI_SEQUENCE, NEWLINE_LIST}, {PIPELINE, LINEBREAK}, {PIPELINE, SEPARATOR_OP}, {PIPELINE, NEWLINE_LIST}, - {AND_OR, LINEBREAK}, {AND_OR, SEPARATOR_OP}, {AND_OR, NEWLINE_LIST}, - {LIST, LINEBREAK}, {LIST, NEWLINE_LIST}, - {COMPLETE_COMMAND, LINEBREAK}, {COMPLETE_COMMAND, NEWLINE_LIST}, - {COMPLETE_COMMANDS, LINEBREAK}, {0, 0}, }; @@ -448,7 +376,7 @@ int eval_sym(t_sym stack, t_sym new_sym) i = 0; while (g_stackmatch[i].top) { - if (new_sym == g_stackmatch[i].top && stack == g.stackmatch[i].under) + if (new_sym == g_stackmatch[i].top && stack == g_stackmatch[i].under) return (0); i++; } diff --git a/42sh/src/parser/ft_parse.c b/42sh/src/parser/ft_parse.c index 8a2e2a44..a774e88f 100644 --- a/42sh/src/parser/ft_parse.c +++ b/42sh/src/parser/ft_parse.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 14:30:22 by ariard #+# #+# */ -/* Updated: 2017/02/11 16:22:51 by ariard ### ########.fr */ +/* Updated: 2017/02/13 22:59:00 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -17,6 +17,8 @@ int ft_parse(t_btree **ast, t_list **token) t_sym *new_sym; t_sym *stack; t_parstate state; +//to delete + t_token *content; (void)ast; state = UNDEFINED; @@ -25,16 +27,18 @@ int ft_parse(t_btree **ast, t_list **token) push_stack(stack, LINEBREAK); while (*token) { + content = (*token)->content; produce_sym(*stack, new_sym, token); DG("new sym %s", read_state(*new_sym)); if (eval_sym(*stack, *new_sym)) state = ERROR; else { -// aggregate_sym(&stack, new_sym); - //superflous sym + aggregate_sym(&stack, new_sym, &state, (*token)->next); push_stack(++stack, *new_sym); } + ft_putstr("\n"); + ft_read_stack(stack); if (*stack == PROGRAM) state = SUCCESS; if (state == ERROR) @@ -42,8 +46,10 @@ int ft_parse(t_btree **ast, t_list **token) if (state == SUCCESS) ft_putstr("success"); // build_tree(token, ast); - ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free); + if (*stack == TK_PIPE) + content->type = LINEBREAK; + else + ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free); } - ft_read_stack(stack); return (0); } diff --git a/42sh/src/parser/pop_stack.c b/42sh/src/parser/pop_stack.c index 29e7045f..597d3867 100644 --- a/42sh/src/parser/pop_stack.c +++ b/42sh/src/parser/pop_stack.c @@ -6,15 +6,21 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 19:12:44 by ariard #+# #+# */ -/* Updated: 2017/02/09 20:02:05 by ariard ### ########.fr */ +/* Updated: 2017/02/13 22:51:52 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ #include "parser.h" -int pop_stack(t_sym **stack, int k) +int pop_stack(t_sym **stack, t_sym erase_sym) { - while (k--) - *stack-- = 0; + t_sym *temp; + + DG("pop until :%s", read_state(erase_sym)); + temp = *stack; + while (*temp != erase_sym) + *temp-- = 0; + *temp-- = 0; + *stack = temp; return (0); } diff --git a/42sh/src/parser/produce_sym.c b/42sh/src/parser/produce_sym.c index 8dea1220..bf36bd82 100644 --- a/42sh/src/parser/produce_sym.c +++ b/42sh/src/parser/produce_sym.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 17:58:34 by ariard #+# #+# */ -/* Updated: 2017/02/12 17:41:45 by ariard ### ########.fr */ +/* Updated: 2017/02/13 22:59:16 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,37 +14,49 @@ t_prodmatch g_prodmatch[] = { - {TK_WORD, TK_DLESS, HERE_END}, - {TK_WORD, TK_DLESSDASH, HERE_END}, - {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_N_WORD, TK_DLESS, HERE_END}, + {TK_N_WORD, TK_DLESSDASH, HERE_END}, + {TK_N_WORD, TK_LESS, FILENAME}, + {TK_N_WORD, TK_LESSAND, FILENAME}, + {TK_N_WORD, TK_GREAT, FILENAME}, + {TK_N_WORD, TK_GREATAND, FILENAME}, + {TK_N_WORD, TK_DGREAT, FILENAME}, + {TK_N_WORD, TK_LESSGREAT, FILENAME}, + {TK_N_WORD, TK_CLOBBER, FILENAME}, + {TK_N_WORD, CMD_WORD, CMD_SUFFIX}, + {TK_N_WORD, CMD_NAME, CMD_SUFFIX}, + {TK_N_WORD, LINEBREAK, CMD_NAME}, + {TK_N_WORD, NEWLINE_LIST, CMD_NAME}, +//to delete + {TK_N_WORD, TK_SEMI, CMD_NAME}, + + {TK_N_WORD, TK_BANG, CMD_NAME}, + {TK_N_WORD, PIPE_SEMI_SEQUENCE, CMD_NAME}, + {TK_N_WORD, SEPARATOR_OP, CMD_NAME}, + {TK_N_WORD, IN, WORDLIST}, + {TK_N_WORD, CASE_LIST, PATTERN}, + {TK_N_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}, - + {TK_SEMI, TERM, SEPARATOR_OP}, + {TK_SEMI, LIST, SEPARATOR_OP}, + {TK_SEMI, COMPLETE_COMMAND, SEPARATOR_OP}, + {TK_SEMI, COMPLETE_COMMANDS, SEPARATOR_OP}, + {TK_AMP, TERM, SEPARATOR_OP}, + {TK_AMP, LIST, SEPARATOR_OP}, + {TK_AMP, COMPLETE_COMMAND, SEPARATOR_OP}, + {TK_AMP, COMPLETE_COMMANDS, SEPARATOR_OP}, + + {0, 0, 0}, }; @@ -54,13 +66,18 @@ 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)); i = 0; - *new_sym = NULL; + *new_sym = 0; while (g_prodmatch[i].new_sym) { if (token->type == g_prodmatch[i].token - && stack & g_prodmatch[i].stack) + && stack == g_prodmatch[i].stack) + { + DG("MATCH : %s", read_state(g_prodmatch[i].new_sym)); *new_sym = g_prodmatch[i].new_sym; + } i++; } if (!*new_sym) diff --git a/42sh/src/parser/push_stack.c b/42sh/src/parser/push_stack.c index a3cd4af9..1d0d9278 100644 --- a/42sh/src/parser/push_stack.c +++ b/42sh/src/parser/push_stack.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 16:48:30 by ariard #+# #+# */ -/* Updated: 2017/02/09 20:00:35 by ariard ### ########.fr */ +/* Updated: 2017/02/13 20:19:33 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ diff --git a/42sh/src/parser/read_stack.c b/42sh/src/parser/read_stack.c index e7505232..31c9bebc 100644 --- a/42sh/src/parser/read_stack.c +++ b/42sh/src/parser/read_stack.c @@ -6,7 +6,7 @@ /* By: ariard +#+ +:+ +#+ */ /* +#+#+#+#+#+ +#+ */ /* Created: 2017/02/09 15:32:10 by ariard #+# #+# */ -/* Updated: 2017/02/10 01:41:47 by ariard ### ########.fr */ +/* Updated: 2017/02/13 22:40:40 by ariard ### ########.fr */ /* */ /* ************************************************************************** */ @@ -14,8 +14,42 @@ char *read_state(t_sym current) { + if (current == PIPE_SEMI_SEQUENCE) + return ("PIPE_SEMI_SEQUENCE"); + if (current == TK_PIPE) + return ("TK_PIPE"); + if (current == PROGRAM) + return ("PROGRAM"); + if (current == COMMAND) + return ("COMMAND"); + if (current == PIPE_SEQUENCE) + return ("PIPE_SEQUENCE"); + if (current == PIPELINE) + return ("PIPELINE"); + if (current == AND_OR) + return ("AND_OR"); + if (current == LIST) + return ("LIST"); + if (current == COMPLETE_COMMAND) + return ("COMPLETE_COMMAND"); + if (current == COMPLETE_COMMANDS) + return ("COMPLETE_COMMANDS"); + if (current == TK_N_WORD) + return ("TK_WORD"); if (current == CMD_NAME) return ("CMD_NAME"); + if (current == HERE_END) + return ("HERE_END"); + if (current == FILENAME) + return ("FILENAME"); + if (current == CMD_SUFFIX) + return ("CMD_SUFFIX"); + if (current == SIMPLE_COMMAND) + return ("SIMPLE_COMMAND"); + if (current == TK_SEMI) + return ("TK_SEMI"); + if (current == ALL) + return ("ALL"); /* if (current == NEWLINE_LIST) return ("NEWLINE_LIST"); if (current == SYM_DLESS) diff --git a/42sh/tofix b/42sh/tofix new file mode 100644 index 00000000..f031f6a3 --- /dev/null +++ b/42sh/tofix @@ -0,0 +1,13 @@ +valeur all, all_separator, paren_case, +integrer decoupe temporaire +soigner les regles avec les separateurs +ajouter linebreak sur token needed + +pour jack, jerter les separateurs a la formation +rajouter les noms de tous les tokens pour la sortie d erreur + +->passer a une stack infinie +->construire if, while, else if +->tester les combinaisons deja existantes +->integrer erreurs +->erreur speciale : EOF