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

nice tree printing, starting to look good

Browse source
This commit is contained in:
Jack Halford 2016-11-20 23:32:39 +01:00
parent bce0f37b8e
commit 2f2e7c03b1
23 changed files with 246 additions and 150 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
42sh/includes/lexer.h
View file

@ -64,10 +64,11 @@ t_token *token_init();
int ft_tokenize(t_list **alst, char *str, t_lexstate state); int ft_tokenize(t_list **alst, char *str, t_lexstate state);
int token_append(t_token *token, char c); int token_append(t_token *token, char c);
void token_free(void *data, size_t size); void token_free(void *data, size_t size);
int token_cmp_type(t_type data, t_type ref); int token_cmp_type(t_token *token, t_type *ref);
void token_print(t_list *lst); void token_print(t_list *lst);
int ft_is_delim(char c); int ft_is_delim(char c);
void qstate_update(t_data *data, char c);
t_lexer lexer_default; t_lexer lexer_default;
t_lexer lexer_delim; t_lexer lexer_delim;

5
42sh/includes/minishell.h
View file

@ -53,7 +53,6 @@ extern pid_t g_pid;
void sig_handler(int signo); void sig_handler(int signo);
int data_init(t_data *data); int data_init(t_data *data);
void qstate_update(t_data *data, char c);
int ft_cmd_process(char **argv, char ***env_p); int ft_cmd_process(char **argv, char ***env_p);
int ft_cmd_exec(char *execpath, char **argv, char ***env_p); int ft_cmd_exec(char *execpath, char **argv, char ***env_p);
@ -68,7 +67,9 @@ int builtin_unsetenv(char **av, char ***env);
int builtin_env(char **av, char ***env); int builtin_env(char **av, char ***env);
void ft_expand_dollar(char **av, char **env); void ft_expand_dollar(char **av, char **env);
char *ft_findexec(char **path, char *file); char *ft_findexec(char **path, char *file);
char *ft_putast(void *node);
void ft_putast2(void *node);
#endif #endif

25
42sh/includes/parser.h
View file

@ -23,17 +23,18 @@ typedef struct s_redir t_redir;
struct s_parser struct s_parser
{ {
t_type type; t_type type;
int (*f)(t_btree **ast, t_list *start, t_list *token); int (*f)(t_btree **ast, t_list **start, t_list **token);
}; };
struct s_redir struct s_redir
{ {
int n; int n;
int close;
union u_word union u_word
{ {
char *word; char *word;
int fd; int fd;
} word; } u_word;
}; };
struct s_astnode struct s_astnode
@ -48,16 +49,14 @@ struct s_astnode
extern t_parser g_parser[]; extern t_parser g_parser[];
int ft_parse(t_btree **ast, t_list *token); int ft_parse(t_btree **ast, t_list **token);
int parse_separator(t_btree **ast, t_list *start, t_list *lst); int parse_separator(t_btree **ast, t_list **start, t_list **lst);
int parse_less(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_great(t_btree **ast, t_list **start, t_list **lst);
int parse_dless(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_dgreat(t_btree **ast, t_list **start, t_list **lst);
int parse_lessand(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_greatand(t_btree **ast, t_list **start, t_list **lst);
int parse_word(t_btree **ast, t_list *start, t_list *lst); int parse_word(t_btree **ast, t_list **start, t_list **lst);
void tree_type(t_btree *tree);
#endif #endif

2
42sh/libft

@ -1 +1 @@
Subproject commit 3741ee4abd2986790543bb1877371570da39a435 Subproject commit a9043dc03b7b46d4644785b77bc38736481deedc

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

@ -3,16 +3,19 @@
int lexer_default(t_list **alst, char *str) int lexer_default(t_list **alst, char *str)
{ {
t_lexstate state; t_lexstate state;
t_token *token;
state = DEFAULT; state = DEFAULT;
if (*str == '>') if (*str == '>')
state = GREAT; return (ft_tokenize(alst, str, GREAT));
else if (*str == '<') else if (*str == '<')
state = LESS; return (ft_tokenize(alst, str, LESS));
else if (ft_isdigit(*str)) else if (ft_isdigit(*str))
state = NUMBER; state = NUMBER;
else else
state = WORD; state = WORD;
token_append((*alst)->content ,*str); token = (*alst)->content;
token_append(token, *str);
token->type = TK_WORD;
return (ft_tokenize(alst, str + 1, state)); return (ft_tokenize(alst, str + 1, state));
} }

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

@ -5,20 +5,22 @@ int lexer_great(t_list **alst, char *str)
t_token *token; t_token *token;
token = (*alst)->content; token = (*alst)->content;
if (*str == '&') token_append(token, str[0]);
if (*(str + 1) == '&')
{ {
token_append(token, *str); token->type = TK_GREATAND;
return (lexer_greatand(alst, str + 1)); token_append(token, str[1]);
return (lexer_greatand(alst, str + 2));
} }
else if (*str == '>') else if (*(str + 1) == '>')
{ {
token->type = TK_DGREAT; token->type = TK_DGREAT;
token_append(token, *str); token_append(token, str[1]);
return (ft_tokenize(&(*alst)->next, str + 1, DEFAULT)); return (ft_tokenize(&(*alst)->next, str + 2, DEFAULT));
} }
else else
{ {
token->type = TK_GREAT; token->type = TK_GREAT;
return (ft_tokenize(&(*alst)->next, str, DEFAULT)); return (ft_tokenize(&(*alst)->next, str + 1, DEFAULT));
} }
} }

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

@ -5,21 +5,22 @@ int lexer_less(t_list **alst, char *str)
t_token *token; t_token *token;
token = (*alst)->content; token = (*alst)->content;
if (*str == '&') token_append(token, str[0]);
if (*(str + 1) == '&')
{ {
token_append(token, *str); token->type = TK_LESSAND;
return (lexer_lessand(alst, str + 1)); token_append(token, str[1]);
return (lexer_lessand(alst, str + 2));
} }
else if (*str == '<') else if (*(str + 1) == '<')
{ {
token->type = TK_DLESS; token->type = TK_DLESS;
token_append(token, *str); token_append(token, str[1]);
return (ft_tokenize(&(*alst)->next, str + 1, DEFAULT)); return (ft_tokenize(&(*alst)->next, str + 2, DEFAULT));
} }
else else
{ {
token->type = TK_LESS; token->type = TK_LESS;
token_append(token, *str); return (ft_tokenize(&(*alst)->next, str + 1, DEFAULT));
return (ft_tokenize(alst, str + 1, DEFAULT));
} }
} }

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

@ -6,15 +6,9 @@ int lexer_number(t_list **alst, char *str)
token = (*alst)->content; token = (*alst)->content;
if (*str == '>') if (*str == '>')
{ return (ft_tokenize(alst, str, GREAT));
token_append(token, *str);
return (lexer_great(alst, str + 1));
}
else if (*str == '<') else if (*str == '<')
{ return (ft_tokenize(alst, str, LESS));
token_append(token, *str);
return (lexer_less(alst, str + 1));
}
else if (ft_isdigit(*str)) else if (ft_isdigit(*str))
{ {
token_append(token, *str); token_append(token, *str);

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

@ -15,7 +15,7 @@ int lexer_sep(t_list **alst, char *str)
token = token_init(); token = token_init();
*alst = ft_lstnew(token, sizeof(*token)); *alst = ft_lstnew(token, sizeof(*token));
} }
token->type = *str == ';' ? TK_SEMI : TK_PIPE; token = (*alst)->content;
token_append(token, *str); token->type = (*str == ';') ? TK_SEMI : TK_PIPE;
return (ft_tokenize(&(*alst)->next, str + 1, DEFAULT)); return (ft_tokenize(&(*alst)->next, str + 1, DEFAULT));
} }

0
42sh/src/main/qstate_update.c → 42sh/src/lexer/qstate_update.c
View file

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

@ -1,6 +1,6 @@
#include "lexer.h" #include "lexer.h"
int token_cmp_type(t_type data, t_type ref) int token_cmp_type(t_token *token, t_type *ref)
{ {
return (data != ref); return (token->type - *ref);
} }

35
42sh/src/parser/tree_type.c → 42sh/src/main/ft_putast.c
View file

@ -10,12 +10,37 @@
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "parser.h" #include "minishell.h"
void tree_type(t_btree *tree) char *ft_putast(void *nodein)
{ {
t_astnode *item; t_astnode *node;
item = tree->item; node = nodein;
ft_printf("%i", item->type); if (node->type == TK_SEMI)
return (" ; ");
else if (node->type == TK_PIPE)
return (" | ");
else if (node->type == TK_COMMAND)
{
/*char **sstr = node->u_data.sstr; */
/* while (*sstr) */
/* ft_printf("%s,", *sstr++); */
/* return (ft_itoa_base(node->type, "0123456789abcdef", "")); */
return (" COM ");
}
else if (node->type == TK_GREAT)
return (" > ");
else if (node->type == TK_LESS)
return (" < ");
else if (node->type == TK_DGREAT)
return (" >> ");
else if (node->type == TK_DLESS)
return (" << ");
else if (node->type == TK_GREATAND)
return (" >& ");
else if (node->type == TK_LESSAND)
return (" <& ");
else
return ("OTHER");
} }

52
42sh/src/main/ft_putast2.c Normal file
View file

@ -0,0 +1,52 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* tree_type.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2016/11/14 18:18:04 by jhalford #+# #+# */
/* Updated: 2016/11/14 18:21:50 by jhalford ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
void ft_putast2(void *nodein)
{
t_astnode *node;
node = nodein;
if (node->type == TK_SEMI)
ft_putendl(";");
else if (node->type == TK_PIPE)
ft_putendl("|");
else if (node->type == TK_COMMAND)
{
ft_putstr("COMMAND: ");
ft_putstr(node->u_data.sstr[0]);
/* ft_sstrprint(node->u_data.sstr, ','); */
/* char **sstr = node->u_data.sstr; */
/* while (*sstr) */
/* ft_printf("%s,", *sstr++); */
ft_putchar('\n');
}
if (node->type | TK_REDIR)
{
ft_putnbr(node->u_data.redir.n);
if (node->type == TK_GREAT)
ft_putendl(">:");
else if (node->type == TK_LESS)
ft_putendl("<:");
else if (node->type == TK_DGREAT)
ft_putendl(">>:");
else if (node->type == TK_DLESS)
ft_putendl("<<:");
else if (node->type == TK_GREATAND)
ft_putendl(">&:");
else if (node->type == TK_LESSAND)
ft_putendl("<&:");
}
else
ft_putendl("OTHER");
}

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

@ -18,7 +18,6 @@ int main(void)
t_list *token; t_list *token;
t_btree *ast; t_btree *ast;
ast = NULL;
if (data_init(&data)) if (data_init(&data))
return (1); return (1);
if (signal(SIGINT, sig_handler) == SIG_ERR) if (signal(SIGINT, sig_handler) == SIG_ERR)
@ -27,15 +26,17 @@ int main(void)
{ {
if (ft_interactive_sh(&data)) if (ft_interactive_sh(&data))
return (1); return (1);
ft_printf("got command:'%s'\n", data.input); ft_printf("command='%s'\n", data.input);
if (ft_tokenize(&token, data.input, DEFAULT)) if (ft_tokenize(&token, data.input, DEFAULT))
return (1); return (1);
token_print(token); token_print(token);
if (ft_parse(&ast, token)) ast = NULL;
if (ft_parse(&ast, &token))
return (1); return (1);
btree_print(ast, &tree_type); btree_print(ast, &ft_putast);
ft_printf("root: %i\n", ((t_astnode*)ast->item)->type); ft_printf("\n--- INFIX BREAKDOWN ---\n");
ft_lstdel(&token, &token_free); btree_apply_infix(ast, &ft_putast2);
/* ft_lstdel(&token, &token_free); */
token = NULL; token = NULL;
/* if (ft_exec(ast)) */ /* if (ft_exec(ast)) */
/* return (1); */ /* return (1); */

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

@ -26,24 +26,28 @@ t_parser g_parser[] =
{0, 0}, {0, 0},
}; };
int ft_parse(t_btree **ast, t_list *start) int ft_parse(t_btree **ast, t_list **start)
{ {
t_list *lst; t_list *lst;
t_astnode item; t_astnode item;
int i; int i;
i = 0; i = 0;
if(!start) if(!*start)
return (0); return (0);
if (!*ast) if (!*ast)
{
*ast = btree_create_node(&item, sizeof(item)); *ast = btree_create_node(&item, sizeof(item));
((t_astnode *)(*ast)->item)->u_data.sstr = NULL;
}
while (g_parser[i].type) while (g_parser[i].type)
{ {
if ((lst = ft_lst_find(start, &g_parser[i].type, &token_cmp_type))) if ((lst = ft_lst_find(*start, &g_parser[i].type, &token_cmp_type)))
{ {
/* ft_printf("found token:%#06llx\n", g_parser[i].type); */
item.type = g_parser[i].type; item.type = g_parser[i].type;
if (g_parser[i].f) if (g_parser[i].f)
(*g_parser[i].f)(ast, start, lst); (*g_parser[i].f)(ast, start, &lst);
return (0); return (0);
} }
else else

24
42sh/src/parser/parse_dgreat.c
View file

@ -12,25 +12,25 @@
#include "parser.h" #include "parser.h"
int parse_dgreat(t_btree **ast, t_list *start, t_list *lst) int parse_dgreat(t_btree **ast, t_list **start, t_list **lst)
{ {
t_astnode *item; t_astnode *node;
t_token *tok; t_token *tok;
t_token *next_tok; t_token *next_tok;
item = (*ast)->item; node = (*ast)->item;
item->type = TK_LESS; node->type = TK_DGREAT;
if (!lst->next) if (!(*lst)->next)
return (1); return (1);
tok = lst->content; tok = (*lst)->content;
next_tok = lst->next->content; next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD) if (next_tok->type != TK_WORD)
return (1); return (1);
item->u_data.redir.u_word.word = ft_strdup(next_tok->data); node->u_data.redir.u_word.word = ft_strdup(next_tok->data);
ft_lst_delif(start, (*lst)->content, &ft_addrcmp, &token_free);
ft_lst_delif(start, (*lst)->next->content, &ft_addrcmp, &token_free);
/* ft_lstdelone(lst, &token_free); */
/* ft_lstdelone(&(*lst)->next, &token_free); */
ft_parse(&(*ast)->left, start); ft_parse(&(*ast)->left, start);
ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free);
ft_lst_delif(&start, lst->next->content, &ft_addrcmp, &token_free);
ft_parse(&(*ast)->right, lst->next);
return (0); return (0);
} }

25
42sh/src/parser/parse_dless.c
View file

@ -12,24 +12,27 @@
#include "parser.h" #include "parser.h"
int parse_dless(t_btree **ast, t_list *start, t_list *lst) int parse_dless(t_btree **ast, t_list **start, t_list **lst)
{ {
t_astnode *item; t_astnode *node;
t_token *tok; t_token *tok;
t_token *next_tok; t_token *next_tok;
item = (*ast)->item; node = (*ast)->item;
item->type = TK_LESS; node->type = TK_DGREAT;
if (!lst->next) if (!(*lst)->next)
return (1); return (1);
tok = lst->content; tok = (*lst)->content;
next_tok = lst->next->content; next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD) if (next_tok->type != TK_WORD)
return (1); return (1);
item->u_data.redir.u_word.word = ft_strdup(next_tok->data); node->u_data.redir.u_word.word = ft_strdup(next_tok->data);
/* ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free); */
/* ft_lst_delif(&start, lst->next->content, &ft_addrcmp, &token_free); */
/* ft_parse(&(*ast)->right, (*lst)->next->next); */
ft_lstdelone(lst, &token_free);
ft_lstdelone(&(*lst)->next, &token_free);
ft_parse(&(*ast)->left, start); ft_parse(&(*ast)->left, start);
ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free);
ft_lst_delif(&start, lst->next->content, &ft_addrcmp, &token_free);
ft_parse(&(*ast)->right, lst->next);
return (0); return (0);
} }

28
42sh/src/parser/parse_great.c
View file

@ -1,7 +1,7 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* parse_less.c :+: :+: :+: */ /* parse_great.c :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */ /* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
@ -12,27 +12,25 @@
#include "parser.h" #include "parser.h"
int parse_great(t_btree **ast, t_list *start, t_list *lst) int parse_great(t_btree **ast, t_list **start, t_list **lst)
{ {
t_astnode *item; t_astnode *node;
t_token *tok; t_token *tok;
t_token *next_tok; t_token *next_tok;
char *end;
item = (*ast)->item; node = (*ast)->item;
item->type = TK_LESS; node->type = TK_GREAT;
if (!lst->next) if (!(*lst)->next)
return (1); return (1);
tok = lst->content; tok = (*lst)->content;
next_tok = lst->next->content; next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD) if (next_tok->type != TK_WORD)
return (1); return (1);
end = ft_strchr(tok->data, '>'); node->u_data.redir.u_word.word = ft_strdup(next_tok->data);
*end = '\0'; node->u_data.redir.n = ft_atoi(tok->data);
item->u_data.redir.n = ft_atoi(tok->data); ft_printf("stored redir n=%i, word=%s\n", node->u_data.redir.n, node->u_data.redir.u_word.word);
item->u_data.redir.u_word.word = ft_strdup(next_tok->data); ft_lst_delif(start, (*lst)->content, &ft_addrcmp, &token_free);
ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free); ft_lst_delif(start, (*lst)->next->content, &ft_addrcmp, &token_free);
ft_lst_delif(&start, lst->next->content, &ft_addrcmp, &token_free);
ft_parse(&(*ast)->left, start); ft_parse(&(*ast)->left, start);
return (0); return (0);
} }

24
42sh/src/parser/parse_greatand.c
View file

@ -12,24 +12,26 @@
#include "parser.h" #include "parser.h"
int parse_greatand(t_btree **ast, t_list *start, t_list *lst) int parse_greatand(t_btree **ast, t_list **start, t_list **lst)
{ {
t_astnode *item; t_astnode *node;
t_token *tok; t_token *tok;
t_token *next_tok; t_token *next_tok;
item = (*ast)->item; node = (*ast)->item;
item->type = TK_LESS; node->type = TK_GREATAND;
if (!lst->next) if (!(*lst)->next)
return (1); return (1);
tok = lst->content; tok = (*lst)->content;
next_tok = lst->next->content; next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD) if (next_tok->type != TK_WORD)
return (1); return (1);
item->u_data.redir.u_word.word = ft_strdup(next_tok->data); node->u_data.redir.u_word.word = ft_strdup(next_tok->data);
/* ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free); */
/* ft_lst_delif(&start, lst->next->content, &ft_addrcmp, &token_free); */
/* ft_parse(&(*ast)->right, (*lst)->next->next); */
ft_lstdelone(lst, &token_free);
ft_lstdelone(&(*lst)->next, &token_free);
ft_parse(&(*ast)->left, start); ft_parse(&(*ast)->left, start);
ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free);
ft_lst_delif(&start, lst->next->content, &ft_addrcmp, &token_free);
ft_parse(&(*ast)->right, lst->next);
return (0); return (0);
} }

26
42sh/src/parser/parse_less.c
View file

@ -12,27 +12,25 @@
#include "parser.h" #include "parser.h"
int parse_less(t_btree **ast, t_list *start, t_list *lst) int parse_less(t_btree **ast, t_list **start, t_list **lst)
{ {
t_astnode *item; t_astnode *node;
t_token *tok; t_token *tok;
t_token *next_tok; t_token *next_tok;
char *end;
item = (*ast)->item; node = (*ast)->item;
item->type = TK_LESS; node->type = TK_LESS;
if (!lst->next) if (!(*lst)->next)
return (1); return (1);
tok = lst->content; tok = (*lst)->content;
next_tok = lst->next->content; next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD) if (next_tok->type != TK_WORD)
return (1); return (1);
end = ft_strchr(tok->data, '<'); node->u_data.redir.u_word.word = ft_strdup(next_tok->data);
*end = '\0'; ft_lst_delif(start, (*lst)->content, &ft_addrcmp, &token_free);
item->u_data.redir.n = ft_atoi(tok->data); ft_lst_delif(start, (*lst)->next->content, &ft_addrcmp, &token_free);
item->u_data.redir.u_word.word = ft_strdup(next_tok->data); /* ft_lstdelone(lst, &token_free); */
ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free); /* ft_lstdelone(&(*lst)->next, &token_free); */
ft_lst_delif(&start, lst->next->content, &ft_addrcmp, &token_free);
ft_parse(&(*ast)->left, start); ft_parse(&(*ast)->left, start);
return (0); return (0);
} }

26
42sh/src/parser/parse_lessand.c
View file

@ -2,7 +2,7 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* parse_less.c :+: :+: :+: */ /* parse_lessand.c :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */ /* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
@ -13,24 +13,26 @@
#include "parser.h" #include "parser.h"
int parse_lessand(t_btree **ast, t_list *start, t_list *lst) int parse_lessand(t_btree **ast, t_list **start, t_list **lst)
{ {
t_astnode *item; t_astnode *node;
t_token *tok; t_token *tok;
t_token *next_tok; t_token *next_tok;
item = (*ast)->item; node = (*ast)->item;
item->type = TK_LESS; node->type = TK_DGREAT;
if (!lst->next) if (!(*lst)->next)
return (1); return (1);
tok = lst->content; tok = (*lst)->content;
next_tok = lst->next->content; next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD) if (next_tok->type != TK_WORD)
return (1); return (1);
item->u_data.redir.u_word.word = ft_strdup(next_tok->data); node->u_data.redir.u_word.word = ft_strdup(next_tok->data);
/* ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free); */
/* ft_lst_delif(&start, lst->next->content, &ft_addrcmp, &token_free); */
/* ft_parse(&(*ast)->right, (*lst)->next->next); */
ft_lstdelone(lst, &token_free);
ft_lstdelone(&(*lst)->next, &token_free);
ft_parse(&(*ast)->left, start); ft_parse(&(*ast)->left, start);
ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free);
ft_lst_delif(&start, lst->next->content, &ft_addrcmp, &token_free);
ft_parse(&(*ast)->right, lst->next);
return (0); return (0);
} }

12
42sh/src/parser/parse_separator.c
View file

@ -1,9 +1,15 @@
#include "parser.h" #include "parser.h"
int parse_separator(t_btree **ast, t_list *start, t_list *lst) int parse_separator(t_btree **ast, t_list **start, t_list **lst)
{ {
ft_parse(&(*ast)->right, lst->next); t_token *token;
ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free); t_astnode *node;
token = (*lst)->content;
node = (*ast)->item;
ft_parse(&(*ast)->right, &(*lst)->next);
node->type = token->type;
ft_lstdelone(lst, &token_free);
ft_parse(&(*ast)->left, start); ft_parse(&(*ast)->left, start);
return (0); return (0);
} }

24
42sh/src/parser/parse_word.c
View file

@ -1,7 +1,7 @@
/* ************************************************************************** */ /* ************************************************************************** */
/* */ /* */
/* ::: :::::::: */ /* ::: :::::::: */
/* parse_less.c :+: :+: :+: */ /* parse_word.c :+: :+: :+: */
/* +:+ +:+ +:+ */ /* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */ /* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
@ -12,17 +12,21 @@
#include "parser.h" #include "parser.h"
int parse_word(t_btree **ast, t_list *start, t_list *lst) int parse_word(t_btree **ast, t_list **start, t_list **lst)
{ {
t_astnode *item; t_astnode *node;
t_token *tok; t_token *token;
(void)start; (void)start;
item = (*ast)->item; token = (*lst)->content;
tok = lst->content; node = (*ast)->item;
item->type = TK_COMMAND; node->type = TK_COMMAND;
item->u_data.sstr = ft_sstradd(item->u_data.sstr, tok->data); ft_printf("adding '%s' to sstr\n", token->data);
ft_parse(ast, lst->next); node->u_data.sstr = ft_sstradd(node->u_data.sstr, token->data);
ft_lstdelone(&lst, &token_free); /* ft_printf("added '%s'\n", node->u_data.sstr[0]); */
ft_sstrprint(node->u_data.sstr, ',');
ft_putchar('\n');
ft_parse(ast, &(*lst)->next);
ft_lstdelone(lst, &token_free);
return (0); return (0);
} }