willem/minishell
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'main' into quinten

Browse Source
This commit is contained in:
Quinten Mennen 2025-02-25 20:03:59 +01:00
commit 873d6b48fc
75 changed files with 1044 additions and 561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
.vscode/launch.json vendored
View File

@ -5,7 +5,7 @@
"name": "Debug minishell",
"type": "cppdbg",
"request": "launch",
"program": "${workspaceFolder}/minishell",
"program": "${workspaceFolder}/build/debug/minishell",
"args": [],
"stopAtEntry": false,
"cwd": "${workspaceFolder}",
@ -19,7 +19,7 @@
"ignoreFailures": true
}
],
"preLaunchTask": "Build minishell",
"preLaunchTask": "Build minishell debug",
"miDebuggerPath": "/usr/bin/gdb",
"logging": {
"engineLogging": true

12
.vscode/tasks.json vendored
View File

@ -13,6 +13,18 @@
"problemMatcher": ["$gcc"],
"detail": "Generated task for building minishell"
},
{
"label": "Build minishell debug",
"type": "shell",
"command": "make debug",
"args": [],
"group": {
"kind": "build",
"isDefault": true
},
"problemMatcher": ["$gcc"],
"detail": "Generated task for building minishell in debug mode"
},
{
"label": "Run minishell",
"type": "shell",

258
Makefile
View File

@ -1,78 +1,180 @@
# **************************************************************************** #
# #
# :::::::: #
# Makefile :+: :+: #
# +:+ #
# By: marvin <marvin@student.42.fr> +#+ #
# +#+ #
# Created: 2024/10/15 11:48:46 by whaffman #+# #+# #
# Updated: 2025/02/23 12:28:40 by Quinten ######## odam.nl #
# #
# **************************************************************************** #
NAME = minishell
SRC_PATH = src
INC_PATH = inc
LIB_PATH = lib
LIBFT_PATH = $(LIB_PATH)/libft
LIBFT_INC_PATH = $(LIBFT_PATH)/inc
LIBFT = $(LIBFT_PATH)/libft.a
OBJ_PATH = obj
VPATH = src:src/environment:src/prompt:src/lexer:src/token:src/utils:
VPATH += src/executor:src/parser:src/expander:src/debug:src/signal:src/builtin
VPATH += src/redirect
SOURCES = $(shell basename -a $(shell find $(SRC_PATH) -type f -name "*.c"))
OBJECTS = $(addprefix $(OBJ_PATH)/, $(SOURCES:.c=.o))
DEPENDS = ${OBJECTS:.o=.d}
CC = cc
RM = rm -rf
INCLUDES = -I./$(INC_PATH) -I./$(LIBFT_INC_PATH)
CFLAGS = -Wall -Wextra -Werror -fsanitize=address,undefined -MMD -g3
UNAME_S := $(shell uname -s)
ifeq ($(UNAME_S),Linux)
LDLIBS := -L$(LIBFT_PATH) -lft -lreadline
endif
all: $(NAME)
echo $(SOURCES)
$(NAME): $(LIBFT) $(OBJECTS)
$(CC) $(CFLAGS) $(OBJECTS) $(LDLIBS) -o $(NAME)
-include ${DEPENDS}
$(LIBFT): $(LIBFT_PATH)
$(MAKE) -C $(LIBFT_PATH)
$(LIBFT_PATH):
git submodule add https://gitea.duinvoetje.nl/willem/libft.git $(LIBFT_PATH)
$(OBJ_PATH):
mkdir -p $@
$(OBJ_PATH)/%.o: %.c $(LIBFT) | $(OBJ_PATH)
$(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@
clean:
$(RM) $(OBJECTS) $(OBJ_PATH)
$(MAKE) -C $(LIBFT_PATH) clean
fclean: clean
$(RM) $(NAME)
$(MAKE) -C $(LIBFT_PATH) fclean
re: fclean all
run: all
./$(NAME)
.PHONY: all clean fclean re run
# **************************************************************************** #
# #
# :::::::: #
# Makefile :+: :+: #
# +:+ #
# By: qmennen <qmennen@student.codam.nl> +#+ #
# +#+ #
# Created: 2024/10/15 11:48:46 by whaffman #+# #+# #
# Updated: 2025/02/25 18:15:50 by whaffman ######## odam.nl #
# #
# **************************************************************************** #
NAME = minishell
SRC_PATH = src
INC_PATH = inc
LIB_PATH = lib
BUILD_PATH = build
LIBFT_PATH = $(LIB_PATH)/libft
LIBFT_INC_PATH = $(LIBFT_PATH)/inc
LIBFT = $(LIBFT_PATH)/libft.a
CC = cc
RM = rm -rf
INCLUDES = -I./$(INC_PATH) -I./$(LIBFT_INC_PATH)
UNAME_S := $(shell uname -s)
ifeq ($(UNAME_S),Linux)
LDLIBS := -L$(LIBFT_PATH) -lft -lreadline
endif
# Include sources.mk if it exists
-include sources.mk
# Build configurations
BUILD_CONFIGS = release debug asan tsan
release_CFLAGS = -Wall -Werror -Werror -O2
debug_CFLAGS = -Wall -Werror -Werror -g3 -DDEBUG
asan_CFLAGS = -Wall -Werror -Werror -fsanitize=address,leak,undefined -g3
tsan_CFLAGS = -Wall -Werror -Werror -fsanitize=thread -g3
# Targets for each build configuration
define BUILD_TARGETS
$(1)_OBJ_PATH = $(BUILD_PATH)/$(1)/obj
$(1)_DEPENDS = $$(addprefix $$($(1)_OBJ_PATH)/, $$(SOURCES:.c=.d))
$(1)_OBJECTS = $$(addprefix $$($(1)_OBJ_PATH)/, $$(SOURCES:.c=.o))
.PHONY: $(1)
$(1): CFLAGS = $$($(1)_CFLAGS)
$(1): $(BUILD_PATH)/$(1)/$(NAME)
.PHONY: run_$(1)
run_$(1): $(1)
$$(info $$(bold)$$(green)Running $(1)$$(reset))
./$(BUILD_PATH)/$(1)/$(NAME)
$(BUILD_PATH)/$(1)/$(NAME): $(LIBFT) $$($(1)_OBJECTS)
$$(info $$(bold)$$(green)Linking $(1) config$$(reset))
$$(CC) $$(CFLAGS) $$($(1)_OBJECTS) $$(LDLIBS) -o $$@
-include $$($(1)_DEPENDS)
$$($(1)_OBJ_PATH)/%.o: %.c $(LIBFT) | $$($(1)_OBJ_PATH)
$$(CC) $$(CFLAGS) $$(INCLUDES) -MMD -MP -c $$< -o $$@
$$($(1)_OBJ_PATH):
$$(info $$(bold)$$(green)Creating $(1) object directory$$(reset))
mkdir -p $$@
endef
# Copy the release build configuration to the root
$(NAME): $(BUILD_PATH)/release/$(NAME)
$(info $(bold)$(green)Copying release build to root$(reset))
cp $< $@
$(foreach config,$(BUILD_CONFIGS),$(eval $(call BUILD_TARGETS,$(config))))
# Build all configurations
all: release debug asan tsan
$(info $(bold)$(green)All builc config have been build$(reset))
# Build libft
$(LIBFT): $(LIBFT_PATH) submodules
$(info $(bold)$(green)Building libft$(reset))
$(MAKE) -C $(LIBFT_PATH)
$(LIBFT_PATH):
$(info $(bold)$(green)Adding libft submodule$(reset))
git submodule add https://gitea.duinvoetje.nl/willem/libft.git $(LIBFT_PATH)
# Generate sources.mk
sources.mk:
$(info $(bold)$(green)Generating sources.mk$(reset))
@echo "VPATH = $$(find $(SRC_PATH) -type d | tr '\n' ':')" > sources.mk
@echo "SOURCES = $$(find $(SRC_PATH) -type f -name '*.c' -exec basename {} \; | tr '\n' ' ' | fold -s -w 70 | sed 's/$$/ \\/')" >> sources.mk
# Remove build artifacts
clean:
$(info $(bold)$(red)Cleaning$(reset))
find $(BUILD_PATH) -type d -name 'obj' -exec $(RM) {} +
$(MAKE) -C $(LIBFT_PATH) clean
# Remove build artifacts and the executable
fclean: clean
$(info $(bold)$(red)Full cleaning$(reset))
$(RM) $(BUILD_PATH)
$(RM) $(NAME)
$(MAKE) -C $(LIBFT_PATH) fclean
# Rebuild the project
re: fclean
$(info $(bold)$(green)Rebuilding$(reset))
$(MAKE) all $(NAME)
# Run the project with the release build configuration
run: run_release
# Remove sources.mk to force regeneration
srcs:
$(info $(bold)$(green)Regenerating sources.mk on next make$(reset))
$(RM) sources.mk
# Show this help.
help:
@echo "Usage: make [target]"
@echo ""
@echo "Targets:"
@echo " $(green)$(bold)all $(reset)- Build all configurations (release, debug, asan, tsan)"
@echo " $(green)$(bold)clean $(reset)- Remove build artifacts"
@echo " $(green)$(bold)fclean $(reset)- Remove build artifacts and the executable"
@echo " $(green)$(bold)re $(reset)- Rebuild the project"
@echo " $(green)$(bold)run $(reset)- Run the release build"
@echo " $(green)$(bold)srcs $(reset)- Remove sources.mk"
@echo " $(green)$(bold)help $(reset)- Show this help message"
@echo ""
@echo "Build configurations:"
@echo " $(green)$(bold)release $(reset)- Build with release configuration"
@echo " $(green)$(bold)debug $(reset)- Build with debug configuration"
@echo " $(green)$(bold)asan $(reset)- Build with AddressSanitizer configuration"
@echo " $(green)$(bold)tsan $(reset)- Build with ThreadSanitizer configuration"
@echo ""
@echo "Run configurations:"
@echo " $(green)$(bold)run_release $(reset)- Run the release build"
@echo " $(green)$(bold)run_debug $(reset)- Run the debug build"
@echo " $(green)$(bold)run_asan $(reset)- Run the AddressSanitizer build"
@echo " $(green)$(bold)run_tsan $(reset)- Run the ThreadSanitizer build"
@echo ""
@echo "Other targets:"
@echo " $(green)$(bold)submodules $(reset)- Check and reinitialize git submodules"
@echo " $(green)$(bold)libft $(reset)- Build libft"
@echo " $(green)$(bold)sources.mk $(reset)- Generate sources.mk"
@echo ""
.PHONY: submodules
submodules:
$(info $(bold)$(green)Checking and reinitializing submodules$(reset))
@if git submodule status | egrep -q '^[-+]' ; then \
echo "INFO: Need to reinitialize git submodules"; \
git submodule update --init; \
fi
.PHONY: all clean fclean re srcs run help
red:=$(shell tput setaf 1)
green:=$(shell tput setaf 2)
yellow:=$(shell tput setaf 3)
blue:=$(shell tput setaf 4)
magenta:=$(shell tput setaf 5)
cyan:=$(shell tput setaf 6)
white:=$(shell tput setaf 7)
bold:=$(shell tput bold)
underline:=$(shell tput smul)
reset:=$(shell tput sgr0)

77
Makefile.old Normal file
View File

@ -0,0 +1,77 @@
# **************************************************************************** #
# #
# :::::::: #
# Makefile :+: :+: #
# +:+ #
# By: qmennen <qmennen@student.codam.nl> +#+ #
# +#+ #
# Created: 2024/10/15 11:48:46 by whaffman #+# #+# #
# Updated: 2025/02/20 11:10:42 by whaffman ######## odam.nl #
# #
# **************************************************************************** #
NAME = minishell
SRC_PATH = src
INC_PATH = inc
LIB_PATH = lib
LIBFT_PATH = $(LIB_PATH)/libft
LIBFT_INC_PATH = $(LIBFT_PATH)/inc
LIBFT = $(LIBFT_PATH)/libft.a
OBJ_PATH = obj
VPATH = src:src/environment:src/prompt:src/lexer:src/token:src/utils:
VPATH += src/executor:src/parser:src/expander:src/debug:src/signal:src/builtin
SOURCES = $(shell basename -a $(shell find $(SRC_PATH) -type f -name "*.c"))
OBJECTS = $(addprefix $(OBJ_PATH)/, $(SOURCES:.c=.o))
DEPENDS = ${OBJECTS:.o=.d}
CC = cc
RM = rm -rf
INCLUDES = -I./$(INC_PATH) -I./$(LIBFT_INC_PATH)
CFLAGS = -Wall -Wextra -Werror -fsanitize=address,undefined -MMD -g3
UNAME_S := $(shell uname -s)
ifeq ($(UNAME_S),Linux)
LDLIBS := -L$(LIBFT_PATH) -lft -lreadline
endif
all: $(NAME)
echo $(SOURCES)
$(NAME): $(LIBFT) $(OBJECTS)
$(CC) $(CFLAGS) $(OBJECTS) $(LDLIBS) -o $(NAME)
-include ${DEPENDS}
$(LIBFT): $(LIBFT_PATH)
$(MAKE) -C $(LIBFT_PATH)
$(LIBFT_PATH):
git submodule add https://gitea.duinvoetje.nl/willem/libft.git $(LIBFT_PATH)
$(OBJ_PATH):
mkdir -p $@
$(OBJ_PATH)/%.o: %.c $(LIBFT) | $(OBJ_PATH)
$(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@
clean:
$(RM) $(OBJECTS) $(OBJ_PATH)
$(MAKE) -C $(LIBFT_PATH) clean
fclean: clean
$(RM) $(NAME)
$(MAKE) -C $(LIBFT_PATH) fclean
re: fclean all
run: all
./$(NAME)
.PHONY: all clean fclean re run

18
README.md
View File

@ -5,15 +5,15 @@ A lot of amazing shell stuff
- libncurses-dev
## TODO
-[x] Find absolute path for command input ('/', './', 'cmd')
- Add heredoc to tokenizer
-[x] Environment to `t_list`
-[x] Get environment array (export)
-[x] Set environment variable (export)
-[x] Simple builtin export
-[x] builtins
-[x] Preliminary signals
-[x] Define struct for commands, something like (
- [x] Find absolute path for command input ('/', './', 'cmd')
- [x]Add heredoc to tokenizer
- [x] Environment to `t_list`
- [x] Get environment array (export)
- [x] Set environment variable (export)
- [x] Simple builtin export
- [x] builtins
- [x] Preliminary signals
- [x] Define struct for commands, something like (
```c
typedef struct s_command
{

1
inc/debug.h
View File

@ -18,5 +18,6 @@
void print_commands(void *param);
void token_print(void *param);
void print_redirects(void *param);
void print_freelist(t_minishell *minishell);
#endif

19
inc/environment.h
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/04 16:26:35 by whaffman #+# #+# */
/* Updated: 2025/02/11 15:39:15 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 15:19:01 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -15,13 +15,14 @@
# include "minishell.h"
void environment_add(t_list **environment, char *name, char *value);
void environment_print(t_list *environment);
t_environment *environment_get(t_list *environment, char *name);
void environment_free_list(t_list **environment);
int environment_parse(char **envp, t_list **environment);
char **environment_get_arr(t_list *environment);
void environment_del(t_list **environment, char *name);
void environment_free(void *content);
void environment_add(t_minishell *minishell,
char *name, char *value);
void environment_print(t_minishell *minishell);
t_environment *environment_get(t_minishell *minishell, char *name);
void environment_free_list(t_minishell *minishell);
int environment_parse(t_minishell *minishell, char **envp);
char **environment_get_arr(t_minishell *minishell);
void environment_del(t_minishell *minishell, char *name);
void environment_free(t_minishell *minishell, void *content);
#endif // ENVIRONMENT_H

15
inc/executor.h
View File

@ -6,7 +6,7 @@
/* By: willem <willem@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/08 17:06:07 by willem #+# #+# */
/* Updated: 2025/02/18 15:45:27 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:52:05 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -15,15 +15,14 @@
# include "minishell.h"
char *executor_absolute_path(t_list *env, char *cmd);
void executor_child(t_command *command);
pid_t executor_fork(t_command *command);
char *executor_absolute_path(t_minishell *minishell, char *cmd);
void executor_child(t_minishell *minishell, t_command *command);
pid_t executor_fork(t_minishell *minishell, t_command *command);
void executor_create_pipes(t_minishell *minishell);
int executor_execute_pipeline(t_minishell *minishell);
void executor_close_fds(int n_fds);
int executor_count_fds(t_minishell *minishell);
int executor_open_fds(t_list *redirect_list, int og_fd);
void executor_create_redirects(t_minishell *minishell);
#endif // EXECUTOR_H

30
inc/expander.h
View File

@ -1,25 +1,31 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* expander.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/18 19:00:51 by qmennen #+# #+# */
/* Updated: 2025/02/19 15:19:50 by qmennen ### ########.fr */
/* :::::::: */
/* expander.h :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/18 19:00:51 by qmennen #+# #+# */
/* Updated: 2025/02/25 14:32:18 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#ifndef EXPANDER_H
# define EXPANDER_H
#include "minishell.h"
# include "minishell.h"
t_environment *expander_get_var(const char *s, int idx, t_minishell *minishell);
t_list *expander_parse_variables(const char *s, t_minishell *minishell);
char *expander_allocate_memory(const char *s, t_list *variables);
t_environment *expander_get_var(const char *s, int idx,
t_minishell *minishell);
t_list *expander_parse_variables(const char *s,
t_minishell *minishell);
char *expander_allocate_memory(
t_minishell *minishell,
const char *s,
t_list *variables);
char *expander_parse_string(char *s, t_minishell *minishell);
int expander_character_valid(const char c);
int expander_expand_dollar(char *src, char *dest, int *j, t_list *variables);
int expander_expand_dollar(char *src, char *dest,
int *j, t_list *variables);
#endif

6
inc/minishell.h
View File

@ -45,6 +45,12 @@
# define PROMPT RESET "🐚" GREEN "minishell" RESET ": "
# define PROMPT_LEN 51
# ifdef DEBUG
# define DEBUG 1
# else
# define DEBUG 0
# endif // DEBUG
void token_print(void *param);
#endif

2
inc/parser.h
View File

@ -15,7 +15,7 @@
# include "minishell.h"
t_command *parser_command_new(char *cmd);
t_command *parser_command_new(t_minishell *minishell, char *cmd);
char **parser_get_arguments(t_list *list, t_minishell *minishell);
t_list *parser_get_commands(t_minishell *minishell);
t_list *parser_get_input_redirects(t_list *list);

8
inc/redirect.h
View File

@ -14,11 +14,11 @@
# define REDIRECT_H
# include "minishell.h"
t_redirect *redirect_new(t_token_type type, char *value);
t_list *redirect_get_inputs(t_list *list);
t_list *redirect_get_outputs(t_list *list);
t_redirect *redirect_new(t_minishell *minishell, t_token_type type, char *value);
t_list *redirect_get_inputs(t_minishell *minishell, t_list *list);
t_list *redirect_get_outputs(t_minishell *minishell, t_list *list);
int redirect_is_valid(t_list *lst, t_token *token);
int redirect_token_type(t_token *token);
int redirect_is_delimiter(t_token *token);
#endif
#endif

32
inc/tokenizer.h
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* tokenizer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 12:36:00 by whaffman #+# #+# */
/* Updated: 2025/02/18 17:02:17 by qmennen ### ########.fr */
/* :::::::: */
/* tokenizer.h :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 12:36:00 by whaffman #+# #+# */
/* Updated: 2025/02/25 16:19:05 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -16,18 +16,18 @@
/**
* Lexer
*/
t_lexer *ft_lexer_new(const char *input);
void ft_lexer_free(t_lexer *lexer);
t_lexer *ft_lexer_new(t_minishell *minishell);
void ft_lexer_free(t_minishell *minishell, t_lexer *lexer);
void lexer_readchar(t_lexer *lexer);
char *lexer_readword(t_lexer *lexer);
t_list *ft_parse_input(t_lexer *lexer);
char *lexer_readword(t_minishell *minishell, t_lexer *lexer);
t_list *ft_parse_input(t_minishell *minishell);
/**
* Token
*/
t_token *ft_token_next(t_lexer *lexer);
t_token *token_new(t_token_type type, char *c, int pos);
void ft_token_free(t_token *token);
void ft_clear_tokenlist(void *content);
t_token *token_parse(t_lexer *lexer);
t_token *ft_token_next(t_minishell *minishell, t_lexer *lexer);
t_token *token_new(t_minishell *minishell, t_token_type type, char *c, int pos);
void ft_token_free(t_minishell *minishell, t_token *token);
void ft_clear_tokenlist(t_minishell *minishell, void *content);
t_token *token_parse(t_minishell *minishell, t_lexer *lexer);
#endif // TOKENIZER_H

15
inc/typedef.h
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* typedef.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 12:36:08 by whaffman #+# #+# */
/* Updated: 2025/02/20 16:45:55 by qmennen ### ########.fr */
/* :::::::: */
/* typedef.h :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 12:36:08 by whaffman #+# #+# */
/* Updated: 2025/02/25 13:23:12 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -78,6 +78,7 @@ typedef struct s_minishell
t_lexer *lexer;
t_list *tokens;
t_list *commands;
t_list *freelist;
} t_minishell;
typedef int (*t_builtin_fn)(t_minishell *, t_command *);

18
inc/utils.h
View File

@ -14,16 +14,22 @@
# define UTILS_H
void free_minishell_line(t_minishell *minishell);
void free_minishell(t_minishell *minishell);
void free_command_list(void *content);
void free_minishell(t_minishell **minishell);
void free_command_list(t_minishell *minishell, void *content);
t_minishell *init_minishell(void);
void print_banner(void);
void print_list(void *content);
void simple_builtins(t_minishell *minishell);
void error_msg(char *func, char *msg);
void check_malloc(void *ptr);
char *ft_strdup_safe(const char *str);
char *ft_strjoin_safe(const char *s1, const char *s2);
void *ft_malloc_safe(size_t size);
void check_malloc(t_minishell *minishell, void *ptr);
char *ft_strdup_safe(t_minishell *minishell, const char *str);
char *ft_strjoin_safe(t_minishell *minishell,
const char *s1, const char *s2);
void *malloc_safe(t_minishell *minishell, size_t size);
void free_safe(t_minishell *minishell, void **ptr);
void free_freelist(t_minishell *minishell);
void ft_lstclear_safe(t_minishell *minishell, t_list **lst,
void (*del)(t_minishell *minishell, void *));
t_list *ft_lstnew_safe(t_minishell *minishell, void *content);
#endif // UTILS_H

2
lib/libft

@ -1 +1 @@
Subproject commit 5944b0f8116007fd65a4224750cc4cdbf7ac9952
Subproject commit de8a369a6264465d4cb2979ff6d6938048a2857d

16
sources.mk
View File

@ -1,9 +1,9 @@
VPATH = src:src/prompt:src/utils:src/lexer:src/token:src/environment:src/executor:src/parser:src/debug:src/expander:src/builtin:src/signal:src/redirect:
SOURCES = history_load.c history_write.c prompt.c check_malloc.c error_msg.c \
VPATH = src:src/prompt:src/utils:src/lexer:src/token:src/environment:src/executor:src/parser:src/signal:src/debug:src/expander:src/builtin:src/redirect:
SOURCES = history_load.c history_write.c prompt.c ft_lstclear_safe.c \
ft_lstnew_safe.c ft_strdup_safe.c ft_strjoin_safe.c init_minishell.c \
malloc_safe.c print_banner.c error_msg.c check_malloc.c \
free_command_list.c free_freelist.c free_lexer.c free_minishell.c \
free_minishell_line.c free_safe.c free_token.c free_token_list.c \
ft_lstclear_safe.c ft_lstnew_safe.c ft_strdup_safe.c \
ft_strjoin_safe.c init_minishell.c malloc_safe.c print_banner.c \
lexer_read_char.c lexer_new.c lexer_parse_input.c lexer_read_word.c \
lexer_token_next.c token_new.c token_parse.c environment_add.c \
environment_del.c environment_free.c environment_free_list.c \
@ -12,11 +12,11 @@ environment_print.c executor_close_fds.c executor_absolute_path.c \
executor_child.c executor_count_fds.c executor_create_pipes.c \
executor_create_redirects.c executor_execute_pipeline.c \
executor_fork.c executor_open_fds.c parser_get_arguments.c \
parser_get_commands.c parser_new_command.c print_commands.c \
print_freelist.c expander_is_character.c expander_expand_dollar.c \
parser_get_commands.c parser_new_command.c signal.c print_commands.c \
print_freelist.c expander_expand_dollar.c expander_is_character.c \
expander_allocate_memory.c expander_get_variable.c \
expander_parse_string.c expander_parse_variables.c builtin_echo.c \
builtin_router.c simple_builtins.c is_builtin.c builtin_cd.c \
builtin_env.c builtin_exit.c builtin_export.c builtin_pwd.c \
builtin_unset.c signal.c main.c redirect_get_inputs.c \
redirect_get_outputs.c redirect_new.c redirect_valid_type.c \
builtin_unset.c redirect_valid_type.c redirect_get_inputs.c \
redirect_get_outputs.c redirect_new.c main.c \

4
src/builtin/builtin_cd.c
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/20 11:33:07 by whaffman #+# #+# */
/* Updated: 2025/02/20 12:49:36 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:57:57 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -19,7 +19,7 @@ int builtin_cd(t_minishell *minishell, t_command *cmd)
if (cmd->args[1] == NULL)
{
env = environment_get(minishell->environment, "HOME");
env = environment_get(minishell, "HOME");
if (env == NULL || env->value == NULL)
{
ft_putendl_fd("minishell: cd: HOME not set", STDERR_FILENO);

4
src/builtin/builtin_env.c
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/20 11:33:02 by whaffman #+# #+# */
/* Updated: 2025/02/20 12:17:10 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:57:49 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -15,6 +15,6 @@
int builtin_env(t_minishell *minishell, t_command *cmd)
{
(void)cmd;
environment_print(minishell->environment);
environment_print(minishell);
return (SUCCESS);
}

5
src/builtin/builtin_exit.c
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/20 11:32:59 by whaffman #+# #+# */
/* Updated: 2025/02/20 15:54:11 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 16:04:17 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -36,7 +36,8 @@ int builtin_exit(t_minishell *minishell, t_command *cmd)
}
exit_status = ft_atoi(cmd->args[1]);
}
free_minishell(minishell);
//print_freelist(minishell);
free_minishell(&minishell);
exit(exit_status);
return (FAILURE);
}

10
src/builtin/builtin_export.c
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/20 11:32:53 by whaffman #+# #+# */
/* Updated: 2025/02/20 12:30:21 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 16:39:13 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -28,14 +28,14 @@ int builtin_export(t_minishell *minishell, t_command *cmd)
i++;
continue ;
}
env = environment_get(minishell->environment, arr[0]);
env = environment_get(minishell, arr[0]);
if (env != NULL)
{
free(env->value);
env->value = ft_strdup(arr[1]); //TODO: malloc check
free_safe(minishell, (void **)&(env->value));
env->value = ft_strdup_safe(minishell, arr[1]);
}
else
environment_add(&(minishell->environment), arr[0], arr[1]);
environment_add(minishell, arr[0], arr[1]);
ft_free_arr(arr);
i++;
}

4
src/builtin/builtin_pwd.c
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/20 11:32:28 by whaffman #+# #+# */
/* Updated: 2025/02/20 13:57:01 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 15:17:51 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -20,6 +20,6 @@ int builtin_pwd(t_minishell *minishell, t_command *cmd)
(void)cmd;
cwd = getcwd(NULL, 0);
printf("%s\n", cwd);
free(cwd);
free_safe(minishell, (void **)&(cwd));
return (SUCCESS);
}

6
src/builtin/builtin_unset.c
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/20 11:25:43 by whaffman #+# #+# */
/* Updated: 2025/02/20 15:04:59 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:57:29 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -19,8 +19,8 @@ int builtin_unset(t_minishell *minishell, t_command *cmd)
i = 1;
while (cmd->args[i] != NULL)
{
if (environment_get(minishell->environment, cmd->args[i]) != NULL)
environment_del(&(minishell->environment), cmd->args[i]);
if (environment_get(minishell, cmd->args[i]) != NULL)
environment_del(minishell, cmd->args[i]);
i++;
}
return (SUCCESS);

10
src/debug/print_commands.c
View File

@ -17,18 +17,20 @@ void print_commands(void *param)
t_command *command;
int i;
if (!DEBUG)
return ;
command = (t_command *)param;
if (!command)
return ;
printf("command: %s\n", command->command);
printf("-- Args: ");
i = 0;
while (command->args[i++])
printf("%s ", command->args[i]);
while (command->args[i])
printf("%s ", command->args[i++]);
printf("\n");
printf("-- Input redirects:\n");
ft_lstiter(command->redirect_in, print_redirects);
printf("-- Output redirects:\n");
printf("-- Output redirects:\n");
ft_lstiter(command->redirect_out, print_redirects);
}
@ -46,6 +48,8 @@ void token_print(void *param)
{
t_token *token;
if (!DEBUG)
return ;
token = (t_token *)param;
printf("token type %i, value %s\n", token->type, token->value);
}

30
src/debug/print_freelist.c Normal file
View File

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* print_freelist.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/25 15:46:03 by whaffman #+# #+# */
/* Updated: 2025/02/25 18:17:13 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void print_freelist(t_minishell *minishell)
{
t_list *freelist;
int i;
if (!DEBUG)
return ;
i = 0;
freelist = minishell->freelist;
while (freelist)
{
printf("%d: %p\n", i, freelist->content);
i++;
freelist = freelist->next;
}
}

16
src/environment/environment_add.c
View File

@ -6,30 +6,32 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/04 16:13:33 by whaffman #+# #+# */
/* Updated: 2025/02/12 21:33:20 by willem ######## odam.nl */
/* Updated: 2025/02/25 16:50:12 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void environment_add(t_list **environment, char *name, char *value)
void environment_add(t_minishell *minishell, char *name, char *value)
{
t_environment *new_environment;
t_list *new_node;
t_list **environment;
environment = &minishell->environment;
if (name != NULL && value != NULL)
{
new_environment = malloc(sizeof(t_environment));
new_environment = malloc_safe(minishell, sizeof(t_environment));
if (new_environment == NULL)
return (perror("malloc"));
new_environment->name = ft_strdup(name);
new_environment->value = ft_strdup(value);
new_node = ft_lstnew(new_environment);
new_environment->name = ft_strdup_safe(minishell, name);
new_environment->value = ft_strdup_safe(minishell, value);
new_node = ft_lstnew_safe(minishell, new_environment);
if (new_node == NULL
|| new_environment->name == NULL
|| new_environment->value == NULL)
{
environment_free(new_environment);
environment_free(minishell, new_environment);
return (perror("malloc"));
}
ft_lstadd_back(environment, new_node);

12
src/environment/environment_del.c
View File

@ -6,13 +6,13 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/11 14:17:53 by whaffman #+# #+# */
/* Updated: 2025/02/11 17:20:26 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 15:19:14 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void environment_del(t_list **environment, char *name)
void environment_del(t_minishell *minishell, char *name)
{
t_list *prev;
t_list *current;
@ -21,17 +21,17 @@ void environment_del(t_list **environment, char *name)
prev = NULL;
next = NULL;
current = *environment;
current = minishell->environment;
while (current != NULL)
{
env = (t_environment *)current->content;
if (ft_strncmp(env->name, name, ft_strlen(name) + 1) == 0)
{
next = current->next;
environment_free(current->content);
free(current);
environment_free(minishell, current->content);
free_safe(minishell, (void **)&(current));
if (prev == NULL)
*environment = next;
minishell->environment = next;
else
prev->next = next;
return ;

10
src/environment/environment_free.c
View File

@ -6,18 +6,18 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/11 15:38:43 by whaffman #+# #+# */
/* Updated: 2025/02/11 15:38:48 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 15:18:45 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void environment_free(void *content)
void environment_free(t_minishell *minishell, void *content)
{
t_environment *env;
env = (t_environment *)content;
free(env->name);
free(env->value);
free(env);
free_safe(minishell, (void **)&(env->name));
free_safe(minishell, (void **)&(env->value));
free_safe(minishell, (void **)&(env));
}

21
src/environment/environment_free_list.c
View File

@ -6,13 +6,28 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/04 16:13:59 by whaffman #+# #+# */
/* Updated: 2025/02/11 17:18:27 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 15:24:08 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void environment_free_list(t_list **environment)
void environment_free_list(t_minishell *minishell)
{
ft_lstclear(environment, environment_free);
t_list **lst;
t_list *next;
lst = &minishell->environment;
if (!lst)
return ;
while (*lst)
{
if ((*lst)->next)
next = (*lst)->next;
else
next = NULL;
environment_free(minishell, (*lst)->content);
free(*lst);
*lst = next;
}
}

6
src/environment/environment_get.c
View File

@ -6,16 +6,18 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/04 16:15:05 by whaffman #+# #+# */
/* Updated: 2025/02/11 17:04:28 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:35:13 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
t_environment *environment_get(t_list *environment, char *name)
t_environment *environment_get(t_minishell *minishell, char *name)
{
t_environment *env;
t_list *environment;
environment = minishell->environment;
while (environment != NULL)
{
env = (t_environment *)environment->content;

14
src/environment/environment_get_arr.c
View File

@ -6,28 +6,26 @@
/* By: willem <willem@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/08 13:59:48 by willem #+# #+# */
/* Updated: 2025/02/11 17:18:15 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 14:29:49 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
char **environment_get_arr(t_list *environment)
char **environment_get_arr(t_minishell *minishell)
{
char **arr;
t_environment *env;
int i;
t_list *environment;
arr = malloc(sizeof(char *) * (ft_lstsize(environment) + 1));
if (arr == NULL)
return (NULL);
environment = minishell->environment;
arr = malloc_safe(minishell, sizeof(char *) * (ft_lstsize(environment) + 1));
i = 0;
while (environment != NULL)
{
env = (t_environment *)environment->content;
arr[i] = malloc(ft_strlen(env->name) + ft_strlen(env->value) + 2);
if (arr[i] == NULL)
return (ft_free_arr(arr), NULL);
arr[i] = malloc_safe(minishell, ft_strlen(env->name) + ft_strlen(env->value) + 2);
ft_strlcpy(arr[i], env->name, ft_strlen(env->name) + 1);
ft_strlcat(arr[i], "=", ft_strlen(env->name) + 2);
ft_strlcat(arr[i], env->value,

8
src/environment/environment_parse.c
View File

@ -6,23 +6,23 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 15:52:33 by whaffman #+# #+# */
/* Updated: 2025/02/11 17:18:43 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:42:22 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
int environment_parse(char **envp, t_list **environment)
int environment_parse(t_minishell *minishell, char **envp)
{
char **env;
*environment = NULL;
if (envp == NULL)
return (FAILURE);
while (*envp != NULL)
{
env = ft_split(*envp, '=');
environment_add(environment, env[0], env[1]);
environment_add(minishell, env[0], env[1]);
ft_free_arr(env);
envp++;
}

11
src/environment/environment_print.c
View File

@ -6,23 +6,18 @@
/* By: willem <willem@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/08 13:52:08 by willem #+# #+# */
/* Updated: 2025/02/11 17:05:10 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:39:45 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void environment_print(t_list *environment)
void environment_print(t_minishell *minishell)
{
char **arr;
int i;
arr = environment_get_arr(environment);
if (arr == NULL)
{
perror("malloc");
return ;
}
arr = environment_get_arr(minishell);
i = 0;
while (arr[i] != NULL)
{

14
src/executor/executor_absolute_path.c
View File

@ -6,13 +6,13 @@
/* By: willem <willem@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/08 17:00:24 by willem #+# #+# */
/* Updated: 2025/02/13 15:04:09 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 16:39:59 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
char *executor_absolute_path(t_list *env, char *cmd)
char *executor_absolute_path(t_minishell *minishell, char *cmd)
{
char **path;
t_environment *path_env;
@ -23,23 +23,21 @@ char *executor_absolute_path(t_list *env, char *cmd)
{
if (access(cmd, F_OK) == 0)
{
executable = ft_strdup(cmd);
executable = ft_strdup_safe(minishell, cmd);
if (!executable)
return (NULL);
return (executable);
}
return (NULL);
}
path_env = environment_get(env, "PATH");
path_env = environment_get(minishell, "PATH");
if (!path_env)
return (NULL);
path = ft_split(path_env->value, ':');
i = 0;
while (path[i] != NULL)
{
executable = malloc(ft_strlen(path[i]) + ft_strlen(cmd) + 2);
if (!executable)
return (ft_free_arr(path), NULL);
executable = malloc_safe(minishell, ft_strlen(path[i]) + ft_strlen(cmd) + 2);
ft_strlcpy(executable, path[i], ft_strlen(path[i]) + 1);
ft_strlcat(executable, "/", ft_strlen(path[i]) + 2);
ft_strlcat(executable, cmd, ft_strlen(path[i]) + ft_strlen(cmd) + 2);
@ -48,7 +46,7 @@ char *executor_absolute_path(t_list *env, char *cmd)
ft_free_arr(path);
return (executable);
}
free(executable);
free_safe(minishell, (void **)&executable);
i++;
}
return (ft_free_arr(path), NULL);

9
src/executor/executor_child.c
View File

@ -6,21 +6,22 @@
/* By: willem <willem@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/12 21:25:10 by willem #+# #+# */
/* Updated: 2025/02/19 12:56:03 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:52:53 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void executor_child(t_command *command)
void executor_child(t_minishell *minishell, t_command *command)
{
char *path;
if (command->fd_in != 0)
dup2(command->fd_in, 0);
if (command->fd_out != 1)
dup2(command->fd_out, 1);
executor_close_fds(command->n_fds);
path = executor_absolute_path(command->environment, command->command);
path = executor_absolute_path(minishell, command->command);
if (path == NULL)
{
ft_putstr_fd(RED BOLD, 2);
@ -28,5 +29,5 @@ void executor_child(t_command *command)
ft_putstr_fd(": " RESET "command not found\n", 2);
return ;
}
execve(path, command->args, environment_get_arr(command->environment));
execve(path, command->args, environment_get_arr(minishell));
}

31
src/executor/executor_count_fds.c Normal file
View File

@ -0,0 +1,31 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* executor_count_fds.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/21 12:42:26 by whaffman #+# #+# */
/* Updated: 2025/02/21 13:05:55 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
int executor_count_fds(t_minishell *minishell)
{
int count;
t_list *current;
t_command *command;
current = minishell->commands;
count = (ft_lstsize(current) - 1) * 2;
while (current)
{
command = (t_command *)current->content;
count += ft_lstsize(command->redirect_in);
count += ft_lstsize(command->redirect_out);
current = current->next;
}
return (count);
}

8
src/executor/executor_create_pipes.c
View File

@ -6,7 +6,7 @@
/* By: willem <willem@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/12 21:25:22 by willem #+# #+# */
/* Updated: 2025/02/13 14:58:49 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 14:19:57 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -29,6 +29,7 @@ void executor_create_pipes(t_minishell *minishell)
t_command *command;
int fd[2];
int fd_in;
const int n_fds = executor_count_fds(minishell);
fd_in = 0;
current = minishell->commands;
@ -37,13 +38,14 @@ void executor_create_pipes(t_minishell *minishell)
command = (t_command *)current->content;
if (current->next)
{
pipe(fd);
if (pipe(fd) == -1)
error_msg("pipe", "pipe creation failed");
command->fd_out = fd[1];
}
else
command->fd_out = 1;
command->fd_in = fd_in;
command->n_fds = (ft_lstsize(minishell->commands) - 1) * 2;
command->n_fds = n_fds;
fd_in = fd[0];
current = current->next;
}

28
src/executor/executor_create_redirects.c Normal file
View File

@ -0,0 +1,28 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* executor_create_redirects.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/21 13:00:00 by whaffman #+# #+# */
/* Updated: 2025/02/21 13:16:03 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void executor_create_redirects(t_minishell *minishell)
{
t_list *current;
t_command *cmd;
current = minishell->commands;
while (current)
{
cmd = (t_command *)current->content;
cmd->fd_in = executor_open_fds(cmd->redirect_in, cmd->fd_in);
cmd->fd_out = executor_open_fds(cmd->redirect_out, cmd->fd_out);
current = current->next;
}
}

5
src/executor/executor_execute_pipeline.c
View File

@ -6,7 +6,7 @@
/* By: willem <willem@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/12 21:25:02 by willem #+# #+# */
/* Updated: 2025/02/19 13:40:45 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:52:35 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -20,13 +20,14 @@ int executor_execute_pipeline(t_minishell *minishell)
int exit_status;
executor_create_pipes(minishell);
executor_create_redirects(minishell);
current = minishell->commands;
last_pid = 0;
while (current)
{
command = (t_command *)current->content;
command->environment = minishell->environment;
last_pid = executor_fork(command);
last_pid = executor_fork(minishell, command);
current = current->next;
}
waitpid(last_pid, &exit_status, 0);

6
src/executor/executor_fork.c
View File

@ -6,13 +6,13 @@
/* By: willem <willem@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/12 21:24:52 by willem #+# #+# */
/* Updated: 2025/02/19 13:40:19 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 13:51:48 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
pid_t executor_fork(t_command *command)
pid_t executor_fork(t_minishell *minishell, t_command *command)
{
pid_t pid;
// int status;
@ -31,7 +31,7 @@ pid_t executor_fork(t_command *command)
else if (pid == 0)
{
signal_init_child();
executor_child(command);
executor_child(minishell, command);
exit(127);
}
else

39
src/executor/executor_open_fds.c Normal file
View File

@ -0,0 +1,39 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* executor_open_fds.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/21 12:50:42 by whaffman #+# #+# */
/* Updated: 2025/02/21 13:15:04 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
int executor_open_fds(t_list *redirect_list, int og_fd)
{
t_redirect *redirect;
int fd;
fd = og_fd;
while (redirect_list)
{
redirect = (t_redirect *)redirect_list->content;
if (redirect->type == T_REDIRECT_IN)
fd = open(redirect->value, O_RDONLY);
else if (redirect->type == T_REDIRECT_OUT)
fd = open(redirect->value, O_WRONLY | O_CREAT | O_TRUNC, 0644);
else if (redirect->type == T_APPEND_OUT)
fd = open(redirect->value, O_WRONLY | O_CREAT | O_APPEND, 0644);
if (fd < 0)
{
error_msg("executor_open_fds", "can't open file");
return (og_fd);
}
redirect_list = redirect_list->next;
}
return (fd);
}

27
src/expander/expander_allocate_memory.c
View File

@ -1,40 +1,41 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* expander_allocate_memory.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/19 13:57:19 by qmennen #+# #+# */
/* Updated: 2025/02/19 13:57:36 by qmennen ### ########.fr */
/* :::::::: */
/* expander_allocate_memory.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/19 13:57:19 by qmennen #+# #+# */
/* Updated: 2025/02/25 17:54:08 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
char *expander_allocate_memory(const char *s, t_list *variables)
char *expander_allocate_memory(
t_minishell *minishell,
const char *s,
t_list *variables)
{
int size;
t_list *current;
t_environment *env;
char *string;
size = 0;
size = 1;
current = variables;
while (current)
{
if (current->content == NULL)
{
current = current->next;
continue;
continue ;
}
env = (t_environment *)current->content;
size += (ft_strlen(env->value) - ft_strlen(env->name));
current = current->next;
}
size += ft_strlen(s);
string = malloc(size);
if (!string)
perror("expander malloc");
string = malloc_safe(minishell, size);
return (string);
}

18
src/expander/expander_get_variable.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* expander_get_variable.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/19 13:59:03 by qmennen #+# #+# */
/* Updated: 2025/02/19 13:59:14 by qmennen ### ########.fr */
/* :::::::: */
/* expander_get_variable.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/19 13:59:03 by qmennen #+# #+# */
/* Updated: 2025/02/25 15:26:36 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -24,7 +24,7 @@ t_environment *expander_get_var(const char *s, int idx, t_minishell *minishell)
name = ft_substr(s, idx, i);
if (!name || !*name)
return (NULL);
env = environment_get(minishell->environment, name);
free(name);
env = environment_get(minishell, name);
free_safe(minishell, (void **)&name);
return (env);
}

22
src/expander/expander_parse_string.c
View File

@ -1,18 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* expander_parse_string.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/18 19:00:35 by qmennen #+# #+# */
/* Updated: 2025/02/20 16:38:28 by qmennen ### ########.fr */
/* :::::::: */
/* expander_parse_string.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/18 19:00:35 by qmennen #+# #+# */
/* Updated: 2025/02/25 16:14:16 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
static void free_variables(t_list *variables)
static void free_variables(t_minishell *minishell, t_list *variables)
{
t_list *current;
t_list *last;
@ -22,7 +22,7 @@ static void free_variables(t_list *variables)
{
last = current;
current = current->next;
free(last);
free_safe(minishell, (void **)&last);
}
}
@ -35,7 +35,7 @@ char *expander_parse_string(char *s, t_minishell *minishell)
int j;
variables = expander_parse_variables(s, minishell);
string = expander_allocate_memory(s, variables);
string = expander_allocate_memory(minishell, s, variables);
i = 0;
j = 0;
current = variables;
@ -54,6 +54,6 @@ char *expander_parse_string(char *s, t_minishell *minishell)
//TODO: Figure out why echo "> echo "\as"" breaks
string[j] = 0;
free_variables(variables);
free_variables(minishell, variables);
return (string);
}

18
src/expander/expander_parse_variables.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* expander_parse_variables.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/19 13:58:13 by qmennen #+# #+# */
/* Updated: 2025/02/19 15:07:23 by qmennen ### ########.fr */
/* :::::::: */
/* expander_parse_variables.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/19 13:58:13 by qmennen #+# #+# */
/* Updated: 2025/02/25 16:51:16 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -27,9 +27,9 @@ t_list *expander_parse_variables(const char *s, t_minishell *minishell)
{
env = expander_get_var(s, i + 1, minishell);
if (env)
ft_lstadd_back(&var_list, ft_lstnew(env));
ft_lstadd_back(&var_list, ft_lstnew_safe(minishell, env));
else
ft_lstadd_back(&var_list, ft_lstnew(NULL));
ft_lstadd_back(&var_list, ft_lstnew_safe(minishell, NULL));
}
i++;
}

29
src/lexer/lexer_new.c
View File

@ -1,28 +1,25 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lexer_new.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 19:03:01 by qmennen #+# #+# */
/* Updated: 2025/02/05 19:08:41 by qmennen ### ########.fr */
/* :::::::: */
/* lexer_new.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 19:03:01 by qmennen #+# #+# */
/* Updated: 2025/02/25 16:40:16 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
t_lexer *ft_lexer_new(const char *input)
t_lexer *ft_lexer_new(t_minishell *minishell)
{
t_lexer *lexer;
char *input;
lexer = malloc(sizeof(t_lexer));
if (!lexer)
{
perror("failed assigning lexer memory");
exit(EXIT_FAILURE);
}
lexer->input = ft_strdup(input);
t_lexer *lexer;
input = minishell->line;
lexer = malloc_safe(minishell, sizeof(t_lexer));
lexer->input = ft_strdup_safe(minishell, input);
lexer->pos = 0;
lexer->n_pos = 1;
lexer->current_char = '\0';

24
src/lexer/lexer_parse_input.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lexer_parse_input.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 19:09:20 by qmennen #+# #+# */
/* Updated: 2025/02/20 16:42:39 by qmennen ### ########.fr */
/* :::::::: */
/* lexer_parse_input.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 19:09:20 by qmennen #+# #+# */
/* Updated: 2025/02/25 16:51:27 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -23,20 +23,22 @@
* the input to be parsed.
* @return A linked list of tokens parsed from the input.
*/
t_list *ft_parse_input(t_lexer *lexer)
t_list *ft_parse_input(t_minishell *minishell)
{
t_list *list;
t_token *token;
t_lexer *lexer;
lexer = minishell->lexer;
list = NULL;
while (TRUE)
{
//TODO: Check if unicode support is viable
token = ft_token_next(lexer);
token = ft_token_next(minishell, lexer);
if (token->type == T_EOF || token->type == T_ERROR) //TODO T_ERROR removes the inf loop
break ;
ft_lstadd_back(&list, ft_lstnew(token));
ft_lstadd_back(&list, ft_lstnew_safe(minishell, token));
}
ft_token_free(token);
ft_token_free(minishell, token);
return (list);
}

26
src/lexer/lexer_read_word.c
View File

@ -1,18 +1,18 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lexer_read_word.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 19:03:47 by qmennen #+# #+# */
/* Updated: 2025/02/19 14:12:19 by qmennen ### ########.fr */
/* :::::::: */
/* lexer_read_word.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 19:03:47 by qmennen #+# #+# */
/* Updated: 2025/02/25 15:27:01 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
static char *parse_quotes(t_lexer *lexer)
static char *parse_quotes(t_minishell *minishell, t_lexer *lexer)
{
int start;
int len;
@ -26,19 +26,19 @@ static char *parse_quotes(t_lexer *lexer)
while (lexer->current_char != '\0' && lexer->current_char != qc)
lexer_readchar(lexer);
len = lexer->pos - start;
word = malloc(sizeof(char) * len + 1);
word = malloc_safe(minishell, sizeof(char) * len + 1);
ft_strlcpy(word, lexer->input + start, len + 1);
if (lexer->current_char == qc)
lexer_readchar(lexer);
else
{
free(word);
free_safe(minishell, (void **)&word);
return (NULL);
}
return (word);
}
char *lexer_readword(t_lexer *lexer)
char *lexer_readword(t_minishell *minishell, t_lexer *lexer)
{
int start;
int len;
@ -47,7 +47,7 @@ char *lexer_readword(t_lexer *lexer)
start = lexer->pos;
if (lexer->current_char == '"' || lexer->current_char == '\'')
{
return (parse_quotes(lexer));
return (parse_quotes(minishell, lexer));
}
while (ft_isprint(lexer->current_char) && lexer->current_char != '<'
&& lexer->current_char != '>' && lexer->current_char != '|'
@ -57,7 +57,7 @@ char *lexer_readword(t_lexer *lexer)
lexer_readchar(lexer);
}
len = lexer->pos - start;
word = malloc(sizeof(char) * len + 1);
word = malloc_safe(minishell, sizeof(char) * len + 1);
ft_strlcpy(word, lexer->input + start, len + 1);
return (word);
}

18
src/lexer/lexer_token_next.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/04 16:07:58 by qmennen #+# #+# */
/* Updated: 2025/02/20 10:39:50 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 15:27:11 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -42,7 +42,7 @@ static t_token_type get_word_type(char c)
* - If it is a printable character, reads the word and creates a word token.
* - Otherwise, creates an error token.
*/
t_token *ft_token_next(t_lexer *lexer)
t_token *ft_token_next(t_minishell *minishell, t_lexer *lexer)
{
t_token *token;
t_token_type word_type;
@ -54,22 +54,22 @@ t_token *ft_token_next(t_lexer *lexer)
lexer_readchar(lexer);
current_pos = lexer->pos;
if (lexer->current_char == '\0')
token = token_new(T_EOF, NULL, current_pos);
token = token_new(minishell, T_EOF, NULL, current_pos);
else if (lexer->current_char == '<' || lexer->current_char == '>'
|| lexer->current_char == '|')
token = token_parse(lexer);
token = token_parse(minishell, lexer);
else if (ft_isprint(lexer->current_char))
{
word_type = get_word_type(lexer->current_char);
word = lexer_readword(lexer);
word = lexer_readword(minishell, lexer);
if (!word)
return (token_new(T_ERROR, &lexer->current_char, current_pos));
token = token_new(word_type, word, current_pos);
free(word);
return (token_new(minishell, T_ERROR, &lexer->current_char, current_pos));
token = token_new(minishell, word_type, word, current_pos);
free_safe(minishell, (void **)&word);
}
else
{
token = token_new(T_ERROR, NULL, current_pos);
token = token_new(minishell, T_ERROR, NULL, current_pos);
printf("token->type: %d\n", token->type);
}
return (token);

10
src/main.c
View File

@ -24,20 +24,20 @@ int main(int argc, char **argv, char **envp)
history_load();
minishell = init_minishell();
signal_init_minishell();
environment_parse(envp, &(minishell->environment));
environment_parse(minishell, envp);
while (TRUE)
{
minishell->line = ft_prompt(minishell);
if (minishell->line == NULL)
break ;
minishell->lexer = ft_lexer_new(minishell->line);
minishell->tokens = ft_parse_input(minishell->lexer);
minishell->lexer = ft_lexer_new(minishell);
minishell->tokens = ft_parse_input(minishell);
//ft_lstiter(minishell->tokens, token_print);
minishell->commands = parser_get_commands(minishell);
simple_builtins(minishell);
free_minishell_line(minishell);
}
ft_lstclear(&minishell->commands, free_command_list);
free_minishell(minishell);
ft_lstclear_safe(minishell, &minishell->commands, free_command_list);
free_minishell(&minishell);
return (EXIT_SUCCESS);
}

11
src/parser/parser_get_arguments.c
View File

@ -6,7 +6,7 @@
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/11 16:20:09 by qmennen #+# #+# */
/* Updated: 2025/02/12 12:58:42 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 16:40:26 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -50,12 +50,7 @@ char **parser_get_arguments(t_list *list, t_minishell *minishell)
int i;
cmds = count_cmds(list);
args = malloc((cmds + 1) * sizeof(char *));
if (!args)
{
perror("malloc");
exit(EXIT_FAILURE);
}
args = malloc_safe(minishell, (cmds + 1) * sizeof(char *));
current = list;
i = -1;
while ((++i) < cmds && current)
@ -66,7 +61,7 @@ char **parser_get_arguments(t_list *list, t_minishell *minishell)
}
else if (((t_token *)current->content)->type == T_WORD ||
((t_token *)current->content)->type == T_SQWORD)
args[i] = ft_strdup(((t_token *)current->content)->value);
args[i] = ft_strdup_safe(minishell, ((t_token *)current->content)->value);
current = current->next;
}
args[i] = 0;

8
src/parser/parser_get_commands.c
View File

@ -31,11 +31,11 @@ t_list *parser_get_commands(t_minishell *minishell)
while (current)
{
token = (t_token *) current->content;
command = parser_command_new(ft_strdup(token->value));
command = parser_command_new(minishell, ft_strdup_safe(minishell, token->value));
command->args = parser_get_arguments(current, minishell);
command->redirect_in = redirect_get_inputs(current);
command->redirect_out = redirect_get_outputs(current);
ft_lstadd_back(&command_list, ft_lstnew(command));
command->redirect_in = redirect_get_inputs(minishell, current);
command->redirect_out = redirect_get_outputs(minishell, current);
ft_lstadd_back(&command_list, ft_lstnew_safe(minishell, command));
while (current && is_command_token((t_token *)current->content))
current = current->next;
if (current && ((t_token *)current->content)->type >= 3)

28
src/parser/parser_new_command.c
View File

@ -1,30 +1,30 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parser_new_command.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/11 16:18:21 by qmennen #+# #+# */
/* Updated: 2025/02/11 16:25:12 by qmennen ### ########.fr */
/* :::::::: */
/* parser_new_command.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/11 16:18:21 by qmennen #+# #+# */
/* Updated: 2025/02/25 14:41:57 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
t_command *parser_command_new(char *cmd)
t_command *parser_command_new(t_minishell *minishell, char *cmd)
{
t_command *command;
command = malloc(sizeof(t_command));
if (!command)
{
perror("minishell malloc error");
exit(EXIT_FAILURE);
}
command = malloc_safe(minishell, sizeof(t_command));
\
command->args = NULL;
command->fd_in = 0;
command->fd_out = 1;
command->redirect_in = NULL;
command->redirect_out = NULL;
command->environment = NULL;
command->n_fds = 0;
command->command = cmd;
return (command);
}

67
src/prompt/prompt.c
View File

@ -1,18 +1,18 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* prompt.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/04 16:13:08 by whaffman #+# #+# */
/* Updated: 2025/02/19 13:44:20 by whaffman ######## odam.nl */
/* ::: :::::::: */
/* prompt.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/04 16:13:08 by whaffman #+# #+# */
/* Updated: 2025/02/25 18:41:56 by qmennen ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
char *get_user(t_list *environment)
char *get_user(t_minishell *minishell)
{
const char guest[] = "guest";
int len;
@ -20,37 +20,32 @@ char *get_user(t_list *environment)
char *username;
char *result;
user = environment_get(environment, "USER");
user = environment_get(minishell, "USER");
if (user == NULL)
username = (char *)guest;
else
username = user->value;
len = ft_strlen(username) + ft_strlen(PROMPT GREEN) + 1;
result = (char *)malloc(len);
if (result == NULL)
{
perror("malloc");
return (NULL);
}
result = (char *)malloc_safe(minishell, len);
ft_strlcpy(result, GREEN, ft_strlen(GREEN) + 1);
ft_strlcat(result, username, ft_strlen(GREEN) + ft_strlen(username) + 1);
ft_strlcat(result, PROMPT, len);
return (result);
}
int get_home_len(char *cwd, t_list *environment)
int get_home_len(t_minishell *minishell, char *cwd)
{
t_environment *home;
int home_len;
home = environment_get(environment, "HOME");
home = environment_get(minishell, "HOME");
home_len = 0;
if (home && !ft_strncmp(cwd, home->value, ft_strlen(home->value)))
home_len = ft_strlen(home->value) - 1;
return (home_len);
}
char *get_path_with_home(t_list *environment)
char *get_path_with_home(t_minishell *minishell)
{
char *result;
char *cwd;
@ -60,11 +55,9 @@ char *get_path_with_home(t_list *environment)
cwd = getcwd(NULL, 0);
if (cwd == NULL)
return (perror("getcwd"), NULL);
home_len = get_home_len(cwd, environment);
home_len = get_home_len(minishell, cwd);
len = ft_strlen(cwd) - home_len + 1;
result = malloc(len);
if (result == NULL)
return (free(cwd), NULL);
result = malloc_safe(minishell, len);
if (home_len)
{
ft_strlcpy(result, "~", 2);
@ -76,26 +69,21 @@ char *get_path_with_home(t_list *environment)
return (result);
}
char *get_path(t_list *environment)
char *get_path(t_minishell *minishell)
{
char *result;
char *cwd;
int len;
cwd = get_path_with_home(environment);
cwd = get_path_with_home(minishell);
if (cwd == NULL)
return (NULL);
len = ft_strlen(cwd) + ft_strlen(BLUE RESET "> ") + 1;
result = malloc(len);
if (result == NULL)
{
perror("malloc");
return (free(cwd), NULL);
}
result = malloc_safe(minishell, len);
ft_strlcpy(result, BLUE, len);
ft_strlcat(result, cwd, len);
ft_strlcat(result, RESET "> ", len);
free(cwd);
free_safe(minishell,(void **) &cwd);
return (result);
}
@ -106,23 +94,18 @@ char *ft_prompt(t_minishell *minishell)
char *prompt;
char *user;
cwd = get_path(minishell->environment);
cwd = get_path(minishell);
if (cwd == NULL)
return (NULL);
user = get_user(minishell->environment);
user = get_user(minishell);
if (user == NULL)
return (free(cwd), NULL);
prompt = ft_strjoin(user, cwd);
if (prompt == NULL)
{
perror("malloc");
return (free(cwd), free(user), NULL);
}
free(user);
free(cwd);
prompt = ft_strjoin_safe(minishell, user, cwd);
free_safe(minishell, (void **)&user);
free_safe(minishell, (void **)&cwd);
rl_on_new_line();
line = readline(prompt);
free(prompt);
free_safe(minishell, (void **)&prompt);
if (line == NULL)
return (NULL);
history_write(line);

67
src/redirect/redirect_get_inputs.c
View File

@ -10,38 +10,41 @@
/* */
/* ************************************************************************** */
# include "redirect.h"
#include "redirect.h"
t_list *redirect_get_inputs(t_list *list)
t_list *redirect_get_inputs(t_minishell *minishell, t_list *list)
{
t_list *current;
t_list *redirects;
t_token *token;
t_list *current;
t_list *redirects;
t_token *token;
redirects = NULL;
current = list;
while (current)
{
token = (t_token *)current->content;
if (redirect_is_delimiter(token))
break ;
if (token->type != T_REDIRECT_IN && token->type != T_HEREDOC)
{
current = current->next;
continue ;
}
if (redirect_is_valid(current, token))
{
ft_lstadd_front(&redirects, ft_lstnew(redirect_new(token->type, ft_strdup(((t_token *)current->next->content)->value))));
current = current->next;
continue ;
}
else
{
ft_lstadd_front(&redirects, ft_lstnew(redirect_new(T_ERROR, NULL)));
break ;
}
current = current->next;
}
return (redirects);
}
redirects = NULL;
current = list;
while (current)
{
token = (t_token *)current->content;
if (redirect_is_delimiter(token))
break ;
if (token->type != T_REDIRECT_IN && token->type != T_HEREDOC)
{
current = current->next;
continue ;
}
if (redirect_is_valid(current, token))
{
ft_lstadd_front(&redirects, ft_lstnew_safe(minishell,
redirect_new(minishell, token->type,
ft_strdup_safe(minishell,
((t_token *)current->next->content)->value))));
current = current->next;
continue ;
}
else
{
ft_lstadd_front(&redirects, ft_lstnew_safe(minishell, redirect_new(minishell, T_ERROR, NULL)));
break ;
}
current = current->next;
}
return (redirects);
}

63
src/redirect/redirect_get_outputs.c
View File

@ -12,36 +12,37 @@
#include "minishell.h"
t_list *redirect_get_outputs(t_list *list)
t_list *redirect_get_outputs(t_minishell *minishell, t_list *list)
{
t_list *current;
t_list *redirects;
t_token *token;
t_list *current;
t_list *redirects;
t_token *token;
redirects = NULL;
current = list;
while (current)
{
token = (t_token *)current->content;
if (redirect_is_delimiter(token))
break;
if (token->type != T_REDIRECT_OUT && token->type != T_APPEND_OUT)
{
current = current->next;
continue ;
}
if (redirect_is_valid(current, token))
{
ft_lstadd_front(&redirects, ft_lstnew(redirect_new(token->type, ft_strdup(((t_token *)current->next->content)->value))));
current = current->next;
continue ;
}
else
{
ft_lstadd_front(&redirects, ft_lstnew(redirect_new(T_ERROR, NULL)));
break ;
}
current = current->next;
}
return (redirects);
}
redirects = NULL;
current = list;
while (current)
{
token = (t_token *)current->content;
if (redirect_is_delimiter(token))
break ;
if (token->type != T_REDIRECT_OUT && token->type != T_APPEND_OUT)
{
current = current->next;
continue ;
}
if (redirect_is_valid(current, token))
{
ft_lstadd_front(&redirects,
ft_lstnew_safe(minishell, redirect_new(minishell, token->type, ft_strdup_safe(minishell, ((t_token *)current->next->content)->value))));
current = current->next;
continue ;
}
else
{
ft_lstadd_front(&redirects, ft_lstnew_safe(minishell, redirect_new(minishell, T_ERROR, NULL)));
break ;
}
current = current->next;
}
return (redirects);
}

6
src/redirect/redirect_new.c
View File

@ -12,14 +12,14 @@
#include "minishell.h"
t_redirect *redirect_new(t_token_type type, char *value)
t_redirect *redirect_new(t_minishell * minishell, t_token_type type, char *value)
{
t_redirect *result;
result = ft_malloc_safe(sizeof(t_redirect));
result = malloc_safe(minishell, sizeof(t_redirect));
result->type = type;
result->value = NULL;
if (value)
result->value = value;
return (result);
}
}

25
src/token/token_new.c
View File

@ -1,31 +1,26 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* token_new.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 19:10:49 by qmennen #+# #+# */
/* Updated: 2025/02/18 17:01:52 by qmennen ### ########.fr */
/* :::::::: */
/* token_new.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 19:10:49 by qmennen #+# #+# */
/* Updated: 2025/02/25 16:42:52 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
t_token *token_new(t_token_type type, char *c, int pos)
t_token *token_new(t_minishell *minishell, t_token_type type, char *c, int pos)
{
t_token *token;
token = malloc(sizeof(t_token));
if (!token)
{
perror("failed assigning token memory");
exit(EXIT_FAILURE);
}
token = malloc_safe(minishell, sizeof(t_token));
token->type = type;
token->position = pos;
if (c)
token->value = ft_strdup(c);
token->value = ft_strdup_safe(minishell, c);
else
token->value = NULL;
return (token);

18
src/token/token_parse.c
View File

@ -1,12 +1,12 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* token_parse.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 19:10:17 by qmennen #+# #+# */
/* Updated: 2025/02/18 17:02:17 by qmennen ### ########.fr */
/* :::::::: */
/* token_parse.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 19:10:17 by qmennen #+# #+# */
/* Updated: 2025/02/25 14:45:08 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -56,7 +56,7 @@ static char *char_from_type(t_token_type type)
return (NULL);
}
t_token *token_parse(t_lexer *lexer)
t_token *token_parse(t_minishell *minishell, t_lexer *lexer)
{
int is_double;
char c;
@ -66,7 +66,7 @@ t_token *token_parse(t_lexer *lexer)
c = lexer->current_char;
is_double = lexer->input[lexer->pos + 1] == c;
type = token_from_char(c, is_double);
token = token_new(type, char_from_type(type), lexer->pos);
token = token_new(minishell, type, char_from_type(type), lexer->pos);
if (is_double)
lexer_readchar(lexer);
lexer_readchar(lexer);

17
src/utils/check_malloc.c
View File

@ -13,11 +13,26 @@
#include "minishell.h"
void check_malloc(void *ptr)
void check_malloc(t_minishell *minishell, void *ptr)
{
t_list *new;
if (ptr == NULL)
{
error_msg("malloc", "can't allocate memory");
ft_lstclear(&(minishell->freelist), free);
exit(1);
}
else
{
new = ft_lstnew(ptr);
if (new == NULL)
{
error_msg("malloc", "can't allocate memory");
ft_lstclear(&(minishell->freelist), free);
exit(1);
}
else
ft_lstadd_front(&(minishell->freelist), new);
}
}

26
src/utils/free_command_list.c
View File

@ -12,20 +12,20 @@
#include "minishell.h"
static void free_args(char **args)
static void free_args(t_minishell *minishell, char **args)
{
int i;
i = 0;
while (args[i])
{
free(args[i]);
free_safe(minishell, (void **)&args[i]);
i++;
}
free(args);
free_safe(minishell, (void **)&args);
}
static void free_redirects(t_list *lst)
static void free_redirects(t_minishell *minishell, t_list *lst)
{
t_redirect *redir;
t_list *current;
@ -37,26 +37,26 @@ static void free_redirects(t_list *lst)
last = current;
redir = (t_redirect *)current->content;
if (redir && redir->value)
free(redir->value);
free_safe(minishell, (void **)&redir->value);
if (redir)
free(redir);
free_safe(minishell, (void **)&redir);
current = current->next;
free(last);
free_safe(minishell, (void **)&last);
}
}
void free_command_list(void *content)
void free_command_list(t_minishell *minishell, void *content)
{
t_command *command;
command = (t_command *)content;
if (command->command)
free(command->command);
free_safe(minishell, (void **)&(command->command));
if (command->args)
free_args(command->args);
free_args(minishell, command->args);
if (command->redirect_in)
free_redirects(command->redirect_in);
free_redirects(minishell, command->redirect_in);
if (command->redirect_out)
free_redirects(command->redirect_out);
free(command);
free_redirects(minishell, command->redirect_out);
free_safe(minishell, (void **)&command);
}

29
src/utils/free_freelist.c Normal file
View File

@ -0,0 +1,29 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* free_freelist.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/25 13:23:30 by whaffman #+# #+# */
/* Updated: 2025/02/25 15:56:40 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void free_freelist(t_minishell *minishell)
{
t_list *freelist;
t_list *next;
freelist = minishell->freelist;
while (freelist)
{
next = freelist->next;
free(freelist->content);
free(freelist);
freelist = next;
}
minishell->freelist = NULL;
}

20
src/utils/free_lexer.c
View File

@ -1,20 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* free_lexer.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 19:07:01 by qmennen #+# #+# */
/* Updated: 2025/02/05 19:07:18 by qmennen ### ########.fr */
/* :::::::: */
/* free_lexer.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 19:07:01 by qmennen #+# #+# */
/* Updated: 2025/02/25 16:16:01 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void ft_lexer_free(t_lexer *lexer)
void ft_lexer_free(t_minishell *minishell, t_lexer *lexer)
{
if (lexer->input)
free(lexer->input);
free(lexer);
free_safe(minishell, (void **)&(lexer->input));
free_safe(minishell, (void **)&lexer);
}

16
src/utils/free_minishell.c
View File

@ -6,17 +6,19 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 16:03:57 by whaffman #+# #+# */
/* Updated: 2025/02/11 15:36:24 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 16:02:57 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void free_minishell(t_minishell *minishell)
void free_minishell(t_minishell **minishell)
{
if (minishell->line)
free_minishell_line(minishell);
if (minishell->environment)
environment_free_list(&minishell->environment);
free(minishell);
// if ((*minishell)->line)
// free_minishell_line(*minishell);
// if ((*minishell)->environment)
// environment_free_list(*minishell);
free_freelist(*minishell);
free(*minishell);
*minishell = NULL;
}

8
src/utils/free_minishell_line.c
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 16:01:44 by whaffman #+# #+# */
/* Updated: 2025/02/05 16:02:07 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 17:40:32 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -17,9 +17,9 @@ void free_minishell_line(t_minishell *minishell)
if (minishell->line)
free(minishell->line);
if (minishell->lexer)
ft_lexer_free(minishell->lexer);
ft_lexer_free(minishell, minishell->lexer);
if (minishell->tokens)
ft_lstclear(&minishell->tokens, ft_clear_tokenlist);
ft_lstclear_safe(minishell, &minishell->tokens, ft_clear_tokenlist);
if (minishell->commands)
ft_lstclear(&minishell->commands, free_command_list);
ft_lstclear_safe(minishell, &minishell->commands, free_command_list);
}

47
src/utils/free_safe.c Normal file
View File

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* free_safe.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/25 15:09:34 by whaffman #+# #+# */
/* Updated: 2025/02/25 18:06:06 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
#include <execinfo.h>
#include <stdio.h>
#include <stdlib.h>
void free_safe(t_minishell *minishell, void **ptr)
{
t_list *prev;
t_list *current;
prev = NULL;
current = minishell->freelist;
if (*ptr)
{
while (current)
{
if (current->content == *ptr)
{
if (prev)
prev->next = current->next;
else
minishell->freelist = current->next;
free(*ptr);
free(current);
return ;
}
prev = current;
current = current->next;
}
error_msg("free_safe", "pointer not found in freelist");
}
*ptr = NULL;
}

20
src/utils/free_token.c
View File

@ -1,20 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* free_token.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 19:07:45 by qmennen #+# #+# */
/* Updated: 2025/02/05 19:07:54 by qmennen ### ########.fr */
/* :::::::: */
/* free_token.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 19:07:45 by qmennen #+# #+# */
/* Updated: 2025/02/25 16:17:52 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void ft_token_free(t_token *token)
void ft_token_free(t_minishell *minishell, t_token *token)
{
if (token->value)
free(token->value);
free(token);
free_safe(minishell, (void **)&token->value);
free_safe(minishell, (void **)&token);
}

18
src/utils/free_token_list.c
View File

@ -1,21 +1,21 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* free_token_list.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2025/02/05 19:08:14 by qmennen #+# #+# */
/* Updated: 2025/02/05 19:08:31 by qmennen ### ########.fr */
/* :::::::: */
/* free_token_list.c :+: :+: */
/* +:+ */
/* By: qmennen <qmennen@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 19:08:14 by qmennen #+# #+# */
/* Updated: 2025/02/25 16:18:44 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void ft_clear_tokenlist(void *content)
void ft_clear_tokenlist(t_minishell *minishell, void *content)
{
t_token *token;
token = (t_token *)content;
ft_token_free(token);
ft_token_free(minishell, token);
}

30
src/utils/ft_lstclear_safe.c Normal file
View File

@ -0,0 +1,30 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* minishell_lstclear.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/25 16:21:16 by whaffman #+# #+# */
/* Updated: 2025/02/25 16:48:43 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
void ft_lstclear_safe(t_minishell *minishell, t_list **lst,
void (*del)(t_minishell *minishell, void *))
{
t_list *current;
t_list *next;
current = *lst;
while (current)
{
next = current->next;
del(minishell, current->content);
free_safe(minishell, (void **)&current);
current = next;
}
*lst = NULL;
}

23
src/utils/ft_lstnew_safe.c Normal file
View File

@ -0,0 +1,23 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* minishell_lstnew.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/25 16:47:09 by whaffman #+# #+# */
/* Updated: 2025/02/25 16:49:11 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
#include "minishell.h"
t_list *ft_lstnew_safe(t_minishell *minishell, void *content)
{
t_list *new;
new = malloc_safe(minishell, sizeof(t_list));
new->content = content;
new->next = NULL;
return (new);
}

4
src/utils/ft_strdup_safe.c
View File

@ -12,11 +12,11 @@
#include "minishell.h"
char *ft_strdup_safe(const char *str)
char *ft_strdup_safe(t_minishell *minishell, const char *str)
{
char *new_str;
new_str = ft_strdup(str);
check_malloc(new_str);
check_malloc(minishell, new_str);
return (new_str);
}

4
src/utils/ft_strjoin_safe.c
View File

@ -12,12 +12,12 @@
#include "minishell.h"
char *ft_strjoin_safe(const char *s1, const char *s2)
char *ft_strjoin_safe(t_minishell *minishell, const char *s1, const char *s2)
{
char *new_str;
new_str = ft_strjoin(s1, s2);
check_malloc(new_str);
check_malloc(minishell, new_str);
return (new_str);
}

3
src/utils/init_minishell.c
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 16:03:03 by whaffman #+# #+# */
/* Updated: 2025/02/05 16:03:15 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 14:50:19 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -27,5 +27,6 @@ t_minishell *init_minishell(void)
minishell->lexer = NULL;
minishell->tokens = NULL;
minishell->commands = NULL;
minishell->freelist = NULL;
return (minishell);
}

6
src/utils/ft_malloc_safe.c → src/utils/malloc_safe.c
View File

@ -1,7 +1,7 @@
/* ************************************************************************** */
/* */
/* :::::::: */
/* ft_malloc_safe.c :+: :+: */
/* malloc_safe.c :+: :+: */
/* +:+ */
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
@ -12,11 +12,11 @@
#include "minishell.h"
void *ft_malloc_safe(size_t size)
void *malloc_safe(t_minishell *minishell, size_t size)
{
void *ptr;
ptr = malloc(size);
check_malloc(ptr);
check_malloc(minishell, ptr);
return (ptr);
}

5
src/utils/print_banner.c
View File

@ -6,7 +6,7 @@
/* By: whaffman <whaffman@student.codam.nl> +#+ */
/* +#+ */
/* Created: 2025/02/05 16:04:44 by whaffman #+# #+# */
/* Updated: 2025/02/05 16:05:07 by whaffman ######## odam.nl */
/* Updated: 2025/02/25 17:27:28 by whaffman ######## odam.nl */
/* */
/* ************************************************************************** */
@ -15,7 +15,8 @@
void print_banner(void)
{
printf("%s\n",
"\033[2J\033[1;1H" GREEN
// "\033[2J\033[1;1H" GREEN
GREEN
" • • ┓ ┓┓\n"
" ┏┳┓┓┏┓┓┏┣┓┏┓┃┃\n"
" ┛┗┗┗┛┗┗┛┛┗┗ ┗┗\n"