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

conflicts resolved

Browse source
This commit is contained in:
Jack Halford 2017-02-28 21:40:22 +01:00
commit 03152a9e2b
78 changed files with 1432 additions and 370 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
42sh/Makefile
View file

@ -6,7 +6,7 @@
# By: wescande <wescande@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2016/08/29 21:32:58 by wescande #+# #+# #
# Updated: 2017/02/21 16:38:00 by ariard ### ########.fr #
# Updated: 2017/02/25 00:13:39 by ariard ### ########.fr #
# #
# **************************************************************************** #
@ -74,12 +74,14 @@ exec/exec_redir.c\
exec/exec_semi.c\
exec/exec_until.c\
exec/exec_while.c\
exec/exec_var.c\
exec/exec_for.c\
exec/exec_case.c\
exec/exec_case_branch.c\
exec/fd_is_valid.c\
exec/ft_exec.c\
exec/ft_findexec.c\
exec/launch_process.c\
exec/loop_del.c\
exec/loop_exec.c\
exec/process_redirect.c\
exec/process_reset.c\
exec/process_setexec.c\
@ -170,6 +172,7 @@ lexer/get_lexer_stack.c\
lexer/get_reserved_words.c\
lexer/get_state_global.c\
lexer/get_state_redir.c\
lexer/insert_newline.c\
lexer/lexer_backslash.c\
lexer/lexer_bquote.c\
lexer/lexer_comment.c\
@ -187,6 +190,8 @@ lexer/lexer_lex.c\
lexer/lexer_newline.c\
lexer/lexer_number.c\
lexer/lexer_paren.c\
lexer/lexer_curly_brackets.c\
lexer/lexer_assignement_word.c\
lexer/lexer_quote.c\
lexer/lexer_sep.c\
lexer/lexer_word.c\
@ -223,10 +228,13 @@ main/shell_get_avdata.c\
main/shell_get_opts.c\
main/shell_init.c\
parser/add_cmd.c\
parser/add_subshell.c\
parser/add_condition.c\
parser/add_file.c\
parser/add_loop.c\
parser/add_sep.c\
parser/add_case.c\
parser/add_func.c\
parser/aggregate_sym.c\
parser/build_tree.c\
parser/error_syntax.c\

14
42sh/includes/exec.h
View file

@ -33,8 +33,6 @@
# define IS_PIPEEND(p) (p->fdout == STDOUT)
# define IS_PIPESINGLE(p) (IS_PIPESTART(p) && IS_PIPEEND(p))
# define SCRIPT_LOOP (1 << 0)
# include "libft.h"
# include "types.h"
# include "job_control.h"
@ -52,7 +50,9 @@ struct s_process
t_list *redirs;
int status;
t_flag attributes;
t_flag script;
t_condition if_branch;
t_condition case_branch;
char *case_pattern;
};
struct s_exec
@ -101,7 +101,10 @@ int exec_elif(t_btree **ast);
int exec_else(t_btree **ast);
int exec_until(t_btree **ast);
int exec_default(t_btree **ast);
int exec_var(t_btree **ast);
int exec_for(t_btree **ast);
int exec_case(t_btree **ast);
int exec_case_branch(t_btree **ast);
int launch_process(t_process *p);
int process_setexec(t_type type, t_process *p);
@ -127,7 +130,6 @@ void set_exitstatus(int status, int override);
void ast_free(void *data, size_t content_size);
int loop_exec(t_list *list_ast);
int loop_del(t_list *list_ast);
char **token_to_argv(t_astnode *node);
#endif

10
42sh/includes/lexer.h
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/01 12:15:50 by jhalford #+# #+# */
/* Updated: 2017/02/21 22:39:19 by jhalford ### ########.fr */
/* Updated: 2017/02/24 21:46:08 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -39,9 +39,9 @@ enum e_lexstate
BQUOTE,
DQUOTE_BQUOTE,
BACKSLASH,
VAR,
SPECIAL,
PAREN,
CURLY_BRACKETS,
ASSIGNEMENT_WORD,
COMMENT,
END,
};
@ -91,6 +91,8 @@ char *stack_to_prompt(t_list *stack);
t_lexstate get_state_global(t_lexer *lexer);
t_lexstate get_state_redir(t_lexer *lexer);
int get_lexer_stack(t_lexer lexer);
int get_reserved_words(t_list **alst);
int insert_newline(t_list **alst);
void lexer_init(t_lexer *lexer);
int lexer_lex(t_list **alst, t_lexer *lexer);
int lexer_default(t_list **alst, t_lexer *lexer);
@ -109,6 +111,8 @@ int lexer_dquote(t_list **alst, t_lexer *lexer);
int lexer_bquote(t_list **alst, t_lexer *lexer);
int lexer_backslash(t_list **alst, t_lexer *lexer);
int lexer_paren(t_list **alst, t_lexer *lexer);
int lexer_curly_brackets(t_list **alst, t_lexer *lexer);
int lexer_assignement_word(t_list **alst, t_lexer *lexer);
int lexer_comment(t_list **alst, t_lexer *lexer);
int lexer_end(t_list **alst, t_lexer *lexer);

2
42sh/includes/minishell.h
View file

@ -65,6 +65,8 @@ struct s_data
t_comp *comp;
t_exec exec;
t_jobc jobc;
char **local_var;
t_list *lst_func;
};
extern t_stof g_builtins[];

152
42sh/includes/parser.h
View file

@ -6,7 +6,6 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/01 12:15:54 by jhalford #+# #+# */
/* Updated: 2017/02/21 20:13:57 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
@ -22,112 +21,9 @@
enum e_parstate
{
ERROR = 0,
UNDEFINED,
SUCCESS,
ERROR,
};
enum e_sym
{
LINEBREAK = 1,
TK_COMMAND,
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_WORD,
TK_ASSIGNEMENT_WORD = 50,
TK_BANG,
TK_NAME,
TK_FOR,
TK_IO_NUMBER,
TK_DLESSDASH,
TK_LESSGREAT,
TK_CASE,
TK_IN,
TK_ESAC,
TK_CLOBBER,
TK_LBRACE,
TK_RBRACE,
TK_DSEMI,
PROGRAM = 100,
COMPLETE_COMMAND,
COMPLETE_COMMANDS,
LIST,
AND_OR,
PIPELINE,
PIPE_SEQUENCE,
COMMAND,
COMPOUND_COMMAND,
SUBSHELL,
COMPOUND_LIST,
TERM,
FOR_CLAUSE,
NAME,
IN,
WORDLIST,
CASE_CLAUSE,
CASE_LIST,
CASE_LIST_NS,
CASE_ITEM,
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,
LOOP,
FUNC,
PIPE_SEMI_SEQUENCE,
PATTERN_CASE,
CMD_SUPERIOR,
AND_OR_MAJOR,
AND_OR_MINOR,
END_COMMAND,
CONDITION,
COMPLETE_CONDITION,
ALL = 200,
};
# define TK_REDIR(x) (TK_LESS <= x && x <= TK_GREATAND)
@ -211,14 +107,27 @@ int build_tree(t_btree **ast, t_list **lst);
int add_sep(t_btree **ast, t_list **lst);
int add_cmd(t_btree **ast, t_list **lst);
int add_file(t_btree **ast, t_list **lst);
int add_redir(t_btree **ast, t_list **lst);
int add_loop_cmd(t_btree **ast, t_list **lst);
int add_loop_sep(t_btree **ast, t_list **lst);
int add_loop_condition(t_btree **ast, t_list **lst);
int add_condition_cmd(t_btree **ast, t_list **lst);
int add_condition_sep(t_btree **ast, t_list **lst);
int add_branch(t_btree **ast, t_list **lst);
int isloop(t_btree **ast);
int isdir(t_btree **ast);
int add_case_cmd(t_btree **ast, t_list **lst);
int add_case_sep(t_btree **ast, t_list **lst);
int add_pattern(t_btree **ast, t_list **lst);
int add_subshell_cmd(t_btree **ast, t_list **lst);
int add_subshell_sep(t_btree **ast, t_list **lst);
int add_func_cmd(t_btree **ast, t_list **lst);
int add_func_sep(t_btree **ast, t_list **lst);
int add_one_func(t_btree **ast, t_list **lst);
int isloop(t_btree **ast, t_list **lst);
int isdir(t_btree **ast, t_list **lst);
int iscase(t_btree **ast, t_list **lst);
int iscondition(t_btree **ast, t_list **lst);
int issubshell(t_btree **ast, t_list **lst);
int isfunc(t_btree **ast, t_list **lst);
int join_ast(t_btree **ast, t_btree **new_node);
int gen_node(t_btree **ast);
@ -246,6 +155,7 @@ union u_astdata
{
t_redir redir;
t_ld *token;
t_list *wordlist;
char **sstr;
char *str;
};
@ -255,35 +165,9 @@ struct s_astnode
int nest;
int full;
int pattern;
t_type type;
t_astdata data;
};
int parse(t_btree **ast, t_list **token);
int get_instruction(t_list **lst);
int get_sub_instruction(t_btree **ast, t_list **start, t_list **lst);
int parse_newline(t_btree **ast, t_list **start, t_list **lst);
int parse_separator(t_btree **ast, t_list **start, t_list **lst);
int parse_redir(t_btree **ast, t_list **start, t_list **lst);
int parse_less(t_btree **ast, t_list **start, t_list **lst);
int parse_great(t_btree **ast, t_list **start, t_list **lst);
int parse_dless(t_btree **ast, t_list **start, t_list **lst);
int parse_dgreat(t_btree **ast, t_list **start, t_list **lst);
int parse_lessand(t_btree **ast, t_list **start, t_list **lst);
int parse_greatand(t_btree **ast, t_list **start, t_list **lst);
int parse_word(t_btree **ast, t_list **start, t_list **lst);
int parse_subshell(t_btree **ast, t_list **start, t_list **lst);
int parse_newline(t_btree **ast, t_list **start, t_list **lst);
int parse_while(t_btree **ast, t_list **start, t_list **lst);
int parse_if(t_btree **ast, t_list **start, t_list **lst);
int parse_do(t_btree **ast, t_list **start, t_list **lst);
int parse_done(t_btree **ast, t_list **start, t_list **lst);
int parse_elif(t_btree **ast, t_list **start, t_list **lst);
int parse_else(t_btree **ast, t_list **start, t_list **lst);
int delete_newline(t_list **start, t_list **lst);
int parse_head(t_btree **ast, t_btree **new_ast, t_list **start, t_list **lst);
#endif

111
42sh/includes/types.h
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/13 17:11:48 by jhalford #+# #+# */
/* Updated: 2017/02/21 16:15:41 by ariard ### ########.fr */
/* Updated: 2017/02/25 19:37:31 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -34,6 +34,7 @@ typedef union u_astdata t_astdata;
typedef union u_word t_word;
typedef long long t_type;
typedef int t_condition;
typedef struct s_job t_job;
typedef struct s_execmap t_execmap;
typedef struct s_redirmap t_redirmap;
@ -51,4 +52,112 @@ typedef struct s_treematch t_treematch;
t_data *data_singleton();
enum e_sym
{
LINEBREAK = 1,
TK_COMMAND,
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_NEWLINE,
TK_WHILE,
TK_DO,
TK_DONE,
TK_IF,
TK_THEN,
TK_FI,
TK_ELIF,
TK_ELSE,
TK_UNTIL,
TK_WORD,
TK_ASSIGNEMENT_WORD = 50,
TK_BANG,
TK_NAME,
TK_FOR,
TK_IO_NUMBER,
TK_DLESSDASH,
TK_LESSGREAT,
TK_SUBSHELL,
TK_CASE,
TK_IN,
TK_ESAC,
TK_CLOBBER,
TK_LBRACE,
TK_RBRACE,
TK_DSEMI,
PROGRAM = 100,
COMPLETE_COMMAND,
COMPLETE_COMMANDS,
LIST,
AND_OR,
PIPELINE,
PIPE_SEQUENCE,
COMMAND,
COMPOUND_COMMAND,
SUBSHELL,
COMPOUND_LIST,
TERM,
FOR_CLAUSE,
NAME,
IN,
WORDLIST,
CASE_CLAUSE,
CASE_LIST,
CASE_LIST_NS,
CASE_ITEM,
CASE_ITEM_NS,
PATTERN,
IF_CLAUSE,
BRACE_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,
BRACE,
LOOP,
FUNC,
PIPE_SEMI_SEQUENCE,
CMD_SUPERIOR,
AND_OR_MAJOR,
AND_OR_MINOR,
END_COMMAND,
CONDITION,
COMPLETE_CONDITION,
FOR_WORDLIST,
PATTERN_CASE,
FUNC_NAME,
CLOSE_LIST,
ALL = 200,
};
#endif

1
42sh/sample/assignement/var_01.sh Normal file
View file

@ -0,0 +1 @@
HELLO=WORLD

1
42sh/sample/brace/brace_01.sh Normal file
View file

@ -0,0 +1 @@
{ ls | cat }

6
42sh/sample/case/case.sh Normal file
View file

@ -0,0 +1,6 @@
case $rental in
("bus") case $rental in
("yolo") echo bonjour
esac ;;
("van") echo yolo ;;
esac

11
42sh/sample/for/for.sh Normal file
View file

@ -0,0 +1,11 @@
for i in hello bonjour salut comment
do
for i in echo
do
pwd
done
for i in echo
do
pwd
done
done

6
42sh/sample/func/func01.sh Normal file
View file

@ -0,0 +1,6 @@
hello() {
yolo() {
echo bonjour
}
}

12
42sh/sample/if/01_if_easy.sh
View file

@ -1,8 +1,10 @@
if ls
then
if ls
then
ls | cat
pwd ; ls
fi
ls
elif ls
then
ls
elif ls
then
ls
fi

2
42sh/sample/mix/mix.sh
View file

@ -1,6 +1,6 @@
if ls
then
ls | cat
ls ; cat
while ls
do
until ls

1
42sh/sample/redir/redir.sh Normal file
View file

@ -0,0 +1 @@

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

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

11
42sh/sample/while/while01.sh Normal file
View file

@ -0,0 +1,11 @@
while ls
do
while ls
do
pwd
done
while ls
do
pwd
done
done

22
42sh/src/exec/loop_exec.c → 42sh/src/exec/exec_case.c
View file

@ -1,27 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* loop_exec.c :+: :+: :+: */
/* exec_if.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/30 21:02:10 by ariard #+# #+# */
/* Updated: 2017/01/31 19:27:49 by ariard ### ########.fr */
/* Created: 2017/02/06 18:07:31 by ariard #+# #+# */
/* Updated: 2017/02/20 22:31:46 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "exec.h"
int loop_exec(t_list *list_ast)
int exec_case(t_btree **ast)
{
t_astnode *node;
char **av;
// DG("begin exec loop");
// ft_print_all_ast(*list_ast);
while (list_ast)
{
if (ft_exec((t_btree **)list_ast->content))
return (1);
list_ast = list_ast->next;
}
data_singleton()->exec.process.case_branch = 0;
node = (*ast)->item;
av = token_to_argv(node);
data_singleton()->exec.process.case_pattern = av[0];
return (0);
}

30
42sh/src/exec/exec_case_branch.c Normal file
View file

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* exec_if.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/06 18:07:31 by ariard #+# #+# */
/* Updated: 2017/02/20 22:31:46 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "exec.h"
int exec_case_branch(t_btree **ast)
{
t_astnode *node;
char **av;
if (data_singleton()->exec.process.case_branch == 1)
return (0);
node = (*ast)->item;
av = token_to_argv(node);
if (ft_strcmp(av[0], data_singleton()->exec.process.case_pattern) == 1)
{
data_singleton()->exec.process.case_branch = 1;
ft_exec(&(*ast)->right);
}
return (0);
}

4
42sh/src/exec/exec_command.c
View file

@ -12,7 +12,7 @@
#include "exec.h"
static char **token_to_argv(t_astnode *node)
char **token_to_argv(t_astnode *node)
{
char **my_tab;
int index;
@ -20,7 +20,7 @@ static char **token_to_argv(t_astnode *node)
char **content;
t_ld *ld;
if (node->type == TK_COMMAND)
if (node->type == TK_WORD || node->type == TK_ASSIGNEMENT_WORD)
{
ld = node->data.token;
my_tab = NULL;

11
42sh/src/exec/exec_elif.c
View file

@ -14,14 +14,13 @@
int exec_elif(t_btree **ast)
{
int test;
(void)ast;
test = 0;
if (test)
if (data_singleton()->exec.process.if_branch == 1)
return (0);
ft_exec(&(*ast)->left);
if (data_singleton()->exec.process.status == 1)
{
data_singleton()->exec.process.if_branch = 1;
ft_exec(&(*ast)->right);
}
// btree_delone(ast, &ast_free);
return (0);
}

5
42sh/src/exec/exec_else.c
View file

@ -14,7 +14,10 @@
int exec_else(t_btree **ast)
{
if (data_singleton()->exec.process.if_branch == 0)
{
data_singleton()->exec.process.if_branch = 1;
ft_exec(&(*ast)->right);
//btree_delone(ast, &ast_free);
}
return (0);
}

35
42sh/src/exec/exec_for.c Normal file
View file

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* exec_until.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/06 20:42:20 by ariard #+# #+# */
/* Updated: 2017/02/06 20:42:21 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "exec.h"
int exec_for(t_btree **ast)
{
t_astnode *node;
t_list *temp;
// char **av = NULL;
char *var;
node = (*ast)->item;
temp = node->data.wordlist;
var = temp->content;
builtin_setenv("setenv", (char*[]){var, 0}, data_singleton()->local_var);
while (temp)
{
//process expansion av = token_to_char(temp->content)
builtin_setenv("setenv", (char*[]){var, 0}, data_singleton()->local_var);
ft_exec(&(*ast)->right);
temp = temp->next;
}
return (0);
}

15
42sh/src/exec/exec_func.c Normal file
View file

@ -0,0 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* exec_while.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/30 17:33:53 by ariard #+# #+# */
/* Updated: 2017/02/06 22:05:35 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "exec.h"

7
42sh/src/exec/exec_if.c
View file

@ -14,7 +14,12 @@
int exec_if(t_btree **ast)
{
data_singleton()->exec.process.if_branch = 0;
ft_exec(&(*ast)->left);
if (data_singleton()->exec.process.status == 1)
{
data_singleton()->exec.process.if_branch = 1;
ft_exec(&(*ast)->right);
// btree_delone(ast, &ast_free);
}
return (0);
}

11
42sh/src/exec/exec_until.c
View file

@ -14,12 +14,11 @@
int exec_until(t_btree **ast)
{
int test;
test = 0;
while (test++ != 10)
ft_exec(&(*ast)->left);
while (data_singleton()->exec.process.status == 0)
{
ft_exec(&(*ast)->right);
// btree_delone(ast, &ast_free);
ft_exec(&(*ast)->left);
}
return (0);
}

21
42sh/src/exec/loop_del.c → 42sh/src/exec/exec_var.c
View file

@ -1,27 +1,24 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* loop_del.c :+: :+: :+: */
/* exec_while.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/31 22:39:20 by ariard #+# #+# */
/* Updated: 2017/01/31 23:20:40 by ariard ### ########.fr */
/* Created: 2017/01/30 17:33:53 by ariard #+# #+# */
/* Updated: 2017/02/06 22:05:35 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "exec.h"
int loop_del(t_list *list_ast)
int exec_var(t_btree **ast)
{
t_list *temp;
t_astnode *node;
char **av;
while (list_ast)
{
btree_del((t_btree **)list_ast->content, &ast_free);
temp = list_ast;
list_ast = list_ast->next;
ft_lstdelone(&temp, NULL);
}
node = (*ast)->item;
av = token_to_argv(node);
builtin_setenv("setenv", av, data_singleton()->local_var);
return (0);
}

11
42sh/src/exec/exec_while.c
View file

@ -14,12 +14,11 @@
int exec_while(t_btree **ast)
{
int test;
test = 10;
while (test--)
ft_exec(&(*ast)->left);
while (data_singleton()->exec.process.status == 1)
{
ft_exec(&(*ast)->right);
// btree_delone(ast, &ast_free);
ft_exec(&(*ast)->left);
}
return (0);
}

2
42sh/src/exec/ft_exec.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/27 20:30:32 by jhalford #+# #+# */
/* Updated: 2017/02/21 21:37:58 by jhalford ### ########.fr */
/* Updated: 2017/02/21 18:50:05 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/command_getoutput.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/12 14:01:59 by jhalford #+# #+# */
/* Updated: 2017/02/03 14:46:27 by ariard ### ########.fr */
/* Updated: 2017/02/24 22:04:43 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/dir_glob.c
View file

@ -6,7 +6,7 @@
/* By: wescande <wescande@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/30 12:07:16 by wescande #+# #+# */
/* Updated: 2017/02/07 19:48:12 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:04:49 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/esc_print.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 15:38:14 by jhalford #+# #+# */
/* Updated: 2017/02/20 18:49:02 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:05:04 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/expand_bquote.c
View file

@ -6,7 +6,7 @@
/* By: wescande <wescande@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 17:47:53 by wescande #+# #+# */
/* Updated: 2017/02/20 19:11:11 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:04:59 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/expand_brace.c
View file

@ -6,7 +6,7 @@
/* By: wescande <wescande@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/12 19:00:29 by wescande #+# #+# */
/* Updated: 2017/02/20 18:54:19 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:05:14 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/expand_esc.c
View file

@ -6,7 +6,7 @@
/* By: wescande <wescande@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/31 23:18:56 by wescande #+# #+# */
/* Updated: 2017/02/20 17:25:43 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:05:26 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/expand_var.c
View file

@ -6,7 +6,7 @@
/* By: wescande <wescande@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/06 16:09:27 by wescande #+# #+# */
/* Updated: 2017/02/20 18:56:50 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:05:34 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/ft_strsplit_esc.c
View file

@ -6,7 +6,7 @@
/* By: wescande <wescande@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/31 22:18:46 by wescande #+# #+# */
/* Updated: 2017/01/31 23:15:17 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:05:41 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/ft_strsplit_spe.c
View file

@ -6,7 +6,7 @@
/* By: wescande <wescande@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/31 20:49:30 by wescande #+# #+# */
/* Updated: 2017/02/20 18:57:58 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:03:22 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/glob.c
View file

@ -6,7 +6,7 @@
/* By: wescande <wescande@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/04 16:29:54 by wescande #+# #+# */
/* Updated: 2017/02/20 19:04:44 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:05:48 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/glob/match_pattern.c
View file

@ -6,7 +6,7 @@
/* By: wescande <wescande@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/24 17:30:23 by wescande #+# #+# */
/* Updated: 2017/02/20 14:00:41 by wescande ### ########.fr */
/* Updated: 2017/02/24 22:06:01 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/hash_table/hash.c
View file

@ -6,7 +6,7 @@
/* By: gwojda <gwojda@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/18 11:06:19 by gwojda #+# #+# */
/* Updated: 2017/02/18 14:16:35 by gwojda ### ########.fr */
/* Updated: 2017/02/21 20:57:19 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/hash_table/hash_str.c
View file

@ -6,7 +6,7 @@
/* By: gwojda <gwojda@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/18 11:32:18 by gwojda #+# #+# */
/* Updated: 2017/02/19 12:58:47 by gwojda ### ########.fr */
/* Updated: 2017/02/21 20:57:42 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

16
42sh/src/lexer/get_reserved_words.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/01/26 00:07:05 by ariard #+# #+# */
/* Updated: 2017/02/20 22:06:20 by jhalford ### ########.fr */
/* Updated: 2017/02/21 21:06:16 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,10 +16,12 @@ int get_reserved_words(t_list **alst)
{
t_token *token;
t_token *previous_token;
t_token *ante_token;
t_list *temp;
temp = *alst;
previous_token = NULL;
ante_token = NULL;
while (temp)
{
token = temp->content;
@ -45,8 +47,20 @@ int get_reserved_words(t_list **alst)
token->type = TK_ELSE;
else if (ft_strncmp(token->data, "until", 5) == 0)
token->type = TK_UNTIL;
else if (ft_strncmp(token->data, "case", 4) == 0)
token->type = TK_CASE;
else if (ft_strncmp(token->data, "esac", 4) == 0)
token->type = TK_ESAC;
else if (ft_strncmp(token->data, "for", 3) == 0)
token->type = TK_FOR;
}
}
if (ante_token && (ante_token->type == TK_CASE || ante_token->type == TK_FOR)
&& ft_strncmp(token->data, "in", 2) == 0)
token->type = TK_IN;
if (previous_token && previous_token->type == TK_FOR && token->type == TK_WORD)
token->type = TK_NAME;
ante_token = previous_token;
previous_token = token;
temp = temp->next;
}

6
42sh/src/lexer/get_state_global.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 20:39:06 by jhalford #+# #+# */
/* Updated: 2017/02/20 20:48:53 by ariard ### ########.fr */
/* Updated: 2017/02/24 21:39:47 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -33,6 +33,10 @@ t_lexstate get_state_global(t_lexer *lexer)
return (BQUOTE);
else if (c == '(' || c == ')')
return (PAREN);
else if (c == '{' || c == '}')
return (CURLY_BRACKETS);
else if (c == '=')
return (ASSIGNEMENT_WORD);
else if (c == 0)
return (END);
return (0);

2
42sh/src/lexer/get_state_redir.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 20:37:28 by jhalford #+# #+# */
/* Updated: 2017/02/09 20:39:11 by jhalford ### ########.fr */
/* Updated: 2017/02/24 20:44:40 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

24
42sh/src/lexer/insert_newline.c Normal file
View file

@ -0,0 +1,24 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* insert_newline.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/21 21:05:23 by ariard #+# #+# */
/* Updated: 2017/02/24 16:22:08 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser.h"
int insert_newline(t_list **alst)
{
t_token *token;
DG("insert newline");
token = token_init();
token->type = TK_NEWLINE;
ft_lsteadd(alst, ft_lstnew(token, sizeof(*token)));
return (0);
}

37
42sh/src/lexer/lexer_assignement_word.c Normal file
View file

@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lexer_assignement_word.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/24 20:28:13 by ariard #+# #+# */
/* Updated: 2017/02/24 21:00:13 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "lexer.h"
int lexer_assignement_word(t_list **alst, t_lexer *lexer)
{
t_token *token;
char c;
token = (*alst)->content;
if (token->type != TK_WORD && token->type != TK_ASSIGNEMENT_WORD)
{
token_append(token, lexer, 0, 0);
lexer->pos++;
return (lexer_lex(alst, lexer));
}
token->type = TK_ASSIGNEMENT_WORD;
token_append(token, lexer, 0, 0);
lexer->pos++;
c = lexer->str[lexer->pos];
if ((lexer->state = get_state_global(lexer)))
return (lexer_lex(alst, lexer));
if ((lexer->state = get_state_redir(lexer)))
return (lexer_lex(alst, lexer));
lexer->state = ft_isdigit(c) ? NUMBER : ASSIGNEMENT_WORD;
return(lexer_lex(alst, lexer));
}

46
42sh/src/lexer/lexer_curly_brackets.c Normal file
View file

@ -0,0 +1,46 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lexer_curly_brackets.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/24 21:24:50 by ariard #+# #+# */
/* Updated: 2017/02/24 21:48:52 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser.h"
int lexer_curly_brackets(t_list **alst, t_lexer *lexer)
{
t_token *token;
t_list **lst;
DG("lexer curly brackets");
lst = alst;
if (*alst)
{
token = (*alst)->content;
if (token->type)
lst = &(*alst)->next;
}
token = token_init();
*lst = ft_lstnew(token, sizeof(*token));
token = (*lst)->content;
if (lexer->str[lexer->pos] == '{')
{
DG("lbrace");
token->type = TK_LBRACE;
push(&lexer->stack, CURLY_BRACKETS);
}
else if (lexer->stack && *(int*)lexer->stack->content == CURLY_BRACKETS)
{
DG("rbrace");
token->type = TK_RBRACE;
pop(&lexer->stack);
}
lexer->pos++;
lexer->state = DEFAULT;
return (lexer_lex(&(*lst)->next, lexer));
}

2
42sh/src/lexer/lexer_default.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/28 18:36:21 by jhalford #+# #+# */
/* Updated: 2017/02/20 20:50:30 by ariard ### ########.fr */
/* Updated: 2017/02/25 20:04:41 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

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

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/03 11:58:44 by jhalford #+# #+# */
/* Updated: 2017/02/21 22:14:48 by jhalford ### ########.fr */
/* Updated: 2017/02/25 19:56:31 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -21,9 +21,7 @@ int lexer_delim(t_list **alst, t_lexer *lexer)
lexer->pos++;
lexer->state = DEFAULT;
if (token->type)
{
return (lexer_lex(&(*alst)->next, lexer));
}
else
{
if (lexer->str[lexer->pos] == 0)

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

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/03 12:06:35 by jhalford #+# #+# */
/* Updated: 2017/02/20 20:52:38 by ariard ### ########.fr */
/* Updated: 2017/02/25 20:12:58 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -21,6 +21,7 @@ int lexer_great(t_list **alst, t_lexer *lexer)
lexer->pos++;
if (lexer->str[lexer->pos] == '&')
{
DG("lex greatand");
token->type = TK_GREATAND;
token_append(token, lexer, 0, 0);
lexer->pos++;
@ -28,6 +29,7 @@ int lexer_great(t_list **alst, t_lexer *lexer)
}
if (lexer->str[lexer->pos] == '>')
{
DG("lex great");
token->type = TK_DGREAT;
token_append(token, lexer, 0, 0);
lexer->pos++;

2
42sh/src/lexer/lexer_greatand.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/03 11:56:58 by jhalford #+# #+# */
/* Updated: 2017/02/20 20:52:49 by ariard ### ########.fr */
/* Updated: 2017/02/25 20:11:03 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/lexer/lexer_less.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/03 12:06:53 by jhalford #+# #+# */
/* Updated: 2017/02/20 20:53:06 by ariard ### ########.fr */
/* Updated: 2017/02/25 20:11:17 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

2
42sh/src/lexer/lexer_lessand.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/03 11:58:51 by jhalford #+# #+# */
/* Updated: 2017/02/09 19:56:29 by jhalford ### ########.fr */
/* Updated: 2017/02/25 20:11:10 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

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

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 17:08:51 by jhalford #+# #+# */
/* Updated: 2017/02/21 22:14:51 by jhalford ### ########.fr */
/* Updated: 2017/02/24 21:38:42 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -31,6 +31,8 @@ int (*g_lexer[])(t_list **alst, t_lexer *lexer) =
&lexer_bquote,
&lexer_backslash,
&lexer_paren,
&lexer_curly_brackets,
&lexer_assignement_word,
&lexer_comment,
&lexer_end,
};

3
42sh/src/lexer/lexer_number.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/03 12:06:45 by jhalford #+# #+# */
/* Updated: 2017/02/20 20:53:20 by ariard ### ########.fr */
/* Updated: 2017/02/25 19:55:30 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -18,6 +18,7 @@ int lexer_number(t_list **alst, t_lexer *lexer)
t_lexstate state;
token = (*alst)->content;
token->type = TK_IO_NUMBER;
if ((state = get_state_global(lexer)))
{
lexer->state = state;

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

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

3
42sh/src/lexer/lexer_word.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/03 12:07:11 by jhalford #+# #+# */
/* Updated: 2017/02/20 20:54:32 by ariard ### ########.fr */
/* Updated: 2017/02/25 20:10:39 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -19,6 +19,7 @@ int lexer_word(t_list **alst, t_lexer *lexer)
token = (*alst)->content;
token->type = TK_WORD;
DG("lexer word");
if ((state = get_state_global(lexer)))
{
lexer->state = state;

2
42sh/src/lexer/token_append.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/11 17:18:42 by jhalford #+# #+# */
/* Updated: 2017/02/20 21:03:57 by ariard ### ########.fr */
/* Updated: 2017/02/24 20:33:59 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

15
42sh/src/lexer/token_print.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jack@crans.org> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/28 14:39:01 by jhalford #+# #+# */
/* Updated: 2017/02/20 20:55:43 by ariard ### ########.fr */
/* Updated: 2017/02/24 21:48:47 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -15,19 +15,14 @@
void token_print(t_list *lst)
{
t_token *token;
int i;
t_type type;
int index;
while (lst)
{
i = -1;
DG("token print");
if (lst->content)
token = lst->content;
type = token->type;
while (type >> (i++ + 2))
;
DG("%02i:[%s]", i, token->data);
index = -1;
if (token->type)
DG("token : %s data [%s]\n", read_state(token->type), token->data);
lst = lst->next;
}
}

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

@ -23,7 +23,6 @@ int data_init(void)
data->env = ft_sstrdup(environ);
data->comp = NULL;
data->opts = SH_OPTS_JOBC;
data->exec.process.path = NULL;
data->exec.process.av = NULL;
data->exec.process.to_close = 0;
@ -46,6 +45,9 @@ int data_init(void)
data->jobc.first_job = NULL;
data->jobc.current_id = 1;
data->local_var = NULL;
data->lst_func = NULL;
if ((term_name = ft_getenv(data->env, "TERM")) == NULL)
return (-1);
if (tgetent(NULL, term_name) != 1)

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

@ -6,7 +6,7 @@
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/14 18:18:04 by jhalford #+# #+# */
/* Updated: 2017/02/21 19:20:20 by jhalford ### ########.fr */
/* Updated: 2017/02/25 00:17:44 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,7 +16,32 @@ char *ft_putast(void *nodein)
{
t_astnode *node;
node = nodein;
if (node->type == TK_THEN)
if (node->type == CLOSE_LIST)
return ("CLOSE_LIST");
if (node->type == FNAME)
return ("FNAME");
if (node->type == TK_LBRACE)
return ("TK_LBRACE");
if (node->type == TK_ASSIGNEMENT_WORD)
return ("ASSIGNEMENT_WORD");
if (node->type == SUBSHELL)
return ("SUBSHELL");
if (node->type == TK_NAME)
return ("TK_NAME");
if (node->type == TK_FOR)
return ("TK_FOR");
if (node->type == TK_CASE)
return ("TK_CASE");
else if (node->type == TK_PAREN_OPEN)
return ("TK_OPE");
else if (node->type == TK_PAREN_CLOSE)
return ("TK_CLO");
else if (node->type == TK_IN)
return ("TK_IN");
else if (node->type ==TK_ESAC)
return ("TK_ESAC");
else if (node->type == TK_THEN)
return ("THEN");
else if (node->type == TK_FI)
return ("FI");

14
42sh/src/main/main.c
View file

@ -6,7 +6,7 @@
/* By: jhalford <jhalford@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/12/06 18:40:58 by jhalford #+# #+# */
/* Updated: 2017/02/21 20:32:39 by jhalford ### ########.fr */
/* Updated: 2017/02/25 20:34:27 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -44,12 +44,22 @@ int handle_instruction(int fd)
return (1);
if (get_lexer_stack(lexer))
continue ;
lexer.state = DEFAULT;
token_print(token);
if (get_reserved_words(&token))
return (1);
if (insert_newline(&token))
return (1);
if (ft_parse(&ast, &token, &parser))
continue ;
if (parser.state == SUCCESS)
break ;
else if (parser.state == ERROR)
else if (parser.state == ERROR && !SH_IS_INTERACTIVE(data_singleton()->opts))
return (error_syntax(&token));
else if (parser.state == ERROR)
error_syntax(&token);
token = NULL;
ast = NULL;
}
DG("Before execution:");
btree_print(STDBUG, ast, &ft_putast);

61
42sh/src/parser/add_case.c Normal file
View file

@ -0,0 +1,61 @@
#include "parser.h"
int iscase(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
node = NULL;
token = (*lst)->content;
if (*ast)
{
node = (*ast)->item;
if ((node->type == TK_CASE || node->type == TK_PAREN_OPEN)
&& token->type == TK_WORD && node->pattern == 0)
return (1);
if ((node->type == TK_PAREN_OPEN || node->type == TK_CASE)
&& node->nest == 0 && token->type == TK_PAREN_OPEN)
return (3);
if (node->type == TK_CASE || node->type == TK_PAREN_OPEN)
return (2);
}
return (0);
}
int add_case_cmd(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
token = (*lst)->content;
node = (*ast)->item;
if (token->type == TK_CASE && (node->type == TK_PAREN_OPEN
|| node->type == TK_CASE))
node->nest++;
if (token->type == TK_ESAC && (node->type == TK_PAREN_OPEN
|| node->type == TK_CASE) && node->nest > 0)
return ((node->nest--));
else if (token->type == TK_DSEMI && node->type == TK_PAREN_OPEN
&& node->nest == 0)
return ((node->full = 1));
else if (token->type == TK_ESAC)
return (0);
return (add_cmd(&(*ast)->right, lst));
}
int add_case_sep(t_btree **ast, t_list **lst)
{
return (add_sep(&(*ast)->right, lst));
}
int add_pattern(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
token = (*lst)->content;
node = (*ast)->item;
node->data.str = ft_strdup(token->data);
node->pattern = 1;
return (0);
}

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/15 20:49:15 by ariard #+# #+# */
/* Updated: 2017/02/21 22:40:29 by jhalford ### ########.fr */
/* Updated: 2017/02/25 18:50:30 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -19,27 +19,41 @@ int add_cmd(t_btree **ast, t_list **lst)
char **my_tab;
DG("add cmd");
if (!*ast)
if ((token = (*lst)->content)->type == TK_IN || token->type == TK_PAREN_OPEN)
return (0);
else if (!*ast)
gen_node(ast);
else if (isdir(ast))
else if (isdir(ast, lst))
return (add_file(ast, lst));
else if (isloop(ast))
else if (isloop(ast, lst) == 3)
return (add_loop_condition(ast, lst));
else if (isloop(ast, lst))
return (add_loop_cmd(ast, lst));
else if (iscondition(ast, lst) == 1)
return (add_condition_cmd(ast, lst));
else if (iscondition(ast, lst) == 2)
return (add_branch(ast, lst));
else if ((node = (*ast)->item)->type != TK_DO && node->type != TK_THEN)
else if (iscase(ast, lst) == 1)
return (add_pattern(ast, lst));
else if (iscase(ast, lst) == 2)
return (add_case_cmd(ast, lst));
else if (iscase(ast, lst) == 3)
return (add_branch(ast, lst));
else if (issubshell(ast, lst))
return (add_subshell_cmd(ast, lst));
else if (isfunc(ast, lst))
return (add_func_cmd(ast, lst));
else if ((node = (*ast)->item)->type != TK_DO && node->type != TK_THEN
&& node->type != TK_PAREN_CLOSE)
return (add_cmd(&(*ast)->right, lst));
my_tab = NULL;
token = (*lst)->content;
node = (*ast)->item;
node->type = token->type;
if (token->type == TK_WORD)
if (token->type == TK_WORD || token->type == TK_ASSIGNEMENT_WORD)
{
my_tab = ft_sstradd(my_tab, token->data);
my_tab = ft_sstradd(my_tab, (char *)token->esc);
// ft_ld_pushback(&node->data.token, my_tab);
ft_ld_pushback(&node->data.token, my_tab);
}
return (0);
}

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/19 18:12:52 by ariard #+# #+# */
/* Updated: 2017/02/20 18:18:56 by ariard ### ########.fr */
/* Updated: 2017/02/25 00:11:09 by ariard ### ########.fr */
/* */
/* ************************************************************************** */

51
42sh/src/parser/add_file.c
View file

@ -6,24 +6,35 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 16:39:05 by ariard #+# #+# */
/* Updated: 2017/02/18 16:43:28 by ariard ### ########.fr */
/* Updated: 2017/02/25 20:33:12 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser.h"
int isdir(t_btree **ast)
int isdir(t_btree **ast, t_list **list)
{
t_astnode *node;
t_token *token;
token = (*list)->content;
if (*ast)
{
DG("isdir");
node = (*ast)->item;
if (node->data.redir.word.word)
return (0);
if (node->type == TK_LESS || node->type == TK_GREAT
if ((node->type == TK_LESS || node->type == TK_GREAT
|| node->type == TK_LESSAND || node->type == TK_GREATAND
|| node->type == TK_DGREAT || node->type == TK_LESSGREAT
|| node->type == TK_CLOBBER)
|| node->type == TK_DGREAT)
&& token->type == TK_WORD)
return (1);
if ((node->type == TK_LESS || node->type == TK_GREAT
|| node->type == TK_LESSAND || node->type == TK_GREATAND
|| node->type == TK_DGREAT)
&& (token->type == TK_LESS || token->type == TK_GREAT
|| token->type == TK_LESSAND || token->type == TK_GREATAND
|| token->type == TK_DGREAT))
return (2);
}
return (0);
}
@ -31,10 +42,32 @@ int add_file(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
t_redir *redir;
token = (*lst)->content;
node = (*ast)->item;
node->data.redir.n = ft_atoi(token->data);
node->data.redir.word.word = ft_strdup(token->data);
if (node->data.wordlist)
{
DG("add file");
redir = (ft_lstlast(node->data.wordlist))->content;
redir->word.word = token->data;
}
return (0);
}
int add_redir(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
t_redir *redir;
DG("add redir");
if (!ast)
gen_node(ast);
token = (*lst)->content;
node = (*ast)->item;
redir = ft_memalloc(sizeof(redir));
redir->type = token->type;
ft_lsteadd(&node->data.wordlist, ft_lstnew(redir, sizeof(redir)));
return (0);
}

73
42sh/src/parser/add_func.c Normal file
View file

@ -0,0 +1,73 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* add_func.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/24 23:43:07 by ariard #+# #+# */
/* Updated: 2017/02/25 00:32:00 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser.h"
int isfunc(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
node = NULL;
token = (*lst)->content;
if (*ast)
{
node = (*ast)->item;
if (node->type == TK_WORD && token->type == CLOSE_LIST)
{
node->type = FNAME;
add_one_func(ast, lst);
}
if (node->type == FNAME && node->full == 0)
return (1);
if (isfunc(&(*ast)->right, lst) == 1)
return (1);
}
return (0);
}
int add_func_cmd(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
token = (*lst)->content;
node = (*ast)->item;
if (token->type == CLOSE_LIST && node->nest == 0)
return (0);
if ((token->type == TK_CASE || token->type == TK_WHILE || token->type == TK_IF
|| token->type == TK_UNTIL || token->type == TK_FOR
|| token->type == SUBSHELL || token->type == TK_LBRACE)
&& node->type == FNAME)
node->nest++;
if ((token->type == TK_DONE || token->type == TK_ESAC || token->type == TK_FI
|| token->type == TK_RBRACE || token->type == TK_PAREN_OPEN)
&& node->type == FNAME && node->nest > 0)
node->nest--;
if ((token->type == TK_DONE || token->type == TK_ESAC || token->type == TK_FI
|| token->type == TK_RBRACE || token->type == TK_PAREN_OPEN)
&& node->type == FNAME && node->nest == 0)
node->full = 1;
return (add_cmd(&(*ast)->right, lst));
}
int add_func_sep(t_btree **ast, t_list **lst)
{
return (add_sep(&(*ast)->right, lst));
}
int add_one_func(t_btree **ast, t_list **lst)
{
(void)lst;
ft_lsteadd(&data_singleton()->lst_func, ft_lstnew(ast, sizeof(*ast)));
return (0);
}

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

@ -6,35 +6,34 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/17 22:17:14 by ariard #+# #+# */
/* Updated: 2017/02/20 19:03:04 by ariard ### ########.fr */
/* Updated: 2017/02/25 19:18:01 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser.h"
int isloop(t_btree **ast)
int isloop(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
node = NULL;
token = (*lst)->content;
if (*ast)
{
node = (*ast)->item;
DG("TEST LOOP");
if (node->type == TK_FOR && token->type == TK_WORD && node->pattern == 0)
return (3);
if ((node->type == TK_NEWLINE || node->type == TK_SEMI
|| node->type == TK_AMP) && isloop(&(*ast)->right) == 1)
|| node->type == TK_AMP) && isloop(&(*ast)->right, lst) == 1)
return (1);
if ((node->type == TK_WHILE || node->type == TK_UNTIL) && node->full == 1)
{
DG("DON ENTER");
if ((node->type == TK_WHILE || node->type == TK_UNTIL
|| node->type == TK_FOR) && node->full == 1)
return (2);
}
if ((node->type == TK_WHILE || node->type == TK_UNTIL) && node->full == 0)
{
DG(" NOFULL");
if ((node->type == TK_WHILE || node->type == TK_UNTIL
|| node->type == TK_FOR) && node->full == 0)
return (1);
}
}
return (0);
}
@ -46,27 +45,20 @@ int add_loop_cmd(t_btree **ast, t_list **lst)
token = (*lst)->content;
node = (*ast)->item;
DG("add loop cmd");
if ((token->type == TK_WHILE || token->type == TK_UNTIL)
&& (node->type == TK_WHILE || node->type == TK_UNTIL))
{
DG("nest one more");
if (token->type == TK_DO && node->type == TK_FOR)
node->pattern = 1;
if ((token->type == TK_WHILE || token->type == TK_UNTIL || token->type == TK_FOR)
&& (node->type == TK_WHILE || node->type == TK_UNTIL || node->type == TK_FOR))
node->nest++;
}
if (token->type == TK_DONE && (node->type == TK_WHILE || node->type == TK_UNTIL)
&& node->nest > 0)
{
if (token->type == TK_DONE && (node->type == TK_WHILE
|| node->type == TK_UNTIL || node->type == TK_FOR) && node->nest > 0)
node->nest--;
DG("nest one less");
}
else if (token->type == TK_DONE && (node->type == TK_WHILE
|| node->type == TK_UNTIL) && node->nest == 0)
{
DG("WHILE FULL");
|| node->type == TK_UNTIL || node->type == TK_FOR) && node->nest == 0)
return ((node->full = 1));
}
if (token->type == TK_DO && node->nest == 0)
return (add_cmd(&(*ast)->right, lst));
else if (!(*ast)->right && isloop(&(*ast)->left) != 2)
else if (!(*ast)->right && isloop(&(*ast)->left, lst) != 2)
return (add_cmd(&(*ast)->left, lst));
else
return (add_cmd(&(*ast)->right, lst));
@ -81,3 +73,15 @@ int add_loop_sep(t_btree **ast, t_list **lst)
return (add_sep(&(*ast)->right, lst));
return (0);
}
int add_loop_condition(t_btree **ast, t_list **lst)
{
t_astnode *node;
t_token *token;
token = (*lst)->content;
node = (*ast)->item;
ft_lsteadd(&node->data.wordlist, ft_lstnew(ft_strdup(token->data),
ft_strlen(token->data)));
return (0);
}

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/15 19:12:07 by ariard #+# #+# */
/* Updated: 2017/02/20 17:46:54 by ariard ### ########.fr */
/* Updated: 2017/02/25 19:28:47 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -19,20 +19,26 @@ int add_sep(t_btree **ast, t_list **lst)
t_btree *new_node;
DG("add sep");
if (isloop(ast) == 1)
if (isloop(ast, lst) == 1)
return (add_loop_sep(ast, lst));
else if (iscondition(ast, lst) == 1)
return (add_condition_sep(ast, lst));
else if (iscase(ast, lst) == 2)
return (add_case_sep(ast, lst));
else if (issubshell(ast, lst))
return (add_subshell_sep(ast, lst));
else if (isdir(ast, lst) == 2)
return (add_redir(ast, lst));
else if (isfunc(ast, lst))
return (add_func_sep(ast, lst));
if (!*ast)
gen_node(ast);
token = (*lst)->content;
// if (node->type != TK_DO)
// {
//watch != TK_DO
new_node = NULL;
gen_node(&new_node);
join_ast(ast, &new_node);
node = (new_node)->item;
// }
node->type = token->type;
return (0);
}

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

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

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 17:39:18 by ariard #+# #+# */
/* Updated: 2017/02/21 10:49:53 by ariard ### ########.fr */
/* Updated: 2017/02/25 13:53:57 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,7 +16,13 @@ t_aggrematch g_aggrematch[] =
{
{TK_WORD, CMD_SUFFIX, CMD_SUFFIX, 0},
{TK_WORD, TK_PIPE, PATTERN, 0},
{TK_WORD, WORDLIST, WORDLIST, 0},
{TK_WORD, TK_IN, FOR_WORDLIST, TK_IN},
{TK_WORD, FOR_WORDLIST, FOR_WORDLIST, FOR_WORDLIST},
{TK_SEMI, FOR_WORDLIST, SEQUENTIAL_SEP, 0},
{TK_DSEMI, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{TK_PAREN_OPEN, TK_IN, PATTERN_CASE, 0},
{TK_PAREN_OPEN, CASE_LIST_NS, PATTERN_CASE, 0},
{TK_PAREN_OPEN, CMD_SUPERIOR, FUNC_NAME, CMD_SUPERIOR},
{TK_ASSIGNEMENT_WORD, CMD_PREFIX,CMD_PREFIX, 0},
{TK_PIPE, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR},
{TK_FI, ELSE_PART, IF_CLAUSE, TK_IF},
@ -27,52 +33,66 @@ t_aggrematch g_aggrematch[] =
{TK_DONE, CMD_SUPERIOR, DO_GROUP, TK_DO},
{TK_DONE, COMPOUND_LIST, DO_GROUP, TK_DO},
//Esac ?
{TK_ESAC, CASE_LIST, CASE_CLAUSE, TK_CASE},
{TK_ESAC, TK_IN, CASE_CLAUSE, TK_CASE},
{TK_ESAC, CASE_LIST_NS, CASE_CLAUSE, TK_CASE},
{TK_ESAC, LINEBREAK, CASE_CLAUSE, TK_CASE},
{TK_RBRACE, COMPOUND_LIST, BRACE_GROUP, TK_LBRACE},
{TK_PAREN_CLOSE, COMPOUND_LIST, SUBSHELL, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, CMD_SUPERIOR, SUBSHELL, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE, SUBSHELL, TK_PAREN_OPEN},
{TK_RBRACE, COMPOUND_LIST, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, CMD_SUPERIOR, BRACE_CLAUSE, TK_LBRACE},
{TK_RBRACE, PIPE_SEMI_SEQUENCE, BRACE_CLAUSE, TK_LBRACE},
{TK_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
{TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
//watch this
{SEPARATOR_OP, CMD_SUPERIOR, SEPARATOR, 0},
{SEPARATOR_OP, COMPOUND_LIST, SEPARATOR, 0},
{SEPARATOR_OP, CASE_LIST_NS, SEPARATOR, 0},
{SEPARATOR_OP, PIPE_SEMI_SEQUENCE, SEPARATOR, 0},
{SEPARATOR, CMD_SUPERIOR, END_COMMAND, CMD_SUPERIOR},
{SEPARATOR, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
{SEPARATOR, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{LINEBREAK, SEPARATOR_OP, SEPARATOR, SEPARATOR_OP},
{LINEBREAK, TK_SEMI, SEQUENTIAL_SEP, TK_SEMI},
//to abstract TK_ESAC
{LINEBREAK, TK_PAREN_CLOSE, CASE_ITEM_NS, PATTERN_CASE},
{LINEBREAK, TK_PAREN_CLOSE, FUNC, FNAME},
//paren open
{LINEBREAK, TK_DSEMI, CASE_ITEM, PATTERN_CASE},
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
{LINEBREAK, TK_PIPE, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE},
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
{LINEBREAK, CMD_SUPERIOR, SEPARATOR_OP, 0},
{LINEBREAK, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{LINEBREAK, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
{LINEBREAK, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{LINEBREAK, COMPLETE_COMMANDS, PROGRAM, LINEBREAK},
{NEWLINE_LIST, CMD_NAME, CMD_SUPERIOR, CMD_NAME},
{NEWLINE_LIST, SEQUENTIAL_SEP, SEQUENTIAL_SEP, SEQUENTIAL_SEP},
{NEWLINE_LIST, TK_DO, TK_DO, TK_DO},
{NEWLINE_LIST, TK_PAREN_CLOSE, TK_PAREN_CLOSE, TK_PAREN_CLOSE},
{NEWLINE_LIST, TK_IN, TK_IN, TK_IN},
{NEWLINE_LIST, TK_THEN, TK_THEN, TK_THEN},
{NEWLINE_LIST, TK_IF, TK_IF, TK_IF},
{NEWLINE_LIST, TK_ELIF, TK_ELIF, TK_ELIF},
{NEWLINE_LIST, TK_ELSE, TK_ELSE, TK_ELSE},
{NEWLINE_LIST, TK_WHILE, TK_WHILE, TK_WHILE},
{NEWLINE_LIST, TK_UNTIL, TK_UNTIL, TK_UNTIL},
{NEWLINE_LIST, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{NEWLINE_LIST, NEWLINE_LIST, NEWLINE_LIST, NEWLINE},
{NEWLINE_LIST, NAME, SEQUENTIAL_SEP, 0},
{NEWLINE_LIST, IN, SEQUENTIAL_SEP, 0},
{NEWLINE_LIST, WORDLIST, SEQUENTIAL_SEP, 0},
{NEWLINE_LIST, TERM, SEPARATOR, 0},
{NEWLINE_LIST, COMPOUND_LIST, SEPARATOR, 0},
{NEWLINE_LIST, CASE_LIST_NS, SEPARATOR, 0},
{NEWLINE_LIST, COMPLETE_CONDITION, COMPLETE_CONDITION, COMPLETE_CONDITION},
{NEWLINE_LIST, CONDITION, CONDITION, CONDITION},
{NEWLINE_LIST, COMPLETE_COMMANDS, LINEBREAK, 0},
{NEWLINE_LIST, LINEBREAK, PROGRAM, LINEBREAK},
{NEWLINE_LIST, FOR_WORDLIST, SEQUENTIAL_SEP, 0},
//to check
{HERE_END, TK_DLESS, IO_HERE, TK_DLESS},
{IO_HERE, TK_IO_NUMBER, IO_REDIRECT, TK_IO_NUMBER},
{IO_HERE, ALL, IO_REDIRECT, 0},
{FILENAME, TK_LESS, IO_FILE, TK_LESS},
@ -95,6 +115,9 @@ t_aggrematch g_aggrematch[] =
{IO_REDIRECT, CMD_WORD, CMD_SUFFIX, 0},
{IO_REDIRECT, CMD_PREFIX, CMD_PREFIX, CMD_PREFIX},
{IO_REDIRECT, LINEBREAK, CMD_PREFIX, 0},
{IO_REDIRECT, TK_PAREN_OPEN, CMD_PREFIX, 0},
{IO_REDIRECT, TK_LBRACE, CMD_PREFIX, 0},
{IO_REDIRECT, COMPLETE_COMMANDS, CMD_PREFIX, 0},
{IO_REDIRECT, TK_BANG, CMD_PREFIX, 0},
{IO_REDIRECT, SEPARATOR_OP, CMD_PREFIX, 0},
{IO_REDIRECT, NEWLINE_LIST, CMD_PREFIX, 0},
@ -104,6 +127,9 @@ t_aggrematch g_aggrematch[] =
{CMD_SUFFIX, CMD_SUPERIOR, SIMPLE_COMMAND, CMD_SUPERIOR},
//to abstract
{CMD_PREFIX, LINEBREAK, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_PAREN_OPEN, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_LBRACE, SIMPLE_COMMAND, 0},
{CMD_PREFIX, COMPLETE_COMMANDS, SIMPLE_COMMAND, 0},
{CMD_PREFIX, TK_BANG, SIMPLE_COMMAND, 0},
{CMD_PREFIX, SEPARATOR_OP, SIMPLE_COMMAND, 0},
{CMD_PREFIX, NEWLINE_LIST, SIMPLE_COMMAND, 0},
@ -111,23 +137,29 @@ t_aggrematch g_aggrematch[] =
{CMD_WORD, CMD_PREFIX, SIMPLE_COMMAND, CMD_PREFIX},
//to check
{CMD_NAME, LINEBREAK, CMD_SUPERIOR, 0},
{CMD_NAME, TK_PAREN_OPEN, CMD_SUPERIOR, 0},
{CMD_NAME, TK_LBRACE, CMD_SUPERIOR, 0},
{CMD_NAME, COMPLETE_COMMANDS, 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_WHILE, CMD_SUPERIOR, 0},
{CMD_NAME, TK_UNTIL, CMD_SUPERIOR, 0},
{CMD_NAME, TK_DO, CMD_SUPERIOR, 0},
{CMD_NAME, TK_PAREN_CLOSE, CMD_SUPERIOR, 0},
{CMD_NAME, TK_IF, CMD_SUPERIOR, 0},
{CMD_NAME, TK_ELIF, CMD_SUPERIOR, 0},
{CMD_NAME, TK_ELSE, CMD_SUPERIOR, 0},
{CMD_NAME, TK_THEN, CMD_SUPERIOR, 0},
{CMD_NAME, COMPOUND_LIST, CMD_SUPERIOR, 0},
{CMD_NAME, CASE_LIST_NS, CMD_SUPERIOR, 0},
{CMD_NAME, COMPLETE_CONDITION, CMD_SUPERIOR, 0},
{CMD_NAME, TK_PIPE, CMD_SUPERIOR, 0},
{CMD_NAME, PIPE_SEMI_SEQUENCE, CMD_SUPERIOR, 0},
{CMD_NAME, AND_OR_MAJOR, CMD_SUPERIOR, 0},
{SIMPLE_COMMAND, ALL, COMMAND, 0},
{DO_GROUP, NAME, FOR_CLAUSE, TK_FOR},
{DO_GROUP, IN, FOR_CLAUSE, TK_FOR},
{DO_GROUP, SEQUENTIAL_SEP, FOR_CLAUSE, TK_FOR},
{DO_GROUP, CMD_SUPERIOR, LOOP, CMD_SUPERIOR},
{DO_GROUP, COMPOUND_LIST, LOOP, COMPOUND_LIST},
@ -141,31 +173,35 @@ t_aggrematch g_aggrematch[] =
// {ELSE_PART, COMPOUND_LIST, ELSE_PART, TK_ELIF},
// {ELSE_PART, COMPLETE_CONDITION, IF_CLAUSE, COMPLETE_CONDITION},
{IF_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{PATTERN, 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_LIST_NS, TK_IN, TK_IN, TK_IN},
{CASE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{FOR_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{TERM, LINEBREAK, COMPOUND_LIST, LINEBREAK},
// {COMPOUND_LIST, TK_ELSE, ELSE_PART, TK_ELSE},
{COMPOUND_LIST, TK_IF, CONDITION, TK_IF},
{COMPOUND_LIST, TK_THEN, CONDITION, TK_THEN},
{COMPOUND_LIST, TK_PAREN_CLOSE, CLOSE_LIST, TK_PAREN_CLOSE},
{COMPOUND_LIST, COMPLETE_CONDITION, COMPLETE_CONDITION, COMPLETE_CONDITION},
// {COMPOUND_LIST, TK_THEN, ELSE_PART, TK_ELIF},
{COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
{COMPOUND_LIST, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{CLOSE_LIST, PATTERN, CASE_LIST_NS, PATTERN_CASE},
{CLOSE_LIST, FUNC_NAME, FUNCTION_DEFINITION, FUNC_NAME},
{SUBSHELL, ALL, COMPOUND_COMMAND, 0},
{BRACE_CLAUSE, ALL, COMPOUND_COMMAND, 0},
{COMPOUND_COMMAND, ALL, COMMAND, 0},
{AND_OR_MINOR, PIPE_SEMI_SEQUENCE, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE},
{AND_OR_MINOR, LINEBREAK, AND_OR_MAJOR, 0},
{AND_OR_MINOR, TK_PAREN_OPEN, AND_OR_MAJOR, 0},
{AND_OR_MINOR, TK_LBRACE, AND_OR_MAJOR, 0},
{AND_OR_MINOR, COMPLETE_COMMANDS, AND_OR_MAJOR, 0},
{AND_OR_MINOR, AND_OR_MAJOR, AND_OR_MAJOR, 0},
{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE, PIPE_SEMI_SEQUENCE},
{COMMAND, COMPOUND_LIST, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, CASE_LIST_NS, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_WHILE, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_UNTIL, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_DO, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_IF, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_THEN, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_ELIF, PIPE_SEMI_SEQUENCE, 0},
@ -174,48 +210,70 @@ t_aggrematch g_aggrematch[] =
{COMMAND, SEPARATOR_OP, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, NEWLINE_LIST, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_PAREN_OPEN, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, TK_LBRACE, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, COMPLETE_COMMANDS, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE, 0},
{COMMAND, COMPLETE_CONDITION, PIPE_SEMI_SEQUENCE, 0},
{END_COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},
{END_COMMAND, AND_OR_MAJOR, LIST, AND_OR_MAJOR},
{END_COMMAND, TK_WHILE, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_WHILE, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_UNTIL, PIPE_SEQUENCE, 0},
{END_COMMAND, LINEBREAK, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_PAREN_OPEN, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_LBRACE, PIPE_SEQUENCE, 0},
{END_COMMAND, COMPLETE_COMMANDS, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_DO, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_PAREN_CLOSE, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_IF, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_ELIF, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_THEN, PIPE_SEQUENCE, 0},
{END_COMMAND, TK_ELSE, PIPE_SEQUENCE, 0},
{END_COMMAND, COMPLETE_CONDITION, PIPE_SEQUENCE, 0},
{END_COMMAND, COMPOUND_LIST, COMPOUND_LIST, COMPOUND_LIST},
{END_COMMAND, CASE_LIST_NS, CASE_LIST_NS, CASE_LIST_NS},
{PIPE_SEQUENCE, TK_WHILE, PIPELINE, 0},
{PIPE_SEQUENCE, TK_UNTIL, PIPELINE, 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},
{PIPE_SEQUENCE, TK_PAREN_OPEN, PIPELINE, 0},
{PIPE_SEQUENCE, TK_LBRACE, PIPELINE, 0},
{PIPE_SEQUENCE, COMPLETE_COMMANDS, PIPELINE, 0},
{PIPE_SEQUENCE, AND_OR_MAJOR, PIPELINE, 0},
{PIPE_SEQUENCE, TK_DO, PIPELINE, 0},
{PIPE_SEQUENCE, TK_PAREN_CLOSE, PIPELINE, 0},
{PIPE_SEQUENCE, TK_IF, PIPELINE, 0},
{PIPE_SEQUENCE, TK_ELIF, PIPELINE, 0},
{PIPE_SEQUENCE, TK_THEN, PIPELINE, 0},
{PIPE_SEQUENCE, TK_ELSE, PIPELINE, 0},
{PIPE_SEQUENCE, COMPOUND_LIST, PIPELINE, 0},
{PIPE_SEQUENCE, CASE_LIST_NS, PIPELINE, 0},
{PIPE_SEQUENCE, COMPLETE_CONDITION, PIPELINE, 0},
{PIPELINE, TK_WHILE, AND_OR, 0},
{PIPELINE, TK_UNTIL, AND_OR, 0},
{PIPELINE, TK_DO, AND_OR, 0},
{PIPELINE, TK_PAREN_CLOSE, AND_OR, 0},
{PIPELINE, TK_IF, AND_OR, 0},
{PIPELINE, TK_IF, AND_OR, 0},
{PIPELINE, TK_ELIF, AND_OR, 0},
{PIPELINE, TK_THEN, AND_OR, 0},
{PIPELINE, TK_ELSE, AND_OR, 0},
{PIPELINE, COMPOUND_LIST, AND_OR, 0},
{PIPELINE, CASE_LIST_NS, AND_OR, 0},
{PIPELINE, LINEBREAK, AND_OR, 0},
{PIPELINE, TK_PAREN_OPEN, AND_OR, 0},
{PIPELINE, TK_LBRACE, AND_OR, 0},
{PIPELINE, COMPLETE_COMMANDS, AND_OR, 0},
// {PIPELINE, LINEBREAK, AND_OR, AND_OR},
{PIPELINE, SEPARATOR_OP, AND_OR, 0},
{PIPELINE, COMPLETE_CONDITION, AND_OR, 0},
{PIPELINE, AND_OR_MAJOR, AND_OR, AND_OR_MAJOR},
{AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR, AND_OR_MAJOR},
{AND_OR, TK_DO, COMPOUND_LIST, 0},
{AND_OR, TK_PAREN_CLOSE, COMPOUND_LIST, 0},
{AND_OR, TK_WHILE, COMPOUND_LIST, 0},
{AND_OR, TK_UNTIL, COMPOUND_LIST, 0},
{AND_OR, TK_IF, COMPOUND_LIST, 0},
@ -223,15 +281,22 @@ t_aggrematch g_aggrematch[] =
{AND_OR, TK_THEN, COMPOUND_LIST, 0},
{AND_OR, TK_ELSE, COMPOUND_LIST, 0},
{AND_OR, COMPOUND_LIST, COMPOUND_LIST, 0},
{AND_OR, TK_PAREN_OPEN, COMPOUND_LIST, 0},
{AND_OR, TK_LBRACE, COMPOUND_LIST, 0},
{AND_OR, CASE_LIST_NS, CASE_LIST_NS, 0},
{AND_OR, COMPLETE_CONDITION, COMPOUND_LIST, 0},
{AND_OR, SEPARATOR_OP, LIST, LIST},
{AND_OR, NEWLINE_LIST, LIST, 0},
{AND_OR, LINEBREAK, LIST, 0},
{AND_OR, TK_LBRACE, LIST, 0},
{AND_OR, COMPLETE_COMMANDS, LIST, 0},
{LIST, NEWLINE_LIST, COMPLETE_COMMAND, 0},
{LIST, LINEBREAK, COMPLETE_COMMAND, 0},
{LIST, COMPLETE_COMMANDS, COMPLETE_COMMAND, 0},
{COMPLETE_COMMAND, NEWLINE_LIST, COMPLETE_COMMANDS, COMPLETE_COMMANDS},
{COMPLETE_COMMAND, LINEBREAK, COMPLETE_COMMANDS, 0},
{COMPLETE_COMMANDS, LINEBREAK, PROGRAM, LINEBREAK},
{COMPLETE_COMMAND, COMPLETE_COMMANDS, COMPLETE_COMMANDS, 0},
{COMPLETE_COMMANDS, COMPLETE_COMMANDS, COMPLETE_COMMANDS, COMPLETE_COMMANDS},
{0, 0, 0, 0},
};
@ -240,20 +305,20 @@ int aggregate_sym(t_sym **stack, t_sym *new_sym, t_parstate *state)
int i;
i = 0;
// DG("aggregate head %s && sym %s",
// read_state(**stack), read_state(*new_sym));
DG("aggregate head %s && sym %s",
read_state(**stack), read_state(*new_sym));
while (g_aggrematch[i].top)
{
if (*new_sym == g_aggrematch[i].top
&& MATCH_STACK(**stack, g_aggrematch[i].under))
{
// DG("MATCH : %s", read_state(g_aggrematch[i].new_sym));
DG("MATCH : %s", read_state(g_aggrematch[i].new_sym));
*new_sym = g_aggrematch[i].new_sym;
if (g_aggrematch[i].erase_sym)
{
pop_stack(stack, g_aggrematch[i].erase_sym);
// DG("stack after pop: %s", read_state(**stack));
DG("stack after pop: %s", read_state(**stack));
}
if (eval_sym(**stack, *new_sym))
return ((*state = ERROR));

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/15 18:32:59 by ariard #+# #+# */
/* Updated: 2017/02/20 22:16:04 by jhalford ### ########.fr */
/* Updated: 2017/02/25 19:21:05 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -19,6 +19,8 @@ t_treematch g_treematch[] =
{TK_SEMI, &add_sep},
{TK_GREAT, &add_sep},
{TK_LESS, &add_sep},
{TK_DGREAT, &add_sep},
{TK_DLESS, &add_sep},
{TK_OR_IF, &add_sep},
{TK_AND_IF, &add_sep},
{TK_WHILE, &add_cmd},
@ -31,14 +33,28 @@ t_treematch g_treematch[] =
{TK_THEN, &add_cmd},
{TK_FI, &add_cmd},
{TK_NEWLINE, &add_sep},
{TK_CASE, &add_cmd},
{TK_ESAC, &add_cmd},
{TK_IN, &add_cmd},
{TK_DSEMI, &add_cmd},
{TK_PAREN_OPEN, &add_cmd},
{TK_PAREN_CLOSE, &add_cmd},
{TK_FOR, &add_cmd},
{TK_ASSIGNEMENT_WORD, &add_cmd},
{SUBSHELL, &add_cmd},
{TK_LBRACE, &add_cmd},
{TK_RBRACE, &add_cmd},
{CLOSE_LIST, &add_cmd},
{0, NULL},
};
static int isseparator(int type, int cache)
static int isseparator(t_token *token, int cache)
{
if (type == TK_NEWLINE && (cache == TK_WHILE || cache == TK_DO
|| cache == TK_NEWLINE || cache == TK_THEN))
if (token->type == TK_NEWLINE && (cache == TK_WHILE || cache == TK_DO
|| cache == TK_NEWLINE || cache == TK_THEN || cache == TK_IN
|| cache == TK_DSEMI))
return (0);
//check cache == WORD
return (1);
}
@ -50,10 +66,16 @@ int build_tree(t_btree **ast, t_list **lst)
i = 0;
token = (*lst)->content;
//check bug de cache case ?
// cache = token->type;
if (token->type == TK_PAREN_OPEN && cache != TK_IN && cache != TK_DSEMI
&& cache != TK_WORD)
token->type = SUBSHELL;
if (token->type == TK_PAREN_CLOSE && cache == TK_PAREN_OPEN)
token->type = CLOSE_LIST;
while (g_treematch[i].type)
{
if (g_treematch[i].type == token->type
&& isseparator(token->type, cache))
if ((isseparator(token, cache) && g_treematch[i].type == token->type))
{
DG("func TK : '%s' TK : '%s'",

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 20:15:35 by ariard #+# #+# */
/* Updated: 2017/02/21 19:27:59 by jhalford ### ########.fr */
/* Updated: 2017/02/24 19:12:35 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,6 +16,7 @@ t_errormatch g_errormatch[] =
{
{TK_NEWLINE, "newline"},
{TK_SEMI, ";"},
{TK_DSEMI, ";;"},
{TK_PIPE, "|"},
{TK_AMP, "&"},
{TK_LESS, "<"},
@ -60,9 +61,9 @@ int error_syntax(t_list **lst)
{
if (g_errormatch[i].token == token->type)
{
ft_putstr_fd("syntax error near unexpetcted token `", 2);
ft_putstr_fd("syntax error near unexpected token `", 2);
ft_putstr_fd(g_errormatch[i].error, 2);
ft_putstr_fd("'", 2);
ft_putstr_fd("'\n", 2);
return (1);
}
i++;

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

@ -18,6 +18,11 @@ t_stackmatch g_stackmatch[] =
{TK_WORD, TK_CASE},
{TK_WORD, WORDLIST},
{TK_WORD, LINEBREAK},
{TK_WORD, TK_PAREN_OPEN},
{TK_WORD, TK_LBRACE},
{TK_WORD, COMPLETE_COMMANDS},
{TK_WORD, TK_IN},
{TK_WORD, FOR_WORDLIST},
{TK_ASSIGNEMENT_WORD, CMD_PREFIX},
{TK_IO_NUMBER, REDIRECT_LIST},
{TK_IO_NUMBER, CMD_SUFFIX},
@ -25,6 +30,9 @@ t_stackmatch g_stackmatch[] =
{TK_IO_NUMBER, CMD_NAME},
{TK_IO_NUMBER, CMD_WORD},
{TK_IO_NUMBER, LINEBREAK},
{TK_IO_NUMBER, TK_PAREN_OPEN},
{TK_IO_NUMBER, TK_LBRACE},
{TK_IO_NUMBER, COMPLETE_COMMANDS},
{TK_IO_NUMBER, TK_BANG},
{TK_IO_NUMBER, SEPARATOR_OP},
{TK_IO_NUMBER, NEWLINE_LIST},
@ -37,7 +45,10 @@ t_stackmatch g_stackmatch[] =
{TK_OR_IF, CMD_SUPERIOR},
{TK_OR_IF, AND_OR},
{TK_DSEMI, LINEBREAK},
{TK_DSEMI, COMPLETE_COMMANDS},
{TK_DSEMI, COMPOUND_LIST},
{TK_DSEMI, CASE_LIST_NS},
{TK_DSEMI, PIPE_SEMI_SEQUENCE},
{TK_LESS, TK_IO_NUMBER},
{TK_LESS, REDIRECT_LIST},
{TK_LESS, CMD_SUFFIX},
@ -45,6 +56,9 @@ t_stackmatch g_stackmatch[] =
{TK_LESS, CMD_WORD},
{TK_LESS, CMD_NAME},
{TK_LESS, LINEBREAK},
{TK_LESS, TK_PAREN_OPEN},
{TK_LESS, TK_LBRACE},
{TK_LESS, COMPLETE_COMMANDS},
{TK_LESS, TK_BANG},
{TK_LESS, SEPARATOR_OP},
{TK_LESS, NEWLINE_LIST},
@ -58,6 +72,9 @@ t_stackmatch g_stackmatch[] =
{TK_GREAT, CMD_WORD},
{TK_GREAT, CMD_NAME},
{TK_GREAT, LINEBREAK},
{TK_GREAT, TK_PAREN_OPEN},
{TK_GREAT, TK_LBRACE},
{TK_GREAT, COMPLETE_COMMANDS},
{TK_GREAT, TK_BANG},
{TK_GREAT, SEPARATOR_OP},
{TK_GREAT, NEWLINE_LIST},
@ -73,6 +90,9 @@ t_stackmatch g_stackmatch[] =
{TK_DLESS, CMD_WORD},
{TK_DLESS, CMD_NAME},
{TK_DLESS, LINEBREAK},
{TK_DLESS, TK_PAREN_OPEN},
{TK_DLESS, TK_LBRACE},
{TK_DLESS, COMPLETE_COMMANDS},
{TK_DLESS, TK_BANG},
{TK_DLESS, SEPARATOR_OP},
{TK_DLESS, NEWLINE_LIST},
@ -87,6 +107,10 @@ t_stackmatch g_stackmatch[] =
{TK_DLESSDASH, CMD_WORD},
{TK_DLESSDASH, CMD_NAME},
{TK_DLESSDASH, LINEBREAK},
{TK_DLESSDASH, TK_PAREN_OPEN},
{TK_DLESSDASH, TK_LBRACE},
{TK_DLESSDASH, COMPLETE_COMMANDS},
{TK_DLESSDASH, TK_BANG},
{TK_DLESSDASH, TK_BANG},
{TK_DLESSDASH, SEPARATOR_OP},
{TK_DLESSDASH, NEWLINE_LIST},
@ -101,6 +125,10 @@ t_stackmatch g_stackmatch[] =
{TK_DGREAT, CMD_WORD},
{TK_DGREAT, CMD_NAME},
{TK_DGREAT, LINEBREAK},
{TK_DGREAT, TK_PAREN_OPEN},
{TK_DGREAT, TK_LBRACE},
{TK_DGREAT, COMPLETE_COMMANDS},
{TK_DGREAT, TK_BANG},
{TK_DGREAT, TK_BANG},
{TK_DGREAT, SEPARATOR_OP},
{TK_DGREAT, NEWLINE_LIST},
@ -115,6 +143,10 @@ t_stackmatch g_stackmatch[] =
{TK_LESSAND, CMD_WORD},
{TK_LESSAND, CMD_NAME},
{TK_LESSAND, LINEBREAK},
{TK_LESSAND, TK_PAREN_OPEN},
{TK_LESSAND, TK_LBRACE},
{TK_LESSAND, COMPLETE_COMMANDS},
{TK_LESSAND, TK_BANG},
{TK_LESSAND, TK_BANG},
{TK_LESSAND, SEPARATOR_OP},
{TK_LESSAND, NEWLINE_LIST},
@ -129,6 +161,10 @@ t_stackmatch g_stackmatch[] =
{TK_GREATAND, CMD_WORD},
{TK_GREATAND, CMD_NAME},
{TK_GREATAND, LINEBREAK},
{TK_GREATAND, TK_PAREN_OPEN},
{TK_GREATAND, TK_LBRACE},
{TK_GREATAND, COMPLETE_COMMANDS},
{TK_LESSAND, TK_BANG},
{TK_GREATAND, TK_BANG},
{TK_GREATAND, SEPARATOR_OP},
{TK_GREATAND, NEWLINE_LIST},
@ -143,6 +179,10 @@ t_stackmatch g_stackmatch[] =
{TK_LESSGREAT, CMD_WORD},
{TK_LESSGREAT, CMD_NAME},
{TK_LESSGREAT, LINEBREAK},
{TK_LESSGREAT, TK_PAREN_OPEN},
{TK_LESSGREAT, TK_LBRACE},
{TK_LESSGREAT, COMPLETE_COMMANDS},
{TK_LESSGREAT, TK_BANG},
{TK_LESSGREAT, TK_BANG},
{TK_LESSGREAT, SEPARATOR_OP},
{TK_LESSGREAT, NEWLINE_LIST},
@ -157,6 +197,10 @@ t_stackmatch g_stackmatch[] =
{TK_CLOBBER, CMD_WORD},
{TK_CLOBBER, CMD_NAME},
{TK_CLOBBER, LINEBREAK},
{TK_CLOBBER, TK_PAREN_OPEN},
{TK_CLOBBER, TK_LBRACE},
{TK_CLOBBER, COMPLETE_COMMANDS},
{TK_CLOBBER, TK_BANG},
{TK_CLOBBER, TK_BANG},
{TK_CLOBBER, SEPARATOR_OP},
{TK_CLOBBER, NEWLINE_LIST},
@ -165,6 +209,10 @@ t_stackmatch g_stackmatch[] =
{TK_CLOBBER, AND_OR_MAJOR},
{TK_IF, LINEBREAK},
{TK_IF, TK_PAREN_OPEN},
{TK_IF, TK_LBRACE},
{TK_IF, TK_PAREN_CLOSE},
{TK_IF, COMPLETE_COMMANDS},
{TK_IF, TK_BANG},
{TK_IF, SEPARATOR_OP},
{TK_IF, NEWLINE_LIST},
@ -174,9 +222,12 @@ t_stackmatch g_stackmatch[] =
{TK_IF, TK_IF},
{TK_IF, TK_DO},
{TK_IF, TK_ELIF},
{TK_IF, TK_ELSE},
{TK_IF, TK_THEN},
{TK_IF, TK_PAREN_CLOSE},
{TK_IF, COMPLETE_CONDITION},
{TK_IF, COMPOUND_LIST},
{TK_IF, CASE_LIST_NS},
{TK_THEN, CONDITION},
{TK_THEN, COMPOUND_LIST},
{TK_ELSE, COMPOUND_LIST},
@ -199,49 +250,134 @@ t_stackmatch g_stackmatch[] =
{TK_DONE, COMPOUND_LIST},
{TK_DONE, END_COMMAND},
{TK_CASE, LINEBREAK},
{TK_CASE, TK_PAREN_OPEN},
{TK_CASE, TK_LBRACE},
{TK_CASE, COMPLETE_COMMANDS},
{TK_CASE, TK_BANG},
{TK_CASE, TK_DO},
{TK_CASE, TK_THEN},
{TK_CASE, TK_PAREN_CLOSE},
{TK_CASE, TK_WHILE},
{TK_CASE, TK_UNTIL},
{TK_CASE, TK_IF},
{TK_CASE, TK_ELIF},
{TK_CASE, TK_ELSE},
{TK_CASE, COMPLETE_CONDITION},
{TK_CASE, CASE_LIST_NS},
{TK_CASE, COMPOUND_LIST},
{TK_CASE, NEWLINE_LIST},
{TK_CASE, SEPARATOR_OP},
{TK_CASE, PIPE_SEMI_SEQUENCE},
{TK_ESAC, CASE_LIST},
{TK_IN, TK_WORD},
{TK_IN, NAME},
{TK_ESAC, CASE_LIST_NS},
{TK_ESAC, LINEBREAK},
{TK_ESAC, TK_IN},
{TK_WHILE, LINEBREAK},
{TK_WHILE, TK_PAREN_OPEN},
{TK_WHILE, TK_LBRACE},
{TK_WHILE, COMPLETE_COMMANDS},
{TK_WHILE, TK_BANG},
{TK_WHILE, SEPARATOR_OP},
{TK_WHILE, NEWLINE_LIST},
{TK_WHILE, PIPE_SEMI_SEQUENCE},
{TK_WHILE, TK_DO},
{TK_WHILE, TK_PAREN_CLOSE},
{TK_WHILE, TK_WHILE},
{TK_WHILE, COMPOUND_LIST},
{TK_WHILE, CASE_LIST_NS},
{TK_WHILE, TK_IF},
{TK_WHILE, TK_ELIF},
{TK_WHILE, TK_ELSE},
{TK_WHILE, TK_PAREN_CLOSE},
{TK_WHILE, TK_THEN},
{TK_WHILE, COMPLETE_CONDITION},
{TK_UNTIL, LINEBREAK},
{TK_UNTIL, TK_PAREN_OPEN},
{TK_UNTIL, TK_LBRACE},
{TK_UNTIL, COMPLETE_COMMANDS},
{TK_UNTIL, TK_BANG},
{TK_UNTIL, SEPARATOR_OP},
{TK_UNTIL, NEWLINE_LIST},
{TK_UNTIL, PIPE_SEMI_SEQUENCE},
{TK_UNTIL, TK_DO},
{TK_UNTIL, TK_PAREN_CLOSE},
{TK_UNTIL, TK_WHILE},
{TK_UNTIL, COMPOUND_LIST},
{TK_UNTIL, CASE_LIST_NS},
{TK_UNTIL, TK_IF},
{TK_UNTIL, TK_ELIF},
{TK_UNTIL, TK_ELSE},
{TK_UNTIL, TK_THEN},
{TK_UNTIL, TK_PAREN_CLOSE},
{TK_UNTIL, COMPLETE_CONDITION},
{TK_FOR, LINEBREAK},
{TK_FOR, TK_PAREN_OPEN},
{TK_FOR, TK_LBRACE},
{TK_FOR, COMPLETE_COMMANDS},
{TK_FOR, TK_BANG},
{TK_FOR, TK_BANG},
{TK_FOR, SEPARATOR_OP},
{TK_FOR, NEWLINE_LIST},
{TK_FOR, PIPE_SEMI_SEQUENCE},
{TK_FOR, TK_DO},
{TK_FOR, TK_PAREN_CLOSE},
{TK_FOR, TK_WHILE},
{TK_FOR, COMPOUND_LIST},
{TK_FOR, CASE_LIST_NS},
{TK_FOR, TK_IF},
{TK_FOR, TK_ELIF},
{TK_FOR, TK_THEN},
{TK_FOR, TK_ELSE},
{TK_FOR, TK_PAREN_CLOSE},
{TK_FOR, COMPLETE_CONDITION},
{TK_LBRACE, COMPLETE_COMMANDS},
{TK_LBRACE, LINEBREAK},
{TK_LBRACE, TK_LBRACE},
{TK_LBRACE, TK_BANG},
{TK_LBRACE, SEPARATOR_OP},
{TK_LBRACE, NEWLINE_LIST},
{TK_LBRACE, PIPE_SEMI_SEQUENCE},
{TK_LBRACE, AND_OR_MAJOR},
{TK_LBRACE, TK_WHILE},
{TK_LBRACE, TK_UNTIL},
{TK_LBRACE, TK_DO},
{TK_LBRACE, TK_PAREN_CLOSE},
{TK_LBRACE, TK_LBRACE},
{TK_LBRACE, TK_IF},
{TK_LBRACE, TK_ELIF},
{TK_LBRACE, TK_THEN},
{TK_LBRACE, TK_ELSE},
{TK_LBRACE, COMPOUND_LIST},
{TK_LBRACE, CASE_LIST_NS},
{TK_LBRACE, COMPLETE_CONDITION},
{TK_LBRACE, TK_IN},
{SEQUENTIAL_SEP, NAME},
{TK_RBRACE, TK_SEMI},
{TK_RBRACE, END_COMMAND},
{TK_RBRACE, SEPARATOR_OP},
{TK_RBRACE, WORD},
{TK_RBRACE, IN},
{TK_RBRACE, TK_AND_IF},
{TK_RBRACE, TK_OR_IF},
{TK_RBRACE, TK_PIPE},
{TK_RBRACE, TK_RBRACE},
{TK_RBRACE, COMPLETE_COMMANDS},
{TK_RBRACE, CMD_SUPERIOR},
{TK_RBRACE, PIPE_SEMI_SEQUENCE},
{TK_RBRACE, CASE_LIST_NS},
{TK_RBRACE, PROGRAM},
{TK_RBRACE, TK_PAREN_OPEN},
{TK_RBRACE, TK_LBRACE},
{TK_RBRACE, PATTERN_CASE},
{TK_RBRACE, PATTERN},
{TK_RBRACE, COMPOUND_LIST},
{TK_RBRACE, FUNC_NAME},
{TK_BANG, LINEBREAK},
{TK_BANG, TK_PAREN_OPEN},
{TK_BANG, TK_LBRACE},
{TK_BANG, COMPLETE_COMMANDS},
{TK_BANG, SEPARATOR_OP},
{TK_BANG, SEPARATOR_OP},
{TK_BANG, NEWLINE_LIST},
{TK_IN, LINEBREAK},
@ -252,44 +388,68 @@ t_stackmatch g_stackmatch[] =
{TK_SEMI, TERM},
{TK_SEMI, CMD_NAME},
{TK_SEMI, PROGRAM},
{TK_SEMI, FOR_WORDLIST},
{TK_AMP, LIST},
{TK_AMP, TERM},
{TK_PIPE, PATTERN},
{TK_PIPE, CMD_SUPERIOR},
{TK_PAREN_OPEN, FNAME},
{TK_PAREN_OPEN, CASE_LIST},
{PATTERN_CASE, TK_IN},
{PATTERN_CASE, CASE_LIST_NS},
{TK_PAREN_OPEN, COMPLETE_COMMANDS},
{TK_PAREN_OPEN, LINEBREAK},
{TK_PAREN_OPEN, TK_PAREN_OPEN},
{TK_PAREN_OPEN, TK_BANG},
{TK_PAREN_OPEN, SEPARATOR_OP},
{TK_PAREN_OPEN, NEWLINE_LIST},
{TK_PAREN_OPEN, PIPE_SEMI_SEQUENCE},
{TK_PAREN_CLOSE, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, PATTERN},
{TK_PAREN_CLOSE, COMPOUND_LIST},
{TK_PAREN_OPEN, AND_OR_MAJOR},
{TK_PAREN_OPEN, TK_WHILE},
{TK_PAREN_OPEN, TK_UNTIL},
{TK_PAREN_OPEN, TK_DO},
{TK_PAREN_OPEN, TK_PAREN_CLOSE},
{TK_PAREN_OPEN, TK_IF},
{TK_PAREN_OPEN, TK_ELIF},
{TK_PAREN_OPEN, TK_THEN},
{TK_PAREN_OPEN, TK_ELSE},
{TK_PAREN_OPEN, COMPOUND_LIST},
{TK_PAREN_OPEN, CASE_LIST_NS},
{TK_PAREN_OPEN, COMPLETE_CONDITION},
{TK_PAREN_OPEN, TK_IN},
{TK_PAREN_OPEN, CMD_SUPERIOR},
{SEQUENTIAL_SEP, NAME},
{SEQUENTIAL_SEP, IN},
{SEQUENTIAL_SEP, WORDLIST},
{END_COMMAND, PIPE_SEMI_SEQUENCE},
{END_COMMAND, AND_OR_MAJOR},
{END_COMMAND, TK_WHILE},
{END_COMMAND, TK_WHILE},
{END_COMMAND, TK_UNTIL},
{END_COMMAND, TK_DO},
{END_COMMAND, TK_PAREN_CLOSE},
{END_COMMAND, TK_IF},
{END_COMMAND, TK_THEN},
{END_COMMAND, TK_ELIF},
{END_COMMAND, TK_ELSE},
{END_COMMAND, LINEBREAK},
{END_COMMAND, TK_PAREN_OPEN},
{END_COMMAND, TK_LBRACE},
{END_COMMAND, COMPLETE_COMMANDS},
{END_COMMAND, COMPOUND_LIST},
{END_COMMAND, CASE_LIST_NS},
{END_COMMAND, COMPLETE_CONDITION},
{SEPARATOR, CMD_SUPERIOR},
{SEPARATOR, TERM},
{SEPARATOR, COMPOUND_LIST},
{SEPARATOR, CASE_LIST_NS},
{SEPARATOR, PIPE_SEMI_SEQUENCE},
{SEPARATOR_OP, CMD_SUPERIOR},
{SEPARATOR_OP, LIST},
{SEPARATOR_OP, TERM},
{SEPARATOR_OP, CASE_LIST_NS},
{SEPARATOR_OP, COMPOUND_LIST},
{SEPARATOR_OP, PIPE_SEMI_SEQUENCE},
{LINEBREAK, TK_SEMI},
{LINEBREAK, END_COMMAND},
{LINEBREAK, SEPARATOR_OP},
{LINEBREAK, TK_PAREN_CLOSE},
{LINEBREAK, WORD},
@ -302,8 +462,36 @@ t_stackmatch g_stackmatch[] =
{LINEBREAK, CMD_SUPERIOR},
{LINEBREAK, PIPE_SEMI_SEQUENCE},
{LINEBREAK, COMPOUND_LIST},
{LINEBREAK, CASE_LIST_NS},
{LINEBREAK, PROGRAM},
{LINEBREAK, TK_PAREN_OPEN},
{LINEBREAK, TK_LBRACE},
{TK_PAREN_CLOSE, TK_SEMI},
{TK_PAREN_CLOSE, END_COMMAND},
{TK_PAREN_CLOSE, SEPARATOR_OP},
{TK_PAREN_CLOSE, WORD},
{TK_PAREN_CLOSE, IN},
{TK_PAREN_CLOSE, TK_AND_IF},
{TK_PAREN_CLOSE, TK_OR_IF},
{TK_PAREN_CLOSE, TK_PIPE},
{TK_PAREN_CLOSE, TK_PAREN_CLOSE},
{TK_PAREN_CLOSE, COMPLETE_COMMANDS},
{TK_PAREN_CLOSE, CMD_SUPERIOR},
{TK_PAREN_CLOSE, PIPE_SEMI_SEQUENCE},
{TK_PAREN_CLOSE, CASE_LIST_NS},
{TK_PAREN_CLOSE, PROGRAM},
{TK_PAREN_CLOSE, TK_PAREN_OPEN},
{TK_PAREN_CLOSE, TK_LBRACE},
{TK_PAREN_CLOSE, PATTERN_CASE},
{TK_PAREN_CLOSE, PATTERN},
{TK_PAREN_CLOSE, COMPOUND_LIST},
{TK_PAREN_CLOSE, FUNC_NAME},
{NEWLINE_LIST, TK_DO},
{NEWLINE_LIST, CASE_LIST_NS},
{NEWLINE_LIST, TK_PAREN_CLOSE},
{NEWLINE_LIST, SEQUENTIAL_SEP},
{NEWLINE_LIST, FOR_WORDLIST},
{NEWLINE_LIST, TK_IN},
{NEWLINE_LIST, TK_WHILE},
{NEWLINE_LIST, TK_UNTIL},
{NEWLINE_LIST, TK_IF},
@ -317,9 +505,14 @@ t_stackmatch g_stackmatch[] =
{NEWLINE_LIST, WORDLIST},
{NEWLINE_LIST, TERM},
{NEWLINE_LIST, COMPOUND_LIST},
{NEWLINE_LIST, CASE_LIST_NS},
{NEWLINE_LIST, COMPLETE_COMMANDS},
{NEWLINE_LIST, COMPLETE_CONDITION},
{NEWLINE_LIST, CONDITION},
{NEWLINE_LIST, LINEBREAK},
{NEWLINE_LIST, TK_PAREN_OPEN},
{NEWLINE_LIST, TK_LBRACE},
{HERE_END, TK_DLESS},
{HERE_END, TK_DLESS},
{HERE_END, TK_DLESSDASH},
{IO_HERE, TK_IO_NUMBER},
@ -330,6 +523,10 @@ t_stackmatch g_stackmatch[] =
{IO_HERE, CMD_WORD},
{IO_HERE, CMD_NAME},
{IO_HERE, LINEBREAK},
{IO_HERE, TK_PAREN_OPEN},
{IO_HERE, TK_LBRACE},
{IO_HERE, COMPLETE_COMMANDS},
{IO_HERE, TK_BANG},
{IO_HERE, TK_BANG},
{IO_HERE, SEPARATOR_OP},
{IO_HERE, NEWLINE_LIST},
@ -349,6 +546,8 @@ t_stackmatch g_stackmatch[] =
{IO_FILE, CMD_WORD},
{IO_FILE, CMD_NAME},
{IO_FILE, LINEBREAK},
{IO_FILE, COMPLETE_COMMANDS},
{IO_FILE, TK_BANG},
{IO_FILE, TK_BANG},
{IO_FILE, SEPARATOR_OP},
{IO_FILE, NEWLINE_LIST},
@ -360,6 +559,10 @@ t_stackmatch g_stackmatch[] =
{IO_REDIRECT, CMD_WORD},
{IO_REDIRECT, CMD_NAME},
{IO_REDIRECT, LINEBREAK},
{IO_REDIRECT, TK_PAREN_OPEN},
{IO_REDIRECT, TK_LBRACE},
{IO_REDIRECT, COMPLETE_COMMANDS},
{IO_REDIRECT, TK_BANG},
{IO_REDIRECT, TK_BANG},
{IO_REDIRECT, SEPARATOR_OP},
{IO_REDIRECT, NEWLINE_LIST},
@ -369,12 +572,20 @@ t_stackmatch g_stackmatch[] =
{CMD_SUFFIX, CMD_NAME},
{CMD_SUFFIX, CMD_SUPERIOR},
{CMD_PREFIX, LINEBREAK},
{CMD_PREFIX, TK_PAREN_OPEN},
{CMD_PREFIX, TK_LBRACE},
{CMD_PREFIX, COMPLETE_COMMANDS},
{CMD_PREFIX, TK_BANG},
{CMD_PREFIX, TK_BANG},
{CMD_PREFIX, SEPARATOR_OP},
{CMD_PREFIX, NEWLINE_LIST},
{CMD_PREFIX, PIPE_SEMI_SEQUENCE},
{CMD_WORD, CMD_PREFIX},
{CMD_NAME, COMPLETE_COMMANDS},
{CMD_NAME, LINEBREAK},
{CMD_NAME, TK_PAREN_OPEN},
{CMD_NAME, TK_LBRACE},
{CMD_NAME, TK_BANG},
{CMD_NAME, TK_BANG},
{CMD_NAME, SEPARATOR_OP},
{CMD_NAME, NEWLINE_LIST},
@ -383,23 +594,31 @@ t_stackmatch g_stackmatch[] =
{CMD_NAME, TK_WHILE},
{CMD_NAME, TK_UNTIL},
{CMD_NAME, TK_DO},
{CMD_NAME, TK_PAREN_CLOSE},
{CMD_NAME, TK_IF},
{CMD_NAME, TK_ELIF},
{CMD_NAME, TK_THEN},
{CMD_NAME, TK_ELSE},
{CMD_NAME, COMPOUND_LIST},
{CMD_NAME, CASE_LIST_NS},
{CMD_NAME, COMPLETE_CONDITION},
{CMD_SUPERIOR, TK_WHILE},
{CMD_SUPERIOR, TK_UNTIL},
{CMD_SUPERIOR, TK_DO},
{CMD_SUPERIOR, TK_PAREN_CLOSE},
{CMD_SUPERIOR, TK_IF},
{CMD_SUPERIOR, TK_ELIF},
{CMD_SUPERIOR, TK_THEN},
{CMD_SUPERIOR, TK_ELSE},
{CMD_SUPERIOR, COMPOUND_LIST},
{CMD_SUPERIOR, CASE_LIST_NS},
{CMD_SUPERIOR, COMPLETE_CONDITION},
{CMD_SUPERIOR, LINEBREAK,},
{CMD_SUPERIOR, LINEBREAK},
{CMD_SUPERIOR, TK_PAREN_OPEN},
{CMD_SUPERIOR, TK_LBRACE},
{CMD_SUPERIOR, COMPLETE_COMMANDS},
{CMD_SUPERIOR, TK_BANG},
{CMD_SUPERIOR, TK_BANG},
{CMD_SUPERIOR, SEPARATOR_OP},
{CMD_SUPERIOR, NEWLINE_LIST},
@ -410,13 +629,19 @@ t_stackmatch g_stackmatch[] =
{SIMPLE_COMMAND, TK_WHILE},
{SIMPLE_COMMAND, TK_UNTIL},
{SIMPLE_COMMAND, TK_DO},
{SIMPLE_COMMAND, TK_PAREN_CLOSE},
{SIMPLE_COMMAND, TK_IF},
{SIMPLE_COMMAND, TK_ELIF},
{SIMPLE_COMMAND, TK_THEN},
{SIMPLE_COMMAND, TK_ELSE},
{SIMPLE_COMMAND, COMPOUND_LIST},
{SIMPLE_COMMAND, CASE_LIST_NS},
{SIMPLE_COMMAND, COMPLETE_CONDITION},
{SIMPLE_COMMAND, LINEBREAK},
{SIMPLE_COMMAND, TK_PAREN_OPEN},
{SIMPLE_COMMAND, TK_LBRACE},
{SIMPLE_COMMAND, COMPLETE_COMMANDS},
{SIMPLE_COMMAND, TK_BANG},
{SIMPLE_COMMAND, TK_BANG},
{SIMPLE_COMMAND, SEPARATOR_OP},
{SIMPLE_COMMAND, NEWLINE_LIST},
@ -429,32 +654,56 @@ t_stackmatch g_stackmatch[] =
{LOOP, TK_WHILE},
{LOOP, TK_UNTIL},
{CONDITION, LINEBREAK},
{CONDITION, TK_PAREN_OPEN},
{CONDITION, TK_LBRACE},
{CONDITION, COMPLETE_COMMANDS},
{CONDITION, COMPOUND_LIST},
{CONDITION, CASE_LIST_NS},
{CONDITION, COMPLETE_CONDITION},
{COMPLETE_CONDITION, LINEBREAK},
{COMPLETE_CONDITION, TK_PAREN_OPEN},
{COMPLETE_CONDITION, TK_LBRACE},
{COMPLETE_CONDITION, COMPLETE_COMMANDS},
{COMPLETE_CONDITION, COMPLETE_CONDITION},
{COMPLETE_CONDITION, COMPLETE_CONDITION},
{BRACE_GROUP, LINEBREAK},
{BRACE_GROUP, TK_PAREN_OPEN},
{BRACE_GROUP, TK_LBRACE},
{BRACE_GROUP, COMPLETE_COMMANDS},
{BRACE_GROUP, TK_BANG},
{BRACE_GROUP, TK_BANG},
{BRACE_GROUP, SEPARATOR_OP},
{BRACE_GROUP, NEWLINE_LIST},
{BRACE_GROUP, PIPE_SEMI_SEQUENCE},
{FNAME, LINEBREAK},
{FNAME, TK_PAREN_OPEN},
{FNAME, TK_LBRACE},
{FNAME, COMPLETE_COMMANDS},
{FNAME, TK_BANG},
{FNAME, TK_BANG},
{FNAME, SEPARATOR_OP},
{FNAME, NEWLINE_LIST},
{FNAME, PIPE_SEMI_SEQUENCE},
{FUNCTION_BODY, FUNC},
{FUNCTION_DEFINITION, LINEBREAK},
{FUNCTION_DEFINITION, TK_PAREN_OPEN},
{FUNCTION_DEFINITION, TK_LBRACE},
{FUNCTION_DEFINITION, COMPLETE_COMMANDS},
{FUNCTION_DEFINITION, TK_BANG},
{FUNCTION_DEFINITION, TK_BANG},
{FUNCTION_DEFINITION, SEPARATOR_OP},
{FUNCTION_DEFINITION, NEWLINE_LIST},
{FUNCTION_DEFINITION, PIPE_SEMI_SEQUENCE},
{UNTIL_CLAUSE, LINEBREAK},
{UNTIL_CLAUSE, TK_PAREN_OPEN},
{UNTIL_CLAUSE, TK_LBRACE},
{UNTIL_CLAUSE, COMPLETE_COMMANDS},
{UNTIL_CLAUSE, TK_BANG},
{UNTIL_CLAUSE, SEPARATOR_OP},
{UNTIL_CLAUSE, NEWLINE_LIST},
{UNTIL_CLAUSE, PIPE_SEMI_SEQUENCE},
{UNTIL_CLAUSE, TK_DO},
{UNTIL_CLAUSE, TK_PAREN_CLOSE},
{UNTIL_CLAUSE, TK_WHILE},
{UNTIL_CLAUSE, TK_UNTIL},
{UNTIL_CLAUSE, TK_IF},
@ -462,13 +711,17 @@ t_stackmatch g_stackmatch[] =
{UNTIL_CLAUSE, TK_THEN},
{UNTIL_CLAUSE, TK_ELSE},
{UNTIL_CLAUSE, COMPOUND_LIST},
{UNTIL_CLAUSE, CASE_LIST_NS},
{UNTIL_CLAUSE, COMPLETE_CONDITION},
{UNTIL_CLAUSE, AND_OR_MAJOR},
{WHILE_CLAUSE, LINEBREAK},
{WHILE_CLAUSE, COMPLETE_COMMANDS},
{WHILE_CLAUSE, TK_BANG},
{WHILE_CLAUSE, SEPARATOR_OP},
{WHILE_CLAUSE, NEWLINE_LIST},
{WHILE_CLAUSE, PIPE_SEMI_SEQUENCE},
{WHILE_CLAUSE, TK_DO},
{WHILE_CLAUSE, TK_PAREN_CLOSE},
{WHILE_CLAUSE, TK_WHILE},
{WHILE_CLAUSE, TK_UNTIL},
{WHILE_CLAUSE, TK_IF},
@ -476,15 +729,21 @@ t_stackmatch g_stackmatch[] =
{WHILE_CLAUSE, TK_THEN},
{WHILE_CLAUSE, TK_ELSE},
{WHILE_CLAUSE, COMPOUND_LIST},
{WHILE_CLAUSE, CASE_LIST_NS},
{WHILE_CLAUSE, COMPLETE_CONDITION},
{WHILE_CLAUSE, AND_OR_MAJOR},
// {ELSE_PART, COMPOUND_LIST},
// {ELSE_PART, COMPLETE_CONDITION},
{IF_CLAUSE, LINEBREAK},
{IF_CLAUSE, TK_PAREN_OPEN},
{IF_CLAUSE, TK_LBRACE},
{IF_CLAUSE, COMPLETE_COMMANDS},
{IF_CLAUSE, TK_BANG},
{IF_CLAUSE, SEPARATOR_OP},
{IF_CLAUSE, NEWLINE_LIST},
{IF_CLAUSE, PIPE_SEMI_SEQUENCE},
{IF_CLAUSE, TK_DO},
{IF_CLAUSE, TK_PAREN_CLOSE},
{IF_CLAUSE, TK_WHILE},
{IF_CLAUSE, TK_UNTIL},
{IF_CLAUSE, TK_IF},
@ -492,33 +751,86 @@ t_stackmatch g_stackmatch[] =
{IF_CLAUSE, TK_THEN},
{IF_CLAUSE, TK_ELSE},
{IF_CLAUSE, COMPOUND_LIST},
{IF_CLAUSE, CASE_LIST_NS},
{IF_CLAUSE, COMPLETE_COMMAND},
{IF_CLAUSE, COMPLETE_CONDITION},
{PATTERN, TK_PAREN_OPEN},
{IF_CLAUSE, AND_OR_MAJOR},
{BRACE_CLAUSE, LINEBREAK},
{BRACE_CLAUSE, TK_PAREN_OPEN},
{BRACE_CLAUSE, TK_LBRACE},
{BRACE_CLAUSE, COMPLETE_COMMANDS},
{BRACE_CLAUSE, TK_BANG},
{BRACE_CLAUSE, SEPARATOR_OP},
{BRACE_CLAUSE, NEWLINE_LIST},
{BRACE_CLAUSE, PIPE_SEMI_SEQUENCE},
{BRACE_CLAUSE, TK_DO},
{BRACE_CLAUSE, TK_PAREN_CLOSE},
{BRACE_CLAUSE, TK_WHILE},
{BRACE_CLAUSE, TK_UNTIL},
{BRACE_CLAUSE, TK_IF},
{BRACE_CLAUSE, TK_ELIF},
{BRACE_CLAUSE, TK_THEN},
{BRACE_CLAUSE, TK_ELSE},
{BRACE_CLAUSE, COMPOUND_LIST},
{BRACE_CLAUSE, CASE_LIST_NS},
{BRACE_CLAUSE, COMPLETE_COMMAND},
{BRACE_CLAUSE, COMPLETE_CONDITION},
{BRACE_CLAUSE, AND_OR_MAJOR},
{PATTERN, PATTERN_CASE},
{PATTERN, CASE_LIST},
{PATTERN_CASE, CASE_LIST},
{CASE_ITEM, CASE_LIST},
{CASE_ITEM, LINEBREAK},
{CASE_ITEM_NS, CASE_LIST},
{CASE_ITEM_NS, LINEBREAK},
{CASE_LIST, LINEBREAK},
{PATTERN, TK_IN},
{CASE_LIST_NS, LINEBREAK},
{CASE_CLAUSE, LINEBREAK},
{CASE_CLAUSE, TK_PAREN_OPEN},
{CASE_CLAUSE, TK_LBRACE},
{CASE_CLAUSE, COMPLETE_COMMANDS},
{CASE_CLAUSE, TK_BANG},
{CASE_CLAUSE, SEPARATOR_OP},
{CASE_CLAUSE, NEWLINE_LIST},
{CASE_CLAUSE, PIPE_SEMI_SEQUENCE},
{CASE_CLAUSE, TK_PAREN_CLOSE},
{CASE_CLAUSE, CASE_LIST_NS},
{CASE_CLAUSE, TK_DO},
{CASE_CLAUSE, TK_WHILE},
{CASE_CLAUSE, TK_UNTIL},
{CASE_CLAUSE, TK_IF},
{CASE_CLAUSE, TK_ELIF},
{CASE_CLAUSE, TK_THEN},
{CASE_CLAUSE, TK_ELSE},
{CASE_CLAUSE, COMPOUND_LIST},
{CASE_CLAUSE, CASE_LIST_NS},
{CASE_CLAUSE, COMPLETE_CONDITION},
{CASE_CLAUSE, AND_OR_MAJOR},
{WORDLIST, IN},
{IN, LINEBREAK},
{NAME, TK_FOR},
{FOR_WORDLIST, NAME},
{FOR_CLAUSE, LINEBREAK},
{FOR_CLAUSE, TK_PAREN_OPEN},
{FOR_CLAUSE, TK_LBRACE},
{FOR_CLAUSE, COMPLETE_COMMANDS},
{FOR_CLAUSE, TK_BANG},
{FOR_CLAUSE, TK_BANG},
{FOR_CLAUSE, SEPARATOR_OP},
{FOR_CLAUSE, NEWLINE_LIST},
{FOR_CLAUSE, PIPE_SEMI_SEQUENCE},
{FOR_CLAUSE, TK_DO},
{FOR_CLAUSE, TK_PAREN_CLOSE},
{FOR_CLAUSE, TK_WHILE},
{FOR_CLAUSE, TK_UNTIL},
{FOR_CLAUSE, TK_IF},
{FOR_CLAUSE, TK_ELIF},
{FOR_CLAUSE, TK_THEN},
{FOR_CLAUSE, TK_ELSE},
{FOR_CLAUSE, COMPOUND_LIST},
{FOR_CLAUSE, CASE_LIST_NS},
{FOR_CLAUSE, COMPLETE_CONDITION},
{FOR_CLAUSE, AND_OR_MAJOR},
{TERM, LINEBREAK},
{TERM, COMPLETE_COMMANDS},
{COMPOUND_LIST, TK_DO},
{COMPOUND_LIST, TK_PAREN_CLOSE},
{COMPOUND_LIST, TK_LBRACE},
{COMPOUND_LIST, TK_WHILE},
{COMPOUND_LIST, TK_UNTIL},
@ -529,18 +841,41 @@ t_stackmatch g_stackmatch[] =
{COMPOUND_LIST, TK_ELSE},
{COMPOUND_LIST, COMPOUND_LIST},
{COMPOUND_LIST, COMPLETE_CONDITION},
{CLOSE_LIST, PATTERN_CASE},
{CLOSE_LIST, FUNC_NAME},
{SUBSHELL, LINEBREAK},
{SUBSHELL, COMPLETE_COMMANDS},
{SUBSHELL, TK_BANG},
{SUBSHELL, SEPARATOR_OP},
{SUBSHELL, NEWLINE_LIST},
{SUBSHELL, PIPE_SEMI_SEQUENCE},
{SUBSHELL, SEPARATOR_OP},
{SUBSHELL, NEWLINE_LIST},
{SUBSHELL, PIPE_SEMI_SEQUENCE},
{SUBSHELL, TK_DO},
{SUBSHELL, TK_PAREN_CLOSE},
{SUBSHELL, TK_WHILE},
{SUBSHELL, TK_UNTIL},
{SUBSHELL, TK_IF},
{SUBSHELL, TK_ELIF},
{SUBSHELL, TK_THEN},
{SUBSHELL, TK_ELSE},
{SUBSHELL, COMPOUND_LIST},
{SUBSHELL, CASE_LIST_NS},
{SUBSHELL, COMPLETE_CONDITION},
{SUBSHELL, AND_OR_MAJOR},
{COMPOUND_COMMAND, LINEBREAK},
{COMPOUND_COMMAND, TK_PAREN_OPEN},
{COMPOUND_COMMAND, TK_LBRACE},
{COMPOUND_COMMAND, COMPLETE_COMMANDS},
{COMPOUND_COMMAND, TK_BANG},
{COMPOUND_COMMAND, TK_BANG},
{COMPOUND_COMMAND, SEPARATOR_OP},
{COMPOUND_COMMAND, NEWLINE_LIST},
{COMPOUND_COMMAND, PIPE_SEMI_SEQUENCE},
{COMPOUND_COMMAND, FUNC},
{COMPOUND_COMMAND, TK_DO},
{COMPOUND_COMMAND, TK_PAREN_CLOSE},
{COMPOUND_COMMAND, TK_WHILE},
{COMPOUND_COMMAND, TK_UNTIL},
{COMPOUND_COMMAND, TK_IF},
@ -548,16 +883,23 @@ t_stackmatch g_stackmatch[] =
{COMPOUND_COMMAND, TK_THEN},
{COMPOUND_COMMAND, TK_ELSE},
{COMPOUND_COMMAND, COMPOUND_LIST},
{COMPOUND_COMMAND, CASE_LIST_NS},
{COMPOUND_COMMAND, COMPLETE_CONDITION},
{COMPOUND_COMMAND, AND_OR_MAJOR},
{COMMAND, TK_WHILE},
{COMMAND, TK_UNTIL},
{COMMAND, LINEBREAK},
{COMMAND, TK_PAREN_OPEN},
{COMMAND, TK_LBRACE},
{COMMAND, COMPLETE_COMMANDS},
{COMMAND, TK_DO},
{COMMAND, TK_PAREN_CLOSE},
{COMMAND, TK_IF},
{COMMAND, TK_ELIF},
{COMMAND, TK_THEN},
{COMMAND, TK_ELSE},
{COMMAND, COMPOUND_LIST},
{COMMAND, CASE_LIST_NS},
{COMMAND, COMPLETE_CONDITION},
{COMMAND, TK_BANG},
{COMMAND, SEPARATOR_OP},
@ -566,17 +908,26 @@ t_stackmatch g_stackmatch[] =
{COMMAND, AND_OR_MAJOR},
{AND_OR_MINOR, PIPE_SEMI_SEQUENCE},
{AND_OR_MINOR, LINEBREAK},
{AND_OR_MINOR, TK_PAREN_OPEN},
{AND_OR_MINOR, TK_LBRACE},
{AND_OR_MINOR, COMPLETE_COMMANDS},
{AND_OR_MINOR, AND_OR_MAJOR},
{PIPE_SEQUENCE, TK_WHILE},
{PIPE_SEQUENCE, TK_UNTIL},
{PIPE_SEQUENCE, TK_DO},
{PIPE_SEQUENCE, TK_PAREN_CLOSE},
{PIPE_SEQUENCE, TK_IF},
{PIPE_SEQUENCE, TK_ELIF},
{PIPE_SEQUENCE, TK_THEN},
{PIPE_SEQUENCE, TK_ELSE},
{PIPE_SEQUENCE, COMPOUND_LIST},
{PIPE_SEQUENCE, CASE_LIST_NS},
{PIPE_SEQUENCE, COMPLETE_CONDITION},
{PIPE_SEQUENCE, LINEBREAK},
{PIPE_SEQUENCE, TK_PAREN_OPEN},
{PIPE_SEQUENCE, TK_LBRACE},
{PIPE_SEQUENCE, COMPLETE_COMMANDS},
{PIPE_SEQUENCE, TK_BANG},
{PIPE_SEQUENCE, TK_BANG},
{PIPE_SEQUENCE, SEPARATOR_OP},
{PIPE_SEQUENCE, NEWLINE_LIST},
@ -584,13 +935,19 @@ t_stackmatch g_stackmatch[] =
{PIPE_SEMI_SEQUENCE, TK_WHILE},
{PIPE_SEMI_SEQUENCE, TK_UNTIL},
{PIPE_SEMI_SEQUENCE, TK_DO},
{PIPE_SEMI_SEQUENCE, TK_PAREN_CLOSE},
{PIPE_SEMI_SEQUENCE, TK_IF},
{PIPE_SEMI_SEQUENCE, TK_ELIF},
{PIPE_SEMI_SEQUENCE, TK_THEN},
{PIPE_SEMI_SEQUENCE, TK_ELSE},
{PIPE_SEMI_SEQUENCE, COMPOUND_LIST},
{PIPE_SEMI_SEQUENCE, CASE_LIST_NS},
{PIPE_SEMI_SEQUENCE, COMPLETE_CONDITION},
{PIPE_SEMI_SEQUENCE, LINEBREAK},
{PIPE_SEMI_SEQUENCE, TK_PAREN_OPEN},
{PIPE_SEMI_SEQUENCE, TK_LBRACE},
{PIPE_SEMI_SEQUENCE, COMPLETE_COMMANDS},
{PIPE_SEMI_SEQUENCE, TK_BANG},
{PIPE_SEMI_SEQUENCE, TK_BANG},
{PIPE_SEMI_SEQUENCE, SEPARATOR_OP},
{PIPE_SEMI_SEQUENCE, NEWLINE_LIST},
@ -598,19 +955,30 @@ t_stackmatch g_stackmatch[] =
{PIPELINE, TK_WHILE},
{PIPELINE, TK_UNTIL},
{PIPELINE, TK_DO},
{PIPELINE, TK_PAREN_CLOSE},
{PIPELINE, TK_IF},
{PIPELINE, TK_ELIF},
{PIPELINE, TK_THEN},
{PIPELINE, TK_ELSE},
{PIPELINE, COMPOUND_LIST},
{PIPELINE, CASE_LIST_NS},
{PIPELINE, COMPLETE_CONDITION},
{PIPELINE, LINEBREAK},
{PIPELINE, TK_PAREN_OPEN},
{PIPELINE, TK_LBRACE},
{PIPELINE, COMPLETE_COMMANDS},
{PIPELINE, SEPARATOR_OP},
{PIPELINE, SEPARATOR_OP},
{PIPELINE, NEWLINE_LIST},
{PIPELINE, AND_OR_MAJOR},
{AND_OR_MAJOR, LINEBREAK},
{AND_OR_MAJOR, TK_PAREN_OPEN},
{AND_OR_MAJOR, TK_LBRACE},
{AND_OR_MAJOR, COMPLETE_COMMANDS},
{AND_OR_MAJOR, AND_OR_MAJOR},
{AND_OR_MAJOR, AND_OR_MAJOR},
{AND_OR, TK_DO},
{AND_OR, TK_PAREN_CLOSE},
{AND_OR, TK_WHILE},
{AND_OR, TK_UNTIL},
{AND_OR, TK_IF},
@ -618,15 +986,22 @@ t_stackmatch g_stackmatch[] =
{AND_OR, TK_THEN},
{AND_OR, TK_ELSE},
{AND_OR, COMPOUND_LIST},
{AND_OR, CASE_LIST_NS},
{AND_OR, COMPLETE_CONDITION},
{AND_OR, LINEBREAK},
{AND_OR, TK_PAREN_OPEN},
{AND_OR, TK_LBRACE},
{AND_OR, COMPLETE_COMMANDS},
{AND_OR, SEPARATOR_OP},
{AND_OR, SEPARATOR_OP},
{AND_OR, NEWLINE_LIST},
{LIST, LINEBREAK},
{LIST, COMPLETE_COMMANDS},
{LIST, NEWLINE_LIST},
{COMPLETE_COMMAND, LINEBREAK},
{COMPLETE_COMMAND, COMPLETE_COMMANDS},
{COMPLETE_COMMAND, NEWLINE_LIST},
{COMPLETE_COMMANDS, LINEBREAK},
{COMPLETE_COMMANDS, COMPLETE_COMMANDS},
{0, 0},
};

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

@ -6,7 +6,6 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/30 17:14:58 by jhalford #+# #+# */
/* Updated: 2017/02/21 20:09:19 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
@ -15,30 +14,37 @@
static void insert_linebreak(t_list **lst)
{
t_token *token;
token = (*lst)->content;
token->type = LINEBREAK;
}
static int end_instruction(t_sym sym)
{
if (sym == CMD_SUPERIOR || sym == PIPE_SEMI_SEQUENCE)
if (sym == CMD_SUPERIOR || sym == PIPE_SEMI_SEQUENCE
|| sym == COMPLETE_COMMANDS || sym == END_COMMAND)
return (1);
return (0);
}
int ft_parse(t_btree **ast, t_list **token, t_parser *parser)
{
(void)ast;
if (parser->state == SUCCESS || parser->state == ERROR)
parser_init(parser);
while (*token)
{
produce_sym(*parser->stack, parser->new_sym, token);
DG("new sym %s", read_state(*parser->new_sym));
if (eval_sym(*parser->stack, *parser->new_sym))
parser->state = ERROR;
return ((parser->state = ERROR));
else
{
aggregate_sym(&parser->stack, parser->new_sym, &parser->state);
push_stack(++parser->stack, *parser->new_sym);
}
ft_read_stack(parser->stack);
DG("\n");
if (*parser->stack == PROGRAM)
parser->state = SUCCESS;
else
@ -46,11 +52,11 @@ int ft_parse(t_btree **ast, t_list **token, t_parser *parser)
build_tree(ast, token);
btree_print(STDBUG, *ast, &ft_putast);
if ((end_instruction(*parser->stack) && !(*token)->next))
/* || *parser->stack == PROGRAM) */
insert_linebreak(token);
else
ft_lst_delif(token, (*token)->content, &ft_addrcmp, &token_free);
}
ft_read_stack(parser->stack);
if (parser->state == SUCCESS)
DG("sucessful parsing");
return (0);
}

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 17:58:34 by ariard #+# #+# */
/* Updated: 2017/02/20 22:37:22 by jhalford ### ########.fr */
/* Updated: 2017/02/25 13:54:08 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -33,29 +33,40 @@ t_prodmatch g_prodmatch[] =
{TK_WORD, TK_WHILE, CMD_NAME},
{TK_WORD, TK_UNTIL, CMD_NAME},
{TK_WORD, TK_DO, CMD_NAME},
{TK_WORD, TK_PAREN_CLOSE, CMD_NAME},
{TK_WORD, TK_IF, CMD_NAME},
{TK_WORD, TK_THEN, CMD_NAME},
{TK_WORD, TK_ELIF, CMD_NAME},
{TK_WORD, TK_ELSE, CMD_NAME},
{TK_WORD, COMPOUND_LIST, CMD_NAME},
{TK_WORD, CASE_LIST_NS, CMD_NAME},
{TK_WORD, COMPLETE_CONDITION, CMD_NAME},
{TK_WORD, NEWLINE_LIST, CMD_NAME},
{TK_WORD, TK_BANG, CMD_NAME},
{TK_WORD, PIPE_SEMI_SEQUENCE, CMD_NAME},
{TK_WORD, SEPARATOR_OP, CMD_NAME},
{TK_WORD, IN, WORDLIST},
{TK_WORD, TK_PAREN_OPEN, CMD_NAME},
{TK_WORD, TK_LBRACE, CMD_NAME},
{TK_WORD, CASE_LIST, PATTERN},
{TK_WORD, TK_PAREN_OPEN, PATTERN},
{TK_WORD, PATTERN_CASE, PATTERN},
{TK_WORD, COMPLETE_COMMANDS, CMD_NAME},
{TK_ASSIGNEMENT_WORD, LINEBREAK, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_PAREN_OPEN, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_LBRACE, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, TK_BANG, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, SEPARATOR_OP, CMD_PREFIX},
{TK_ASSIGNEMENT_WORD, NEWLINE_LIST, CMD_PREFIX},
{TK_NAME, LINEBREAK, FNAME},
{TK_NAME, TK_PAREN_OPEN, FNAME},
{TK_NAME, TK_LBRACE, FNAME},
{TK_NAME, TK_BANG, FNAME},
{TK_NAME, SEPARATOR_OP, FNAME},
{TK_NAME, NEWLINE_LIST, FNAME},
{TK_NAME, TK_FOR, NAME},
{TK_NEWLINE, CASE_LIST_NS, NEWLINE_LIST},
{TK_NEWLINE, TK_DO, NEWLINE_LIST},
{TK_NEWLINE, TK_PAREN_CLOSE, NEWLINE_LIST},
{TK_NEWLINE, TK_IN, NEWLINE_LIST},
{TK_NEWLINE, TK_WHILE, NEWLINE_LIST},
{TK_NEWLINE, TK_UNTIL, NEWLINE_LIST},
{TK_NEWLINE, TK_IF, NEWLINE_LIST},
@ -66,11 +77,17 @@ t_prodmatch g_prodmatch[] =
{TK_NEWLINE, CMD_NAME, NEWLINE_LIST},
{TK_NEWLINE, COMPLETE_COMMANDS, NEWLINE_LIST},
{TK_NEWLINE, LINEBREAK, NEWLINE_LIST},
{TK_NEWLINE, TK_PAREN_OPEN, NEWLINE_LIST},
{TK_NEWLINE, TK_LBRACE, NEWLINE_LIST},
{TK_NEWLINE, CMD_SUPERIOR, LINEBREAK},
{TK_NEWLINE, PIPE_SEMI_SEQUENCE, LINEBREAK},
{TK_NEWLINE, CASE_LIST_NS, NEWLINE_LIST},
{TK_NEWLINE, COMPOUND_LIST, NEWLINE_LIST},
{TK_NEWLINE, COMPLETE_CONDITION, NEWLINE_LIST},
{TK_NEWLINE, CONDITION, NEWLINE_LIST},
{TK_NEWLINE, FOR_WORDLIST, NEWLINE_LIST},
{TK_NEWLINE, SEQUENTIAL_SEP, NEWLINE_LIST},
{TK_SEMI, CMD_SUPERIOR, SEPARATOR_OP},
{TK_SEMI, CMD_SUPERIOR, SEPARATOR_OP},
{TK_SEMI, TERM, SEPARATOR_OP},
{TK_SEMI, LIST, SEPARATOR_OP},
@ -88,8 +105,8 @@ int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst)
int i;
token = (*lst)->content;
// DG("produce stack : %s && token : %s", read_state(stack),
// read_state(token->type));
DG("produce stack : %s && token : %s", read_state(stack),
read_state(token->type));
i = 0;
*new_sym = 0;
while (g_prodmatch[i].new_sym)
@ -97,7 +114,7 @@ int produce_sym(t_sym stack, t_sym *new_sym, t_list **lst)
if (token->type == g_prodmatch[i].token
&& stack == g_prodmatch[i].stack)
{
// DG("MATCH : %s", read_state(g_prodmatch[i].new_sym));
DG("MATCH : %s", read_state(g_prodmatch[i].new_sym));
*new_sym = g_prodmatch[i].new_sym;
}
i++;

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

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/09 15:32:10 by ariard #+# #+# */
/* Updated: 2017/02/20 22:38:48 by jhalford ### ########.fr */
/* Updated: 2017/02/25 00:15:00 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,6 +14,46 @@
char *read_state(t_sym current)
{
if (current == BRACE_CLAUSE)
return ("BRACE_CLAUSE");
if (current == FUNC_NAME)
return ("FUNC_NAME");
if (current == TK_LBRACE)
return ("TK_LBRACE");
if (current == TK_RBRACE)
return ("TK_RBRACE");
if (current == TK_ASSIGNEMENT_WORD)
return ("TK_ASSIGNEMENT_WORD");
if (current == CASE_CLAUSE)
return ("CASE_CLAUSE");
if (current == CASE_LIST_NS)
return ("CASE_LIST_NS");
if (current == TK_DSEMI)
return ("TK_DSEMI");
if (current == TK_PAREN_OPEN)
return ("TK_PAREN_OPEN");
if (current == TK_PAREN_CLOSE)
return ("TK_PAREN_CLOSE");
if (current == FOR_WORDLIST)
return ("FOR_WORDLIST");
if (current == FOR_CLAUSE)
return ("FOR_CLAUSE");
if (current == TK_NAME)
return ("TK_NAME");
if (current == TK_FOR)
return ("FOR");
if (current == NAME)
return ("NAME");
if (current == 0)
return ("NULL");
if (current == PATTERN)
return ("PATTERN");
if (current == TK_CASE)
return ("TK_CASE");
if (current == TK_IN)
return ("TK_IN");
if (current == TK_ESAC)
return ("TK_ESAC");
if (current == UNTIL_CLAUSE)
return ("UNTIL_CLAUSE");
if (current == TK_UNTIL)
@ -161,10 +201,8 @@ char *read_state(t_sym current)
int ft_read_stack(t_sym *stack)
{
DG("read stack :");
while (*stack)
{
ft_putstr(read_state(*stack--));
ft_putchar(10);
}
DG("%s", read_state(*stack--));
return (0);
}

5
42sh/src/parser/tree_wrapper.c
View file

@ -6,7 +6,7 @@
/* By: ariard <ariard@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2017/02/15 18:57:44 by ariard #+# #+# */
/* Updated: 2017/02/19 16:34:17 by ariard ### ########.fr */
/* Updated: 2017/02/25 19:10:34 by ariard ### ########.fr */
/* */
/* ************************************************************************** */
@ -31,6 +31,9 @@ int gen_node(t_btree **ast)
((t_astnode *)(*ast)->item)->nest = 0;
((t_astnode *)(*ast)->item)->full = 0;
((t_astnode *)(*ast)->item)->type = 0;
((t_astnode *)(*ast)->item)->pattern = 0;
}
return (0);
}