Modular build system

.gitattributes

@@ -1 +1 @@
-make/** linguist-language=make
+*make/** linguist-language=make

.make/all_functions

@@ -0,0 +1,9 @@
+include .make/functions/comparison
+include .make/functions/directory
+include .make/functions/file_system
+include .make/functions/library
+include .make/functions/list
+include .make/functions/path
+include .make/functions/recursion
+include .make/functions/shell
+include .make/functions/variables

.make/commands

@@ -0,0 +1,22 @@
+# Generates a directory creation command.
+# Does not fail if the directory already exists.
+# Creates all parent directories as needed.
+#
+# Arguments:
+#   $(1) = directories to create
+#
+# Returns:
+#   command line that creates $(1)
+#
+mkdir_p = mkdir -p $(1)
+
+# Generates a file download command.
+#
+# Arguments:
+#   $(1) = what to download
+#   $(2) = where to write downloaded data to
+#
+# Returns:
+#   command line that downloads $(1) to $(2)
+#
+download = curl --output $(2) $(1)

.make/compiler

@@ -0,0 +1 @@
+include .make/compilers/gcc

.make/compilers/gcc

@@ -0,0 +1,79 @@
+# GCC executable
+gcc := gcc
+
+# GCC option variable and function definitions
+gcc.options.output = -o $(1)
+gcc.options.compile := -c
+gcc.options.preprocess := -E
+gcc.options.dependency_generation = -MD -MF $(1) $(foreach target,$(2),-MT $(target))
+gcc.options.standard = -std=$(1)
+gcc.options.directory.include = -I $(1)
+gcc.options.directory.library = -L$(1)
+gcc.options.include.macros = $(foreach file,$(1),-imacros $(file))
+gcc.options.dump.macro_names := -dN
+gcc.redirect_input_to = - < $(1)
+gcc.null_input := $(call gcc.redirect_input_to,/dev/null)
+
+gcc_dialect_options = $(strip $(call gcc.options.standard,$(or $(1),c99)) $(if $(2),-ffreestanding))
+gcc_warning_options := -Wall -Wextra -Wpedantic
+gcc_preprocessor_options = $(call gcc.options.directory.include,$(include_directory)) $(gcc_inhibit_linemarkers_option)
+
+# Generates a GCC command line that compiles a source file into an object file.
+#
+# Arguments:
+#   $(1) = source file
+#   $(2) = object file
+#   $(3) = dependency data file
+#   $(4) = options
+#   $(5) = GCC executable to use
+#
+# Returns:
+#   command line that uses $(5) with the options in $(4)
+#   to compile $(1) into $(2) and emit dependency data to $(3)
+#
+define gcc.compile
+$(or $(5),$(gcc)) \
+$(4) \
+$(call gcc.options.dependency_generation,$(3),$(2)) \
+$(call gcc.options.output,$(2)) \
+$(gcc.options.compile) $(1)
+endef
+
+# Generates a GCC command line that links object files.
+#
+# Arguments:
+#   $(1) = object files
+#   $(2) = output file
+#   $(3) = options
+#   $(4) = GCC executable to use
+#
+# Returns:
+#   command line that uses $(4) with the options in $(3)
+#   to link $(1) into $(2)
+#
+define gcc.link
+$(or $(4),$(gcc)) \
+$(3) \
+$(call gcc.options.output,$(2)) \
+$(1)
+endef
+
+# Generates a GCC command line that lists all defined macros.
+#
+# Arguments:
+#   $(1) = files to include
+#   $(2) = options
+#   $(3) = GCC executable to use
+#
+# Returns:
+#   command line that uses $(3) with the options in $(2)
+#   to list all macros defined after including the files in $(1)
+#
+define gcc.list_defined_macros
+$(or $(3),$(gcc)) \
+$(gcc.options.preprocess) \
+$(gcc.options.dump.macro_names) \
+$(call gcc.options.include.macros,$(1)) \
+$(2) \
+$(gcc.null_input)
+endef

.make/configuration

@@ -0,0 +1,2 @@
+configuration.separator ?= -
+configuration.current = $(call coalesce,$(configuration),$(configuration.separator))

.make/definitions

@@ -0,0 +1,7 @@
+space :=
+space +=
+
+define \n :=
+
+
+endef

.make/dependencies

@@ -0,0 +1,17 @@
+# The wildcard function returns existing files that match its parameters.
+# This prevents make from including files that don't exist.
+#
+# Make tries to rebuild included files, without the wildcard function
+# the dependency data files would be generated with every invocation of make,
+# even make clean.
+#
+# References:
+#
+#     https://www.gnu.org/software/make/manual/html_node/Remaking-Makefiles.html
+#     https://make.mad-scientist.net/papers/advanced-auto-dependency-generation/#include
+#     https://make.mad-scientist.net/constructed-include-files/
+#
+
+dependency_file? = $(call boolean,$(and $(call equal?,$(suffix $(1)),.d),$(call file?,$(1))))
+
+include $(call find,$(build_dependencies_directory),dependency_file?)

.make/file

@@ -0,0 +1,36 @@
+# Disable all predefined rules and variables
+MAKEFLAGS += --no-builtin-rules --no-builtin-variables
+
+# Boolean logic in make
+include .make/logic
+
+# Useful variables
+include .make/definitions
+
+# Commands used by the build system
+include .make/commands
+
+# Make functions available to the entire build system
+include .make/all_functions
+
+# Build configuration
+include .make/configuration
+
+# File system structure of the build tree
+include .make/structure
+
+# Compiler and archiver configuration
+include .make/compiler
+include .make/archiver
+
+# Rule templates
+include $(addprefix .make/rules/,template objects executable libraries run)
+
+# Project interface
+include .make/project
+
+# Include the user's makefile, if it exists
+include $(wildcard make/file)
+
+# Include all generated dependency files
+include .make/dependencies

make/functions/comparison → .make/functions/comparison

@@ -1,5 +1,5 @@
 # x - y = 0 ∴ x = y
-equal? = $(if $(subst $(1),,$(2)),,=)
+equal? = $(if $(subst $(1),,$(2))$(subst $(2),,$(1)),,=)
 
 # x - y ≠ 0 ∴ x ≠ y
 not_equal? = $(if $(call equal?,$(1),$(2)),,≠)

.make/functions/directory

@@ -0,0 +1,10 @@
+# Generates a command that makes sure the given directory exists.
+# Generates the empty string if the directory already exists.
+#
+# $(1) = path to directory to create
+#
+ensure_directory_exists = $(if $(call directory?,$(1)),,$(call mkdir_p,$(1)))
+
+# Ensures the existence of the directory where the target of a rule is located in.
+# This function references an automatic variable so it should only be used inside recipes.
+ensure_target_directory_exists = $(call ensure_directory_exists,$(@D))

.make/functions/file_system

@@ -0,0 +1,107 @@
+# Determines whether the given path exists and is a directory.
+# Only existing directories contain a "." entry.
+#
+# Arguments:
+#   $(1) = path to check
+#
+# Returns:
+#   whether $(1) refers to an existing directory
+#
+# References:
+#   MadScientist's answer:
+#     http://stackoverflow.com/a/9456282/512904
+#
+directory? = $(if $(1),$(call boolean,$(wildcard $(addsuffix /.,$(1)))))
+
+# Determines whether the given path exists and is a file.
+# Files are defined as everything that is not a directory.
+#
+# Arguments:
+#   $(1) = path to check
+#
+# Returns:
+#   whether $(1) refers to an existing file
+#
+file? = $(call boolean,$(and $(wildcard $(1)),$(call not,$(call directory?,$(1)))))
+
+# Returns a sorted list of unique paths matching the specified pattern.
+#
+# Arguments:
+#   $(1) = pattern entries must match
+#
+# Defaults:
+#   $(1) = *
+#
+# Returns:
+#   list of paths matching $(1)
+#
+glob = $(sort $(wildcard $(or $(1),$(glob.default))))
+
+# By default, glob with match everything except hidden files in the current directory.
+glob.default := *
+
+# Returns a sorted list of unique paths inside the specified directory
+# that match the specified pattern.
+#
+# Arguments:
+#   $(1) = list of directories to work with
+#   $(2) = pattern entries must match
+#
+# Defaults:
+#   $(1) = .
+#   $(2) = *
+#
+# Returns:
+#   list of paths in $(1) matching $(2)
+#
+# Example:
+#
+#   # Enumerates all entries in the current directory.
+#   $(call glob.directory)
+#
+# Example:
+#
+#   # Enumerates all entries in the current directory that start with ".git".
+#   $(call glob.directory,,.git*)
+#
+glob.directory = $(call glob,$(addsuffix /$(or $(2),$(glob.default)),$(or $(1),$(glob.directory.default))))
+
+# By default, glob.directory operates on the current directory.
+glob.directory.default := .
+
+# Traverses the file system recursively.
+#
+# Arguments:
+#   $(1) = starting directory
+#
+# Defaults:
+#   $(1) = .
+#
+# Returns:
+#   list with the contents of the tree rooted in $(1)
+#
+file_system.traverse = $(call recurse,glob.directory,file?,$(or $(1),$(file_system.traverse.default)))
+
+# By default, file_system.traverse operates on the current directory.
+file_system.traverse.default := .
+
+# Walks the directory and returns all files satisfying the predicate function.
+# Behaves just like file_system.traverse if not given a predicate function.
+#
+# Arguments:
+#   $(1) = starting directory
+#   $(2) = optional predicate function
+#
+# Defaults:
+#   $(1) = .
+#   $(2) = true
+#
+# Returns:
+#   list containing paths in $(1) that satisfy $(2)
+#
+# Example:
+#
+#   # Find all source files.
+#   $(call find,source,file?)
+#
+find = $(strip $(foreach entry,$(call file_system.traverse,$(1)),$(if $(call $(or $(2),true),$(entry)),$(entry))))

.make/functions/library

@@ -0,0 +1,14 @@
+library.prefix := lib
+library.extension.static := .a
+library.extension.dynamic := .so
+
+# Computes the file name for the given library name and type.
+#
+# Arguments:
+#   $(1) = library name
+#   $(2) = linkage type: static | dynamic
+#
+# Returns:
+#   the file name for the $(1) library
+#
+library.file_name = $(addsuffix $(library.extension.$(2)),$(addprefix $(library.prefix),$(1)))

.make/functions/list

@@ -0,0 +1,42 @@
+# Maps the given function to all values in the given list.
+#
+# Arguments:
+#   $(1) = function to map to values
+#   $(2) = list of values
+#
+# Returns:
+#   results of calling the $(1) function on each value of the $(2) list
+#
+map = $(foreach value,$(strip $(2)),$(call $(1),$(value)))
+
+# Removes the first element of the list and returns the rest.
+#
+# Arguments:
+#   $(1) = list of values
+#
+# Returns:
+#   the list without the first element
+#
+rest =  $(wordlist 2,$(words $(1)),$(1))
+
+# Inverts the order of the elements of the list.
+#
+# Arguments:
+#   $(1) = list of values
+#
+# Returns:
+#   the reversed list reversed
+#
+reverse = $(if $(word 2,$(1)),$(call reverse,$(call rest,$(1))) $(firstword $(1)),$(1))
+
+# Joins all elements of the given list.
+#
+# Arguments:
+#   $(1) = list of values
+#   $(2) = optional separator
+#
+# Returns:
+#   elements of $(1) combined into one
+#
+coalesce* = $(if $(2),$(addprefix $(addsuffix $(3),$(1)),$(2)),$(1))
+coalesce  = $(if $(word 2,$(1)),$(call $(0)*,$(firstword $(1)),$(call $(0),$(call rest,$(1)),$(2)),$(2)),$(1))