Makefile

code: malloc.Makefile

ifeq ($(HOSTTYPE),)

HOSTTYPE := $(shell uname -m)_$(shell uname -s)

endif

CC = gcc

CFLAGS_COMMON = -Wall -Wextra -Werror -std=c11

CFLAGS_DEBUG = -g -O0

CFLAGS = $(CFLAGS_COMMON) $(CFLAGS_DEBUG)

MAKE = make

# Build Directories

BUILD_DIR = build

OBJ_DIR = $(BUILD_DIR)/obj

BIN_DIR = $(BUILD_DIR)/bin

# Debug

DEBUG_BIN = $(BIN_DIR)/debug.out

DEBUG_DIR = debug

DEBUG_SRC = $(wildcard $(DEBUG_DIR)/*.c)

DEBUG_OBJ_DIR = $(OBJ_DIR)/debug

DEBUG_OBJ = $(patsubst $(DEBUG_DIR)/%.c,$(DEBUG_OBJ_DIR)/%.o,$(DEBUG_SRC))

# Tests

TEST_BIN = $(BIN_DIR)/test.out

TEST_OBJ_DIR = $(OBJ_DIR)/test

TEST_OBJ = $(patsubst $(TEST_DIR)/%.c,$(TEST_OBJ_DIR)/%.o,$(TEST_SRC))

TEST_DIR = test

TEST_SRC = $(TEST_DIR)/test.c $(TEST_DIR)/munit.c

# Malloc

MALLOC_BIN = $(BIN_DIR)/libft_malloc_$(HOSTTYPE).so

MALLOC_BIN_SYM = $(BIN_DIR)/libft_malloc.so

MALLOC_INCLUDE = include

MALLOC_OBJ_DIR = $(OBJ_DIR)/malloc

MALLOC_OBJ = $(patsubst $(MALLOC_DIR)/%.c,$(MALLOC_OBJ_DIR)/%.o,$(MALLOC_SRC))

MALLOC_DIR = src

MALLOC_SRC = $(wildcard $(MALLOC_DIR)/*.c)

# Libft

LIBFT_DIR = libft

LIBFT_BIN = $(LIBFT_DIR)/libft.a

LIBFT_INCLUDE = $(LIBFT_DIR)/include

LIBFT_SRC = $(wildcard $(LIBFT_DIR)/*.c)

# Rules

all: $(MALLOC_BIN) $(DEBUG_BIN) $(TEST_BIN)

malloc: $(MALLOC_BIN_SYM)

debug: $(DEBUG_BIN)

test: $(TEST_BIN)

run-test: $(TEST_BIN)

./$(TEST_BIN)

debug-test: $(TEST_BIN)

gdb $(TEST_BIN)

clean:

rm -rf $(DEBUG_BIN) $(DEBUG_OBJ) $(TEST_BIN) $(TEST_OBJ) $(MALLOC_BIN_SYM) $(MALLOC_BIN) $(MALLOC_OBJ)

$(MAKE) -C $(LIBFT_DIR) fclean

re: clean

$(MAKE) all

.PHONY: all malloc debug test clean re run-test

# Debug

$(DEBUG_BIN): $(DEBUG_OBJ) $(MALLOC_BIN_SYM)

$(CC) $(CFLAGS) -o $@ $(DEBUG_OBJ) -L$(BIN_DIR) -lft_malloc -Wl,-rpath=$(BIN_DIR) -L$(LIBFT_DIR) -lft

$(DEBUG_OBJ): $(DEBUG_OBJ_DIR)/%.o: $(DEBUG_DIR)/%.c

$(CC) $(CFLAGS) -c -I$(MALLOC_INCLUDE) -I$(LIBFT_INCLUDE) $< -o $@

# Tests

$(TEST_BIN): $(TEST_OBJ) $(MALLOC_BIN_SYM)

$(CC) $(CFLAGS) -o $@ $(TEST_OBJ) -L$(BIN_DIR) -lft_malloc -Wl,-rpath=$(BIN_DIR)

$(TEST_OBJ): $(TEST_OBJ_DIR)/%.o: $(TEST_DIR)/%.c

$(CC) $(CFLAGS) -c -I$(MALLOC_INCLUDE) $< -o $@

# Malloc

$(MALLOC_BIN_SYM): $(MALLOC_BIN)

ln -sf $(notdir $(MALLOC_BIN)) $(MALLOC_BIN_SYM)

$(MALLOC_BIN): $(LIBFT_BIN) $(MALLOC_OBJ)

$(CC) -shared -o $@ $(MALLOC_OBJ) -L$(LIBFT_DIR) -lft -Wl,--version-script=libft_malloc.map

$(MALLOC_OBJ): $(MALLOC_OBJ_DIR)/%.o: $(MALLOC_DIR)/%.c

$(CC) $(CFLAGS) -I$(MALLOC_INCLUDE) -I$(LIBFT_INCLUDE) -fPIC -c $< -o $@

# Libft

$(LIBFT_BIN):

$(MAKE) -C $(LIBFT_DIR)

code: traceroute.Makefile

CC = cc

EXEC = ft_traceroute

CFLAGS = -Wall -Werror -Wextra -I include/

CLIBS = -lm

SRCS_DIR=src/

SRCS = $(wildcard $(SRCS_DIR)*.c)

OBJS_DIR=obj/

OBJS = $(SRCS:$(SRCS_DIR)%.c=$(OBJS_DIR)%.o)

DEBUG_EXEC = ft_traceroute_debug.out

DEBUG_CFLAGS = -g

DEBUG_OBJS_DIR = obj_debug/

DEBUG_OBJS = $(SRCS:$(SRCS_DIR)%.c=$(DEBUG_OBJS_DIR)%.o)

all: $(EXEC)

$(EXEC): $(OBJS)

$(CC) $(CFLAGS) -o $(EXEC) $(OBJS) $(CLIBS)

$(OBJS_DIR)%.o: $(SRCS_DIR)%.c | $(OBJS_DIR)

$(CC) $(CFLAGS) -c $< -o $@

$(OBJS_DIR):

mkdir -p $(OBJS_DIR)

debug: $(DEBUG_EXEC)

$(DEBUG_EXEC): $(DEBUG_OBJS)

$(CC) $(CFLAGS) $(DEBUG_CFLAGS) -o $(DEBUG_EXEC) $(DEBUG_OBJS) $(CLIBS)

$(DEBUG_OBJS_DIR)%.o: $(SRCS_DIR)%.c | $(DEBUG_OBJS_DIR)

$(CC) $(CFLAGS) $(DEBUG_CFLAGS) -c $< -o $@

$(DEBUG_OBJS_DIR):

mkdir -p $(DEBUG_OBJS_DIR)

clean:

rm -rf $(OBJS_DIR) $(DEBUG_OBJS_DIR)

fclean: clean

rm -f $(EXEC) $(DEBUG_EXEC)

re: fclean all

.PHONY: clean fclean re debug

code: minishell.Makefile

CC = cc

CFLAGS = -Wall -Werror -Wextra

LIBS = -L$(LIBFT_DIR) -lft -lreadline -framework OpenGL -framework AppKit

NAME_LIBFT = libft.a

LIBFT_DIR = libft/

NAME = minishell

INCLUDES = -I $(INCLUDESDIR) -I $(LIBFT_DIR)

INCLUDESDIR = includes/

SRCSDIR = srcs/ srcs/utils/ srcs/builtins/ srcs/interpreter/

SRCS =\

expansion.c expansion_utils.c\

interpreter.c\

parser.c parser_iomod.c parser_argv.c\

tokenizer.c tokenizer_get.c\

env.c map.c errors.c heap.c number.c string_galloc.c string.c\

main.c

OBJSDIR = objs/

OBJS = $(SRCS:%.c=$(OBJSDIR)%.o)

CFLAGS_DEBUG = -g -fsanitize=address -fsanitize=undefined

NAME_DEBUG = debug

INCLUDES_DEBUG = $(INCLUDES)

SRCS_DEBUG = $(SRCS)

OBJSDIR_DEBUG = objs_debug/

OBJS_DEBUG = $(SRCS_DEBUG:%.c=$(OBJSDIR_DEBUG)%.o)

vpath %.c $(SRCSDIR)

vpath %.h $(INCLUDESDIR)

vpath %.o $(OBJSDIR) $(OBJSDIR_DEBUG)

vpath %.a $(LIBFT_DIR)

all: $(NAME)

$(NAME_LIBFT):

make -C $(LIBFT_DIR)

$(NAME) : $(NAME_LIBFT) $(OBJS)

$(CC) $(CFLAGS) $(OBJS) $(LIBS) -o $@

$(OBJSDIR)%.o: %.c

@mkdir -p $(OBJSDIR)

$(CC) $(CFLAGS) $(INCLUDES) -c $< -o $@

debug: $(NAME_DEBUG)

$(NAME_DEBUG) : $(NAME_LIBFT) $(OBJS_DEBUG)

$(CC) $(CFLAGS_DEBUG) $(OBJS_DEBUG) $(LIBS) -o $@

$(OBJSDIR_DEBUG)%.o: %.c

@mkdir -p $(OBJSDIR_DEBUG)

$(CC) $(CFLAGS_DEBUG) $(INCLUDES_DEBUG) -c $< -o $@

run: all

./$(NAME)

clean:

make clean -C $(LIBFT_DIR)

rm -rf $(OBJS) $(OBJS_BONUS) $(OBJS_DEBUG)

fclean: clean

make fclean -C $(LIBFT_DIR)

rm -f $(NAME) $(NAME_BONUS) $(NAME_DEBUG)

re: fclean all

.PHONY: fclean all re clean debug run