raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Started work on AST printing (as shell acceptable stuff)

Browse source
This commit is contained in:
Maix0 2024-07-03 22:07:06 +02:00
parent 4a0a5fbb8d
commit d2a59f770e
4 changed files with 416 additions and 14 deletions
Download patch file Download diff file Expand all files Collapse all files

1
ast/src.list
View file

@ -1,3 +1,4 @@
empty empty
from_node from_node
not_done_function not_done_function
print_ast

26
ast/src/from_node.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/17 12:41:56 by maiboyer #+# #+# */ /* Created: 2024/06/17 12:41:56 by maiboyer #+# #+# */
/* Updated: 2024/07/03 18:47:44 by maiboyer ### ########.fr */ /* Updated: 2024/07/03 21:57:05 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -386,7 +386,7 @@ void ast_set_term(t_ast_node *node, t_ast_terminator_kind term)
t_ast_node val; t_ast_node val;
if (node == NULL) if (node == NULL)
return; return ((void)printf("node == NULL\n"));
val = *node; val = *node;
ptr = &void_storage; ptr = &void_storage;
if (val->kind == AST_CASE) if (val->kind == AST_CASE)
@ -399,8 +399,12 @@ void ast_set_term(t_ast_node *node, t_ast_terminator_kind term)
ptr = &val->data.compound_statement.term; ptr = &val->data.compound_statement.term;
if (val->kind == AST_IF) if (val->kind == AST_IF)
ptr = &val->data.if_.term; ptr = &val->data.if_.term;
if (val->kind == AST_SUBSHELL)
ptr = &val->data.subshell.term;
*ptr = term; *ptr = term;
if (ptr == &void_storage)
printf("node wasn't a term capable node\n");
(void)(void_storage); (void)(void_storage);
} }
@ -677,10 +681,9 @@ t_error build_sym_expansion(t_parse_node self, t_const_str input, t_ast_node *ou
continue; continue;
if (ts_node_field_id_for_child(self, i) == field_len) if (ts_node_field_id_for_child(self, i) == field_len)
ret->data.expansion.len_operator = true; ret->data.expansion.len_operator = true;
if (ts_node_field_id_for_child(self, i) == field_var) if (ts_node_field_id_for_child(self, i) == field_name)
ret->data.expansion.var_name = _extract_str(ts_node_child(self, i), input); ret->data.expansion.var_name = _extract_str(ts_node_child(self, i), input);
if (ts_node_field_id_for_child(self, i) == field_op) if (ts_node_field_id_for_child(self, i) == field_op)
ret->data.expansion.kind = _extract_exp_op(ts_node_child(self, i)); ret->data.expansion.kind = _extract_exp_op(ts_node_child(self, i));
if (ts_node_field_id_for_child(self, i) == field_args) if (ts_node_field_id_for_child(self, i) == field_args)
{ {
@ -1517,20 +1520,19 @@ t_error build_sym_program(t_parse_node self, t_const_str input, t_ast_node *out)
while (i < ts_node_child_count(self)) while (i < ts_node_child_count(self))
{ {
temp = NULL; temp = NULL;
if (i < ts_node_child_count(self) && ts_node_field_id_for_child(self, i) == field_stmt) if (ts_node_field_id_for_child(self, i) == field_stmt)
{ {
if (ast_from_node(ts_node_child(self, i), input, &temp)) if (ast_from_node(ts_node_child(self, i), input, &temp))
return (ast_free(ret), ERROR); return (ast_free(ret), ERROR);
i++; vec_ast_push(&ret->data.program.body, temp);
} }
if (i < ts_node_child_count(self) && ts_node_field_id_for_child(self, i) == field_term) if (ts_node_field_id_for_child(self, i) == field_term)
{ {
printf("%s\n", (ts_node_grammar_type(ts_node_child(self, i)))); if (ret->data.program.body.len == 0 && (i++, true))
i++; continue;
ast_set_term(&ret->data.program.body.buffer[ret->data.program.body.len - 1], _select_term(ts_node_child(self, i)));
} }
if (temp == NULL) i++;
break;
vec_ast_push(&ret->data.program.body, temp);
} }
return (*out = ret, NO_ERROR); return (*out = ret, NO_ERROR);
} }

398
ast/src/print_ast.c Normal file
View file

@ -0,0 +1,398 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* print_ast.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/03 20:38:29 by maiboyer #+# #+# */
/* Updated: 2024/07/03 22:06:15 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "ast/ast.h"
#include "me/types.h"
#include <stdio.h>
void ast_print_node(t_ast_node self);
#define NOT_DONE \
{ \
printf("function `%s` isn't done !\n", __func__); \
(void)(self); \
}
/*
t_ast_arithmetic_expansion arithmetic_expansion;
t_ast_case case_;
t_ast_case_item case_item;
t_ast_command command;
t_ast_command_substitution command_substitution;
t_ast_compound_statement compound_statement;
t_ast_elif elif;
t_ast_else else_;
t_ast_empty empty;
t_ast_expansion expansion;
t_ast_extglob extglob;
t_ast_file_redirection file_redirection;
t_ast_for for_;
t_ast_function_definition function_definition;
t_ast_heredoc_redirection heredoc_redirection;
t_ast_if if_;
t_ast_list list;
t_ast_pipeline pipeline;
t_ast_program program;
t_ast_raw_string raw_string;
t_ast_regex regex;
t_ast_string string;
t_ast_subshell subshell;
t_ast_until until;
t_ast_variable_assignment variable_assignment;
t_ast_while while_;
t_ast_word word;
*/
void ast_print_node_command(t_ast_node self);
void ast_print_node_compound_statement(t_ast_node self);
void ast_print_node_expansion(t_ast_node self);
void ast_print_node_program(t_ast_node self);
void ast_print_node_raw_string(t_ast_node self);
void ast_print_node_regex(t_ast_node self);
void ast_print_node_subshell(t_ast_node self);
void ast_print_node_word(t_ast_node self);
void ast_print_node_command_substitution(t_ast_node self);
void ast_print_node_file_redirection(t_ast_node self);
/*^^^ DONE ^^^*/
/*vvv NOT DONE vvv*/
void ast_print_node_arithmetic_expansion(t_ast_node self) NOT_DONE;
void ast_print_node_case(t_ast_node self) NOT_DONE;
void ast_print_node_case_item(t_ast_node self) NOT_DONE;
void ast_print_node_elif(t_ast_node self) NOT_DONE;
void ast_print_node_else(t_ast_node self) NOT_DONE;
void ast_print_node_extglob(t_ast_node self) NOT_DONE;
void ast_print_node_for(t_ast_node self) NOT_DONE;
void ast_print_node_function_definition(t_ast_node self) NOT_DONE;
void ast_print_node_heredoc_redirection(t_ast_node self) NOT_DONE;
void ast_print_node_if(t_ast_node self) NOT_DONE;
void ast_print_node_list(t_ast_node self) NOT_DONE;
void ast_print_node_pipeline(t_ast_node self) NOT_DONE;
void ast_print_node_string(t_ast_node self) NOT_DONE;
void ast_print_node_until(t_ast_node self) NOT_DONE;
void ast_print_node_variable_assignment(t_ast_node self) NOT_DONE;
void ast_print_node_while(t_ast_node self) NOT_DONE;
/// HELPER_FUNCS
void _print_term(t_ast_terminator_kind term)
{
if (term == AST_TERM_NONE)
return;
if (term == AST_TERM_FORK)
printf("&");
if (term == AST_TERM_SEMI)
printf(";");
if (term == AST_TERM_DOUBLE_SEMI)
printf(";;");
if (term == AST_TERM_NEWLINE)
printf("\n");
}
/// IMPL
void ast_print_node_file_redirection(t_ast_node self)
{
if (self == NULL)
return;
if (self->kind != AST_FILE_REDIRECTION)
return;
ast_print_node(self->data.file_redirection.input);
if (self->data.file_redirection.op == AST_REDIR_INPUT)
printf("<");
if (self->data.file_redirection.op == AST_REDIR_OUTPUT)
printf(">");
if (self->data.file_redirection.op == AST_REDIR_INPUT_OUTPUT)
printf("<>");
if (self->data.file_redirection.op == AST_REDIR_APPEND)
printf(">>");
if (self->data.file_redirection.op == AST_REDIR_DUP_INPUT)
printf("<&");
if (self->data.file_redirection.op == AST_REDIR_DUP_OUTPUT)
printf(">&");
if (self->data.file_redirection.op == AST_REDIR_OUTPUT_CLOBBER)
printf(">|");
// if (self->data.file_redirection.op == AST_REDIR_HEREDOC)
// printf("<<");
// if (self->data.file_redirection.op == AST_REDIR_HEREDOC_INDENT)
// printf("<<-");
ast_print_node(self->data.file_redirection.output);
}
void ast_print_node_expansion(t_ast_node self)
{
t_usize i;
if (self == NULL)
return;
if (self->kind != AST_EXPANSION)
return;
printf("${");
if (self->data.expansion.len_operator)
printf("#");
printf("%s", self->data.expansion.var_name);
if (self->data.expansion.kind == E_OP_NONE)
(void)(false);
if (self->data.expansion.kind == E_OP_ERROR)
printf("?");
if (self->data.expansion.kind == E_OP_DEFAULT)
printf("-");
if (self->data.expansion.kind == E_OP_ALTERNATE)
printf("+");
if (self->data.expansion.kind == E_OP_ASSIGN_DEFAULT)
printf("=");
if (self->data.expansion.kind == E_OP_ERROR_COLON)
printf(":?");
if (self->data.expansion.kind == E_OP_DEFAULT_COLON)
printf(":-");
if (self->data.expansion.kind == E_OP_ALTERNATE_COLON)
printf(":+");
if (self->data.expansion.kind == E_OP_ASSIGN_DEFAULT_COLON)
printf(":=");
i = 0;
while (i < self->data.expansion.args.len)
ast_print_node(self->data.expansion.args.buffer[i++]);
printf("}");
}
void ast_print_node_command_substitution(t_ast_node self)
{
t_usize i;
if (self == NULL)
return;
if (self->kind != AST_COMMAND_SUBSTITUTION)
return;
printf("$(");
i = 0;
while (i < self->data.command_substitution.body.len)
{
ast_print_node(self->data.command_substitution.body.buffer[i++]);
}
printf(")");
}
void ast_print_node_command(t_ast_node self)
{
t_usize i;
if (self == NULL)
return;
if (self->kind != AST_COMMAND)
return;
if (self->data.command.bang)
printf("! ");
i = 0;
while (i < self->data.command.prefixes.len)
{
ast_print_node(self->data.command.prefixes.buffer[i++]);
printf(" ");
}
i = 0;
while (i < self->data.command.cmd_word.len)
{
ast_print_node(self->data.command.cmd_word.buffer[i++]);
printf(" ");
}
i = 0;
while (i < self->data.command.suffixes_redirections.len)
{
ast_print_node(self->data.command.suffixes_redirections.buffer[i++]);
printf(" ");
}
_print_term(self->data.command.term);
}
void ast_print_node_empty(t_ast_node self)
{
if (self == NULL)
return;
if (self->kind != AST_EMPTY)
return;
}
void ast_print_node_compound_statement(t_ast_node self)
{
t_usize i;
if (self == NULL)
return;
if (self->kind != AST_COMPOUND_STATEMENT)
return;
i = 0;
if (self->data.compound_statement.bang)
printf("! ");
printf("{ ");
while (i < self->data.compound_statement.body.len)
{
ast_print_node(self->data.compound_statement.body.buffer[i++]);
printf(" ");
}
printf("}");
i = 0;
while (i < self->data.compound_statement.suffixes_redirections.len)
{
printf(" ");
ast_print_node(self->data.compound_statement.suffixes_redirections.buffer[i++]);
}
printf(" ");
_print_term(self->data.compound_statement.term);
}
void ast_print_node_subshell(t_ast_node self)
{
t_usize i;
if (self == NULL)
return;
if (self->kind != AST_SUBSHELL)
return;
i = 0;
if (self->data.subshell.bang)
printf("! ");
printf("( ");
while (i < self->data.subshell.body.len)
{
ast_print_node(self->data.subshell.body.buffer[i++]);
printf(" ");
}
printf(")");
i = 0;
while (i < self->data.subshell.suffixes_redirections.len)
{
printf(" ");
ast_print_node(self->data.subshell.suffixes_redirections.buffer[i++]);
}
printf(" ");
_print_term(self->data.subshell.term);
}
void ast_print_node_program(t_ast_node self)
{
t_usize i;
if (self == NULL)
return;
if (self->kind != AST_PROGRAM)
return;
i = 0;
while (i < self->data.program.body.len)
{
ast_print_node(self->data.program.body.buffer[i++]);
printf(" ");
}
}
void ast_print_node_word(t_ast_node self)
{
t_usize i;
t_str quote_type;
if (self == NULL)
return;
if (self->kind != AST_WORD)
return;
quote_type = "";
if (self->data.word.kind == AST_WORD_SINGLE_QUOTE)
quote_type = "\'";
if (self->data.word.kind == AST_WORD_DOUBLE_QUOTE)
quote_type = "\"";
i = 0;
printf("%s", quote_type);
while (i < self->data.word.inner.len)
ast_print_node(self->data.word.inner.buffer[i++]);
printf("%s", quote_type);
}
void ast_print_node_regex(t_ast_node self)
{
if (self == NULL)
return;
if (self->kind != AST_REGEX)
return;
printf("%s", self->data.regex.pattern);
}
void ast_print_node_raw_string(t_ast_node self)
{
if (self == NULL)
return;
if (self->kind != AST_RAW_STRING)
return;
printf("%s", self->data.raw_string.str);
}
void ast_print_node(t_ast_node self)
{
if (self == NULL)
return ((void)printf("ast == NULL\n"));
if (self->kind == AST_ARITHMETIC_EXPANSION)
return (ast_print_node_arithmetic_expansion(self));
if (self->kind == AST_CASE)
return (ast_print_node_case(self));
if (self->kind == AST_CASE_ITEM)
return (ast_print_node_case_item(self));
if (self->kind == AST_COMMAND)
return (ast_print_node_command(self));
if (self->kind == AST_COMMAND_SUBSTITUTION)
return (ast_print_node_command_substitution(self));
if (self->kind == AST_COMPOUND_STATEMENT)
return (ast_print_node_compound_statement(self));
if (self->kind == AST_ELIF)
return (ast_print_node_elif(self));
if (self->kind == AST_ELSE)
return (ast_print_node_else(self));
if (self->kind == AST_EMPTY)
return (ast_print_node_empty(self));
if (self->kind == AST_EXPANSION)
return (ast_print_node_expansion(self));
if (self->kind == AST_EXTGLOB)
return (ast_print_node_extglob(self));
if (self->kind == AST_FILE_REDIRECTION)
return (ast_print_node_file_redirection(self));
if (self->kind == AST_FOR)
return (ast_print_node_for(self));
if (self->kind == AST_FUNCTION_DEFINITION)
return (ast_print_node_function_definition(self));
if (self->kind == AST_HEREDOC_REDIRECTION)
return (ast_print_node_heredoc_redirection(self));
if (self->kind == AST_IF)
return (ast_print_node_if(self));
if (self->kind == AST_LIST)
return (ast_print_node_list(self));
if (self->kind == AST_PIPELINE)
return (ast_print_node_pipeline(self));
if (self->kind == AST_PROGRAM)
return (ast_print_node_program(self));
if (self->kind == AST_RAW_STRING)
return (ast_print_node_raw_string(self));
if (self->kind == AST_REGEX)
return (ast_print_node_regex(self));
if (self->kind == AST_STRING)
return (ast_print_node_string(self));
if (self->kind == AST_SUBSHELL)
return (ast_print_node_subshell(self));
if (self->kind == AST_UNTIL)
return (ast_print_node_until(self));
if (self->kind == AST_VARIABLE_ASSIGNMENT)
return (ast_print_node_variable_assignment(self));
if (self->kind == AST_WHILE)
return (ast_print_node_while(self));
if (self->kind == AST_WORD)
return (ast_print_node_word(self));
printf("Unknown ast->kind: %#04x\n", self->kind);
}

5
sources/main.c
View file

@ -6,7 +6,7 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */ /* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/28 14:40:38 by rparodi #+# #+# */ /* Created: 2024/03/28 14:40:38 by rparodi #+# #+# */
/* Updated: 2024/07/03 18:46:59 by maiboyer ### ########.fr */ /* Updated: 2024/07/03 21:23:17 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -28,6 +28,7 @@
#include "ast/ast.h" #include "ast/ast.h"
t_error ast_from_node(t_parse_node node, t_str input, t_ast_node *out); t_error ast_from_node(t_parse_node node, t_str input, t_ast_node *out);
void ast_print_node(t_ast_node self);
// Foutre envp dans env // Foutre envp dans env
// Chaque elemenet d'envp split au premier = // Chaque elemenet d'envp split au premier =
@ -103,7 +104,7 @@ t_node parse_to_nodes(t_first_parser *parser, t_const_str input)
if (ast_from_node(node, (t_str)input, &out)) if (ast_from_node(node, (t_str)input, &out))
printf("Error when building node\n"); printf("Error when building node\n");
else else
ast_free(out); (ast_print_node(out), printf("\n"), ast_free(out));
ret = build_node(node, input); ret = build_node(node, input);
ts_tree_delete(tree); ts_tree_delete(tree);
return (ret); return (ret);