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

Created: test main for the parser

Browse source
This commit is contained in:
Maieul BOYER 2024-04-28 18:58:46 +02:00
parent c28d673db7
commit 3bde20ba23
No known key found for this signature in database
10 changed files with 236 additions and 37 deletions
Download patch file Download diff file Expand all files Collapse all files

9
shcat_c/.clang-format Normal file
View file

@ -0,0 +1,9 @@
BasedOnStyle: Microsoft
IndentWidth: 4
ColumnLimit: 80
UseTab: Always
SortIncludes: CaseInsensitive
IndentPPDirectives: AfterHash
PPIndentWidth: 1
AllowShortIfStatementsOnASingleLine: false
AlignConsecutiveDeclarations: true

1
shcat_c/.clangd
View file

@ -1,4 +1,5 @@
CompileFlags: # Tweak the parse settings CompileFlags: # Tweak the parse settings
Add: Add:
- "-I/usr/include" - "-I/usr/include"
- "-I/home/maiboyer/Documents/ring-2/shcat/shcat_c/includes"

13
shcat_c/Minishell.mk
View file

@ -6,7 +6,7 @@
# By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ # # By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ # # +#+#+#+#+#+ +#+ #
# Created: 2024/04/28 17:28:30 by maiboyer #+# #+# # # Created: 2024/04/28 17:28:30 by maiboyer #+# #+# #
# Updated: 2024/04/28 18:17:52 by maiboyer ### ########.fr # # Updated: 2024/04/28 18:56:27 by maiboyer ### ########.fr #
# # # #
# **************************************************************************** # # **************************************************************************** #
@ -15,8 +15,7 @@
OBJDIRNAME ?= OBJDIRNAME ?=
# Flags # Flags
CFLAGS = -Werror -Wextra -Wall -Wno-unused-command-line-argument -g3 -MMD -lreadline -L$(OBJDIRNAME) -lme -lgmr -I./includes -I./stdme/includes -I./parser_src/includes CFLAGS = -Werror -Wextra -Wall -Wno-unused-command-line-argument -g3 -MMD -lreadline -I./includes
# Sources # Sources
LIB = ./libft/ft_bzero.c \ LIB = ./libft/ft_bzero.c \
./libft/ft_calloc.c \ ./libft/ft_calloc.c \
@ -32,7 +31,8 @@ SRC = ./sources/ft_cmd.c \
./sources/ft_echo.c \ ./sources/ft_echo.c \
./sources/ft_exit.c \ ./sources/ft_exit.c \
./sources/ft_pwd.c \ ./sources/ft_pwd.c \
./sources/main.c ./sources/main.c \
./sources/node/node.c
# Name # Name
NAME = minishell NAME = minishell
@ -64,21 +64,20 @@ bonus: $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libme.a $(OBJDIRNAME)/libgmr.a
@mkdir -p $(OBJDIRNAME)/$(LIBDIRNAME) @mkdir -p $(OBJDIRNAME)/$(LIBDIRNAME)
@mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME) @mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME)
@printf '$(GREY) Be Carefull ur in $(END)$(GREEN)Debug Mode$(END)\n' @printf '$(GREY) Be Carefull ur in $(END)$(GREEN)Debug Mode$(END)\n'
@cc $(CFLAGS) -D DEBUG=42 -o $(NAME) $(OBJ) @cc $(CFLAGS) -D DEBUG=42 -o $(NAME) $(OBJ) -L$(OBJDIRNAME) -lme -lgmr
# Dependences for all # Dependences for all
$(NAME): $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libme.a $(OBJDIRNAME)/libgmr.a $(NAME): $(OBJ) $(LIB_OBJ) $(OBJDIRNAME)/libme.a $(OBJDIRNAME)/libgmr.a
@mkdir -p $(OBJDIRNAME) @mkdir -p $(OBJDIRNAME)
@mkdir -p $(OBJDIRNAME)/$(LIBDIRNAME) @mkdir -p $(OBJDIRNAME)/$(LIBDIRNAME)
@mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME) @mkdir -p $(OBJDIRNAME)/$(SRCDIRNAME)
@cc $(CFLAGS) -o $(NAME) $(OBJ) $(LIB_OBJ) @cc $(CFLAGS) -o $(NAME) $(OBJ) $(LIB_OBJ) -L$(OBJDIRNAME) -lme -lgmr
# Creating the objects # Creating the objects
$(OBJDIRNAME)/%.o: %.c $(OBJDIRNAME)/%.o: %.c
@mkdir -p $(dir $@) @mkdir -p $(dir $@)
@printf '$(GREY) Compiling $(END)$(GREEN)$<$(END)\n' @printf '$(GREY) Compiling $(END)$(GREEN)$<$(END)\n'
@cc $(CFLAGS) -o $@ -c $< @cc $(CFLAGS) -o $@ -c $<
$(OBJDIRNAME)/libme.a: $(OBJDIRNAME)/libme.a:
@$(MAKE) --no-print-directory -C ./stdme/ LIB_NAME="$(realpath ./$(stdme))/" "BUILD_DIR=$(shell realpath ./$(OBJDIRNAME))" libme.a @$(MAKE) --no-print-directory -C ./stdme/ LIB_NAME="$(realpath ./$(stdme))/" "BUILD_DIR=$(shell realpath ./$(OBJDIRNAME))" libme.a

35
shcat_c/includes/app/node.h Normal file
View file

@ -0,0 +1,35 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* node.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/28 18:35:22 by maiboyer #+# #+# */
/* Updated: 2024/04/28 18:53:13 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef NODE_H
#define NODE_H
#include "me/types.h"
#include "parser/api.h"
typedef struct s_node
{
t_u64 kind;
const char *kind_str;
const char *input;
char *single_str;
t_usize start;
t_usize end;
t_usize childs_count;
struct s_node *childs;
} t_node;
t_node build_node(TSNode curr, t_const_str input);
t_str node_getstr(t_node *node);
void free_node(t_node t);
#endif /* NODE_H */

1
shcat_c/includes/me Symbolic link
View file

@ -0,0 +1 @@
../stdme/include/me/

4
shcat_c/includes/minishell.h
View file

@ -6,14 +6,14 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */ /* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/28 14:41:15 by rparodi #+# #+# */ /* Created: 2024/03/28 14:41:15 by rparodi #+# #+# */
/* Updated: 2024/04/13 20:17:16 by rparodi ### ########.fr */ /* Updated: 2024/04/28 18:34:45 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#ifndef MINISHELL_H #ifndef MINISHELL_H
#define MINISHELL_H #define MINISHELL_H
# include "./type_rust.h" # include "me/types.h"
# include <unistd.h> # include <unistd.h>
# include <fcntl.h> # include <fcntl.h>

1
shcat_c/includes/parser Symbolic link
View file

@ -0,0 +1 @@
../parser/includes/

105
shcat_c/sources/main.c
View file

@ -6,13 +6,13 @@
/* 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/04/13 17:47:50 by rparodi ### ########.fr */ /* Updated: 2024/04/28 18:58:04 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "../includes/minishell.h" #include "../includes/minishell.h"
t_i32 ft_check_type_operators(t_str operators) t_i32 ft_check_type_operators(t_str operators)
{ {
if (operators == NULL) if (operators == NULL)
printf("End of input"); printf("End of input");
@ -45,10 +45,10 @@ t_i32 ft_check_type_operators(t_str operators)
return (1); return (1);
} }
void ft_check(t_utils *shcat, char **input) void ft_check(t_utils *shcat, char **input)
{ {
t_usize i; t_usize i;
t_usize prev_i; t_usize prev_i;
i = 0; i = 0;
prev_i = 0; prev_i = 0;
@ -69,9 +69,9 @@ void ft_check(t_utils *shcat, char **input)
} }
} }
void ft_take_args(t_utils *shcat) void ft_take_args(t_utils *shcat)
{ {
t_i32 i; t_i32 i;
i = 0; i = 0;
while (1) while (1)
@ -85,21 +85,21 @@ void ft_take_args(t_utils *shcat)
ft_check(shcat, shcat->strs_input); ft_check(shcat, shcat->strs_input);
add_history(shcat->str_input); add_history(shcat->str_input);
ft_free_strs(shcat->strs_input); ft_free_strs(shcat->strs_input);
free(shcat->str_input); free(shcat->str_input);
i++; i++;
} }
} }
void ft_init_arge(t_str arge[], t_utils *utils) void ft_init_arge(t_str arge[], t_utils *utils)
{ {
size_t i; size_t i;
char *temp; char *temp;
i = 0; i = 0;
temp = NULL; temp = NULL;
while (arge[i] != NULL) while (arge[i] != NULL)
{ {
if (arge[i][0] == 'P' && arge[i][1] == 'A' && arge[i][2] == 'T' && \ if (arge[i][0] == 'P' && arge[i][1] == 'A' && arge[i][2] == 'T' &&
arge[i][3] == 'H' && arge[i][4] == '=') arge[i][3] == 'H' && arge[i][4] == '=')
{ {
temp = ft_strdup(arge[i] + 5); temp = ft_strdup(arge[i] + 5);
@ -107,7 +107,7 @@ void ft_init_arge(t_str arge[], t_utils *utils)
ft_exit(utils, 1); ft_exit(utils, 1);
else else
utils->path = ft_split(temp, ':'); utils->path = ft_split(temp, ':');
break ; break;
} }
i++; i++;
} }
@ -115,16 +115,69 @@ void ft_init_arge(t_str arge[], t_utils *utils)
free(temp); free(temp);
} }
t_i32 main(t_i32 argc, t_str argv[], t_str arge[]) // t_i32 main(t_i32 argc, t_str argv[], t_str arge[])
{ // {
t_utils *shcat; // t_utils *shcat;
//
// shcat = (t_utils *)ft_calloc(sizeof(t_utils), 1);
// if (argc == 2)
// shcat->name_shell = ft_strdup(strcat(argv[1], " \001🐱\002 > "));
// else
// shcat->name_shell = ft_strdup("shcat \001🐱\002 > ");
// shcat->envp = arge;
// ft_init_arge(arge, shcat);
// ft_take_args(shcat);
// }
shcat = (t_utils *)ft_calloc(sizeof(t_utils), 1); #include "app/node.h"
if (argc == 2) #include "me/string/str_len.h"
shcat->name_shell = ft_strdup(strcat(argv[1], " \001🐱\002 > ")); #include "parser/api.h"
else #include "parser/parser.h"
shcat->name_shell = ft_strdup("shcat \001🐱\002 > ");
shcat->envp = arge; TSLanguage *tree_sitter_bash(void);
ft_init_arge(arge, shcat);
ft_take_args(shcat); t_node parse_to_nodes(TSParser *parser, t_const_str input)
{
TSTree *tree;
TSNode node;
t_node ret;
tree = ts_parser_parse_string(parser, NULL, input, str_len(input));
node = ts_tree_root_node(tree);
ret = build_node(node, input);
ts_tree_delete(tree);
return (ret);
}
void print_node_data(t_node *t, t_usize depth)
{
t_usize idx;
idx = 0;
while (idx++ < depth)
printf("\t");
idx = 0;
printf("%s = %s\n", t->kind_str, node_getstr(t));
while (idx < t->childs_count)
print_node_data(&t->childs[idx++], depth + 1);
}
t_i32 main(t_i32 argc, t_str argv[], t_str envp[])
{
t_str input;
TSLanguage *lang;
TSParser *parser;
t_node root_node;
(void)(argc);
(void)(argv);
(void)(envp);
lang = tree_sitter_bash();
parser = ts_parser_new();
ts_parser_set_language(parser, lang);
input = "test \n cmd";
root_node = parse_to_nodes(parser, input);
print_node_data(&root_node, 0);
free_node(root_node);
ts_parser_delete(parser);
} }

13
shcat_c/sources/node/create_node.c Normal file
View file

@ -0,0 +1,13 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* create_node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/28 18:29:36 by maiboyer #+# #+# */
/* Updated: 2024/04/28 18:31:36 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/api.h"

87
shcat_c/sources/node/node.c Normal file
View file

@ -0,0 +1,87 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* node.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/28 18:36:40 by maiboyer #+# #+# */
/* Updated: 2024/04/28 18:53:21 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "app/node.h"
#include "me/mem/mem_alloc.h"
#include "me/mem/mem_alloc_array.h"
#include "me/string/str_l_copy.h"
#include "parser/api.h"
t_node build_node(TSNode curr, t_const_str input);
t_node *build_childs(TSNode parent, t_const_str input, t_usize count)
{
t_node *ret;
t_usize idx;
TSNode child;
ret = mem_alloc_array(sizeof(*ret), count);
if (ret == NULL)
return (NULL);
idx = 0;
while (idx < count)
{
child = ts_node_named_child(parent, idx);
ret[idx] = build_node(child, input);
idx++;
}
return (ret);
}
t_node build_node(TSNode curr, t_const_str input)
{
t_node out;
out.kind = ts_node_symbol(curr);
out.kind_str = ts_node_type(curr);
out.start = ts_node_start_byte(curr);
out.end = ts_node_end_byte(curr);
out.input = input;
out.single_str = NULL;
out.childs_count = ts_node_named_child_count(curr);
if (out.childs_count == 0)
out.childs = NULL;
else
out.childs = build_childs(curr, input, out.childs_count);
return (out);
}
t_str node_getstr(t_node *node)
{
t_usize start;
t_usize end;
t_str ret;
if (node->single_str == NULL)
{
start = node->start;
end = node->end;
if (start > end)
return (NULL);
ret = mem_alloc(end - start + 1);
str_l_copy(ret, node->input + start, end - start + 1);
node->single_str = ret;
}
return (node->single_str);
}
void free_node(t_node t)
{
t_usize idx;
idx = 0;
while (idx < t.childs_count)
free_node(t.childs[idx++]);
free(t.childs);
if (t.single_str != NULL)
free(t.single_str);
}