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

Update: Work on AST

Browse source
This commit is contained in:
Maix0 2024-06-09 22:27:00 +02:00
parent 8f00b8fd9b
commit 5759396eb2
9 changed files with 79 additions and 1297 deletions
Download patch file Download diff file Expand all files Collapse all files

570
ast/include/ast/ast.h
View file

@ -1,570 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ast.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/25 19:30:30 by maiboyer #+# #+# */
/* Updated: 2024/05/28 14:49:05 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef AST_H
#define AST_H
#include "ast/forward.h"
#include "me/types.h"
/// @brief Node types enumeration
/// @details This enumeration is used to identify the type of a node
enum e_ast_type
{
TY_EMPTY = 0,
TY_AND_LIST,
TY_AND_OR_LIST,
TY_ARITHMETIC_EXPANSION,
TY_ASSIGNMENT,
TY_ASSIGNMENT_LIST,
TY_AST_STRING,
TY_ASYNC_COMMAND,
TY_BRACE_COMMAND,
TY_CASE_COMMAND,
TY_CASE_ITEM,
TY_COMMAND,
TY_COMMAND_BACKTICKS,
TY_COMMAND_SUBSTITUTION,
TY_COMPOUND_LIST,
TY_DOUBLE_QUOTE_STRING,
TY_ELIF_CLAUSE,
TY_ELSE_CLAUSE,
TY_FOR_COMMAND,
TY_FUNCTION_DEFINITION,
TY_IF_CLAUSE,
TY_IF_COMMAND,
TY_NAME,
TY_NOT,
TY_OR_LIST,
TY_PARAMETER_EXPANSION,
TY_PIPE_LIST,
TY_PROGRAM,
TY_REDIRECT_FILE,
TY_REDIRECT_HEREDOC,
TY_SEQUENTIAL_LIST,
TY_SIMPLE_COMMAND,
TY_SUBSHELL_COMMAND,
TY_UNTIL_COMMAND,
TY_WHILE_COMMAND,
TY_WORD,
};
/// Can be either a t_sequential_list, t_async_command, t_and_or_list, t_not,
/// t_pipe_list or an t_command
union u_program_body {
t_ast_type *type;
t_sequential_list *sequential_list;
t_async_command *async_command;
t_and_or_list *and_or_list;
t_not *not_;
t_pipe_list *pipe_list;
t_command *command;
};
/// @brief Entry point of the AST
struct s_program
{
t_ast_type type;
t_program_body *cmds;
t_usize cmds_len;
};
/// Can be either a t_sequential_list, t_async_command, t_and_or_list, t_not,
/// t_pipe_list or an t_command
union u_compound_list_body {
t_ast_type *type;
t_sequential_list *sequential_list;
t_async_command *async_command;
t_and_or_list *and_or_list;
t_not *not_;
t_pipe_list *pipe_list;
t_command *command;
};
struct s_compound_list
{
t_ast_type type;
t_compound_list_body *cmds;
t_usize cmds_len;
};
/// Can be either a t_async_command, t_and_or_list, t_not, t_pipe_list or an
/// t_command
union u_sequential_list_body {
t_ast_type *type;
t_async_command *async_command;
t_and_or_list *and_or_list;
t_not *not_;
t_pipe_list *pipe_list;
t_command *command;
};
/// @note Commands that are separated by a semicolon ; shall be executed
/// sequentially.
/// @note Read more:
/// http://pubs.opengroup.org/onlinepubs/9699919799/utilities/V3_chap02.html#tag_02_09_03_04
/// @note Format: `command1; command2 [; command3 ] ... [;]`
struct s_sequential_list
{
t_ast_type type;
t_sequential_list_body *cmds;
t_usize cmds_len;
};
/// Can be either a t_and_or_list, t_not t_pipe_list or t_command
union u_async_command_body {
t_ast_type *type;
t_and_or_list *and_or_list;
t_not *not_;
t_pipe_list *pipe_list;
t_command *command;
};
/// @note Commands that are ended by an & shall be executed asynchronously.
struct s_async_command
{
t_ast_type type;
t_async_command_body cmd;
};
/*
Part of AND_OR list
*/
/// Can be either a t_not t_pipe_list or t_command.
/// The first element CAN be an t_or_list
union u_and_list_body {
t_ast_type *type;
t_pipe_list *pipe_list;
t_command *cmd;
t_or_list *or_list;
};
struct s_and_list
{
t_ast_type type;
t_and_list_body *cmds;
t_usize cmds_len;
};
/// Can be either a t_not t_pipe_list or t_command.
/// The first element CAN be an t_and_list
union u_or_list_body {
t_ast_type *type;
t_pipe_list *pipe_list;
t_command *cmd;
t_and_list *or_list;
};
struct s_or_list
{
t_ast_type type;
t_or_list_body *cmds;
t_usize cmds_len;
};
/// Either an ast_node of type `t_and_list` or `t_or_list`
union u_and_or_list_body {
t_ast_type *type;
t_and_list *and_list;
t_or_list *or_list;
};
struct s_and_or_list
{
t_ast_type type;
t_and_or_list_body cmds;
};
/// Can be either a t_pipe_list or a t_command
union u_not_body {
t_ast_type *type;
t_pipe_list *pipe_list;
t_command *cmd;
};
struct s_not
{
t_ast_type type;
t_not_body cmd;
};
struct s_pipe_list
{
t_ast_type type;
t_ast_node **cmds;
t_usize cmds_len;
};
union u_command_inner {
t_ast_type *type;
t_simple_command *simple_command;
t_compound_command *compound_command;
t_assignment_list *assignments_list;
t_function_definition *function_definition;
};
/// Can be either an t_simple_command, t_compound_command, t_assignments_list or
/// t_function_definition
struct s_command
{
t_ast_type type;
t_command_inner inner;
};
union u_redirect_or_assign {
t_ast_type *type;
t_redirect *redirect;
t_assignment_list *assignments;
};
union u_redirect_or_word {
t_ast_type *type;
t_redirect *redirect;
t_word *word;
};
struct s_simple_command
{
t_ast_type type;
t_redirect_or_assign *prefix;
t_usize prefix_len;
t_word *_Nullable cmd;
t_redirect_or_word *suffix;
t_usize suffix_len;
};
enum e_assignement_modifier
{
AM_NONE = 0,
AM_EXPORT,
AM_LOCAL,
AM_READONLY,
};
struct s_assignment_list
{
t_ast_type type;
t_assignment *assignments;
t_usize assignments_len;
t_assignement_modifier modifier;
};
// Compound command
// Can be either a t_brace_command, t_subshell_command, t_if_command,
// t_for_command, t_case_command, t_while_command, t_until_command
union u_compound_command {
t_ast_type *type;
t_brace_command *brace_command;
t_subshell_command *subshell_command;
t_if_command *if_command;
t_for_command *for_command;
t_case_command *case_command;
t_while_command *while_command;
t_until_command *until_command;
};
struct s_brace_command
{
t_ast_type type;
t_compound_list *body;
t_redirect *redirects;
t_usize redirects_len;
};
struct s_subshell_command
{
t_ast_type type;
t_compound_list *_Nullable body;
t_redirect *redirects;
t_usize redirects_len;
};
union u_if_clauses {
t_ast_type *type;
t_if_clause *if_clause;
t_elif_clause *elif_clause;
t_else_clause *else_clause;
};
struct s_if_command
{
t_ast_type type;
t_if_clauses *clauses;
t_usize clauses_len;
t_redirect *redirect;
t_usize redirect_len;
};
struct s_if_clause
{
t_ast_type type;
t_compound_list *condition;
t_compound_list *body;
};
struct s_elif_clause
{
t_ast_type type;
t_compound_list *condition;
t_compound_list *body;
};
struct s_else_clause
{
t_ast_type type;
t_compound_list *body;
};
struct s_for_command
{
t_ast_type type;
t_name *var;
t_word *items;
t_usize items_len;
t_compound_list *body;
t_redirect *redirects;
t_usize redirects_len;
};
struct s_case_command
{
t_ast_type type;
t_name *var;
t_case_item *cases;
t_usize cases_len;
t_redirect *redirects;
t_usize redirects_len;
};
struct s_case_item
{
t_ast_type type;
t_word *pattern;
t_usize pattern_len;
t_compound_list *body;
};
struct s_while_command
{
t_ast_type type;
t_compound_list *condition;
t_compound_list *body;
t_redirect *redirects;
t_usize redirects_len;
};
struct s_until_command
{
t_ast_type type;
t_compound_list *condition;
t_compound_list *body;
t_redirect *redirects;
t_usize redirects_len;
};
struct s_function_definition
{
t_ast_type type;
t_name *name;
t_compound_command *body;
t_redirect *redirects;
t_usize redirects_len;
};
/// Can be either a t_redirect_file or t_redirect_heredoc
union u_redirect {
t_ast_type *type;
t_redirect_file *file;
t_redirect_heredoc *heredoc;
};
enum e_redirect_file_op
{
RF_INPUT, // <
RF_OUTPUT, // >
RF_APPEND, // >>
RF_DUP_INPUT, // <&
RF_DUP_OUTPUT, // >&
RF_CLOBBER, // >|
RF_INPUT_OUPUT, // <>
};
struct s_redirect_file
{
t_ast_type type;
t_isize fd;
t_redirect_file_op op;
t_word *file;
};
enum e_redirect_heredoc_op
{
RH_HEREDOC, // <<
RH_HEREDOC_IDENT // <<-
};
struct s_redirect_heredoc
{
t_ast_type type;
t_isize fd;
t_redirect_heredoc_op op;
t_word *delimiter;
t_word *content;
};
struct s_assignment
{
t_ast_type type;
t_ast_string *name;
t_word *_Nullable value;
};
struct s_ast_string
{
t_ast_type type;
t_str value;
};
struct s_name
{
t_ast_type type;
t_ast_string *value;
};
// Can be either a t_expension or a t_ast_string
union u_expension_or_string {
t_ast_type *type;
t_expension *expension;
t_ast_string *string;
};
struct s_word
{
t_ast_type type;
t_expension_or_string *contents;
t_usize contents_len;
};
#define OP_NONE 0
enum e_op_pre
{
OP_PRE_HASH = 1, // '#'
};
enum e_op_in
{
OP_IN_COLON_MINUS = 1, // ':-'
OP_IN_MINUS, // '-'
OP_IN_COLON_EQUAL, // ':='
OP_IN_EQUAL, // '='
OP_IN_COLON_QUESTION, // ':?'
OP_IN_QUESTION, // '?'
OP_IN_COLON_PLUS, // ':+'
OP_IN_PLUS, // '+'
OP_IN_PERCENT_PERCENT, // '%%'
OP_IN_PERCENT, // '%'
OP_IN_HASH_HASH, // '##'
OP_IN_HASH, // '#'
OP_IN_COLON, // ':'
OP_IN_SLASH_SLASH, // '//'
OP_IN_SLASH, // '/'
};
/// is either a t_parameter_expansion, t_arithmetic_expansion,
/// t_command_substitution or t_command_backticks
union u_expension {
t_ast_type *type;
t_parameter_expansion *parameter_expansion;
t_arithmetic_expansion *arithmetic_expansion;
t_command_substitution *command_substitution;
t_command_backticks *command_backticks;
t_double_quote_string *double_quote_string;
};
struct s_double_quote_string
{
t_ast_type type;
t_expension_or_string *parts;
t_usize parts_len;
};
struct s_parameter_expansion
{
t_ast_type type;
t_op_in op_pre;
t_ast_string *param;
t_op_in op_in;
t_word *_Nullable word;
};
struct s_arithmetic_expansion
{
t_ast_type type;
t_ast_string *expr;
};
struct s_command_substitution
{
t_ast_type type;
t_compound_list *cmds;
t_usize cmds_len;
};
struct s_command_backticks
{
t_ast_type type;
t_ast_string *text;
};
union u_ast_node {
t_ast_type type;
t_and_list and_list;
t_and_or_list and_or_list;
t_arithmetic_expansion arithmetic_expansion;
t_assignment assignment;
t_assignment_list assignment_list;
t_ast_string ast_string;
t_async_command async_command;
t_brace_command brace_command;
t_case_command case_command;
t_case_item case_item;
t_command command;
t_command_backticks command_backticks;
t_command_substitution command_substitution;
t_compound_list compound_list;
t_double_quote_string double_quote_string;
t_elif_clause elif_clause;
t_else_clause else_clause;
t_for_command for_command;
t_function_definition function_definition;
t_if_clause if_clause;
t_if_command if_command;
t_name name;
t_not not_;
t_or_list or_list;
t_parameter_expansion parameter_expansion;
t_pipe_list pipe_list;
t_program program;
t_redirect_file redirect_file;
t_redirect_heredoc redirect_heredoc;
t_sequential_list sequential_list;
t_simple_command simple_command;
t_subshell_command subshell_command;
t_until_command until_command;
t_while_command while_command;
t_word word;
};
#endif /* AST_H */

78
ast/include/ast/forward.h
View file

@ -1,78 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* forward.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/28 13:24:34 by maiboyer #+# #+# */
/* Updated: 2024/05/28 13:51:40 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FORWARD_H
#define FORWARD_H
typedef union u_ast_node t_ast_node;
typedef enum e_assignement_modifier t_assignement_modifier;
typedef enum e_ast_type t_ast_type;
typedef enum e_op_in t_op_in;
typedef enum e_op_pre t_op_pre;
typedef enum e_redirect_file_op t_redirect_file_op;
typedef enum e_redirect_heredoc_op t_redirect_heredoc_op;
typedef struct s_and_list t_and_list;
typedef struct s_and_or_list t_and_or_list;
typedef struct s_arithmetic_expansion t_arithmetic_expansion;
typedef struct s_assignment_list t_assignment_list;
typedef struct s_assignment t_assignment;
typedef struct s_ast_string t_ast_string;
typedef struct s_async_command t_async_command;
typedef struct s_brace_command t_brace_command;
typedef struct s_case_command t_case_command;
typedef struct s_case_item t_case_item;
typedef struct s_command_backticks t_command_backticks;
typedef struct s_command_substitution t_command_substitution;
typedef struct s_command t_command;
typedef struct s_compound_list t_compound_list;
typedef struct s_double_quote_string t_double_quote_string;
typedef struct s_elif_clause t_elif_clause;
typedef struct s_else_clause t_else_clause;
typedef struct s_for_command t_for_command;
typedef struct s_function_definition t_function_definition;
typedef struct s_if_clause t_if_clause;
typedef struct s_if_command t_if_command;
typedef struct s_name t_name;
typedef struct s_not t_not;
typedef struct s_or_list t_or_list;
typedef struct s_parameter_expansion t_parameter_expansion;
typedef struct s_pipe_list t_pipe_list;
typedef struct s_program t_program;
typedef struct s_redirect_file t_redirect_file;
typedef struct s_redirect_heredoc t_redirect_heredoc;
typedef struct s_sequential_list t_sequential_list;
typedef struct s_simple_command t_simple_command;
typedef struct s_subshell_command t_subshell_command;
typedef struct s_until_command t_until_command;
typedef struct s_while_command t_while_command;
typedef struct s_word t_word;
typedef union u_and_list_body t_and_list_body;
typedef union u_and_or_list_body t_and_or_list_body;
typedef union u_async_command_body t_async_command_body;
typedef union u_command_inner t_command_inner;
typedef union u_compound_command t_compound_command;
typedef union u_compound_list_body t_compound_list_body;
typedef union u_expension_or_string t_expension_or_string;
typedef union u_expension t_expension;
typedef union u_if_clauses t_if_clauses;
typedef union u_not_body t_not_body;
typedef union u_or_list_body t_or_list_body;
typedef union u_program_body t_program_body;
typedef union u_redirect_or_assign t_redirect_or_assign;
typedef union u_redirect_or_word t_redirect_or_word;
typedef union u_redirect t_redirect;
typedef union u_sequential_list_body t_sequential_list_body;
#endif /* FORWARD_H */

204
ast/include/ast/from_node.h
View file

@ -1,204 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* from_node.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/05/28 13:14:10 by maiboyer #+# #+# */
/* Updated: 2024/05/29 00:54:00 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef FROM_PROGRAM_C
#define FROM_PROGRAM_C
#include "forward.h"
#include "me/types.h"
#include "app/node.h"
#include "ast/ast.h"
t_ast_node *from_node(t_node *node);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_and_list *build_and_list(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_and_or_list *build_and_or_list(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_arithmetic_expansion *build_arithmetic_expansion(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_assignment_list *build_assignment_list(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_assignment *build_assignment(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_ast_string *build_ast_string(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_async_command *build_async_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_brace_command *build_brace_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_case_command *build_case_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_case_item *build_case_item(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_command_backticks *build_command_backticks(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_command_substitution *build_command_substitution(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_command *build_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_compound_list *build_compound_list(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_double_quote_string *build_double_quote_string(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_for_command *build_for_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_function_definition *build_function_definition(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_if_command *build_if_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_if_clause *build_if_clause(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_elif_clause *build_elif_clause(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_else_clause *build_else_clause(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_name *build_name(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_not *build_not(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_or_list *build_or_list(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_parameter_expansion *build_parameter_expansion(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_pipe_list *build_pipe_list(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_program *build_program(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_redirect_file *build_redirect_file(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_redirect_heredoc *build_redirect_heredoc(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_sequential_list *build_sequential_list(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_simple_command *build_simple_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_subshell_command *build_subshell_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_until_command *build_until_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_while_command *build_while_command(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_word *build_word(t_node *node, t_usize size);
/// @param node a pointer to an array of `t_node` of size `size`
/// @param size the size of the nodes
/// @note can be null in case of error
t_ast_node *build_comment(t_node *node, t_usize size);
#endif /* FROM_NODE_C */

2
ast/src.list
View file

@ -1 +1 @@
from_node
empty

0
ast/src/empty.c Normal file
View file

341
ast/src/from_node.c
View file

@ -1,341 +0,0 @@
// /* ************************************************************************** */
// /* */
// /* ::: :::::::: */
// /* from_node.c :+: :+: :+: */
// /* +:+ +:+ +:+ */
// /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
// /* +#+#+#+#+#+ +#+ */
// /* Created: 2024/05/28 13:18:44 by maiboyer #+# #+# */
// /* Updated: 2024/05/29 22:48:00 by maiboyer ### ########.fr */
// /* */
// /* ************************************************************************** */
// #include "me/str/str.h"
// #include "me/types.h"
// #include "app/node.h"
// #include "ast/from_node.h"
// #include "gmr/field_identifiers.h"
// #include "gmr/symbols.h"
// #include <stdio.h>
// t_ast_node *alloc_node(t_ast_type ty)
// {
// t_ast_node *ptr;
// ptr = mem_alloc(sizeof(*ptr));
// ptr->type = ty;
// return (ptr);
// }
// t_ast_node *build_comment(t_node *node, t_usize size)
// {
// t_ast_node *ptr;
// (void)(node);
// (void)(size);
// ptr = alloc_node(TY_EMPTY);
// return (ptr);
// }
// t_and_list *build_and_list(t_node *node, t_usize size)
// {
// t_and_list *ptr;
// t_usize i;
// t_usize j;
// (void)(size);
// if (node == NULL || node->kind != sym_list || size == 0 ||
// node->childs_count <= 1)
// me_abort("Invalid arguments to build ast!");
// ptr = (void *)alloc_node(TY_AND_LIST);
// ptr->cmds = mem_alloc_array(sizeof(t_ast_node *), node->childs_count);
// i = 0;
// j = 0;
// while (i < node->childs_count)
// {
// if ((node->childs[i].kind == anon_sym_AMP_AMP ||
// node->childs[i].kind == anon_sym_PIPE_PIPE) &&
// (i++, true))
// continue;
// ptr->cmds[j++].cmd = (void *)from_node(&node->childs[i]);
// i++;
// }
// ptr->cmds_len = j;
// return (ptr);
// }
// t_or_list *build_or_list(t_node *node, t_usize size)
// {
// t_or_list *ptr;
// t_usize i;
// t_usize j;
// (void)(size);
// if (node == NULL || node->kind != sym_list || size == 0 ||
// node->childs_count <= 1)
// me_abort("Invalid arguments to build ast!");
// ptr = (void *)alloc_node(TY_OR_LIST);
// ptr->cmds = mem_alloc_array(sizeof(t_ast_node *), node->childs_count);
// i = 0;
// j = 0;
// while (i < node->childs_count)
// {
// if ((node->childs[i].kind == anon_sym_AMP_AMP ||
// node->childs[i].kind == anon_sym_PIPE_PIPE) &&
// (i++, true))
// continue;
// ptr->cmds[j++].cmd = (void *)from_node(&node->childs[i]);
// i++;
// }
// ptr->cmds_len = j;
// return (ptr);
// }
// t_ast_string *build_ast_string(t_node *node, t_usize size)
// {
// t_ast_string *ptr;
// (void)(size);
// if (node == NULL ||
// (node->kind != sym_string_content && node->kind != sym_raw_string &&
// node->kind == sym_ansi_c_string) ||
// size == 0)
// me_abort("Invalid arguments to build ast!");
// ptr = (void *)alloc_node(TY_AST_STRING);
// ptr->value = str_clone(node_getstr(node));
// return (ptr);
// }
// t_and_or_list *build_and_or_list(t_node *node, t_usize size)
// {
// t_and_or_list *ptr;
// (void)(node);
// (void)(size);
// if (node == NULL || node->kind != sym_list || size == 0 ||
// node->childs_count <= 1)
// me_abort("Invalid arguments to build ast!");
// ptr = (void *)alloc_node(TY_AND_OR_LIST);
// if (node->childs[1].kind == anon_sym_PIPE_PIPE)
// ptr->cmds.or_list = build_or_list(node, 1);
// else if (node->childs[1].kind == anon_sym_AMP_AMP)
// ptr->cmds.and_list = build_and_list(node, 1);
// else
// return (mem_free(ptr), NULL);
// return (ptr);
// }
// t_pipe_list *build_pipe_list(t_node *node, t_usize size)
// {
// t_pipe_list *ptr;
// t_usize i;
// t_usize j;
// (void)(size);
// if (node == NULL || node->kind != sym_pipeline || size == 0 ||
// node->childs_count <= 1)
// me_abort("Invalid arguments to build ast!");
// ptr = (void *)alloc_node(TY_PIPE_LIST);
// ptr->cmds = mem_alloc_array(sizeof(t_ast_node *), node->childs_count);
// i = 0;
// j = 0;
// while (i < node->childs_count)
// {
// if (node->childs[i].kind == anon_sym_PIPE)
// i++;
// ptr->cmds[j++] = from_node(&node->childs[i]);
// i++;
// }
// return (ptr);
// }
// t_double_quote_string *build_double_qoute_string(t_node *node, t_usize size)
// {
// t_double_quote_string *ptr;
// t_usize i;
// t_usize j;
// (void)(size);
// if (node == NULL || node->kind != sym_string || size == 0)
// me_abort("Invalid arguments to build ast!");
// ptr = (void *)alloc_node(TY_DOUBLE_QUOTE_STRING);
// ptr->parts = mem_alloc_array(sizeof(*ptr->parts), node->childs_count);
// i = 0;
// j = 0;
// while (i < node->childs_count)
// ptr->parts[j++].expension->type = (void *)from_node(&node->childs[i++]);
// ptr->parts_len = j;
// return (ptr);
// }
// t_not *build_not(t_node *node, t_usize size)
// {
// t_not *ptr;
// (void)(size);
// if (node == NULL || node->kind != sym_negated_command || size == 0)
// me_abort("Invalid arguments to build ast!");
// ptr = (void *)alloc_node(TY_NOT);
// ptr->cmd.type = (void *)from_node(&node->childs[1]);
// return (ptr);
// }
// t_command *build_command(t_node *node, t_usize size)
// {
// t_command *ptr;
// t_usize i;
// t_usize j;
// (void)(size);
// if (node == NULL || size == 0 ||
// (node->kind != sym_redirected_statement && node->kind != sym_command &&
// node->kind != sym_test_command &&
// node->kind != sym_declaration_command &&
// node->kind != sym_unset_command))
// me_abort("Invalid arguments to build ast!");
// ptr = (void *)alloc_node(TY_COMMAND);
// if (node->kind == sym_redirected_statement)
// {
// if (node->childs[0].field == field_body)
// {
// ptr->inner.type = (void *)from_node(&node->childs[0]);
// }
// i = 0;
// j = 0;
// while (i < node->childs_count)
// {
// if (node->childs[i].field == field_redirect)
// {
// if (*ptr->inner.type == TY_SIMPLE_COMMAND)
// {
// ptr->inner.simple_command->suffix[j++].type = (void *)from_node(&node->childs[i]);
// ptr->inner.simple_command->suffix_len = j;
// }
// }
// i++;
// }
// }
// return (ptr);
// }
// /*
// */
// t_ast_node *from_node(t_node *node)
// {
// if (node == NULL)
// return (NULL);
// if (node->kind == sym_program)
// return ((t_ast_node *)build_program(node, 1));
// if (node->kind == sym_string)
// return ((t_ast_node *)build_double_quote_string(node, 1));
// if (node->kind == sym_word)
// return ((t_ast_node *)build_word(node, 1));
// if (node->kind == sym_concatenation)
// return ((t_ast_node *)build_word(node, 1));
// if (node->kind == sym_variable_name)
// return ((t_ast_node *)build_word(node, 1));
// if (node->kind == sym_command_name)
// return ((t_ast_node *)build_word(node, 1));
// if (node->kind == sym_translated_string)
// return ((t_ast_node *)build_word(node, 1));
// if (node->kind == sym_string_content)
// return ((t_ast_node *)build_ast_string(node, 1));
// if (node->kind == sym_raw_string)
// return ((t_ast_node *)build_ast_string(node, 1));
// if (node->kind == sym_ansi_c_string)
// return ((t_ast_node *)build_ast_string(node, 1));
// if (node->kind == sym_variable_assignments)
// return (t_ast_node *)build_assignment_list(node, 1);
// if (node->kind == sym_variable_assignment)
// return (t_ast_node *)build_assignment_list(node, 1);
// if (node->kind == sym_command_substitution)
// return (t_ast_node *)build_parameter_expansion(node, 1);
// if (node->kind == sym_expansion)
// return (t_ast_node *)build_parameter_expansion(node, 1);
// if (node->kind == sym_simple_expansion)
// return (t_ast_node *)build_parameter_expansion(node, 1);
// if (node->kind == sym_arithmetic_expansion)
// return ((t_ast_node *)build_arithmetic_expansion(node, 1));
// if (node->kind == sym_comment)
// return ((t_ast_node *)build_comment(node, 1));
// if (node->kind == sym_negated_command)
// return ((t_ast_node *)build_not(node, 1));
// if (node->kind == sym_redirected_statement)
// return ((t_ast_node *)build_command(node, 1));
// if (node->kind == sym_command)
// return ((t_ast_node *)build_command(node, 1));
// if (node->kind == sym_test_command)
// return ((t_ast_node *)build_command(node, 1));
// if (node->kind == sym_declaration_command)
// return ((t_ast_node *)build_command(node, 1));
// if (node->kind == sym_unset_command)
// return ((t_ast_node *)build_command(node, 1));
// if (node->kind == sym_file_redirect)
// return ((t_ast_node *)build_redirect_file(node, 1));
// if (node->kind == sym_heredoc_redirect)
// return ((t_ast_node *)build_redirect_heredoc(node, 1));
// if (node->kind == sym_list)
// return ((t_ast_node *)build_and_or_list(node, 1));
// if (node->kind == sym_pipeline)
// return ((t_ast_node *)build_pipe_list(node, 1));
// if (node->kind == sym_subshell)
// return ((t_ast_node *)build_subshell_command(node, 1));
// if (node->kind == sym_brace_expression)
// return ((t_ast_node *)build_brace_command(node, 1));
// if (node->kind == sym_compound_statement)
// return ((t_ast_node *)build_compound_list(node, 1));
// if (node->kind == sym_if_statement)
// return ((t_ast_node *)build_if_command(node, 1));
// if (node->kind == sym_else_clause)
// return ((t_ast_node *)build_else_clause(node, 1));
// if (node->kind == sym_elif_clause)
// return ((t_ast_node *)build_elif_clause(node, 1));
// if (node->kind == sym_case_statement)
// return ((t_ast_node *)build_case_command(node, 1));
// if (node->kind == sym_case_item)
// return ((t_ast_node *)build_case_item(node, 1));
// if (node->kind == sym_last_case_item)
// return ((t_ast_node *)build_case_item(node, 1));
// if (node->kind == sym_while_statement)
// return ((t_ast_node *)build_while_command(node, 1));
// if (node->kind == sym_for_statement)
// return ((t_ast_node *)build_for_command(node, 1));
// if (node->kind == sym_function_definition)
// return ((t_ast_node *)build_function_definition(node, 1));
// printf("unknown node of kind '%s'\n", node->kind_str);
// return (NULL);
// }