Makefile

# Compiler and flags
CC := gcc
CFLAGS := -Wall -Wextra -I./include -fPIC
LDFLAGS :=
EXE_LDFLAGS ?= $(LDFLAGS)
USE_OPENSSL ?= 0
ifeq ($(OS),Windows_NT)
COMPILER_VERSION := $(shell $(CC) -dumpfullversion -dumpversion 2>NUL)
COMPILER_TARGET := $(shell $(CC) -dumpmachine 2>NUL)
COMPILER_PATH := $(shell where $(CC) 2>NUL)
else
COMPILER_VERSION := $(shell $(CC) -dumpfullversion -dumpversion 2>/dev/null)
COMPILER_TARGET := $(shell $(CC) -dumpmachine 2>/dev/null)
COMPILER_PATH := $(shell command -v $(CC) 2>/dev/null)
endif

# Platform-specific settings
ifeq ($(OS),Windows_NT)
PLATFORM := windows
LDFLAGS += -lws2_32
CFLAGS += -D_WIN32 -D__USE_MINGW_ANSI_STDIO=1
SHARED_EXT := dll
SHARED_LDFLAGS := -shared
EXE_EXT := .exe
else
UNAME_S := $(shell uname -s 2>/dev/null || echo Unknown)
ifeq ($(UNAME_S),Darwin)
PLATFORM := macos
SHARED_EXT := dylib
SHARED_LDFLAGS := -dynamiclib
EXE_EXT :=
else ifeq ($(UNAME_S),Linux)
PLATFORM := linux
SHARED_EXT := so
SHARED_LDFLAGS := -shared
EXE_EXT :=
else
PLATFORM := unix
SHARED_EXT := so
SHARED_LDFLAGS := -shared
EXE_EXT :=
endif
# Add pthread flag for Unix-like systems
LDFLAGS += -pthread
endif

ifeq ($(USE_OPENSSL),1)
LDFLAGS += -lssl -lcrypto
CFLAGS += -DUSE_OPENSSL=1
endif

# Debug/Release flags
DEBUG_FLAGS := -g -DDEBUG
RELEASE_FLAGS := -O2 -DNDEBUG

# Directories
SRC_DIR := src
CORE_SRC_DIR := $(SRC_DIR)/core
CLI_SRC_DIR := $(SRC_DIR)/cli
INC_DIR := include
BUILD_DIR := build
OBJ_DIR := $(BUILD_DIR)/obj
CORE_BUILD_DIR := $(OBJ_DIR)/core
CLI_BUILD_DIR := $(OBJ_DIR)/cli
LIB_DIR := lib
BIN_DIR := $(BUILD_DIR)/bin
TOOLCHAIN_STAMP := $(BUILD_DIR)/.toolchain
OBJECT_CHECK := $(OBJ_DIR)/.object-check.o

# Source files
MAIN_SRC := $(SRC_DIR)/main.c
CORE_SRCS := $(wildcard $(CORE_SRC_DIR)/*.c)
CLI_SRCS := $(wildcard $(CLI_SRC_DIR)/*.c)
OBJS := $(CORE_SRCS:$(CORE_SRC_DIR)/%.c=$(CORE_BUILD_DIR)/%.o)
CLI_OBJS := $(CLI_SRCS:$(CLI_SRC_DIR)/%.c=$(CLI_BUILD_DIR)/%.o)

# Main executable
MAIN_OBJ := $(OBJ_DIR)/main.o
EXECUTABLE := polycall$(EXE_EXT)
DEPS := $(OBJS:.o=.d) $(CLI_OBJS:.o=.d) $(MAIN_OBJ:.o=.d)

# Library name
LIB_NAME := libpolycall
STATIC_LIB := $(LIB_DIR)/$(LIB_NAME).a
SHARED_LIB := $(LIB_DIR)/$(LIB_NAME).$(SHARED_EXT)

# Installation paths
PREFIX := /usr/local
INSTALL_INC_DIR := $(PREFIX)/include/$(LIB_NAME)
INSTALL_LIB_DIR := $(PREFIX)/lib
INSTALL_BIN_DIR := $(PREFIX)/bin

# Default target
.PHONY: all
all: dirs verify-objects $(STATIC_LIB) $(SHARED_LIB) $(BIN_DIR)/$(EXECUTABLE)

# Create necessary directories
.PHONY: dirs
ifeq ($(PLATFORM),windows)
dirs:
	@if not exist "$(BUILD_DIR)" mkdir "$(BUILD_DIR)"
	@if not exist "$(OBJ_DIR)" mkdir "$(OBJ_DIR)"
	@if not exist "$(OBJ_DIR)\core" mkdir "$(OBJ_DIR)\core"
	@if not exist "$(OBJ_DIR)\cli" mkdir "$(OBJ_DIR)\cli"
	@if not exist "$(LIB_DIR)" mkdir "$(LIB_DIR)"
	@if not exist "$(BIN_DIR)" mkdir "$(BIN_DIR)"
else
dirs:
	@mkdir -p $(BUILD_DIR) $(OBJ_DIR) $(CORE_BUILD_DIR) $(CLI_BUILD_DIR) $(LIB_DIR) $(BIN_DIR)
endif

# Debug build
.PHONY: debug
debug: CFLAGS += $(DEBUG_FLAGS)
debug: all

# Release build
.PHONY: release
release: CFLAGS += $(RELEASE_FLAGS)
release: all

# Static release executable for minimal container runtimes
.PHONY: static
static: static-check
static: CFLAGS += $(RELEASE_FLAGS)
static: EXE_LDFLAGS += -static
static: all

.PHONY: static-check
static-check:
ifeq ($(PLATFORM),linux)
	@echo "Building static executable for Linux"
else ifeq ($(PLATFORM),macos)
	@echo "make static is unsupported on macOS because fully static executables are not available with the standard toolchain"
	@exit 1
else ifeq ($(PLATFORM),windows)
	@$(CC) -dumpmachine 2>NUL | findstr /i "mingw" >NUL || (echo make static requires a MinGW GCC toolchain on Windows & exit 1)
else
	@echo "make static is unsupported on this Unix platform"
	@exit 1
endif

# Compile core library source files
$(CORE_BUILD_DIR)/%.o: $(CORE_SRC_DIR)/%.c $(TOOLCHAIN_STAMP)
	$(CC) $(CFLAGS) -MMD -MP -c $< -o $@

# Compile CLI source files
$(CLI_BUILD_DIR)/%.o: $(CLI_SRC_DIR)/%.c $(TOOLCHAIN_STAMP)
	$(CC) $(CFLAGS) -MMD -MP -c $< -o $@

# Compile main executable
$(OBJ_DIR)/main.o: $(MAIN_SRC) $(TOOLCHAIN_STAMP)
	$(CC) $(CFLAGS) -MMD -MP -c $< -o $@

# Rebuild objects whenever compiler, target platform, architecture, or flags change.
.PHONY: FORCE
FORCE:

ifeq ($(PLATFORM),windows)
$(TOOLCHAIN_STAMP): FORCE | dirs
	@if not exist build mkdir build
	@echo CC=$(CC)>build\.toolchain.tmp
	@echo COMPILER_PATH=$(COMPILER_PATH)>>build\.toolchain.tmp
	@echo COMPILER_VERSION=$(COMPILER_VERSION)>>build\.toolchain.tmp
	@echo COMPILER_TARGET=$(COMPILER_TARGET)>>build\.toolchain.tmp
	@echo PLATFORM=$(PLATFORM)>>build\.toolchain.tmp
	@echo CFLAGS=$(CFLAGS);>>build\.toolchain.tmp
	@if not exist build\.toolchain (del /s /q build\*.o build\*.d 2>NUL & move /Y build\.toolchain.tmp build\.toolchain >NUL) else (fc /b build\.toolchain build\.toolchain.tmp >NUL || (echo Toolchain changed; removing stale build artifacts. & del /s /q build\*.o build\*.d lib\*.a lib\*.dll build\bin\polycall*.exe 2>NUL & move /Y build\.toolchain.tmp build\.toolchain >NUL))
	@if exist build\.toolchain.tmp del /q build\.toolchain.tmp
else
$(TOOLCHAIN_STAMP): FORCE | dirs
	@printf '%s\n' \
		'CC=$(CC)' \
		'COMPILER_PATH=$(COMPILER_PATH)' \
		'COMPILER_VERSION=$(COMPILER_VERSION)' \
		'COMPILER_TARGET=$(COMPILER_TARGET)' \
		'PLATFORM=$(PLATFORM)' \
		'CFLAGS=$(CFLAGS)' > $(TOOLCHAIN_STAMP).tmp
	@if test ! -f $(TOOLCHAIN_STAMP) || ! cmp -s $(TOOLCHAIN_STAMP) $(TOOLCHAIN_STAMP).tmp; then \
		echo "Toolchain changed; removing stale build artifacts."; \
		find $(BUILD_DIR) -name '*.o' -o -name '*.d' | xargs rm -f; \
		rm -f \
			$(LIB_DIR)/*.a $(LIB_DIR)/*.so $(LIB_DIR)/*.dylib \
			$(BIN_DIR)/polycall; \
		mv $(TOOLCHAIN_STAMP).tmp $(TOOLCHAIN_STAMP); \
	else \
		rm -f $(TOOLCHAIN_STAMP).tmp; \
	fi
endif

.PHONY: objects
objects: $(OBJS) $(CLI_OBJS) $(MAIN_OBJ)

# A relocatable link detects corrupt or foreign-format objects before final link.
.PHONY: verify-objects
verify-objects: $(OBJS) $(CLI_OBJS) $(MAIN_OBJ)
ifeq ($(PLATFORM),windows)
	@$(CC) -r -nostdlib -o build\obj\.object-check.o $(OBJS) $(CLI_OBJS) $(MAIN_OBJ) >NUL 2>&1 || (echo Stale object files detected; recompiling all objects. & del /s /q build\*.o build\*.d 2>NUL & $(MAKE) --no-print-directory objects)
	@$(CC) -r -nostdlib -o build\obj\.object-check.o $(OBJS) $(CLI_OBJS) $(MAIN_OBJ)
	@del /q build\obj\.object-check.o
else
	@$(CC) -r -nostdlib -o $(OBJECT_CHECK) $(OBJS) $(CLI_OBJS) $(MAIN_OBJ) 2>/dev/null || \
		(echo "Stale object files detected; recompiling all objects."; \
		find $(BUILD_DIR) -name '*.o' -o -name '*.d' | xargs rm -f; \
		$(MAKE) --no-print-directory objects)
	@$(CC) -r -nostdlib -o $(OBJECT_CHECK) $(OBJS) $(CLI_OBJS) $(MAIN_OBJ)
	@rm -f $(OBJECT_CHECK)
endif

$(STATIC_LIB) $(SHARED_LIB): | verify-objects

# Create static library
$(STATIC_LIB): $(OBJS)
ifeq ($(PLATFORM),windows)
	@if exist "$(LIB_DIR)\$(LIB_NAME).a" del /q "$(LIB_DIR)\$(LIB_NAME).a"
else
	@rm -f $@
endif
	ar rcs $@ $^

# Create shared library
$(SHARED_LIB): $(OBJS)
	$(CC) $(SHARED_LDFLAGS) -o $@ $^ $(LDFLAGS)

# Link executable
$(BIN_DIR)/$(EXECUTABLE): $(MAIN_OBJ) $(CLI_OBJS) $(STATIC_LIB)
	$(CC) $(MAIN_OBJ) $(CLI_OBJS) $(STATIC_LIB) -o $@ $(EXE_LDFLAGS)

# Install (Unix-like systems only)
.PHONY: install
install: all
ifeq ($(PLATFORM),windows)
	@echo "make install is not supported on Windows"
else
	@mkdir -p $(INSTALL_INC_DIR)
	@mkdir -p $(INSTALL_INC_DIR)/core
	@mkdir -p $(INSTALL_LIB_DIR)
	@mkdir -p $(INSTALL_BIN_DIR)
	cp $(INC_DIR)/*.h $(INSTALL_INC_DIR)
	cp $(INC_DIR)/core/*.h $(INSTALL_INC_DIR)/core
	cp $(STATIC_LIB) $(SHARED_LIB) $(INSTALL_LIB_DIR)
	cp $(BIN_DIR)/$(EXECUTABLE) $(INSTALL_BIN_DIR)
ifeq ($(PLATFORM),linux)
	ldconfig
endif
endif

# Uninstall (Unix-like systems only)
.PHONY: uninstall
uninstall:
ifeq ($(PLATFORM),windows)
	@echo "make uninstall is not supported on Windows"
else
	rm -rf $(INSTALL_INC_DIR)
	rm -f $(INSTALL_LIB_DIR)/$(LIB_NAME).*
	rm -f $(INSTALL_BIN_DIR)/$(EXECUTABLE)
endif

# Clean build files
.PHONY: clean
ifeq ($(PLATFORM),windows)
clean:
	@if exist $(BUILD_DIR) rmdir /s /q $(BUILD_DIR)
	@if exist "$(LIB_DIR)\*.a" del /q "$(LIB_DIR)\*.a"
	@if exist "$(LIB_DIR)\*.dll" del /q "$(LIB_DIR)\*.dll"
	@if exist "$(BIN_DIR)\polycall*.exe" del /q "$(BIN_DIR)\polycall*.exe"
	@if exist "bin\polycall*.exe" del /q "bin\polycall*.exe"
else
clean:
	rm -rf $(BUILD_DIR)
	rm -f $(LIB_DIR)/*.a $(LIB_DIR)/*.so $(LIB_DIR)/*.dylib
	rm -f $(BIN_DIR)/polycall bin/polycall
endif

# Remove every compiled artifact and regenerate libraries and the CLI.
.PHONY: rebuild
rebuild: clean
	$(MAKE) --no-print-directory all

# Clean everything including installed files
.PHONY: distclean
distclean: clean uninstall

# Ensure output directories exist before generating artifacts
$(OBJS) $(CLI_OBJS) $(MAIN_OBJ) $(STATIC_LIB) $(SHARED_LIB) $(BIN_DIR)/$(EXECUTABLE): | dirs

# Include dependency files
-include $(DEPS)

# Help target
.PHONY: help
help:
	@echo "Available targets:"
	@echo "  all        - Build everything (default)"
	@echo "  debug      - Build with debug flags"
	@echo "  release    - Build with release flags"
	@echo "  static     - Build a static executable on supported platforms"
	@echo "  clean      - Remove build files"
	@echo "  rebuild    - Clean and recompile all libraries and the CLI"
	@echo "  install    - Install libraries and headers (unsupported on Windows)"
	@echo "  uninstall  - Remove installed files (unsupported on Windows)"
	@echo "  distclean  - Remove all generated files"
	@echo "  help       - Show this help message"
	@echo ""
	@echo "Options:"
	@echo "  USE_OPENSSL=1 - Link libssl/libcrypto when crypto APIs are used"