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 token_append(t_token *token, char c);
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);
int ft_is_delim(char c);
void qstate_update(t_data *data, char c);
t_lexer lexer_default;
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);
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_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);
void ft_expand_dollar(char **av, char **env);
char *ft_findexec(char **path, char *file);
char *ft_putast(void *node);
void ft_putast2(void *node);
#endif

25
42sh/includes/parser.h
View file

@ -23,17 +23,18 @@ typedef struct s_redir t_redir;
struct s_parser
{
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
{
int n;
int close;
union u_word
{
char *word;
int fd;
} word;
} u_word;
};
struct s_astnode
@ -48,16 +49,14 @@ struct s_astnode
extern t_parser g_parser[];
int ft_parse(t_btree **ast, t_list *token);
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_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);
void tree_type(t_btree *tree);
int ft_parse(t_btree **ast, t_list **token);
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_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);
#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)
{
t_lexstate state;
t_token *token;
state = DEFAULT;
if (*str == '>')
state = GREAT;
return (ft_tokenize(alst, str, GREAT));
else if (*str == '<')
state = LESS;
return (ft_tokenize(alst, str, LESS));
else if (ft_isdigit(*str))
state = NUMBER;
else
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));
}

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

@ -5,20 +5,22 @@ int lexer_great(t_list **alst, char *str)
t_token *token;
token = (*alst)->content;
if (*str == '&')
token_append(token, str[0]);
if (*(str + 1) == '&')
{
token_append(token, *str);
return (lexer_greatand(alst, str + 1));
token->type = TK_GREATAND;
token_append(token, str[1]);
return (lexer_greatand(alst, str + 2));
}
else if (*str == '>')
else if (*(str + 1) == '>')
{
token->type = TK_DGREAT;
token_append(token, *str);
return (ft_tokenize(&(*alst)->next, str + 1, DEFAULT));
token_append(token, str[1]);
return (ft_tokenize(&(*alst)->next, str + 2, DEFAULT));
}
else
{
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;
token = (*alst)->content;
if (*str == '&')
token_append(token, str[0]);
if (*(str + 1) == '&')
{
token_append(token, *str);
return (lexer_lessand(alst, str + 1));
token->type = TK_LESSAND;
token_append(token, str[1]);
return (lexer_lessand(alst, str + 2));
}
else if (*str == '<')
else if (*(str + 1) == '<')
{
token->type = TK_DLESS;
token_append(token, *str);
return (ft_tokenize(&(*alst)->next, str + 1, DEFAULT));
token_append(token, str[1]);
return (ft_tokenize(&(*alst)->next, str + 2, DEFAULT));
}
else
{
token->type = TK_LESS;
token_append(token, *str);
return (ft_tokenize(alst, str + 1, DEFAULT));
return (ft_tokenize(&(*alst)->next, 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;
if (*str == '>')
{
token_append(token, *str);
return (lexer_great(alst, str + 1));
}
return (ft_tokenize(alst, str, GREAT));
else if (*str == '<')
{
token_append(token, *str);
return (lexer_less(alst, str + 1));
}
return (ft_tokenize(alst, str, LESS));
else if (ft_isdigit(*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();
*alst = ft_lstnew(token, sizeof(*token));
}
token->type = *str == ';' ? TK_SEMI : TK_PIPE;
token_append(token, *str);
token = (*alst)->content;
token->type = (*str == ';') ? TK_SEMI : TK_PIPE;
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"
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;
ft_printf("%i", item->type);
node = nodein;
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_btree *ast;
ast = NULL;
if (data_init(&data))
return (1);
if (signal(SIGINT, sig_handler) == SIG_ERR)
@ -27,15 +26,17 @@ int main(void)
{
if (ft_interactive_sh(&data))
return (1);
ft_printf("got command:'%s'\n", data.input);
ft_printf("command='%s'\n", data.input);
if (ft_tokenize(&token, data.input, DEFAULT))
return (1);
token_print(token);
if (ft_parse(&ast, token))
ast = NULL;
if (ft_parse(&ast, &token))
return (1);
btree_print(ast, &tree_type);
ft_printf("root: %i\n", ((t_astnode*)ast->item)->type);
ft_lstdel(&token, &token_free);
btree_print(ast, &ft_putast);
ft_printf("\n--- INFIX BREAKDOWN ---\n");
btree_apply_infix(ast, &ft_putast2);
/* ft_lstdel(&token, &token_free); */
token = NULL;
/* if (ft_exec(ast)) */
/* return (1); */

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

@ -26,24 +26,28 @@ t_parser g_parser[] =
{0, 0},
};
int ft_parse(t_btree **ast, t_list *start)
int ft_parse(t_btree **ast, t_list **start)
{
t_list *lst;
t_astnode item;
int i;
i = 0;
if(!start)
if(!*start)
return (0);
if (!*ast)
{
*ast = btree_create_node(&item, sizeof(item));
((t_astnode *)(*ast)->item)->u_data.sstr = NULL;
}
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;
if (g_parser[i].f)
(*g_parser[i].f)(ast, start, lst);
(*g_parser[i].f)(ast, start, &lst);
return (0);
}
else

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

@ -12,25 +12,25 @@
#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 *next_tok;
item = (*ast)->item;
item->type = TK_LESS;
if (!lst->next)
node = (*ast)->item;
node->type = TK_DGREAT;
if (!(*lst)->next)
return (1);
tok = lst->content;
next_tok = lst->next->content;
tok = (*lst)->content;
next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD)
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_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);
}

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

@ -12,24 +12,27 @@
#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 *next_tok;
item = (*ast)->item;
item->type = TK_LESS;
if (!lst->next)
node = (*ast)->item;
node->type = TK_DGREAT;
if (!(*lst)->next)
return (1);
tok = lst->content;
next_tok = lst->next->content;
tok = (*lst)->content;
next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD)
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_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);
}

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

@ -1,7 +1,7 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parse_less.c :+: :+: :+: */
/* parse_great.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: jhalford <marvin@42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
@ -12,27 +12,25 @@
#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 *next_tok;
char *end;
item = (*ast)->item;
item->type = TK_LESS;
if (!lst->next)
node = (*ast)->item;
node->type = TK_GREAT;
if (!(*lst)->next)
return (1);
tok = lst->content;
next_tok = lst->next->content;
tok = (*lst)->content;
next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD)
return (1);
end = ft_strchr(tok->data, '>');
*end = '\0';
item->u_data.redir.n = ft_atoi(tok->data);
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->next->content, &ft_addrcmp, &token_free);
node->u_data.redir.u_word.word = ft_strdup(next_tok->data);
node->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);
ft_lst_delif(start, (*lst)->content, &ft_addrcmp, &token_free);
ft_lst_delif(start, (*lst)->next->content, &ft_addrcmp, &token_free);
ft_parse(&(*ast)->left, start);
return (0);
}

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

@ -12,24 +12,26 @@
#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 *next_tok;
item = (*ast)->item;
item->type = TK_LESS;
if (!lst->next)
node = (*ast)->item;
node->type = TK_GREATAND;
if (!(*lst)->next)
return (1);
tok = lst->content;
next_tok = lst->next->content;
tok = (*lst)->content;
next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD)
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_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);
}

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

@ -12,27 +12,25 @@
#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 *next_tok;
char *end;
item = (*ast)->item;
item->type = TK_LESS;
if (!lst->next)
node = (*ast)->item;
node->type = TK_LESS;
if (!(*lst)->next)
return (1);
tok = lst->content;
next_tok = lst->next->content;
tok = (*lst)->content;
next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD)
return (1);
end = ft_strchr(tok->data, '<');
*end = '\0';
item->u_data.redir.n = ft_atoi(tok->data);
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->next->content, &ft_addrcmp, &token_free);
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);
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> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
@ -13,24 +13,26 @@
#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 *next_tok;
item = (*ast)->item;
item->type = TK_LESS;
if (!lst->next)
node = (*ast)->item;
node->type = TK_DGREAT;
if (!(*lst)->next)
return (1);
tok = lst->content;
next_tok = lst->next->content;
tok = (*lst)->content;
next_tok = (*lst)->next->content;
if (next_tok->type != TK_WORD)
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_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);
}

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

@ -1,9 +1,15 @@
#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);
ft_lst_delif(&start, lst->content, &ft_addrcmp, &token_free);
t_token *token;
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);
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> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
@ -12,17 +12,21 @@
#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_token *tok;
t_astnode *node;
t_token *token;
(void)start;
item = (*ast)->item;
tok = lst->content;
item->type = TK_COMMAND;
item->u_data.sstr = ft_sstradd(item->u_data.sstr, tok->data);
ft_parse(ast, lst->next);
ft_lstdelone(&lst, &token_free);
token = (*lst)->content;
node = (*ast)->item;
node->type = TK_COMMAND;
ft_printf("adding '%s' to sstr\n", token->data);
node->u_data.sstr = ft_sstradd(node->u_data.sstr, token->data);
/* 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);
}