&& ||

42sh/Makefile

@@ -168,19 +168,7 @@ main/shell_get_opts.c\
 main/shell_init.c\
 main/shell_script.c\
 main/sig_handler.c\
-parser/parse.c\
-parser/ft_parse.c\
 parser/old_parse.c\
-parser/produce_sym.c\
-parser/eval_sym.c\
-parser/aggregate_sym.c\
-parser/pop_stack.c\
-parser/push_stack.c\
-parser/error_syntax.c\
-parser/build_tree.c\
-parser/tree_wrapper.c\
-parser/add_sep.c\
-parser/add_cmd.c\
 parser/get_instruction.c\
 parser/get_sub_instruction.c\
 parser/parse_dgreat.c\
@@ -198,7 +186,19 @@ parser/parse_if.c\
 parser/parse_elif.c\
 parser/parse_else.c\
 parser/parse_word.c\
-parser/read_stack.c
+parser/read_stack.c\
+parser/parse.c\
+parser/ft_parse.c\
+parser/produce_sym.c\
+parser/eval_sym.c\
+parser/aggregate_sym.c\
+parser/pop_stack.c\
+parser/push_stack.c\
+parser/error_syntax.c\
+parser/build_tree.c\
+parser/tree_wrapper.c\
+parser/add_sep.c\
+parser/add_cmd.c
 
 SRCS		=	$(addprefix $(SRC_DIR), $(SRC_BASE))
 OBJS		=	$(addprefix $(OBJ_DIR), $(SRC_BASE:.c=.o))

42sh/file1

@@ -0,0 +1,14 @@
+Makefile
+blind.text
+debug
+file1
+grammar
+includes
+libft
+pdf
+sample
+script.sh
+src
+test.sh
+tofix
+update_makefile.sh

42sh/includes/lexer.h

@@ -36,8 +36,8 @@ typedef long long		t_type;
  *
 */
 
-/*
 
+/*
 # define TK_LESS		(1 << 0)	//transparent
 # define TK_GREAT		(1 << 1)	//transparent
 # define TK_DLESS		(1 << 2)
@@ -67,10 +67,8 @@ typedef long long		t_type;
 # define TK_ELIF		(1 << 26)
 # define TK_ELSE		(1 << 27)
 # define TK_UNTIL		(1 << 28)
-
 */
 
-# define TK_COMMAND			(1 << 10)
 # define TK_WORD			(TK_N_WORD | TK_Q_WORD | TK_DQ_WORD)
 # define TK_REDIR			(0x1 | 0x2 | 0x4 | 0x8 | 0x10 | 0x20)
 # define TK_NON_FREEABLE	(TK_PAREN_OPEN | TK_PAREN_CLOSE | TK_BQUOTE)

42sh/includes/parser.h

@@ -20,9 +20,11 @@
  *
 */
 
+
 enum	e_sym
 {
 	LINEBREAK = 1,
+	TK_COMMAND,
 	TK_LESS,
 	TK_GREAT,
 	TK_DLESS,
@@ -116,6 +118,8 @@ enum	e_sym
 	PIPE_SEMI_SEQUENCE,
 	PATTERN_CASE,
 	CMD_SUPERIOR,
+	AND_OR_MAJOR,
+	AND_OR_MINOR,
 	ALL = 200,
 };
 
@@ -215,7 +219,7 @@ typedef long long		t_type;
 
 struct	s_parser
 {
-	t_type	type;
+	t_type		type;
 	int		(*f)(t_btree **ast,
 			t_list **start, t_list **token);
 };

42sh/sample/stack.sh

@@ -1 +1,3 @@
-ls 
+cat && ls || ls | cat && ls | cat || ls
+
+

42sh/src/exec/ft_exec.c

@@ -28,7 +28,8 @@ t_execmap	g_execmap[] =
 	{TK_ELIF, &exec_elif},
 	{TK_ELSE, &exec_else},
 	{TK_UNTIL, &exec_until},
-	{TK_COMMAND | TK_SUBSHELL, &exec_command},
+	{TK_COMMAND, &exec_command},
+	{TK_SUBSHELL, &exec_command},
 	{0, 0},
 };
 
@@ -43,9 +44,10 @@ int		ft_exec(t_btree **ast)
 	item = (*ast)->item;
 	while (g_execmap[i].type)
 	{
-		if (item->type & g_execmap[i].type)
+		if (item->type == g_execmap[i].type)
-
 		{
+			DG("match : %s and %s", 
+			read_state(item->type), read_state(g_execmap[i].type));
 			/* return ((*g_execmap[i].f)(ast)); */
 			(*g_execmap[i].f)(ast);
 		}

42sh/src/main/ft_putast.c

@@ -22,6 +22,8 @@ char	*ft_putast(void *nodein)
 	node = nodein;
 	if (node->type == TK_AMP)
 		return ("  &  ");
+	else if (node->type == TK_N_WORD)
+		return (" TK_N_WORD");
 	else if (node->type == TK_SEMI)
 		return ("  ;  ");
 	else if (node->type == TK_AND_IF)

42sh/src/main/shell_script.c

@@ -23,23 +23,21 @@ int		shell_script()
 	ast = NULL;
 	list_ast = NULL;
 	script = &data_singleton()->script;
-//	while (script->size)
+	while (script->size)
-//	{
+	{
 		if (ft_lexer(&token, &data_singleton()->script.buffer) || !token)
 			return (1);
 		DG("after post_tokenize");
 		token_print(token);
-//		if (ft_parse2(&ast, &token))
+		if (ft_parse2(&ast, &token))
-//			return (1);
-		if (ft_parse(&ast, &token))
 			return (1);
 		btree_print(STDBUG, ast, &ft_putast);
-		if (ft_exec(&ast))
+//		if (ft_exec(&ast))
-			return (1);
+//			return (1);
 		ast = NULL;
 		script->size = 0;
 		get_script_content(script);	
-//	}
+	}
 	close(script->fd);
 	return (0);
 }

42sh/src/parser/add_cmd.c

@@ -25,7 +25,7 @@ int			add_cmd(t_btree **ast, t_list **lst)
 	my_tab = NULL;
 	token = (*lst)->content;
 	node = (*ast)->item;
-	node->type = TK_COMMAND;
+	node->type = token->type;
 	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);

42sh/src/parser/aggregate_sym.c

@@ -28,6 +28,8 @@ t_aggrematch		g_aggrematch[] =
 	{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_AND_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
+	{TK_OR_IF, CMD_SUPERIOR, AND_OR_MINOR, CMD_SUPERIOR},
 //watch this
 	{SEPARATOR, COMPOUND_LIST, COMPOUND_LIST, 0},
 	{LINEBREAK, SEPARATOR_OP, SEPARATOR, SEPARATOR_OP},
@@ -94,6 +96,7 @@ t_aggrematch		g_aggrematch[] =
 	{CMD_NAME, NEWLINE_LIST, 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, SEQUENTIAL_SEP, FOR_CLAUSE, TK_FOR},
@@ -120,18 +123,25 @@ t_aggrematch		g_aggrematch[] =
 	{COMPOUND_LIST, TK_THEN, ELSE_PART, TK_ELIF},
 	{SUBSHELL, 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, AND_OR_MAJOR, AND_OR_MAJOR, 0},
 	{COMMAND, PIPE_SEMI_SEQUENCE, PIPE_SEQUENCE, PIPE_SEMI_SEQUENCE},		
 	{COMMAND, TK_BANG, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, SEPARATOR_OP, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, NEWLINE_LIST, PIPE_SEMI_SEQUENCE, 0},
 	{COMMAND, LINEBREAK, PIPE_SEMI_SEQUENCE, 0},
+	{COMMAND, AND_OR_MAJOR, PIPE_SEMI_SEQUENCE, 0},
 	{PIPE_SEQUENCE, TK_BANG, PIPELINE, TK_BANG},
 	{PIPE_SEQUENCE, SEPARATOR_OP, PIPELINE, 0},
 	{PIPE_SEQUENCE, NEWLINE_LIST, PIPELINE, 0},
 	{PIPE_SEQUENCE, LINEBREAK, PIPELINE, 0},
+	{PIPE_SEQUENCE, AND_OR_MAJOR, PIPELINE, 0},
 	{PIPELINE, LINEBREAK, AND_OR, 0},
 //	{PIPELINE, LINEBREAK, AND_OR, AND_OR},
 	{PIPELINE, SEPARATOR_OP, 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, SEPARATOR_OP, LIST, LIST},
 	{AND_OR, NEWLINE_LIST, LIST, 0},
 	{AND_OR, LINEBREAK, LIST, 0},
@@ -149,20 +159,20 @@ int			aggregate_sym(t_sym **stack, t_sym *new_sym, t_parstate *state)
 	int		i;
 
 	i = 0;
-//	DG("aggregate head %s && sym %s",
+	DG("aggregate head %s && sym %s",
-//	read_state(**stack), read_state(*new_sym));
+	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));

42sh/src/parser/build_tree.c

@@ -16,6 +16,11 @@ t_treematch			g_treematch[] =
 {
 	{TK_N_WORD, &add_cmd},
 	{TK_PIPE, &add_sep},
+	{TK_SEMI, &add_sep},
+	{TK_GREAT, &add_sep},
+	{TK_LESS, &add_sep},
+	{TK_OR_IF, &add_sep},
+	{TK_AND_IF, &add_sep},
 	{0, NULL},
 };
 
@@ -28,10 +33,13 @@ int		build_tree(t_btree **ast, t_list **lst)
 	token = (*lst)->content;
 	while (g_treematch[i].type)
 	{
-		DG("func TK : '%s' TK : '%s'",
-		read_state(g_treematch[i].type) ,read_state(token->type));
 		if (g_treematch[i].type == token->type)
+		{
+		
+			DG("func TK : '%s' TK : '%s'",
+			read_state(g_treematch[i].type) ,read_state(token->type));
 		   return (g_treematch[i].add(ast, lst));
+		}
 		i++;
 	}
 	return (0);

42sh/src/parser/eval_sym.c

@@ -31,7 +31,11 @@ t_stackmatch	g_stackmatch[] =
 	{TK_IO_NUMBER, NEWLINE_LIST},
 	{TK_IO_NUMBER, PIPE_SEMI_SEQUENCE},
 	{TK_IO_NUMBER, CMD_SUPERIOR},
+	{TK_IO_NUMBER, AND_OR_MAJOR},
 	{TK_AND_IF, AND_OR},
+	{TK_AND_IF, CMD_SUPERIOR},
+	{TK_OR_IF, AND_OR},
+	{TK_OR_IF, CMD_SUPERIOR},
 	{TK_OR_IF, AND_OR},
 	{TK_DSEMI, LINEBREAK},
 	{TK_DSEMI, COMPOUND_LIST},
@@ -47,6 +51,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LESS, NEWLINE_LIST},
 	{TK_LESS, PIPE_SEMI_SEQUENCE},
 	{TK_LESS, CMD_SUPERIOR},
+	{TK_LESS, AND_OR_MAJOR},
 	{TK_GREAT, TK_IO_NUMBER},
 	{TK_GREAT, REDIRECT_LIST},
 	{TK_GREAT, CMD_SUFFIX},
@@ -60,6 +65,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_GREAT, PIPE_SEMI_SEQUENCE},
 //duplicate and extend
 	{TK_GREAT, CMD_SUPERIOR},
+	{TK_GREAT, AND_OR_MAJOR},
 
 	{TK_DLESS, TK_IO_NUMBER},
 	{TK_DLESS, REDIRECT_LIST},
@@ -73,6 +79,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DLESS, NEWLINE_LIST},
 	{TK_DLESS, PIPE_SEMI_SEQUENCE},
 	{TK_DLESS, CMD_SUPERIOR},
+	{TK_DLESS, AND_OR_MAJOR},
 
 	{TK_DLESSDASH, TK_IO_NUMBER},
 	{TK_DLESSDASH, REDIRECT_LIST},
@@ -86,6 +93,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DLESSDASH, NEWLINE_LIST},
 	{TK_DLESSDASH, PIPE_SEMI_SEQUENCE},
 	{TK_DLESSDASH, CMD_SUPERIOR},
+	{TK_DLESSDASH, AND_OR_MAJOR},
 
 	{TK_DGREAT, TK_IO_NUMBER},
 	{TK_DGREAT, REDIRECT_LIST},
@@ -99,6 +107,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_DGREAT, NEWLINE_LIST},
 	{TK_DGREAT, PIPE_SEMI_SEQUENCE},
 	{TK_DGREAT, CMD_SUPERIOR},
+	{TK_DGREAT, AND_OR_MAJOR},
 
 	{TK_LESSAND, TK_IO_NUMBER},
 	{TK_LESSAND, REDIRECT_LIST},
@@ -112,6 +121,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LESSAND, NEWLINE_LIST},
 	{TK_LESSAND, PIPE_SEMI_SEQUENCE},
 	{TK_LESSAND, CMD_SUPERIOR},
+	{TK_LESSAND, AND_OR_MAJOR},
 
 	{TK_GREATAND, TK_IO_NUMBER},
 	{TK_GREATAND, REDIRECT_LIST},
@@ -125,6 +135,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_GREATAND, NEWLINE_LIST},
 	{TK_GREATAND, PIPE_SEMI_SEQUENCE},
 	{TK_GREATAND, CMD_SUPERIOR},
+	{TK_GREATAND, AND_OR_MAJOR},
 
 	{TK_LESSGREAT, TK_IO_NUMBER},
 	{TK_LESSGREAT, REDIRECT_LIST},
@@ -138,6 +149,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_LESSGREAT, NEWLINE_LIST},
 	{TK_LESSGREAT, PIPE_SEMI_SEQUENCE},
 	{TK_LESSGREAT, CMD_SUPERIOR},
+	{TK_LESSGREAT, AND_OR_MAJOR},
 
 	{TK_CLOBBER, TK_IO_NUMBER},
 	{TK_CLOBBER, REDIRECT_LIST},
@@ -151,6 +163,7 @@ t_stackmatch	g_stackmatch[] =
 	{TK_CLOBBER, NEWLINE_LIST},
 	{TK_CLOBBER, PIPE_SEMI_SEQUENCE},
 	{TK_CLOBBER, CMD_SUPERIOR},
+	{TK_CLOBBER, AND_OR_MAJOR},
 
 	{TK_IF, LINEBREAK},
 	{TK_IF, TK_BANG},
@@ -305,6 +318,7 @@ t_stackmatch	g_stackmatch[] =
 	{CMD_NAME, SEPARATOR_OP},
 	{CMD_NAME, NEWLINE_LIST},
 	{CMD_NAME, PIPE_SEMI_SEQUENCE},
+	{CMD_NAME, AND_OR_MAJOR},
 	
 	{CMD_SUPERIOR, LINEBREAK,},
 	{CMD_SUPERIOR, TK_BANG},
@@ -312,12 +326,14 @@ t_stackmatch	g_stackmatch[] =
 	{CMD_SUPERIOR, NEWLINE_LIST},
 	{CMD_SUPERIOR, TK_PIPE},
 	{CMD_SUPERIOR, PIPE_SEMI_SEQUENCE},
+	{CMD_SUPERIOR, AND_OR_MAJOR},
 	
 	{SIMPLE_COMMAND, LINEBREAK},
 	{SIMPLE_COMMAND, TK_BANG},
 	{SIMPLE_COMMAND, SEPARATOR_OP},
 	{SIMPLE_COMMAND, NEWLINE_LIST},
 	{SIMPLE_COMMAND, PIPE_SEMI_SEQUENCE},
+	{SIMPLE_COMMAND, AND_OR_MAJOR},
 	{DO_GROUP, COMPOUND_LIST},
 	{DO_GROUP, NAME},
 	{DO_GROUP, SEQUENTIAL_SEP},
@@ -401,17 +417,26 @@ t_stackmatch	g_stackmatch[] =
 	{COMMAND, SEPARATOR_OP},
 	{COMMAND, NEWLINE_LIST},
 	{COMMAND, PIPE_SEMI_SEQUENCE},
+	{COMMAND, AND_OR_MAJOR},
+	{AND_OR_MINOR, PIPE_SEMI_SEQUENCE},
+	{AND_OR_MINOR, LINEBREAK},
+	{AND_OR_MINOR, AND_OR_MAJOR},
 	{PIPE_SEQUENCE, LINEBREAK},
 	{PIPE_SEQUENCE, TK_BANG},
 	{PIPE_SEQUENCE, SEPARATOR_OP},
 	{PIPE_SEQUENCE, NEWLINE_LIST},
+	{PIPE_SEQUENCE, AND_OR_MAJOR},
 	{PIPE_SEMI_SEQUENCE, LINEBREAK},
 	{PIPE_SEMI_SEQUENCE, TK_BANG},
 	{PIPE_SEMI_SEQUENCE, SEPARATOR_OP},
 	{PIPE_SEMI_SEQUENCE, NEWLINE_LIST},
+	{PIPE_SEMI_SEQUENCE, AND_OR_MAJOR},
 	{PIPELINE, LINEBREAK},
 	{PIPELINE, SEPARATOR_OP},
 	{PIPELINE, NEWLINE_LIST},
+	{PIPELINE, AND_OR_MAJOR},
+	{AND_OR_MAJOR, LINEBREAK},
+	{AND_OR_MAJOR, AND_OR_MAJOR},
 	{AND_OR, LINEBREAK},
 	{AND_OR, SEPARATOR_OP},
 	{AND_OR, NEWLINE_LIST},
@@ -427,7 +452,7 @@ int			eval_sym(t_sym stack, t_sym new_sym)
 {
 	int				i;
 
-//	DG("eval head %s && sym %s", read_state(stack), read_state(new_sym));
+	DG("eval head %s && sym %s", read_state(stack), read_state(new_sym));
 	i = 0;
 	while (g_stackmatch[i].top)
 	{

42sh/src/parser/ft_parse.c

@@ -27,7 +27,7 @@ int			ft_parse2(t_btree **ast, t_list **token)
 	while (*token)
 	{
 		produce_sym(*stack, new_sym, token);	
-//		DG("new sym %s", read_state(*new_sym));
+		DG("new sym %s", read_state(*new_sym));
 		if (eval_sym(*stack, *new_sym))
 			state = ERROR;
 		else

42sh/src/parser/old_parse.c

@@ -48,7 +48,6 @@ int		ft_parse(t_btree **ast, t_list **start)
 	{
 		if ((lst = ft_lst_find(*start, &g_parser[i].type, &token_cmp_type)))
 		{
-			DG("match : %s", read_state(g_parser[i].type));
 			if (g_parser[i].f)
 				(*g_parser[i].f)(ast, start, &lst);
 			return (0);

42sh/src/parser/produce_sym.c

@@ -27,6 +27,8 @@ t_prodmatch		g_prodmatch[] =
 	{TK_N_WORD, CMD_NAME, CMD_SUFFIX},
 	{TK_N_WORD, LINEBREAK, CMD_NAME},
 	{TK_N_WORD, TK_PIPE, CMD_NAME},
+	{TK_N_WORD, AND_OR, CMD_NAME},
+	{TK_N_WORD, AND_OR_MAJOR, CMD_NAME},
 
 	{TK_N_WORD, NEWLINE_LIST, CMD_NAME},
 	{TK_N_WORD, TK_BANG, CMD_NAME},
@@ -64,8 +66,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),
+	DG("produce stack : %s && token : %s", read_state(stack),
-//	read_state(token->type));
+	read_state(token->type));
 	i = 0;
 	*new_sym = 0;
 	while (g_prodmatch[i].new_sym)

42sh/src/parser/read_stack.c

@@ -14,8 +14,36 @@
 
 char			*read_state(t_sym current)
 {
+	if (current == AND_OR_MINOR)
+		return("AND_OR_MINOR");
+	if (current == AND_OR_MAJOR)
+		return ("AND_OR_MAJOR");	
+	if (current == TK_COMMAND)
+		return ("TK_COMMAND");
+	if (current == TK_AND_IF)
+		return ("TK_AND_IF");
+	if (current == TK_OR_IF)
+		return ("TK_OR_IF");
+	if (current == TK_AMP)
+		return ("TK_AMP");
+	if (current == TK_PIPE)
+		return ("TK_PIPE");
+	if (current == TK_LESS)
+		return ("TK_LESS");
+	if (current == TK_GREAT)
+		return ("TK_GREAT");
 	if (current == TK_DLESS)
 		return ("TK_DLESS");
+	if (current == TK_DGREAT)
+		return ("TK_DGREAT");
+	if (current == TK_DGREAT)
+		return ("TK_DGREAT");
+	if (current == TK_LESSAND)
+		return ("TK_LESSAND");
+	if (current == TK_GREATAND)
+		return ("TK_GREATAND");
+	if (current == TK_SUBSHELL)
+		return ("TK_SUBSEHLL");
 	if (current == CMD_SUPERIOR)
 		return ("CMD_SUPERIOR");
 	if (current == TK_IO_NUMBER)