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

combinaison pipe et simple ok

Browse source
This commit is contained in:
ariard@student.42.fr 2017-02-13 23:00:05 +01:00
parent 582087186f
commit fd951302a3
14 changed files with 238 additions and 242 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

BIN
42sh/includes/.parser.h.swm
View file

Binary file not shown.

BIN
42sh/includes/.parser.h.swn
View file

Binary file not shown.

2
42sh/includes/lexer.h
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */ /* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/01 12:15:50 by jhalford #+# #+# */ /* 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 */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */

44
42sh/includes/parser.h
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */ /* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/01 12:15:54 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_DLESSDASH,
TK_LESSGREAT, TK_LESSGREAT,
TK_CASE, TK_CASE,
TK_LBRACE,
TK_IN, TK_IN,
TK_CASE,
TK_ESAC, TK_ESAC,
TK_CLOBBER,
TK_LBRACE,
TK_RBRACE,
TK_DSEMI,
PROGRAM = 100, PROGRAM = 100,
COMPLETE_COMMAND,
COMPLETE_COMMANDS, COMPLETE_COMMANDS,
LIST, LIST,
AND_OR, AND_OR,
@ -79,7 +82,9 @@ enum e_sym
IN, IN,
WORDLIST, WORDLIST,
CASE_CLAUSE, CASE_CLAUSE,
CASE_LIST,
CASE_LIST_NS, CASE_LIST_NS,
CASE_ITEM,
CASE_ITEM_NS, CASE_ITEM_NS,
PATTERN, PATTERN,
IF_CLAUSE, IF_CLAUSE,
@ -109,21 +114,15 @@ enum e_sym
LOOP, LOOP,
FUNC, FUNC,
PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE,
ALL = TK_LESS | TK_GREAT | TK_DLESS | TK_DGREAT | TK_LESSAND | TK_GREATAND\ ALL = 200,
| TK_SEMI | TK_PIPE | TK_AND_IF | TK_OR_IF | TK_AMP | TK_PAREN_OPEN\ PATTERN_CASE,
| TK_PAREN_CLOSE | TK_BQUOTE | TK_SUBSHELL | TK_NEWLINE | TK_WHILE | TK_DO\ ALL_SEPERATOR,
| 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
}; };
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; 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 !0
//#define ALL_SYM -1UL //#define ALL_SYM -1UL
*/ */
typedef int t_parstate;
struct s_aggrematch struct s_aggrematch
{ {
t_sym under;
t_sym top; t_sym top;
t_sym under;
t_sym new_sym; t_sym new_sym;
t_type next_token;
t_sym erase_sym;
}; };
typedef struct s_aggrematch t_aggrematch; 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 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,
int superflous_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 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); int error_syntax(t_list **token);
@ -232,8 +234,6 @@ char *read_state(t_sym current);
#define ERROR (1 << 1) #define ERROR (1 << 1)
#define SUCCESS (1 << 2) #define SUCCESS (1 << 2)
typedef int t_parstate;
/* /*
* Build AST * Build AST
* *

2
42sh/sample/stack.sh
View file

@ -1 +1 @@
ls ls | cat | cat | cat

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 17:39:18 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, CMD_SUFFIX, CMD_SUFFIX, ALL, 0},
{TK_WORD, TK_PIPE, PATTERN, ALL, 0}, {TK_WORD, TK_PIPE, PATTERN, ALL, 0},
{TK_WORD, WORDLIST, WORDLIST, ALL, 0}, {TK_WORD, WORDLIST, WORDLIST, ALL, 0},
{TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, ALL, 0}, {TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, ALL, 0},
{TK_FI, ELSE_PART, IF_CLAUSE, ALL, IF},
{TK_FI, ELSE_PART, IF_CLAUSE, ALL, tant que IF}, {TK_FI, COMPOUND_LIST, IF_CLAUSE, ALL, IF},
{TK_FI, COMPOUND_LIST, IF_CLAUSE, ALL, tant que IF}, {TK_DONE, COMPOUND_LIST, DO_GROUP, ALL, DO},
{TK_DONE, COMPOUND_LIST, DO_GROUP, ALL, tant DO},
//Esac ? //Esac ?
{TK_ESAC, CASE_LIST, CASE_CLAUSE, ALL, tant que CASE}, {TK_ESAC, CASE_LIST, CASE_CLAUSE, ALL, TK_CASE},
{TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, ALL, tant que CASE}, {TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, ALL, TK_CASE},
{TK_ESAC, LINEBREAK, CASE_CLAUSE, ALL, tant que CASE}, {TK_ESAC, LINEBREAK, CASE_CLAUSE, ALL, TK_CASE},
{TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, ALL, TK_LBRACE},
{TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, ALL tant que LBRACE}, {TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, ALL, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, ALL, tant que TK_PAREN_OPEN},
//watch this //watch this
{SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, ALL, 0}, {SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, ALL, 0},
{LINEBREAK, SEPARATOR_OP, SEPARATOR, ALL, SEPARATOR_OP},
{LINEBREAK, TK_SEMI, SEPARATOR_OP, ALL, tant que TK_SEMI}, {LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, ALL, TK_SEMI},
//do one {LINEBREAK, TK_PAREN_CLOSE, TK_ESAC, CASE_ITEM_NS, PATTERN_CASE},
{LINEBREAK, TK_PAREN_CLOSE, TK_ESAC, CASE_ITEM_NS, tant que pattern ou '('},
{LINEBREAK, TK_PAREN_CLOSE, FUNC, ALL, FNAME}, {LINEBREAK, TK_PAREN_CLOSE, FUNC, ALL, FNAME},
{LINEBREAK, TK_DSEMI, CASE_ITEM, ALL, tant que pattern ou '('}, {LINEBREAK, TK_DSEMI, CASE_ITEM, ALL, PATTERN_CASE},
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, tant que linebreak}, {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, LINEBREAK},
{LINEBREAK, TK_PIPE, PIPE_SEMI_SEQUENCE, ALL, PIPE_SEQUENCE}, {LINEBREAK, TK_PIPE, PIPE_SEMI_SEQUENCE, ALL, PIPE_SEQUENCE},
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, LINEBREAK}, {LINEBREAK, COMPLETE_COMMANDS, PROGRAM, ALL, LINEBREAK},
{NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, ALL, NEWLINE},
{NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, ALL, tant que newline}, {NEWLINE_LIST, NAME, SEQUENTIAL_SEP, ALL, 0},
{NEWLINE_LIST, NAME, SEPARATOR_SEP, ALL, 0}, {NEWLINE_LIST, IN, SEQUENTIAL_SEP, ALL, 0},
{NEWlINE_LIST, IN, SEPARATOR_SEP, ALL, 0}, {NEWLINE_LIST, WORDLIST, SEQUENTIAL_SEP, ALL, 0},
{NEWLINE_LIST, WORDLIST, SEPARATOR_SEP, ALL, 0},
{NEWLINE_LIST, TERM, SEPARATOR, ALL, 0}, {NEWLINE_LIST, TERM, SEPARATOR, ALL, 0},
{NEWLINE_LIST, COMPOUND_LIST, SEPARATOR, ALL, 0}, {NEWLINE_LIST, COMPOUND_LIST, SEPARATOR, ALL, 0},
{IO_HERE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER}, {IO_HERE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER},
{FILENAME, TK_LESS, IO_FILE, ALL, TK_LESS}, {FILENAME, TK_LESS, IO_FILE, ALL, TK_LESS},
{FILENAME, TK_LESSAND, IO_FILE, ALL, TK_LESSAND}, {FILENAME, TK_LESSAND, IO_FILE, ALL, TK_LESSAND},
{FILENAME, TK_GREAT, IO_FILE, ALL, TK_GREAT}, {FILENAME, TK_GREAT, IO_FILE, ALL, TK_GREAT},
{FILENAME, TK_GREATAND, IO_FILE, ALL, TK_GREATAND}, {FILENAME, TK_GREATAND, IO_FILE, ALL, TK_GREATAND},
{FILENAME, TK_DGREAT, IO_FILE, ALL, TK_DGREAT}, {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}, {FILENAME, TK_CLOBBER, IO_FILE, ALL, TK_CLOBBER},
{IO_FILE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER}, {IO_FILE, ALL, IO_REDIRECT, ALL, TK_IO_NUMBER},
{IO_REDIRECT, COMPOUND_COMMAND, REDIRECT_LIST, ALL, REDIRECT_LIST}, {IO_REDIRECT, COMPOUND_COMMAND, REDIRECT_LIST, ALL, REDIRECT_LIST},
{IO_REDIRECT, CMD_SUFFIX, CMD_SUFFIX, ALL, CMD_SUFFIX}, {IO_REDIRECT, CMD_SUFFIX, CMD_SUFFIX, ALL, CMD_SUFFIX},
{IO_REDIRECT, CMD_NAME, CMD_SUFFIX, ALL, 0}, {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, TK_BANG, CMD_PREFIX, ALL, 0},
{IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, ALL, 0}, {IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, ALL, 0},
{IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, ALL, 0}, {IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, ALL, 0},
{REDIRECT_LIST, COMPOUND_COMMAND, COMPOUND_COMMAND, ALL, COMPOUND_COMMAND}, {REDIRECT_LIST, COMPOUND_COMMAND, COMPOUND_COMMAND, ALL, COMPOUND_COMMAND},
{CMD_SUFFIX, CMD_WORD, SIMPLE_COMMAND, ALL, CMD_PREFIX}, {CMD_SUFFIX, CMD_WORD, SIMPLE_COMMAND, ALL, CMD_PREFIX},
{CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, ALL, CMD_NAME}, {CMD_SUFFIX, CMD_NAME, SIMPLE_COMMAND, ALL, CMD_NAME},
{CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, ALL_SEPARATOR, 0},
{CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, {CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, ALL_SEPARATOR, 0},
{CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, {CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, ALL_SEPARATOR, 0},
{CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, {CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, ALL_SEPARATOR, 0},
{CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, {CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, ALL_SEPARATOR, CMD_PREFIX},
//to check
{CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, {CMD_NAME, LINEBREAK, SIMPLE_COMMAND, ALL, 0},
CMD_PREFIX}, {CMD_NAME, TK_BANG, SIMPLE_COMMAND, ALL, 0},
{CMD_NAME, SEPARATOR_OP, SIMPLE_COMMAND, ALL, 0},
{CMD_NAME, LINEBREAK, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, {CMD_NAME, NEWLINE_LIST, SIMPLE_COMMAND, ALL, 0},
{CMD_NAME, TK_BANG, SIMPLE_COMMAND, TK_NEWLINE ou TK_SEMI ou TK_AMP, 0}, {CMD_NAME, PIPE_SEMI_SEQUENCE, SIMPLE_COMMAND, ALL, 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},
{SIMPLE_COMMAND, ALL, COMMAND, ALL, 0}, {SIMPLE_COMMAND, ALL, COMMAND, ALL, 0},
{DO_GROUP, NAME, FOR_CLAUSE, ALL, TK_FOR},
{DO_GROUP, NAME, FOR_CLAUSE, ALL, FOR}, {DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, ALL, TK_FOR},
{DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, ALL, FOR},
{DO_GROUP, COMPOUND_LIST, LOOP, ALL, COMPOUND_LIST}, {DO_GROUP, COMPOUND_LIST, LOOP, ALL, COMPOUND_LIST},
{LOOP, WHILE, WHILE_CLAUSE, ALL, WHILE}, {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}, {BRACE_GROUP, ALL, COMPOUND_COMMAND, ALL, 0},
{FUNCTION_BODY, FUNC, FUNCTION_DEFINITION, ALL, 0}, {FUNCTION_BODY, FUNC, FUNCTION_DEFINITION, ALL, 0},
{FUNCTION_DEFINITION, ALL, COMMAND, ALL, 0}, {FUNCTION_DEFINITION, ALL, COMMAND, ALL, 0},
{UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, {UNTIL_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
{WHILE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, {WHILE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
{ELSE_PART, COMPOUND_LIST, ELSE_PART, ALL, TK_ELIF},
{ELSE_PART, COMPOUND_LIST, ELSE_PART, ALL, ELIF},
{IF_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, {IF_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
{CASE_ITEM, CASE_LIST, CASE_LIST, ALL, CASE_LIST}, {CASE_ITEM, CASE_LIST, CASE_LIST, ALL, CASE_LIST},
{CASE_ITEM, LINEBREAK, 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, CASE_LIST, CASE_LIST_NS, ALL, CASE_LIST},
{CASE_ITEM_NS, LINEBREAK, CASE_LIST_NS, ALL, CASE_LIST}, {CASE_ITEM_NS, LINEBREAK, CASE_LIST_NS, ALL, CASE_LIST},
{CASE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, {CASE_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
{FOR_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0}, {FOR_CLAUSE, ALL, COMPOUND_COMMAND, ALL, 0},
{TERM, LINEBREAK, COMPOUND_LIST, ALL, LINEBREAK}, {TERM, LINEBREAK, COMPOUND_LIST, ALL, LINEBREAK},
{COMPOUND_LIST, TK_ELSE, ELSE_PART, ALL, TK_ELSE}, {COMPOUND_LIST, TK_ELSE, ELSE_PART, ALL, TK_ELSE},
{COMPOUND_LIST, TK_THEN, ELSE_PART, ALL, TK_ELIF}, {COMPOUND_LIST, TK_THEN, ELSE_PART, ALL, TK_ELIF},
{SUBSHELL, ALL, COMPOUND_COMMAND, ALL, 0}, {SUBSHELL, ALL, COMPOUND_COMMAND, ALL, 0},
{COMPOUND_COMMAND, ALL, COMMAND, ALL, 0}, {COMPOUND_COMMAND, ALL, COMMAND, ALL, 0},
{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, ALL, PIPE_SEMI_SEQUENCE},
{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, ALL, PIPE_SEQUENCE},
{COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, ALL, PIPE_SEQUENCE},
{COMMAND, TK_BANG, PIPE_SEQUENCE, ALL, 0}, {COMMAND, TK_BANG, PIPE_SEQUENCE, ALL, 0},
{COMMAND, SEPARATOR_OP, PIPE_SEQUENCE, ALL, 0}, {COMMAND, SEPARATOR_OP, PIPE_SEQUENCE, ALL, 0},
{COMMAND, NEWLINE_LIST, 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, TK_BANG, PIPELINE, ALL, TK_BANG},
{PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, ALL, 0}, {PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, ALL, 0},
{PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, ALL, 0}, {PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, ALL, 0},
{PIPE_SEQUENCE, LINEBREAK, PIPELINE, ALL_SEPARATOR, 0},
{PIPELINE, LINEBREAK, AND_OR, ALL, AND_OR}, {PIPELINE, LINEBREAK, AND_OR, ALL, 0},
// {PIPELINE, LINEBREAK, AND_OR, ALL, AND_OR},
{PIPELINE, SEPARATOR_OP, AND_OR, ALL, 0}, {PIPELINE, SEPARATOR_OP, AND_OR, ALL, 0},
{AND_OR, SEPARATOR_OP, LIST, ALL, LIST}, {AND_OR, SEPARATOR_OP, LIST, ALL, LIST},
{AND_OR, NEWLINE_LIST, LIST, ALL, 0}, {AND_OR, NEWLINE_LIST, LIST, ALL, 0},
{AND_OR, LINEBREAK, LIST, ALL, 0},
{LIST, NEWLINE_LIST, COMPLETE_COMMAND, 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, NEWLINE_LIST, COMPLETE_COMMANDS, ALL, COMPLETE_COMMANDS},
{COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, ALL, 0}, {COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, ALL, 0},
// voir decoupe separateur au lexer
{COMPLETE_COMMANDS, LINEBREAK, PROGRAM, ALL_SEPARATOR, 0},
{0, 0, 0, 0, 0},
};
{0, 0, 0}, int aggregate_sym(t_sym **stack, t_sym *new_sym,
} t_parstate *state, t_list *next_token)
int aggregate_sym(t_sym **stack, t_sym *new_sym)
{ {
DG("aggregate head %s && sym %s", read_state(**stack), read_state(*new_sym)); int i;
if (**stack == 0 && *new_sym == CMD_NAME) 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; if (*new_sym == g_aggrematch[i].top && (**stack == g_aggrematch[i].under
aggregate_sym(stack, new_sym); || 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); return (0);
} }

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 20:15:35 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 */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 16:26:30 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[] = t_stackmatch g_stackmatch[] =
{ {
{TK_WORD, CMD_SUFFIX}, {TK_N_WORD, CMD_SUFFIX},
{TK_WORD, TK_PIPE}, {TK_N_WORD, TK_PIPE},
{TK_WORD, CASE}, {TK_N_WORD, TK_CASE},
{TK_WORD, WORDLIST}, {TK_N_WORD, WORDLIST},
{TK_N_WORD, LINEBREAK},
{TK_ASSIGNEMENT_WORD, CMD_PREFIX}, {TK_ASSIGNEMENT_WORD, CMD_PREFIX},
{TK_IO_NUMBER, REDIRECT_LIST}, {TK_IO_NUMBER, REDIRECT_LIST},
{TK_IO_NUMBER, CMD_SUFFIX}, {TK_IO_NUMBER, CMD_SUFFIX},
{TK_IO_NUMBER, CMD_PREFIX}, {TK_IO_NUMBER, CMD_PREFIX},
@ -29,16 +28,12 @@ t_stackmatch g_stackmatch[] =
{TK_IO_NUMBER, LINEBREAK}, {TK_IO_NUMBER, LINEBREAK},
{TK_IO_NUMBER, TK_BANG}, {TK_IO_NUMBER, TK_BANG},
{TK_IO_NUMBER, SEPARATOR_OP}, {TK_IO_NUMBER, SEPARATOR_OP},
{TK_IO_NUMBER, NEWWLINE_LIST}, {TK_IO_NUMBER, NEWLINE_LIST},
{TK_IO_NUMBER, PIPE_SEMI_SEQUENCE}, {TK_IO_NUMBER, PIPE_SEMI_SEQUENCE},
{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_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},
@ -50,7 +45,6 @@ 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_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},
@ -62,7 +56,6 @@ 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_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},
@ -74,7 +67,6 @@ 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_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},
@ -86,7 +78,6 @@ 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_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},
@ -98,7 +89,6 @@ 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_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},
@ -110,7 +100,6 @@ 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_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},
@ -122,82 +111,64 @@ 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_IF, LINEBREAK}, {TK_IF, LINEBREAK},
{TK_IF, TK_BANG}, {TK_IF, TK_BANG},
{TK_IF, SEPARATOR_OP}, {TK_IF, SEPARATOR_OP},
{TK_IF, NEWLINE_LIST}, {TK_IF, NEWLINE_LIST},
{TK_IF, PIPE_SEMI_SEQUENCE}, {TK_IF, PIPE_SEMI_SEQUENCE},
{TK_THEN, COMPOUND_LIST}, {TK_THEN, COMPOUND_LIST},
{TK_ELSE, COMPOUND_LIST}, {TK_ELSE, COMPOUND_LIST},
{TK_ELIF, COMPOUND_LIST}, {TK_ELIF, COMPOUND_LIST},
{TK_FI, ELSE_PART}, {TK_FI, ELSE_PART},
{TK_FI, COMPOUND_LIST}, {TK_FI, COMPOUND_LIST},
{TK_DO, COMPOUND_LIST}, {TK_DO, COMPOUND_LIST},
{TK_DO, NAME}, {TK_DO, NAME},
{TK_DO, SEQUENTIAL_SEP}, {TK_DO, SEQUENTIAL_SEP},
{TK_DONE, COMPOUND_LIST}, {TK_DONE, COMPOUND_LIST},
{TK_CASE, LINEBREAK}, {TK_CASE, LINEBREAK},
{TK_CASE, TK_BANG}, {TK_CASE, TK_BANG},
{TK_CASE, NEWLINE_LIST}, {TK_CASE, NEWLINE_LIST},
{TK_CASE, SEPARATOR_OP}, {TK_CASE, SEPARATOR_OP},
{TK_CASE, PIPE_SEMI_SEQUENCE}, {TK_CASE, PIPE_SEMI_SEQUENCE},
{TK_ESAC, CASE_LIST}, {TK_ESAC, CASE_LIST},
{TK_ESAC, CASE_LIST_NS}, {TK_ESAC, CASE_LIST_NS},
{TK_ESAC, LINEBREAK}, {TK_ESAC, LINEBREAK},
{TK_WHILE, LINEBREAK}, {TK_WHILE, LINEBREAK},
{TK_WHILE, TK_BANG}, {TK_WHILE, TK_BANG},
{TK_WHILE, SEPARATOR_OP}, {TK_WHILE, SEPARATOR_OP},
{TK_WHILE, NEWLINE_LIST}, {TK_WHILE, NEWLINE_LIST},
{TK_WHILE, PIPE_SEMI_SEQUENCE}, {TK_WHILE, PIPE_SEMI_SEQUENCE},
{TK_UNTIL, LINEBREAK}, {TK_UNTIL, LINEBREAK},
{TK_UNTIL, TK_BANG}, {TK_UNTIL, TK_BANG},
{TK_UNTIL, SEPARATOR_OP}, {TK_UNTIL, SEPARATOR_OP},
{TK_UNTIL, NEWLINE_LIST}, {TK_UNTIL, NEWLINE_LIST},
{TK_UNTIL, PIPE_SEMI_SEQUENCE}, {TK_UNTIL, PIPE_SEMI_SEQUENCE},
{TK_FOR, LINEBREAK}, {TK_FOR, LINEBREAK},
{TK_FOR, TK_BANG}, {TK_FOR, TK_BANG},
{TK_FOR, SEPARATOR_OP}, {TK_FOR, SEPARATOR_OP},
{TK_FOR, NEWLINE_LIST}, {TK_FOR, NEWLINE_LIST},
{TK_FOR, PIPE_SEMI_SEQUENCE}, {TK_FOR, PIPE_SEMI_SEQUENCE},
{TK_LBRACE, LINEBREAK}, {TK_LBRACE, LINEBREAK},
{TK_LBRACE, TK_BANG}, {TK_LBRACE, TK_BANG},
{TK_LBRACE, SEPARATOR_OP}, {TK_LBRACE, SEPARATOR_OP},
{TK_LBRACE, NEWLINE_LIST}, {TK_LBRACE, NEWLINE_LIST},
{TK_LBRACE, PIPE_SEMI_SEQUENCE}, {TK_LBRACE, PIPE_SEMI_SEQUENCE},
{TK_RBRACE, COMPOUND_LIST}, {TK_RBRACE, COMPOUND_LIST},
{TK_BANG, LINEBREAK}, {TK_BANG, LINEBREAK},
{TK_BANG, SEPARATOR_OP}, {TK_BANG, SEPARATOR_OP},
{TK_BANG, NEWLINE_LIST}, {TK_BANG, NEWLINE_LIST},
{TK_IN, LINEBREAK}, {TK_IN, LINEBREAK},
{TK_SEMI, NAME}, {TK_SEMI, NAME},
{TK_SEMI, IN}, {TK_SEMI, IN},
{TK_SEMI, WORDLIST}, {TK_SEMI, WORDLIST},
{TK_SEMI, LIST}, {TK_SEMI, LIST},
{TK_SEMI, TERM}, {TK_SEMI, TERM},
{TK_SEMI, CMD_NAME},
{TK_SEMI, PROGRAM},
{TK_AMP, LIST}, {TK_AMP, LIST},
{TK_AMP, TERM}, {TK_AMP, TERM},
{TK_PIPE, PATTERN}, {TK_PIPE, PATTERN},
{TK_PIPE, PIPE_SEQUENCE}, {TK_PIPE, PIPE_SEQUENCE},
{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},
@ -205,23 +176,19 @@ t_stackmatch g_stackmatch[] =
{TK_PAREN_OPEN, SEPARATOR_OP}, {TK_PAREN_OPEN, SEPARATOR_OP},
{TK_PAREN_OPEN, NEWLINE_LIST}, {TK_PAREN_OPEN, NEWLINE_LIST},
{TK_PAREN_OPEN, PIPE_SEMI_SEQUENCE}, {TK_PAREN_OPEN, PIPE_SEMI_SEQUENCE},
{TK_PAREN_CLOSE, TK_PAREN_OPEN}, {TK_PAREN_CLOSE, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, PATTERN}, {TK_PAREN_CLOSE, PATTERN},
{TK_PAREN_CLOSE, COMPOUND_LIST}, {TK_PAREN_CLOSE, COMPOUND_LIST},
{SEQUENTIAL_SEP, NAME}, {SEQUENTIAL_SEP, NAME},
{SEQUENTIAL_SEP, IN}, {SEQUENTIAL_SEP, IN},
{SEQUENTIAL_SEP, WORDLIST}, {SEQUENTIAL_SEP, WORDLIST},
{SEPARATOR, TERM}, {SEPARATOR, TERM},
{SEPARATOR, COMPOUND_LIST}, {SEPARATOR, COMPOUND_LIST},
{SEPARATOR_OP, LIST}, {SEPARATOR_OP, LIST},
{SEPARATOR_OP, TERM}, {SEPARATOR_OP, TERM},
{SEPARATOR_OP, COMPOUND_LIST}, {SEPARATOR_OP, COMPOUND_LIST},
{LINEBREAK, TK_SEMI}, {LINEBREAK, TK_SEMI},
{LINEBREAK, SEPARATOR_OP},
{LINEBREAK, TK_PAREN_CLOSE}, {LINEBREAK, TK_PAREN_CLOSE},
{LINEBREAK, WORD}, {LINEBREAK, WORD},
{LINEBREAK, IN}, {LINEBREAK, IN},
@ -230,7 +197,6 @@ t_stackmatch g_stackmatch[] =
{LINEBREAK, TK_PIPE}, {LINEBREAK, TK_PIPE},
{LINEBREAK, LINEBREAK}, {LINEBREAK, LINEBREAK},
{LINEBREAK, COMPLETE_COMMANDS}, {LINEBREAK, COMPLETE_COMMANDS},
{NEWLINE_LIST, NEWLINE_LIST}, {NEWLINE_LIST, NEWLINE_LIST},
{NEWLINE_LIST, NAME}, {NEWLINE_LIST, NAME},
{NEWLINE_LIST, IN}, {NEWLINE_LIST, IN},
@ -238,10 +204,8 @@ t_stackmatch g_stackmatch[] =
{NEWLINE_LIST, TERM}, {NEWLINE_LIST, TERM},
{NEWLINE_LIST, COMPOUND_LIST}, {NEWLINE_LIST, COMPOUND_LIST},
{NEWLINE_LIST, COMPLETE_COMMANDS}, {NEWLINE_LIST, COMPLETE_COMMANDS},
{HERE_END, TK_DLESS},
{HERE_END, DLESS}, {HERE_END, TK_DLESSDASH},
{HERE_END, DLESSDASH},
{IO_HERE, TK_IO_NUMBER}, {IO_HERE, TK_IO_NUMBER},
{IO_HERE, REDIRECT_LIST}, {IO_HERE, REDIRECT_LIST},
{IO_HERE, CMD_SUFFIX}, {IO_HERE, CMD_SUFFIX},
@ -253,7 +217,6 @@ t_stackmatch g_stackmatch[] =
{IO_HERE, SEPARATOR_OP}, {IO_HERE, SEPARATOR_OP},
{IO_HERE, NEWLINE_LIST}, {IO_HERE, NEWLINE_LIST},
{IO_HERE, PIPE_SEMI_SEQUENCE}, {IO_HERE, PIPE_SEMI_SEQUENCE},
{FILENAME, TK_LESS}, {FILENAME, TK_LESS},
{FILENAME, TK_LESSAND}, {FILENAME, TK_LESSAND},
{FILENAME, TK_GREAT}, {FILENAME, TK_GREAT},
@ -261,7 +224,6 @@ t_stackmatch g_stackmatch[] =
{FILENAME, TK_DGREAT}, {FILENAME, TK_DGREAT},
{FILENAME, TK_LESSGREAT}, {FILENAME, TK_LESSGREAT},
{FILENAME, TK_CLOBBER}, {FILENAME, TK_CLOBBER},
{IO_FILE, TK_IO_NUMBER}, {IO_FILE, TK_IO_NUMBER},
{IO_FILE, REDIRECT_LIST}, {IO_FILE, REDIRECT_LIST},
{IO_FILE, CMD_SUFFIX}, {IO_FILE, CMD_SUFFIX},
@ -273,7 +235,6 @@ t_stackmatch g_stackmatch[] =
{IO_FILE, SEPARATOR_OP}, {IO_FILE, SEPARATOR_OP},
{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_SUFFIX}, {IO_REDIRECT, CMD_SUFFIX},
{IO_REDIRECT, CMD_PREFIX}, {IO_REDIRECT, CMD_PREFIX},
@ -284,112 +245,84 @@ t_stackmatch g_stackmatch[] =
{IO_REDIRECT, SEPARATOR_OP}, {IO_REDIRECT, SEPARATOR_OP},
{IO_REDIRECT, NEWLINE_LIST}, {IO_REDIRECT, NEWLINE_LIST},
{IO_REDIRECT, PIPE_SEMI_SEQUENCE}, {IO_REDIRECT, PIPE_SEMI_SEQUENCE},
{REDIRECT_LIST, COMPOUND_COMMAND},
{REDIRECT_LIST, COMPOUND_COMMAND}
{CMD_SUFFIX, CMD_WORD}, {CMD_SUFFIX, CMD_WORD},
{CMD_SUFFIX, CMD_NAME}, {CMD_SUFFIX, CMD_NAME},
{CMD_PREFIX, LINEBREAK}, {CMD_PREFIX, LINEBREAK},
{CMD_PREFIX, TK_BANG}, {CMD_PREFIX, TK_BANG},
{CMD_PREFIX, SEPARATOR_OP}, {CMD_PREFIX, SEPARATOR_OP},
{CMD_PREFIX, NEWLINE_LIST}, {CMD_PREFIX, NEWLINE_LIST},
{CMD_PREFIX, PIPE_SEMI_SEQUENCE}, {CMD_PREFIX, PIPE_SEMI_SEQUENCE},
{CMD_WORD, CMD_PREFIX}, {CMD_WORD, CMD_PREFIX},
{CMD_NAME, LINEBREAK}, {CMD_NAME, LINEBREAK},
{CMD_NAME, TK_BANG}, {CMD_NAME, TK_BANG},
{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},
{SIMPLE_COMMAND, LINEBREAK},
{SIMPLE_COMMNAND, LINEBREAK},
{SIMPLE_COMMAND, TK_BANG}, {SIMPLE_COMMAND, TK_BANG},
{SIMPLE_COMMAND, SEPARATOR_OP}, {SIMPLE_COMMAND, SEPARATOR_OP},
{SIMPLE_COMMAND, NEWLINE_LIST}, {SIMPLE_COMMAND, NEWLINE_LIST},
{SIMPLE_COMMAND, PIPE_SEMI_SEQUENCE}, {SIMPLE_COMMAND, PIPE_SEMI_SEQUENCE},
{DO_GROUP, COMPOUND_LIST}, {DO_GROUP, COMPOUND_LIST},
{DO_GROUP, NAME}, {DO_GROUP, NAME},
{DO_GROUP, SEQUENTIAL_SEP}, {DO_GROUP, SEQUENTIAL_SEP},
{LOOP, TK_WHILE},
{LOOP, WHILE}, {LOOP, TK_UNTIL},
{LOOP, UNTIL},
{BRACE_GROUP, LINEBREAK}, {BRACE_GROUP, LINEBREAK},
{BRACE_GROUP, TK_BANG}, {BRACE_GROUP, TK_BANG},
{BRACE_GROUP, SEPARATOR_OP}, {BRACE_GROUP, SEPARATOR_OP},
{BRACE_GROUP, NEWLINE_LIST}, {BRACE_GROUP, NEWLINE_LIST},
{BRACE_GROUP, PIPE_SEMI_SEQUENCE}, {BRACE_GROUP, PIPE_SEMI_SEQUENCE},
{FNAME, LINEBREAK}, {FNAME, LINEBREAK},
{FNAME, TK_BANG}, {FNAME, TK_BANG},
{FNAME, SEPARATOR_OP}, {FNAME, SEPARATOR_OP},
{FNAME, NEWLINE_LIST}, {FNAME, NEWLINE_LIST},
{FNAME, PIPE_SEMI_SEQUENCE}, {FNAME, PIPE_SEMI_SEQUENCE},
{FUNCTION_BODY, FUNC}, {FUNCTION_BODY, FUNC},
{FUNCTION_DEFINITION, LINEBREAK}, {FUNCTION_DEFINITION, LINEBREAK},
{FUNCTION_DEFINITION, TK_BANG}, {FUNCTION_DEFINITION, TK_BANG},
{FUNCTION_DEFINITION, SEPARATOR_OP}, {FUNCTION_DEFINITION, SEPARATOR_OP},
{FUNCTION_DEFINITION, NEWLINE_LIST}, {FUNCTION_DEFINITION, NEWLINE_LIST},
{FUNCTION_DEFINITION, PIPE_SEMI_SEQUENCE}, {FUNCTION_DEFINITION, PIPE_SEMI_SEQUENCE},
{UNTIL_CLAUSE, LINEBREAK}, {UNTIL_CLAUSE, LINEBREAK},
{UNTIL_CLAUSE, TK_BANG}, {UNTIL_CLAUSE, TK_BANG},
{UNTIL_CLAUSE, SEPARATOR_OP}, {UNTIL_CLAUSE, SEPARATOR_OP},
{UNTIL_CLAUSE, NEWLINE_LIST}, {UNTIL_CLAUSE, NEWLINE_LIST},
{UNTIL_CLAUSE, PIPE_SEMI_SEQUENCE}, {UNTIL_CLAUSE, PIPE_SEMI_SEQUENCE},
{WHILE_CLAUSE, LINEBREAK}, {WHILE_CLAUSE, LINEBREAK},
{WHILE_CLAUSE, TK_BANG}, {WHILE_CLAUSE, TK_BANG},
{WHILE_CLAUSE, SEPARATOR_OP}, {WHILE_CLAUSE, SEPARATOR_OP},
{WHILE_CLAUSE, NEWLINE_LIST}, {WHILE_CLAUSE, NEWLINE_LIST},
{WHILE_CLAUSE, PIPE_SEMI_SEQUENCE}, {WHILE_CLAUSE, PIPE_SEMI_SEQUENCE},
{ELSE_PART, COMPOUND_LIST}, {ELSE_PART, COMPOUND_LIST},
{IF_CLAUSE, LINEBREAK}, {IF_CLAUSE, LINEBREAK},
{IF_CLAUSE, TK_BANG}, {IF_CLAUSE, TK_BANG},
{IF_CLAUSE, SEPARATOR_OP}, {IF_CLAUSE, SEPARATOR_OP},
{IF_CLAUSE, NEWLINE_LIST}, {IF_CLAUSE, NEWLINE_LIST},
{IF_CLAUSE, PIPE_SEMI_SEQUENCE}, {IF_CLAUSE, PIPE_SEMI_SEQUENCE},
{PATTERN, TK_PAREN_OPEN}, {PATTERN, TK_PAREN_OPEN},
{PATTERN, CASE_LIST}, {PATTERN, 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},
{CASE_ITEM_NS, LINEBREAK}, {CASE_ITEM_NS, LINEBREAK},
{CASE_LIST, LINEBREAK}, {CASE_LIST, LINEBREAK},
{CASE_LIST_NS, LINEBREAK}, {CASE_LIST_NS, LINEBREAK},
{CASE_CLAUSE, LINEBREAK}, {CASE_CLAUSE, LINEBREAK},
{CASE_CLAUSE, TK_BANG}, {CASE_CLAUSE, TK_BANG},
{CASE_CLAUSE, SEPARATOR_OP}, {CASE_CLAUSE, SEPARATOR_OP},
{CASE_CLAUSE, NEWLINE_LIST}, {CASE_CLAUSE, NEWLINE_LIST},
{CASE_CLAUSE, PIPE_SEMI_SEQUENCE}, {CASE_CLAUSE, PIPE_SEMI_SEQUENCE},
{WORDLIST, IN}, {WORDLIST, IN},
{IN, LINEBREAK}, {IN, LINEBREAK},
{NAME, TK_FOR},
{NAME, FOR},
{FOR_CLAUSE, LINEBREAK}, {FOR_CLAUSE, LINEBREAK},
{FOR_CLAUSE, TK_BANG}, {FOR_CLAUSE, TK_BANG},
{FOR_CLAUSE, SEPARATOR_OP}, {FOR_CLAUSE, SEPARATOR_OP},
{FOR_CLAUSE, NEWLINE_LIST}, {FOR_CLAUSE, NEWLINE_LIST},
{FOR_CLAUSE, PIPE_SEMI_SEQUENCE}, {FOR_CLAUSE, PIPE_SEMI_SEQUENCE},
{TERM, LINEBREAK}, {TERM, LINEBREAK},
{COMPOUND_LIST, TK_DO}, {COMPOUND_LIST, TK_DO},
{COMPOUND_LIST, TK_LBRACE}, {COMPOUND_LIST, TK_LBRACE},
{COMPOUND_LIST, TK_WHILE}, {COMPOUND_LIST, TK_WHILE},
@ -397,45 +330,40 @@ t_stackmatch g_stackmatch[] =
{COMPOUND_LIST, TK_ELIF}, {COMPOUND_LIST, TK_ELIF},
{COMPOUND_LIST, TK_ELSE}, {COMPOUND_LIST, TK_ELSE},
{COMPOUND_LIST, TK_IF}, {COMPOUND_LIST, TK_IF},
{SUBSHELL, LINEBREAK}, {SUBSHELL, LINEBREAK},
{SUBSHELL, TK_BANG}, {SUBSHELL, TK_BANG},
{SUBSHELL, SEPARATOR_OP}, {SUBSHELL, SEPARATOR_OP},
{SUBSHELL, NEWLINE_LIST}, {SUBSHELL, NEWLINE_LIST},
{SUBSHELL, PIPE_SEMI_SEQUENCE}, {SUBSHELL, PIPE_SEMI_SEQUENCE},
{COMPOUND_COMMAND, LINEBREAK}, {COMPOUND_COMMAND, LINEBREAK},
{COMPOUND_COMMAND, TK_BANG}, {COMPOUND_COMMAND, TK_BANG},
{COMPOUND_COMMAND, SEPARATOR_OP}, {COMPOUND_COMMAND, SEPARATOR_OP},
{COMPOUND_COMMAND, NEWLINE_LIST}, {COMPOUND_COMMAND, NEWLINE_LIST},
{COMPOUND_COMMAND, PIPE_SEMI_SEQUENCE}, {COMPOUND_COMMAND, PIPE_SEMI_SEQUENCE},
{COMPOUND_COMMAND, FUNC}, {COMPOUND_COMMAND, FUNC},
{COMMAND, LINEBREAK}, {COMMAND, LINEBREAK},
{COMMAND, TK_BANG}, {COMMAND, TK_BANG},
{COMMAND, SEPARATOR_OP}, {COMMAND, SEPARATOR_OP},
{COMMAND, NEWLINE_LIST}, {COMMAND, NEWLINE_LIST},
{COMMAND, PIPE_SEMI_SEQUENCE}, {COMMAND, PIPE_SEMI_SEQUENCE},
{PIPE_SEQUENCE, LINEBREAK}, {PIPE_SEQUENCE, LINEBREAK},
{PIPE_SEQUENCE, TK_BANG}, {PIPE_SEQUENCE, TK_BANG},
{PIPE_SEQUENCE, SEPARATOR_OP}, {PIPE_SEQUENCE, SEPARATOR_OP},
{PIPE_SEQUENCE, NEWLINE_LIST}, {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, LINEBREAK},
{PIPELINE, SEPARATOR_OP}, {PIPELINE, SEPARATOR_OP},
{PIPELINE, NEWLINE_LIST}, {PIPELINE, NEWLINE_LIST},
{AND_OR, LINEBREAK}, {AND_OR, LINEBREAK},
{AND_OR, SEPARATOR_OP}, {AND_OR, SEPARATOR_OP},
{AND_OR, NEWLINE_LIST}, {AND_OR, NEWLINE_LIST},
{LIST, LINEBREAK}, {LIST, LINEBREAK},
{LIST, NEWLINE_LIST}, {LIST, NEWLINE_LIST},
{COMPLETE_COMMAND, LINEBREAK}, {COMPLETE_COMMAND, LINEBREAK},
{COMPLETE_COMMAND, NEWLINE_LIST}, {COMPLETE_COMMAND, NEWLINE_LIST},
{COMPLETE_COMMANDS, LINEBREAK}, {COMPLETE_COMMANDS, LINEBREAK},
{0, 0}, {0, 0},
}; };
@ -448,7 +376,7 @@ int eval_sym(t_sym stack, t_sym new_sym)
i = 0; i = 0;
while (g_stackmatch[i].top) 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); return (0);
i++; i++;
} }

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 14:30:22 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 *new_sym;
t_sym *stack; t_sym *stack;
t_parstate state; t_parstate state;
//to delete
t_token *content;
(void)ast; (void)ast;
state = UNDEFINED; state = UNDEFINED;
@ -25,16 +27,18 @@ 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); aggregate_sym(&stack, new_sym, &state, (*token)->next);
//superflous sym
push_stack(++stack, *new_sym); push_stack(++stack, *new_sym);
} }
ft_putstr("\n");
ft_read_stack(stack);
if (*stack == PROGRAM) if (*stack == PROGRAM)
state = SUCCESS; state = SUCCESS;
if (state == ERROR) if (state == ERROR)
@ -42,8 +46,10 @@ 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);
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); return (0);
} }

14
42sh/src/parser/pop_stack.c
View file

@ -6,15 +6,21 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 19:12:44 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" #include "parser.h"
int pop_stack(t_sym **stack, int k) int pop_stack(t_sym **stack, t_sym erase_sym)
{ {
while (k--) t_sym *temp;
*stack-- = 0;
DG("pop until :%s", read_state(erase_sym));
temp = *stack;
while (*temp != erase_sym)
*temp-- = 0;
*temp-- = 0;
*stack = temp;
return (0); return (0);
} }

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 17:58:34 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,36 +14,48 @@
t_prodmatch g_prodmatch[] = t_prodmatch g_prodmatch[] =
{ {
{TK_WORD, TK_DLESS, HERE_END}, {TK_N_WORD, TK_DLESS, HERE_END},
{TK_WORD, TK_DLESSDASH, HERE_END}, {TK_N_WORD, TK_DLESSDASH, HERE_END},
{TK_WORD, TK_LESS, FILENAME}, {TK_N_WORD, TK_LESS, FILENAME},
{TK_WORD, TK_LESSAND, FILENAME}, {TK_N_WORD, TK_LESSAND, FILENAME},
{TK_WORD, TK_GREAT, FILENAME}, {TK_N_WORD, TK_GREAT, FILENAME},
{TK_WORD, TK_GREATAND, FILENAME}, {TK_N_WORD, TK_GREATAND, FILENAME},
{TK_WORD, TK_DGREAT, FILENAME}, {TK_N_WORD, TK_DGREAT, FILENAME},
{TK_WORD, TK_LESSGREAT, FILENAME}, {TK_N_WORD, TK_LESSGREAT, FILENAME},
{TK_WORD, TK_CLOBBER, FILENAME}, {TK_N_WORD, TK_CLOBBER, FILENAME},
{TK_WORD, CMD_WORD, CMD_SUFFIX}, {TK_N_WORD, CMD_WORD, CMD_SUFFIX},
{TK_WORD, CMD_NAME, CMD_SUFFIX}, {TK_N_WORD, CMD_NAME, CMD_SUFFIX},
{TK_WORD, LINEBREAK, CMD_NAME}, {TK_N_WORD, LINEBREAK, CMD_NAME},
{TK_WORD, NEWLINE_LIST, CMD_NAME}, {TK_N_WORD, NEWLINE_LIST, CMD_NAME},
{TK_WORD, IN, WORDLIST}, //to delete
{{TK_WORD, CASE_LIST, PATTERN}, {TK_N_WORD, TK_SEMI, CMD_NAME},
{TK_WORD, TK_PAREN_OPEN, PATTERN},
{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, LINEBREAK, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_BANG, CMD_PREFIX}, {TK_ASSIGNEMENT_WORD, TK_BANG, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, SEPARATOR_OP, CMD_PREFIX}, {TK_ASSIGNEMENT_WORD, SEPARATOR_OP, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, NEWLINE_LIST, CMD_PREFIX}, {TK_ASSIGNEMENT_WORD, NEWLINE_LIST, CMD_PREFIX},
{TK_NAME, LINEBREAK, FNAME}, {TK_NAME, LINEBREAK, FNAME},
{TK_NAME, TK_BANG, FNAME}, {TK_NAME, TK_BANG, FNAME},
{TK_NAME, SEPARATOR_OP, FNAME}, {TK_NAME, SEPARATOR_OP, FNAME},
{TK_NAME, NEWLINE_LIST, FNAME}, {TK_NAME, NEWLINE_LIST, FNAME},
{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_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}, {0, 0, 0},
}; };
@ -54,13 +66,18 @@ int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst)
int i; int i;
token = (*lst)->content; token = (*lst)->content;
DG("produce stack : %s && token : %s", read_state(stack),
read_state(token->type));
i = 0; i = 0;
*new_sym = NULL; *new_sym = 0;
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
&& 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; *new_sym = g_prodmatch[i].new_sym;
}
i++; i++;
} }
if (!*new_sym) if (!*new_sym)

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 16:48:30 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 */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */ /* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 15:32:10 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) 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) if (current == CMD_NAME)
return ("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) /* if (current == NEWLINE_LIST)
return ("NEWLINE_LIST"); return ("NEWLINE_LIST");
if (current == SYM_DLESS) if (current == SYM_DLESS)

13
42sh/tofix Normal file
View file

@ -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