Makefile.include

# -*- makefile -*-

ifndef TWO
  ${error TWO not defined! You must specify where two resides}
endif

# Find OS
OS = $(word 1, $(shell uname -m -s))

# Default CFLAGS
CFLAGS = -std=c99 -Wall -Wextra

# Use bsd timers
CFLAGS += -D_DEFAULT_SOURCE

# Configure output directories
# Path for final binaries to be stored
TARGET_DIR ?= bin

# Build dir is for temporary files
BUILD_DIR ?= build

SHELL = bash

# Extra definitions can be added using the DEFINES variable
ifeq ($(DEFINES),)
  -include Makefile.defines
  ifneq ($(DEFINES),)
    ${info using saved defines '$(DEFINES)'}
  endif
endif

#More debug information when running in CI
ifdef CI
  ifeq ($(CI),true)
    QUIET = 0
  endif
endif


# Remove duplicates
uniq = $(if $1,$(firstword $1) $(call uniq,$(filter-out $(firstword $1),$1)))

# Path for objects and dependencies
SRC = ${TWO}/src
OBJECTDIR = $(BUILD_DIR)/obj

# Path for test builds
TEST_BUILD = $(BUILD_DIR)/test

# Library paths
LIBRARY = $(BUILD_DIR)/two.a
LIBRARY_OBJECTS = $(addprefix ${OBJECTDIR}/,$(patsubst %.c,%.o,$(LIBRARY_SOURCES)))

# Target objects
OBJECTS = $(addprefix ${OBJECTDIR}/,$(patsubst %.c,%.o,$(SOURCES)))


# Remove implicit rules
.SUFFIXES:
.SUFFIXES: .c .o

# Provide way to recreate necessary directories
DIRS += $(TARGET_DIR) $(TEST_BUILD) $(OBJECTDIR)
$(DIRS):
	$(TRACE_MKDIR)
	$(Q)mkdir -p $@

# Library module configuration (under src/)
# One big module under src for now
MODULEDIRS = $(SRC) $(SRC)/hpack
UNIQUEMODULES = $(call uniq,$(MODULEDIRS))
MODULES_SOURCES = $(foreach d, $(UNIQUEMODULES), ${subst ${SRC}/,,${wildcard $(d)/*.c}})

# Update library sources
LIBRARY_SOURCES += $(MODULES_SOURCES)

# Include module-specific makefiles
MODULES_INCLUDES = ${wildcard ${foreach d, $(UNIQUEMODULES), $(d)/Makefile.${notdir $(d)}}}

### Perform an immediate expansion of MODULES_INCLUDES and store it in a
### variable. This will allow us to subsequently filter-out module Makefiles
### that were included in the first pass, such that we don't end up including
### them twice.
MODULES_INCLUDED_FIRST_PASS := $(MODULES_INCLUDES)
include $(MODULES_INCLUDED_FIRST_PASS)

# Iterate once more: include the modules added from the previous include.
# Only works with one level of nested module inclusion.
include $(filter-out $(MODULES_INCLUDED_FIRST_PASS),$(MODULES_INCLUDES))

define SET_SOURCE_FOR_TARGET
$$(subst /,_,$$(basename ${1})) := ${1}
endef

define GET_SOURCE_FOR_TARGET
$(if ${${1}},$(basename ${${1}}),${1})
endef

# Test configurations
$(foreach s,${LIBRARY_SOURCES},$(eval $(call SET_SOURCE_FOR_TARGET,${s})))

define INCLUDE_TEST
    TEST_SUBDIRS :=
    DIR := $${TWO}/${1}
    ifneq ($$(wildcard $${DIR}/Makefile.$$(notdir $$(DIR))),)
        include $$(DIR)/Makefile.$$(notdir $$(DIR))

        TEST_SUBDIRS := $(addprefix $${DIR}/,$${TEST_SUBDIRS})
        TESTDIRS += $${TEST_SUBDIRS}
        
        # Include Makefile.<dirname> if it exists
        include $$(wildcard $$(foreach d,$${TEST_SUBDIRS},$${d}/Makefile.$$(notdir $${d})))
    endif
endef

#Include all tests in TESTDIRS
$(foreach d,${TESTDIRS},$(eval $(call INCLUDE_TEST,${d:%/=%})))


### Verbosity control. Use  make QUIET=0  to get verbose builds.
ifeq ($(QUIET),0)
  TRACE_CC =
  TRACE_LD =
  TRACE_AR =
  TRACE_AS =
  TRACE_MKDIR =
  TRACE_RM =
  TRACE_CP =
  Q=
else
  MAKEFLAGS = --no-print-directory
  TRACE_CC = @echo "  CC       " $<
  TRACE_LD = @echo "  LD       " $@
  TRACE_AR = @echo "  AR       " $@
  TRACE_AS = @echo "  AS       " $<
  TRACE_MKDIR = @echo "  MKDIR    " $@
  TRACE_RM  = @echo "  RM       " ${1}
  TRACE_CP  = @echo "  CP       " $< "-->" $@
  Q=@
endif

### Forward comma-separated list of arbitrary defines to the compiler
COMMA := ,
CFLAGS += ${addprefix -D,${subst $(COMMA), ,$(DEFINES)}}

### Where to look for source files
SOURCEDIRS = . $(TARGETDIRS) $(MODULEDIRS)
vpath %.c $(SOURCEDIRS) $(TESTDIRS)

### List of include directories for the compiler
CFLAGS += $(addprefix -I,$(SOURCEDIRS))

### Automatic dependency generation
ifneq ($(MAKECMDGOALS),clean)
-include ${addprefix $(OBJECTDIR)/,$(LIBRARY_SOURCES:.c=.d) \
		                           $(SOURCES:.c=.d)}
endif

### See http://make.paulandlesley.org/autodep.html#advanced
define FINALIZE_DEPENDENCY
cp $(@:.o=.d) $(@:.o=.$$$$); \
sed -e 's/#.*//' -e 's/^[^:]*: *//' -e 's/ *\\$$//' \
    -e '/^$$/ d' -e 's/$$/ :/' < $(@:.o=.$$$$) >> $(@:.o=.d); \
rm -f $(@:.o=.$$$$)
endef

.PHONY: clean distclean debug release
clean:
	$(call TRACE_RM,*.d *.o $(CLEAN) $(OBJECTDIR))
	-$(Q)rm -f *.d *.o $(CLEAN)
	-$(Q)rm -rf $(OBJECTDIR)

distclean:
	$(call TRACE_RM,$(BUILD_DIR) $(TARGET_DIR))
	-$(Q)rm -rf $(BUILD_DIR)
	-$(Q)rm -rf $(TARGET_DIR)

.PHONY: debug
debug: CFLAGS += -g $(DEBUG_FLAGS)
debug: all

# disable assertions for release build
.PHONY: release
release: CFLAGS += -DNDEBUG
release: al

# Build regular objects
$(OBJECTDIR)/%.o: %.c | $(OBJECTDIR)
	@mkdir -p $(dir $@)
	$(TRACE_CC)
	$(Q)$(strip $(CC) $(CFLAGS) -MMD -c $< -o $@)
	@$(FINALIZE_DEPENDENCY)

# Build test object
$(TEST_BUILD)/test_%.o: CFLAGS += -g ${TEST_CFLAGS} $(addprefix -I,$(TESTDIRS))
$(TEST_BUILD)/test_%.o: test_%.c | $(TEST_BUILD)
	$(TRACE_CC)
	$(Q)$(strip $(CC) $(CFLAGS) -c $< -o $@)


$(TEST_BUILD)/%.o: %.c | $(TEST_BUILD)
	@mkdir -p $(dir $@)
	$(TRACE_CC)
	$(Q)$(strip $(CC) $(CFLAGS) $(TEST_SRC_CFLAGS) -g -DNDEBUG -MMD -c $< -o $@)
	@$(FINALIZE_DEPENDENCY)

%.o: %.c
	$(TRACE_CC)
	$(Q)$(strip $(CC) $(CFLAGS) -c $< -o $@)

$(LIBRARY): $(LIBRARY_OBJECTS)
	$(TRACE_AR)
	$(Q)$(strip $(AR) $(ARFLAGS) $@ $^)

# Build target rule
$(TARGET_DIR)/%: %.o $(OBJECTS) $(LIBRARY) | $(TARGET_DIR)
	$(TRACE_LD)
	$(Q)$(strip $(CC) $(LDFLAGS) -o $@ ${filter-out %.a,$^} ${filter %.a,$^} $(LDLIBS))

.PHONY: test_%
test_%: $(TEST_BUILD)/test_%
	$(Q)$^

.PRECIOUS: $(TARGET_DIR)/% $(TEST_BUILD)/test_%

# Cancel the predefined implict rule for compiling and linking
# a single C source into a binary to force GNU make to consider
# the match-anything rule below instead.
%: %.c

# Match-anything pattern rule to allow the project makefiles to
# abstract from the actual binary name. It needs to contain some
# command in order to be a rule, not just a prerequisite.
%: $(TARGET_DIR)/%
	@
	
.SECONDEXPANSION:
# Build tests rule
$(TEST_BUILD)/test_%: LDFLAGS += $(TEST_LDFLAGS)
$(TEST_BUILD)/test_%: LDLIBS += $(TEST_LDLIBS)
$(TEST_BUILD)/test_%: $(TEST_BUILD)/test_%.o $(TEST_BUILD)/$$(call GET_SOURCE_FOR_TARGET,%).o $(TEST_PREREQS)
	$(TRACE_LD)
	$(Q)$(strip $(CC) $(LDFLAGS) -o $@ ${filter-out %.a,$^} ${filter %.a,$^} $(LDLIBS))