tvdu29/minishell
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Restart from scratch

Browse Source 
branched out on dev
removed all previous source files
started test on new env2lst function
This commit is contained in:
Tanguy MAZE
2019-09-19 18:00:54 +02:00
parent 5247e0d8e6
commit 852248636f
13 changed files with 128 additions and 942 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitmodules vendored
View File

@@ -1,3 +0,0 @@
[submodule "libft"]
path = libft
url = https://github.com/tvdu29/libft

110
Makefile
View File

@@ -5,45 +5,99 @@
# +:+ +:+ +:+ #
# By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ #
# +#+#+#+#+#+ +#+ #
# Created: 2018/11/22 14:43:33 by tmaze #+# #+# #
# Updated: 2019/02/01 10:20:18 by tmaze ### ########.fr #
# Created: 2019/03/27 16:51:02 by tmaze #+# #+# #
# Updated: 2019/09/19 17:22:10 by tmaze ### ########.fr #
# #
#******************************************************************************#
CC := gcc
CCFLAGS := -Wall -Werror -Wextra -g
CCSTD :=
NAME = minishell
NAME := minishell
# Make options
MAKEFLAGS += --no-print-directory
SRCS := main.c exec.c cmd_echo.c cmd_cd.c cmd_env.c cmd_setenv.c cmd_unsetenv.c ms_env.c ms_env2.c
OBJS_DIR := objs
OBJS := $(SRCS:.c=.o)
INCLS := -Iincludes -Ilibft
LIBS := -Llibft -lft
# Output
UNAME := $(shell uname)
ifeq ($(UNAME), Darwin)
ECHO = @echo
endif
.PHONY = all clean fclean re
ifeq ($(UNAME), Linux)
ECHO = @echo -e
endif
all: $(NAME)
# Compilator
CC = gcc
FLAGS = -Wall -Wextra -Werror
$(NAME): $(OBJS) libft/libft.a
$(CC) $(CCFLAGS) $(CCSTD) $(INCLS) $(OBJS) -o $(NAME) $(LIBS)
# Folders
LIBDIR = libft
SRCDIR = srcs
OBJDIR = objs
INCDIR = includes libft/includes
%.o: srcs/%.c includes/minishell.h
$(CC) $(CCFLAGS) $(CCSTD) $(INCLS) -c $< -o $@
# Source files
SRC = main.c
$(OBJS_DIR):
mkdir $(OBJS_DIR)
OBJ = $(SRC:.c=.o)
libft/libft.a:
$(MAKE) -Clibft all
LIB = ft
LIBFILE = libft.a
clean:
rm -rf $(OBJS)
$(MAKE) -Clibft clean
# Prefixes
OBJP = $(addprefix $(OBJDIR)/, $(SRC:.c=.o))
INCP = $(foreach dir, $(INCDIR), -I$(dir))
fclean: clean
rm -f $(NAME)
$(MAKE) -Clibft fclean
# Default Rule
DRULE = all
re: fclean all
# Main rules
default :
@$(ECHO) -e "$(PUR)===> $(GRE)$(NAME) : $(PUR) START RULE : $(DRULE) <===$(DEF)"
@make $(DRULE)
@$(ECHO) -e "$(PUR)===> $(GRE)$(NAME) : $(PUR) END RULE : $(DRULE) <===$(DEF)"
all : $(NAME)
# Compilation rules
$(OBJDIR)/%.o : $(SRCDIR)/%.c includes/minishell.h
@mkdir -p $(OBJDIR)
$(CC) $(FLAGS) -c -o $@ $< $(INCP)
$(LIBDIR)/$(LIBFILE) :
@$(ECHO) "$(YEL)===> $(GRE)$(NAME) : $(YEL) Librairy Compilation <===$(DEF)"
$(MAKE) -C $(LIBDIR) all
$(NAME) : $(OBJP) $(LIBDIR)/$(LIBFILE)
@$(ECHO) "$(YEL)===> $(GRE)$(NAME) : $(YEL) Binary Compilation <===$(DEF)"
$(CC) $(FLAGS) -o $@ $^ $(INCP) -L$(LIBDIR) -l$(LIB)
# Cleaner rules
clean :
@$(ECHO) "$(RED)===> $(GRE)$(NAME) : $(RED) Delete Object Files <===$(DEF)"
@$(RM) -rf $(OBJDIR)
@$(MAKE) -C $(LIBDIR) clean
fclean : clean
@$(ECHO) "$(RED)===> $(GRE)$(NAME) : $(RED) Delete Binary File <===$(DEF)"
@$(RM) -f $(NAME) $(NAME2)
@$(RM) -rf *.dSYM
@$(MAKE) -C $(LIBDIR) fclean
re : fclean default
# Phony
.PHONY = default all re clean fclean
# Color
DEF = \033[0m
BLA = \033[30m
BLI = \033[5m
BLU = \033[34m
CYA = \033[36m
GRA = \033[1m
GRE = \033[32m
PUR = \033[35m
RED = \033[31m
SOU = \033[4m
WHI = \033[37m
YEL = \033[33m

35
includes/minishell.h
View File

@@ -6,7 +6,7 @@
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/18 13:12:34 by tmaze #+# #+# */
/* Updated: 2019/02/01 10:19:53 by tmaze ### ########.fr */
/* Updated: 2019/09/19 17:08:15 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
@@ -17,37 +17,4 @@
# include <sys/stat.h>
# include "libft.h"
typedef struct s_builtin
{
char *cmd;
int (*f)(char **argv, t_list **env);
} t_builtin;
typedef struct s_envelem
{
char *key;
char *val;
} t_envelem;
t_envelem *elem_new(char *key, char *val);
t_envelem *env_getelemfromkey(char *key, t_list *env);
t_envelem *env_addupdate(char *key, char *val, t_list **env);
void env_delelem(char *key, t_list **env);
t_envelem *ft_envtoenvelem(char *env);
void ft_lstdelenvelem(void *content, size_t size);
void ft_envelemdel(t_envelem **env);
t_list *ft_envtolst(char **env);
int exec_cmd(char **argv, t_list **env);
int cmd_echo(char **argv, t_list **env);
int cmd_cd(char **argv, t_list **env);
int cmd_env(char **argv, t_list **env);
int cmd_setenv(char **argv, t_list **env);
int cmd_unsetenv(char **argv, t_list **env);
int ft_isin(char *str, char c);
char *check_path_slash(char *exec);
char *check_path_dot(char *exec, t_list *env);
#endif

1
libft

Submodule libft deleted from 4b44c49fc6

167
srcs/cmd_cd.c
View File

@@ -1,167 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmd_cd.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/01/07 16:44:40 by tmaze #+# #+# */
/* Updated: 2019/01/30 17:02:05 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
void put_error_cd(char *file, char *msg)
{
ft_putstr("cd: ");
ft_putstr(file);
ft_putstr(": ");
ft_putendl(msg);
}
char *check_path_slash_cd(char *exec)
{
int i;
struct stat info;
if (exec[0] == '/')
{
if ((i = access(exec, F_OK)) != 0)
put_error_cd(exec, "no such file or directory");
if (i != 0)
return (NULL);
if ((i = stat(exec, &info)) != 0)
put_error_cd(exec, "can't determine info");
if (i != 0)
return (NULL);
if (!S_ISDIR(info.st_mode))
{
put_error_cd(exec, "not a directory");
return (NULL);
}
if ((i = access(exec, X_OK)) != 0)
put_error_cd(exec, "permission denied");
if (i != 0)
return (NULL);
return (exec);
}
return (NULL);
}
int cmd_cd_update_env(char *path, t_list **env, char opt)
{
t_envelem *pwd;
char *oldpwd;
char *c_path;
char p_path[4096];
ft_bzero(p_path, 4096);
if (getcwd(p_path, 4096) == NULL)
{
put_error_cd(path, "error");
return (1);
}
if ((pwd = env_getelemfromkey("PWD", *env)) == NULL)
{
put_error_cd(path, "error");
return (1);
}
if ((oldpwd = ft_strdup(pwd->val)) == NULL)
{
put_error_cd(path, "error");
return (1);
}
if (ft_realpath(path, &c_path) == NULL)
{
put_error_cd(path, "error");
return (1);
}
if (env_addupdate("PWD", ((opt == 'P') ? p_path : c_path), env) == NULL
|| env_addupdate("OLDPWD", oldpwd, env) == NULL)
{
put_error_cd(path, "error");
ft_strdel(&oldpwd);
ft_strdel(&c_path);
return (1);
}
ft_strdel(&oldpwd);
ft_strdel(&c_path);
return (0);
}
int cmd_cd_core(char *path, t_list **env, char opt)
{
t_envelem *pwd;
if (check_path_slash_cd(path) == NULL)
{
put_error_cd(path, "invalid path");
return (1);
}
if (chdir(path) == -1
|| (pwd = env_getelemfromkey("PWD", *env)) == NULL)
{
put_error_cd(path, "error");
return (1);
}
return (cmd_cd_update_env(path, env, opt));
}
char cd_getparams(char **argv, size_t *i)
{
char ret[2];
size_t j;
ret[1] = '\0';
ret[0] = 'L';
*i = 0;
while (argv[++(*i)] && argv[*i][0] == '-' && ft_strlen(argv[*i]) > 1)
{
j = 1;
while (argv[*i][j] && (argv[*i][j] == 'L' || argv[*i][j] == 'P'))
ret[0] = argv[*i][j++];
if (argv[*i][j] && argv[*i][j] != 'L' && argv[*i][j] != 'P')
{
ret[0] = argv[*i][j];
put_error_cd(ret, "invalid option");
put_error_cd("usage", "cd [-L|-P] [dir]");
ret[0] = '\0';
break ;
}
}
return (ret[0]);
}
int cmd_cd(char **argv, t_list **env)
{
t_envelem *elem;
size_t i;
char *path;
char opt;
int ret;
i = 0;
if ((opt = cd_getparams(argv, &i)) == '\0')
return (1);
if (!argv[i] && (elem = env_getelemfromkey("HOME", *env)) != NULL && elem->val != NULL)
return (cmd_cd_core(elem->val, env, opt));
else if (argv[i] && argv[i][0] == '/')
return (cmd_cd_core(argv[i], env, opt));
else if (argv[i] && argv[i][0] == '-' && (elem = env_getelemfromkey("OLDPWD", *env)) != NULL)
return (cmd_cd_core(elem->val, env, opt));
else if (argv[i] && argv[i][0] != '/' && (elem = env_getelemfromkey("PWD", *env)) != NULL && elem->val != NULL)
{
if ((path = ft_strnew(ft_strlen(elem->val) + ft_strlen(argv[i]) + 1)) == NULL)
put_error_cd(argv[i], "memory error");
if (path == NULL)
return (1);
ft_strcpy(path, elem->val);
path[ft_strlen(path)] = '/';
ft_strcat(path, argv[i]);
ret = cmd_cd_core(path, env, opt);
ft_strdel(&path);
return (ret);
}
return (1);
}

28
srcs/cmd_echo.c
View File

@@ -1,28 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmd_echo.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/27 16:14:07 by tmaze #+# #+# */
/* Updated: 2019/01/13 16:58:14 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
int cmd_echo(char **argv, t_list **env)
{
size_t i;
(void)env;
i = 0;
while (argv[0] && argv[++i])
{
ft_putstr(argv[i]);
ft_putchar(' ');
}
ft_putchar('\n');
return (0);
}

148
srcs/cmd_env.c
View File

@@ -1,148 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmd_env.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/12/14 15:54:45 by tmaze #+# #+# */
/* Updated: 2019/02/01 16:26:42 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
void put_error(char *exec, char *file, char *msg)
{
ft_putstr(exec);
ft_putstr(": ");
ft_putstr(file);
ft_putstr(": ");
ft_putendl(msg);
}
void put_env(t_list *env)
{
t_list *tmp;
tmp = env;
while (tmp)
{
ft_putstr(((t_envelem*)(tmp->content))->key);
ft_putchar('=');
ft_putendl(((t_envelem*)(tmp->content))->val);
tmp = tmp->next;
}
}
t_envelem *envelemdup(t_envelem *elem)
{
t_envelem *ret;
if ((ret = (t_envelem*)ft_memalloc(sizeof(t_envelem))) == NULL)
return (NULL);
if ((ret->key = ft_strdup(elem->key)) == NULL)
ft_envelemdel(&ret);
if (ret == NULL)
return (0);
if ((ret->val = ft_strdup(elem->val)) == NULL)
{
ft_strdel(&(ret->key));
ft_envelemdel(&ret);
return (NULL);
}
return (ret);
}
t_list *env_cpy(t_list *env)
{
t_list *ret;
t_list *ind;
t_list *tmp;
t_envelem *envelem;
ret = NULL;
ind = env;
while (ind)
{
if ((envelem = envelemdup((t_envelem*)(ind->content))) == NULL)
ft_lstdel(&ret, &ft_lstdelenvelem);
if (envelem == NULL)
break ;
if ((tmp = ft_lstnew((void*)envelem, sizeof(t_envelem))) == NULL
|| ft_lstaddend(&ret, tmp) == NULL)
{
ft_envelemdel(&envelem);
ft_lstdel(&ret, &ft_lstdelenvelem);
break ;
}
ft_envelemdel(&envelem);
ind = ind->next;
}
return (ret);
}
int exec_env(char **argv, t_list **env)
{
int ret;
char **env_tab;
char *path;
if ((env_tab = envlsttotab(*env)) == NULL)
return (1);
if ((path = check_path(argv[0], *env)) == NULL)
ft_del_words_tables(&env_tab);
if (path == NULL)
return (1);
if ((ret = fork()) == 0)
{
execve(path, argv, env_tab);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
ft_del_words_tables(&env_tab);
exit(1);
}
else if (ret == -1)
return (1);
waitpid(ret, NULL, 0);
ft_del_words_tables(&env_tab);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
return (0);
}
int cmd_env(char **argv, t_list **env)
{
t_envelem *elem;
t_list *env_cp;
t_list *new;
char *tmp;
size_t i;
if (argv[1] == NULL)
put_env(*env);
i = 0;
if ((env_cp = env_cpy(*env)) == NULL)
return (2);
while (argv[++i] && (tmp = ft_strchr(argv[i], '=')))
{
if ((elem = ft_envtoenvelem(argv[i])) == NULL)
ft_lstdel(&env_cp, &ft_lstdelenvelem);
if (elem == NULL)
return (1);
if ((new = ft_lstnew((void*)elem, sizeof(t_envelem))) == NULL)
{
ft_envelemdel(&elem);
ft_lstdel(&env_cp, &ft_lstdelenvelem);
return (1);
}
ft_memdel((void**)&elem);
if (ft_lstaddend(&env_cp, new) == NULL)
{
ft_lstdel(&env_cp, &ft_lstdelenvelem);
return (1);
}
}
ft_lstdel(&env_cp, &ft_lstdelenvelem);
return (0);
}

22
srcs/cmd_setenv.c
View File

@@ -1,22 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmd_setenv.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/01/13 16:20:20 by tmaze #+# #+# */
/* Updated: 2019/01/13 17:05:05 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
int cmd_setenv(char **argv, t_list **env)
{
if (argv[1] == NULL)
return (-1);
if (env_addupdate(argv[1], argv[2], env) == NULL)
return (-1);
return (0);
}

21
srcs/cmd_unsetenv.c
View File

@@ -1,21 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* cmd_unsetenv.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/01/15 14:58:05 by tmaze #+# #+# */
/* Updated: 2019/01/15 15:04:05 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
int cmd_unsetenv(char **argv, t_list **env)
{
if (argv[1] == NULL)
return (-1);
env_delelem(argv[1], env);
return (0);
}

222
srcs/exec.c
View File

@@ -1,222 +0,0 @@
'/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* exec.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/27 15:32:29 by tmaze #+# #+# */
/* Updated: 2019/02/01 16:49:31 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
#define S_BIN 5
char **envlsttotab(t_list *env)
{
size_t i;
size_t env_size;
t_list *tmp;
char **ret;
i = 0;
tmp = env;
env_size = ft_lstsize(env);
if ((ret = (char**)ft_memalloc(sizeof(char*) * (env_size + 1))) == NULL)
return (NULL);
while (i <= env_size)
ret[i++] = NULL;
i = 0;
while (tmp)
{
if ((ret[i] = ft_strnew(ft_strlen(((t_envelem*)(tmp->content))->key)
+ ft_strlen(((t_envelem*)(tmp->content))->val) + 1)) == NULL)
{
ft_del_words_tables(&ret);
return (NULL);
}
i++;
tmp = tmp->next;
}
return (ret);
}
/*
** , {"setenv", &cmd_senv}, {"unsetenv", &cmd_senv}, {"env", &cmd_env}};
*/
int ft_isin(char *str, char c)
{
int i;
i = 0;
while (str[i])
if (str[i++] == c)
return (i - 1);
return (-1);
}
void put_error(char *file, char *msg)
{
ft_putstr("minishell: ");
ft_putstr(file);
ft_putstr(": ");
ft_putendl(msg);
}
char *check_path_slash(char *exec)
{
int i;
struct stat info;
if (ft_isin(exec, '/') != -1 && ft_isin(exec, '.') == -1)
{
if ((i = access(exec, F_OK)) != 0)
put_error(exec, "no such file or directory");
if (i != 0)
return (NULL);
if ((i = stat(exec, &info)) != 0)
put_error(exec, "can't determine info");
if (i != 0)
return (NULL);
if (!S_ISREG(info.st_mode))
{
put_error(exec, "not an executable file");
return (NULL);
}
if ((i = access(exec, X_OK)) != 0)
put_error(exec, "permission denied");
if (i != 0)
return (NULL);
return (exec);
}
return (NULL);
}
char *check_path_dot(char *exec, t_list *env)
{
t_envelem *path;
char *tmp;
char *ret;
if (exec[0] == '.')
{
if ((path = env_getelemfromkey("PWD", env)) == NULL
|| path->val == NULL)
{
put_error(exec, "memory error");
return (NULL);
}
if ((tmp = ft_strjoin(path->val, "/")) == NULL)
put_error(exec, "memory error");
if (tmp == NULL)
return (NULL);
if ((ret = ft_strjoin(tmp, exec)) == NULL)
{
put_error(exec, "memory error");
ft_strdel(&tmp);
return (NULL);
}
ft_strdel(&tmp);
if (access(ret, F_OK) == 0)
{
if (access(ret, X_OK) == 0)
return (ret);
put_error(exec, "permission denied");
ft_strdel(&ret);
return (NULL);
}
put_error(exec, "no such file or directory");
ft_strdel(&ret);
}
return (NULL);
}
char *check_path(char *exec, t_list *env)
{
size_t i;
t_envelem *path;
char **path_elems;
char *tmp;
char *ret;
i = 0;
ret = NULL;
if ((ret = check_path_slash(exec)) != NULL)
return (ret);
if ((ret = check_path_dot(exec, env)) != NULL)
return (ret);
if ((path = env_getelemfromkey("PATH", env)) == NULL
|| path->val == NULL)
return (NULL);
if ((path_elems = ft_strsplit(path->val, ':')) == NULL)
return (NULL);
while (path_elems[i])
{
if ((tmp = ft_strjoin(path_elems[i], "/")) == NULL)
put_error(exec, "memory error");
if (tmp == NULL)
break ;
if ((ret = ft_strjoin(tmp, exec)) == NULL)
{
put_error(exec, "memory error");
ft_strdel(&tmp);
break ;
}
ft_strdel(&tmp);
if (access(ret, F_OK) == 0)
{
if (access(ret, X_OK) == 0)
break ;
put_error(exec, "permission denied");
}
ft_strdel(&ret);
i++;
}
if (path_elems[i] == NULL)
put_error(exec, "command not found");
ft_del_words_tables(&path_elems);
return (ret);
}
int exec_cmd(char **argv, t_list **env)
{
int ret;
char **env_tab;
char *path;
size_t i;
static t_builtin builtins[S_BIN] = {{"echo", &cmd_echo},
{"cd", &cmd_cd}, {"setenv", &cmd_setenv},
{"env", &cmd_env}, {"unsetenv", &cmd_unsetenv}};
i = 0;
while (i < S_BIN)
if (ft_strcmp(argv[0], builtins[i++].cmd) == 0)
return ((*(builtins[i - 1].f))(argv, env));
if ((env_tab = envlsttotab(*env)) == NULL)
return (-1);
if ((path = check_path(argv[0], *env)) == NULL)
ft_del_words_tables(&env_tab);
if (path == NULL)
return (-1);
if ((ret = fork()) == 0)
{
execve(path, argv, env_tab);
ft_putendl_fd("minishell: error", 1);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
ft_del_words_tables(&env_tab);
exit(-1);
}
else if (ret == -1)
ft_putendl_fd("minishell: error", 1);
if (ret == -1)
return (-1);
waitpid(ret, NULL, 0);
ft_del_words_tables(&env_tab);
if (ft_strcmp(path, argv[0]) != 0)
ft_strdel(&path);
return (0);
}

129
srcs/main.c
View File

@@ -5,103 +5,64 @@
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2018/11/18 13:09:55 by tmaze #+# #+# */
/* Updated: 2019/02/01 10:18:41 by tmaze ### ########.fr */
/* Created: 2019/09/19 17:08:46 by tmaze #+# #+# */
/* Updated: 2019/09/19 17:59:58 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
int main(void)
void lstdelenvelem(void *content, size_t size)
{
int ret;
char *cmd;
char **tab_cmd;
t_list *lst_env;
extern char **environ;
size = 0;
ft_strdel(&(((char**)content)[1]));
ft_strdel(&(((char**)content)[0]));
ft_memdel(&content);
}
if ((lst_env = ft_envtolst(environ)) == NULL)
ft_putendl("Error envtolst");
if (lst_env == NULL)
t_list *env2lst(char** env)
{
t_list *ret;
t_list *new;
int i;
i = 0;
ret = NULL;
while (env[i])
{
if ((new = (t_list*)ft_memalloc(sizeof(t_list))) == NULL
|| (new->content = ft_strsplit(env[i], '=')) == NULL
|| ft_lstaddend(&ret, new) == NULL)
{
ft_lstdel(&ret, &lstdelenvelem);
return (NULL);
}
i++;
}
return (ret);
}
int main(void)
{
extern char **environ;
t_list *env;
char *cmd;
env = NULL;
if ((env = env2lst(environ)) == NULL)
return (2);
while (1)
{
ret = 0;
ft_putstr(FT_COLOR_GREEN);
ft_putstr("$> ");
ft_putstr(FT_RESET);
ret = get_next_line(1, &cmd);
if (cmd != NULL && ft_strlen(cmd) != 0)
cmd = NULL;
ft_printf("%s$>%s ", FT_COLOR_GREEN, FT_RESET);
if (ft_getline(&cmd) >= 0)
{
if (ret == -1)
{
ft_lstdel(&lst_env, &ft_lstdelenvelem);
ft_strdel(&cmd);
return (2);
}
if (ft_strcmp("exit", cmd) == 0)
{
ft_lstdel(&lst_env, &ft_lstdelenvelem);
ft_strdel(&cmd);
return (0);
}
else if ((tab_cmd = ft_strsplit(cmd, ' ')) == NULL)
{
ft_lstdel(&lst_env, &ft_lstdelenvelem);
ft_strdel(&cmd);
ft_putendl("error split");
return (2);
}
ft_strdel(&cmd);
ft_putnbr(exec_cmd(tab_cmd, &lst_env));
ft_putchar('\n');
ft_del_words_tables(&tab_cmd);
ft_printf("%s\n", cmd);
}
ft_strdel(&cmd);
break;
}
ft_lstdel(&lst_env, &ft_lstdelenvelem);
ft_lstdel(&env, &lstdelenvelem);
return (0);
}
/*
** char *cmd;
** char **tab_cmd;
** t_list *lst_env;
** int ret;
** extern char **environ;
**
** if ((lst_env = ft_envtolst(environ)) == NULL)
** ft_putendl("Error envtolst");
** if (lst_env == NULL)
** return (2);
** while (1)
** {
** ret = 0;
** ft_putstr(FT_COLOR_GREEN);
** ft_putstr("$> ");
** ft_putstr(FT_RESET);
** ret = get_next_line(1, &cmd);
** if (ret == -1)
** {
** ft_lstdel(&lst_env, &ft_lstdelenvelem);
** ft_strdel(&cmd);
** return (2);
** }
** if (ft_strcmp("exit", cmd) == 0)
** {
** ft_lstdel(&lst_env, &ft_lstdelenvelem);
** ft_strdel(&cmd);
** return (0);
** }
** else if ((tab_cmd = ft_strsplit(cmd, ' ')) == NULL)
** {
** ft_lstdel(&lst_env, &ft_lstdelenvelem);
** ft_strdel(&cmd);
** ft_putendl("error split");
** return (2);
** }
** exec_cmd(tab_cmd, lst_env);
** }
** ft_lstdel(&lst_env, &ft_lstdelenvelem);
** return (0);
*/

99
srcs/ms_env.c
View File

@@ -1,99 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ms_env.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/01/13 14:44:20 by tmaze #+# #+# */
/* Updated: 2019/01/25 16:05:29 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
t_envelem *elem_new(char *key, char *val)
{
t_envelem *elem;
if ((elem = (t_envelem*)ft_memalloc(sizeof(t_envelem))) == NULL)
return (NULL);
if ((elem->key = ft_strdup(key)) == NULL)
{
ft_memdel((void**)&elem);
return (NULL);
}
if (val != NULL && (elem->val = ft_strdup(val)) == NULL)
{
ft_strdel(&(elem->key));
ft_memdel((void**)&elem);
return (NULL);
}
elem->val = (val == NULL) ? NULL : elem->val;
return (elem);
}
t_envelem *env_getelemfromkey(char *key, t_list *env)
{
t_list *tmp;
tmp = env;
while (tmp)
{
if (ft_strcmp(((t_envelem*)(tmp->content))->key, key) == 0)
return ((t_envelem*)(tmp->content));
tmp = tmp->next;
}
return (NULL);
}
t_envelem *env_addupdate(char *key, char *val, t_list **env)
{
t_list *new;
t_envelem *elem;
char *tmp;
if ((elem = env_getelemfromkey(key, *env)) != NULL)
{
if (val == NULL)
tmp = val;
else if ((tmp = ft_strdup(val)) == NULL)
return (NULL);
ft_strdel(&(elem->val));
elem->val = tmp;
return (elem);
}
if ((elem = elem_new(key, val)) == NULL
|| (new = ft_lstnew(elem, sizeof(t_envelem))) == NULL)
return (NULL);
ft_lstaddend(env, new);
ft_memdel((void**)&elem);
return ((t_envelem*)(new->content));
}
void env_delelem(char *key, t_list **env)
{
t_list *tmp;
t_list *prec;
if (ft_strcmp(((t_envelem*)((*env)->content))->key, key) == 0)
{
tmp = *env;
*env = (*env)->next;
ft_lstdelone(&tmp, &ft_lstdelenvelem);
return ;
}
tmp = (*env)->next;
prec = (*env);
while (tmp)
{
if (ft_strcmp(((t_envelem*)(tmp->content))->key, key) == 0)
{
prec->next = tmp->next;
ft_lstdelone(&tmp, &ft_lstdelenvelem);
return ;
}
prec = tmp;
tmp = tmp->next;
}
}

85
srcs/ms_env2.c
View File

@@ -1,85 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* ms_env2.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: tmaze <tmaze@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2019/02/01 10:18:01 by tmaze #+# #+# */
/* Updated: 2019/02/01 11:16:28 by tmaze ### ########.fr */
/* */
/* ************************************************************************** */
#include "minishell.h"
t_envelem *ft_envtoenvelem(char *env)
{
size_t i;
t_envelem *ret;
i = 0;
if ((ret = (t_envelem*)ft_memalloc(sizeof(t_envelem))) == NULL)
return (NULL);
while (env[i] && env[i] != '=')
i++;
if ((ret->key = ft_strnew(i)) == NULL)
{
ft_memdel((void**)&ret);
return (NULL);
}
if ((ret->val = ft_strnew(ft_strlen(env) - i - 1)) == NULL)
{
ft_memdel((void**)&ret);
return (NULL);
}
ft_strlcpy(ret->key, env, i + 1);
ft_strlcpy(ret->val, &env[i + 1], ft_strlen(env) - i);
return (ret);
}
void ft_lstdelenvelem(void *content, size_t size)
{
size = 0;
ft_strdel(&(((t_envelem*)(content))->key));
ft_strdel(&(((t_envelem*)(content))->val));
ft_memdel(&content);
}
void ft_envelemdel(t_envelem **env)
{
ft_strdel(&((*env)->key));
ft_strdel(&((*env)->val));
ft_memdel((void**)env);
}
t_list *ft_envtolst(char **env)
{
size_t i;
t_list *ret;
t_list *new;
t_envelem *elem;
ret = NULL;
i = 0;
while (env[i])
{
if ((elem = ft_envtoenvelem(env[i])) == NULL)
ft_lstdel(&ret, &ft_lstdelenvelem);
if (elem == NULL)
return (NULL);
if ((new = ft_lstnew((void*)elem, sizeof(t_envelem))) == NULL)
{
ft_envelemdel(&elem);
ft_lstdel(&ret, &ft_lstdelenvelem);
return (NULL);
}
ft_envelemdel(&elem);
if (ft_lstaddend(&ret, new) == NULL)
{
ft_lstdel(&ret, &ft_lstdelenvelem);
return (NULL);
}
i++;
}
return (ret);
}