default: all
# Source languages handled by this build system
LANGS := c cpp go
+# Source-to-source languages handled by this build system
+SLANGS := y
# Language-specific compilers and flags passed in from environment
c_C := $(strip $(notdir $(CC)))
c_FLAGS := $(strip $(CFLAGS)) -I.
y_C := bison
y_FLAGS := -d
y_STEM := tab
-y_DUP := h
-y_CHDIR := t
+y_TRG := c h
# Compiler-specific associations. Each compiler has a binary object suffix
# (OBJ), an archiver (AR), and an archiver object suffix (AROBJ). Each compiler
# may optionally have defined a linker (LD), and a binary output suffix (OUT).
cc_LD := $(LD)
cc_AR := $(AR)
cc_AROBJ := a
+cc_DBG := gdb
$(cpp_C)_LD := $(cc_LD)
gcc_OBJ := $(cc_OBJ)
gcc_LD := $(cc_LD)
-gcc_AR := $(cc_AR)
+ngcc_AR := $(cc_AR)
gcc_AROBJ := $(cc_AROBJ)
+gcc_DBG := $(cc_DBG)
emcc_OBJ := bc
emcc_AR := emar
emcc_AROBJ := $(emcc_OBJ) #emar is just a python script that reparses shit for emcc
# binaries.
MODULES := $(filter-out $(DRIVER_DIR),$(subst /,,$(shell ls -d */)))
-# Backup the CVS password and CVSROOT environment vars in case we change them
-$(if $(wildcard ~/.cvspass),\
-$(eval CVSPASS_BAK := $(file <~/.cvspass)))
-$(if $(CVSROOT),\
-$(eval CVSROOT_BAK := $(CVSROOT)))
-
# The following awk program reverses the order of a list while also removing
# duplicate entries. The effect of this when run on the dependency tree is that
# it will remove duplicates occurring in reverse order, allowing the most deeply
'
endef
+# Compile any source-to-source languages before executing the majority of make
+define PREMAKE_SOURCE_COMPILER =
+# Find the sources for each source-to-source language
+$(foreach slang,$(SLANGS),
+$(eval SLANG_SRC := $(patsubst ./%,%,$(shell find -name "*.$(slang)")))
+# Foreach target type in the source-to-source language, add this source's
+# targets to the list of the current source-to-source language targets
+$(foreach trg,$($(slang)_TRG),
+$(eval SLANG_TRG += $(SLANG_SRC:%.$(slang)=%.$($(slang)_STEM:%=%.)$(trg))))
+# Stat the source file's last-modified time to the var SRC_TIME
+$(foreach src,$(SLANG_SRC),
+$(eval SRC_TIME := $(shell stat -c %Y $(src)))
+# For each of the targets created by this source language, evaluate the
+# last-modified times of each potential target. If the file does not exist, set
+# the time to '0', otherwise set it to the -c %Y result from statting the file.
+$(foreach srctrg,$(filter $(basename $(src))%, $(SLANG_TRG)),
+$(eval TRG_TIMES += $(if $(wildcard $(srctrg)),$(shell stat -c %Y $(srctrg)),0)==$(srctrg)))
+# Sort TRG_TIMES, which will produce a list of oldest-first files and timestamps
+# of the form [last-modified-deltatime]==[filename]
+$(eval TRG_TIMES := $(shell echo $(sort $(TRG_TIMES)) | $(call AWK_REVERSE_SQUASH)))
+# Evaluate the newest time from our ordered list by splitting the word up by its
+# '==' connectors and looking at the first word
+$(eval NEWEST_TRG_TIME := $(word 1,$(subst ==, ,$(TRG_TIMES))))
+# Find the older of the two times (between SRC_TIME and NEWEST_TRG_TIME)
+$(eval OLDER_TIME := $(firstword $(sort $(NEWEST_TRG_TIME) $(SRC_TIME))))
+# If the older of the two times is the newest target time found, then we need to
+# rebuild, but only if our build rule intends to actually make something
+$(if $(MAKECMDGOALS),
+$(eval BUILDGOALS := $(filter-out clean scrub purge uninstall,$(MAKECMDGOALS))),
+$(eval BUILDGOALS := all))
+$(if $(and $(BUILDGOALS),$(filter $(OLDER_TIME),$(NEWEST_TRG_TIME))),
+$(eval SHELL_CMD := cd $(dir $(src)) && $($(slang)_C) $($(slang)_FLAGS) $(notdir $(src)))
+$(info $(SHELL_CMD) $(shell $(SHELL_CMD)))
+)
+# Put these targets on the MAKE_TARGETS list to be removed during "clean",
+# regardless of whether or not they were built just now.
+$(eval MAKE_TARGETS += $(SLANG_TRG))
+))
+endef
+# Compile a source language to a language that compiles to binary, but only if
+# our build rule intends to build some kind of target
+$(eval $(call PREMAKE_SOURCE_COMPILER,))
+
+
+# Backup the CVS password and CVSROOT environment vars in case we change them
+$(if $(wildcard ~/.cvspass),\
+$(eval CVSPASS_BAK := $(file <~/.cvspass)))
+$(if $(CVSROOT),\
+$(eval CVSROOT_BAK := $(CVSROOT)))
+
+# A long function definition to grab deps from the source's compiler and route
+# errors to /dev/null if the rule generator expresses bogus errors
+define SRC_LANG_FLAGS_OPT_DEPS =
+$(filter-out \ %:,$(shell $($2_C) $3 $4 -MG $1 2> /dev/null))
+endef
+
# Given a source and a language, generate a rule to make the object. The second
# invocation of gcc per file lists only its local includes, and filters out
# anything already caught. Anything remaining should be considered to be
# include 'mymodule/something.h'. this check lets that happen), otherwise it is
# some kind of user error
define SRC_LANG_RULE =
-$(eval MOD := $(firstword $(subst /, ,$(dir $1))))\
-$(eval DEPS := $(filter $(MODULES:%=%/%),$(shell $($2_C) -I$(MOD) -M -MG $1 2> /dev/null)))\
-$(eval LOST := $(filter-out %: $(MODULES:%=%/%),$(shell $($2_C) -I$(MOD) -MM -MG $1 2> /dev/null)))\
-$(eval DEPS += $(LOST:%=$(dir $1)%))\
$(if $($1),,$(eval $1 := t)\
-$(basename $1).$($2_OBJ): $(DEPS)
- $($2_C) $$($2_FLAGS) -I$(MOD) -c -o $$@ $1
-)
+$(eval MOD := $(filter $(MODULES),$(firstword $(subst /, ,$(dir $1)))))\
+$(eval FLG := $($2_FLAGS) $(MOD:%=-I% ))\
+$(if $(wildcard $1),
+$(eval DEPS := $(filter-out \ %:,$(shell $($2_C) $(FLG) -M -MG $1)))\
+$(eval MDEPS := $(filter $(MODULES:%=%/%),$(DEPS)))\
+$(eval LOST := $(filter-out \ %: $(DRIVER_DIR)/% $(MODULES:%=%/%),$(shell $($2_C) $(FLG) -MM -MG $1)))\
+$(eval MDEPS += $(LOST:%=$(dir $1)%))\
+$(eval MDEPS := $(shell echo $(MDEPS) | sed -e 's@[a-zA-Z0-9\-\+/]*\.\./include@../include@g'))\
+$(eval ALLDEPS := $(MDEPS) $(DEPS)),\
+$(error Cannot generate deps for: $1, file not found))\
+$(eval SRC_OBJ := $(basename $1).$($2_OBJ))\
+$(eval MAKE_TARGETS += $(SRC_OBJ))\
+
+# Object for $1
+$(SRC_OBJ): $(ALLDEPS)
+ $($2_C) $$($2_FLAGS) $(FLG) -c -o $$@ $1
+$(if $($2_DBG),\
+$(eval DBG_OBJ := $(dir $1).$($2_DBG)/$(basename $(notdir $1)).$($2_OBJ))\
+$(if $(findstring $(dir $(DBG_OBJ)),$(MAKE_DIRS)),,\
+$(eval MAKE_DIRS += $(dir $(DBG_OBJ))))
+# Object for $1 with $($2_DBG) symbols
+$(DBG_OBJ): $(ALLDEPS) | $(dir $(DBG_OBJ))
+ $($2_C) $$($2_FLAGS) $(FLG) -Og -g$($2_DBG) -c -o $$@ $1
+))
endef
# establish a build and link rule given a source driver and language ############
define SRC_LANG_DRVRULE =
-# turn the non-existent third argument into an identifier for our link data
-$(eval 3 := $(notdir $(basename $1)))
-# generate the dependecies list of the driver itself
-$(eval $3_DRV_OBJ := $(1:%.$2=%.$($2_OBJ)))
-$(eval $3_DRV_DEP := $(filter-out $3:,$(shell $($2_C) -M -MG $1)))
-# Implicit and Manual LD Options to allow .ld files to specify manual linking to
-# one of the built-in modules. Implicit LDOs are ones we can surmise from
-# include rules generated with 'SRC_LANG_DEPS', but these are only caught if
-# there was an explicitly included header, or some other file, within the source
-# file of the driver to one of the internal modules. This practice is a
-# reliable way to automatically link an internal module, but if desired an
-# associated '.ld' file for the driver can contain a list of whitespace
-# separated module names to ensure they link properly
-$(foreach mfile,$(filter $(MODULES:%=%/%),$($3_DRV_DEP)),\
-$(eval $3_MODULES += $(firstword $(subst /, ,$(mfile)))))
-# Find the .ld files, if present, and include their 'links' to our internal libs
-$(if $(wildcard $(1:.$2=.ld)),\
-$(eval $3_MODULES += $(basename $(strip $(file <$(1:.$2=.ld))))))
-# Remove duplicates and sort the module list
-$(eval $3_MODULES := $(sort $($3_MODULES)))
-# If the compiler supports linking, distinguish static from dynamic linking
+$(eval DRIVER_NAME := $(basename $(notdir $1)))
+$(eval DRIVER_TARG := $(1:%.$2=$(ROOT_DIR)/%$($2_OUT)))
+$(eval DRIVER_SOB := $(basename $1).$($2_OBJ))
+
+# Generate a rule for the driver object
+$(eval $(call SRC_LANG_RULE,$1,$2))
+
+# Modules can be implicitly specified by a driver if its dependencies include
+# ANY files from any module directory. The 'MDEPS' var is set by SRC_LANG_RULE
+# and expresses the dependencies required to build the object file only.
+$(foreach module_dep,$(MDEPS),
+$(eval DRIVER_MODULES += $(firstword $(subst /, ,$(module_dep))))
+)
+$(eval DRIVER_MODULES := $(filter-out $(DRIVER_DIR) ..,$(sort $(DRIVER_MODULES))))
+
+# In the event that the driver developer does not wish to include a header to
+# any internal modules, the developer may instead create a file with the same
+# basename as the driver, but with the '.ld' suffix, which contains a space
+# separated list of internal modules to link together during compilation
+$(eval DRIVER_MODULES += $(file <$(1:%.$2=%.ld)))
+
+# List of module archives to link together during compilation
+$(eval DRIVER_ARCHIVES := $(DRIVER_MODULES:%=%.$($2_AROBJ)))
+$(eval DRIVER_DEPS := $(DRIVER_SOB) $(DRIVER_ARCHIVES))
+$(eval DRIVER_DBGARCHIVES := $(DRIVER_MODULES:%=.$($2_DBG)/%.$($2_AROBJ)))
+$(eval DRIVER_DBGDEPS := $(dir $(DRIVER_SOB)).$($2_DBG)/$(notdir $(DRIVER_SOB)))
+$(eval DRIVER_DBGDEPS += $(DRIVER_DBGARCHIVES))
+
+# If the compiler supports linking, distinguish static from dynamic links,
+# otherwise set all libraries to static
$(if $($($2_C)_LD),\
-$(eval $3_STLIBS := $(filter-out $($($2_C)_LDLIBS),$($2_LIBS)))\
-$(eval $3_DLIBS := $(filter-out $($3_STLIBS),$($2_LIBS))),\
-$(eval $3_STLIBS := $($2_LIBS)))
+$(eval STLIBS := $(filter-out $($($2_C)_LDLIBS),$($2_LIBS)))\
+$(eval DLIBS := $(filter-out $(STLIBS),$($2_LIBS))),\
+$(eval STLIBS := $($2_LIBS)))
+
# Directory setup
-$(eval $3_DIR := $(dir $(1:%.$2=$(ROOT_DIR)/%)))
-$(eval MAKE_DIRS += $($3_DIR))
-# Setup the sources for this object
-$(eval $3_SRC := $($3_DRV_OBJ))
-# Find the dependencies
-$(eval $3_DEP := $(filter-out $1,$($3_DRV_DEPS)))
-$(eval $3_DEP += $($3_SRC))
-# Preserver ordering and build out the linking order (don't use -Wstatic/dynamic)
+$(eval DRIVER_TARG_DIR := $(dir $(1:%.$2=$(ROOT_DIR)/%)))
+$(eval MAKE_DIRS += $(DRIVER_TARG_DIR))
+$(if $($2_DBG),$(eval MAKE_DIRS += $(DRIVER_TARG_DIR).$($2_DBG)))
+
+# Setup the sources for this object. A driver build rule does not include any
+# compile steps at all, and so should not contain any sources that are,
+# themselves, traditional "source files" like a language-compiled 'c' file. The
+# driver depends on the existence of its equivalent object file (created through
+# compilation), which is expected to contain a 'main' function (or entry for
+# '_start'). This driver object is then simply linked to its libraries and
+# module archives to create an executable binary in the output folder.
+# ORDER MATTERS HERE, this is for the linker:
+$(eval DRIVER_SRC := $(DRIVER_DEPS))
+$(eval DRIVER_DBGSRC := $(DRIVER_DBGDEPS))
+# Iterate through the list of libraries in our language and stack commands from
+# left to right in the "sources" section of the LD command (or LD section of the
+# commandline for the compiler), to preserve ordering and also ensure that it is
+# linked correctly IN THAT ORDER (static vs dynamic).
$(foreach lib,$($2_LIBS),\
-$(if $(findstring $(lib),$($3_STLIBS)),\
-$(eval $3_SRC := $(LIB_DIR)/lib$(lib).$($($2_C)_AROBJ) $($3_SRC)),\
-$(eval $3_SRC := -l$(lib) $($3_SRC))))
-$(eval $3_SRC += $($3_MODULES:%=%.$($2_AROBJ)))
-# Output the driver object file rule
-$(eval $2_TARGETS += $($3_DRV_OBJ))
-# Filter the dependencies of the object to only include deps inside our modules
-$($3_DRV_OBJ): $(filter $(MODULES:%=%/%),$($3_DRV_DEP))
- $($2_C) $($2_FLAGS) -c -o $$@ $1
-# Output the driver link rule
-$(eval $2_TARGETS += $($3_DIR)$3$($2_OUT))
-$($3_DIR)$3$($2_OUT): $($3_DEP) $($3_SRC) | $($3_DIR)
- $($2_C) $($2_FLAGS) $($3_SRC) -o $$@
+$(if $(findstring $(lib),$(STLIBS)),
+# Evaluate static lib $(lib) and add it to the dependencies and sources of the rules we built
+$(eval STATIC_SRC := $(LIB_DIR)/lib$(lib).$($2_AROBJ))\
+$(eval STATIC_DBGSRC := $(LIB_DIR)/.$($2_DBG)/lib$(lib).$($2_AROBJ))\
+$(eval DRIVER_SRC := $(STATIC_SRC) $(DRIVER_SRC))\
+$(eval DRIVER_DBGSRC := $(STATIC_DBGSRC) $(DRIVER_DBGSRC))\
+$(eval DRIVER_DEPS += $(STATIC_SRC))\
+$(eval DRIVER_DBGDEPS += $(STATIC_DBGSRC)),
+# Add dynamic lib to the sources with a link flag, in its correct ordering
+$(eval DRIVER_SRC := -l$(lib) $(DRIVER_SRC))\
+$(eval DRIVER_DBGSRC := -l$(lib) $(DRIVER_DBGSRC))\
+))
+
+# Add the driver target to this language's targets for cleaning
+$(eval SCRUB_TARGETS += $(DRIVER_TARG))
+$(DRIVER_TARG): $(DRIVER_DEPS) | $(DRIVER_TARG_DIR)
+ $($2_C) $($2_FLAGS) $(DRIVER_SRC) -o $$@
+# Output a rule for building with debug flags
+$(eval DRIVER_DBGTARG := $(DRIVER_TARG_DIR)$(basename $(notdir $(DRIVER_TARG)))-d$($2_OUT))
+$(eval SCRUB_TARGETS += $(DRIVER_DBGTARG))
+$(eval MAKE_DIRS += $(DRIVER_TARG_DIR).$($2_DBG)/)
+$(DRIVER_DBGTARG): $(DRIVER_DBGDEPS) | $(DRIVER_TARG_DIR).$($2_DBG)/
+ $($2_C) $($2_FLAGS) $(DRIVER_DBGSRC) -o $$@
+# Make a rule to run this driver after building
+$(DRIVER_NAME)-run: $(DRIVER_TARG)
+ $(DRIVER_TARG)
+$(DRIVER_NAME)-d: $(DRIVER_DBGTARG)
+
#/SRC_LANG_DRVRULE##############################################################
endef
# a single locally-linked (no external -L libs) object (for simplified linking
# modules as static libs).
define MODULE_ARCRULE =
-$(eval c_TARGETS += $1.$($(c_C)_AROBJ))\
-$(eval $1_ARCDEPS := $(filter $1/%,$(foreach lang,$(LANGS),$($(lang)_MOD_TRG))))\
-$1.$($(c_C)_AROBJ): $($1_ARCDEPS) | $(LCLLIB_DIR)
- $($(c_C)_AR) cr $$@ $$^
+$(eval ARCDEPS := $(filter $1/%.$(c_OBJ),$(foreach lang,$(LANGS),$($(lang)_MOD_TRG))))\
+$(eval MAKE_TARGETS += $1.$(c_AROBJ))\
+$1.$(c_AROBJ): $(ARCDEPS)
+ $(c_AR) cr $$@ $$^
+$(if $(c_DBG),
+$(eval undefine DBGARCDEPS)
+$(foreach arcdep,$(ARCDEPS),$(eval DBGARCDEPS += $(dir $(arcdep)).$(c_DBG)/$(notdir $(arcdep))))
+$(eval MAKE_TARGETS += .$(c_DBG)/$1.$(c_AROBJ))\
+
+.$(c_DBG)/$1.$(c_AROBJ): $(DBGARCDEPS) | .$(c_DBG)/
+ $(c_AR) cr $$@ $$^
+)
endef
# LANG_LIB_PARENT_BUILDRULE######################################################
# either binary or bytecode representation given a library name and, optionally,
# a parent lib that included it for error reporting #############################
define LANG_LIB_PARENT_BUILDRULE =
+$(eval CONF_FLAG := --prefix=$(abspath $(LIB_DIR)).trash)
+$(eval CONF_FLAG += --includedir=$(abspath $(LIBINC_DIR)))
# Setup installation rule steps for this lib
$(eval
BUILDSTEPS := $(if $(AUTOGEN),$(AUTOGEN) && )
-BUILDSTEPS += $(if $(CONFIGURE),$(CONFIGURE) && )
+BUILDSTEPS += $(if $(CONFIGURE),$(CONFIGURE) $(CONF_FLAG) --libdir=$(abspath $(LIB_DIR)) && )
$(if $(MKCMD),\
BUILDSTEPS += $(MKCMD),
$(error $2.mk requires a valid MKCMD definition))
cd $(LIBDL_DIR)/$2 && export LD_RUN_PATH=$(LIBLDPATH) && $(BUILDSTEPS)
cd $(LIBDL_DIR)/$2 && $(INSTALLCMD)
@rm -f $(LIBDL_DIR)/$2.clean
+
+# '$2' Rule for building under debug mode
+$(if $($1_DBG),\
+$(eval LIBDBG_DIR := $(LIB_DIR)/.$($1_DBG))\
+$(eval $(if $(findstring $(LIBDBG_DIR),$(MAKE_DIRS)),,MAKE_DIRS += $(LIBDBG_DIR)))\
+$(eval LIBDBG_TARG := $(LIBDBG_DIR)/lib$2.$($1_AROBJ))\
+$(eval LIBDBG_DEPS := $(LIBDEPS:%=$(LIB_DIR)/.$($1_DBG)/lib%.$($1_AROBJ)))\
+$(eval DBGBUILDSTEPS := $(if $(AUTOGEN),$(if $(AUTOGENDBG),$(AUTOGENDBG),$(AUTOGEN)) && ))\
+$(eval DBGBUILDSTEPS += $(if $(CONFIGURE),$(if $(CONFIGUREDBG),$(CONFIGUREDBG),$(CONFIGURE)) $(CONF_FLAG) --libdir=$(abspath $(LIB_DIR))/.$($1_DBG)))\
+$(eval DBGBUILDSTEPS += $(if $(MKDBGCMD),$(MKDBGCDM),$(MKCMD)))\
+
+# '$2' Make and install rule for debugging
+$(LIBDBG_TARG): $(LIBDBG_DEPS) | $(LIBDL_DIR)
+ @mkdir -p $(LIBDBG_DIR)
+ cd $(LIBDL_DIR)/$2 && export LD_RUN_PATH=$(LIBLDPATH:$(LIB_DIR)%=$(LIBDBG_DIR)) && $(DBGBUILDSTEPS)
+ cd $(LIBDL_DIR)/$2 && $(INSTALLCMD)
+ @rm -f $(LIBDL_DIR)/$2.clean
+)
+
# '$2' Clean rule - drop a marker in the directory so we don't bother cleaning
# things that are clean... by default there is no real way of tracking this in a
# makefile
clean_$2:
$$(if $$(wildcard $(LIBDL_DIR)/$2),$$(if $$(wildcard $(LIBDL_DIR)/$2.clean),,\
cd $(LIBDL_DIR)/$2 && $(CLEANCMD) && touch $(abspath $(LIBDL_DIR))/$2.clean))
+
#/LANG_LIB_PARENT_BUILDRULE######################################################
endef
# can overwrite these vars
$(eval
# Implicit defaults for lib.mk files
-AUTOGEN := ./autogen.sh
-CONFIGURE := ./configure
-CONFIGURE += --prefix=$(abspath $(LIB_DIR)/.trash)
-CONFIGURE += --includedir=$(abspath $(LIBINC_DIR))
-CONFIGURE += --libdir=$(abspath $(LIB_DIR))
-MKCMD := make -k
-MKINSTALL := make -k install
-MKCLEAN := make clean
-LIBDEPS :=
-LIBLANGS := c cpp go
-LIBLDPATH := $(if $($($1_C)_LD),$(if $(LD_LIBRARY_PATH),$(LD_LIBRARY_PATH):,/usr/lib:)$(abspath $(LIB_DIR)))
+AUTOGEN := ./autogen.sh
+AUTOGENDBG := ./autogen.sh --enable-debug
+CONFIGURE := ./configure
+MKCMD := make -k
+MKINSTALL := make -k install
+MKCLEAN := make clean
+MKDBGCMD := make -k
+LIBDEPS :=
+LIBLANGS := c cpp go
+LIBLDPATH := $(if $($($1_C)_LD),$(if $(LD_LIBRARY_PATH),$(LD_LIBRARY_PATH):,/usr/lib:)$(abspath $(LIB_DIR)))
# One of these must be defined in the .mk file imported
$(foreach var, GITADDR WEBADDR HGADDR CVSADDR,\
$(eval undefine $(var)))
# Other, optional, variables to clear
-$(foreach var, WEBTARG WEBINIT CVSGET CVSPASS,
+$(foreach var, WEBTARG WEBINIT CVSGET CVSPASS CONFIGUREDBG,
$(eval undefine $(var)))
)
# Include and evaluate such that it may be called and evaluated for immediate
endef
# If there is a .mk file for this lib, import it. Otherwise, we'll try to link
# it later, unless there is no linker for the language's compiler.
-$(if $(wildcard $2.mk),$(eval $(call EVALINCLUDE)),\
+$(if $(wildcard $2.mk),$(eval $(file <$2.mk)),\
$(if $($($1_C)_LD),\
-$(warning No $2.mk for lib$2, linking from the system),\
+$(warning No $2.mk for lib$2, attempting to link from the system),\
$(error No $2.mk for lib$2 and '$($1_C)' is not configured for linking)))\
# Add dependencies we found (potentially recursively, ignore repeats until later
# Initialize data for supported lanaguages ######################################
define LANG_INIT =
-$(eval
-# Initialize all relevant (although not necessarily used) language relative data
-define $1_VARS_INIT =
$(eval
$1_OBJ := $($($1_C)_OBJ)
$1_OUT := $($($1_C)_OUT)
$1_AROBJ := $($($1_C)_AROBJ)
$1_SOURCES := $(subst ./,,$(shell find -name "*.$1"))
+$1_DBG := $($($1_C)_DBG)
+$1_AR := $($($1_C)_AR)
)
-# For each source language that can compile to this language, add the expected
-# result of such a transformation to the sources of this language. Then, if the
-# source-to-source compiler also creates duplicate files of other formats
-# (i.e. yacc/bison also produce accompanying .h files), add them to the list of
-# source files that this makefile can generate ('$1_TARGETS'), to later be deleted
-# during the clean rule.
-$(foreach srcl,$($1_SRCL),\
-$(eval $(srcl)_SOURCES := $(shell find -name "*.$(srcl)" | \
-sed -e 's@^\(.*\)\.$(srcl)@\1$($(srcl)_STEM:%=.%).$1@g' -e 's@\./@@'))\
-$1_SOURCES += $($(srcl)_SOURCES)
-$(srcl)_TARGETS += $($(srcl)_SOURCES:%.$(srcl)=.$1)
-$(foreach dup,$($(srcl)_DUP),\
-$(srcl)_TARGETS += $($(srcl)_SOURCES:%.$1=%.$(dup))
-))
-endef
-)\
-$(eval $($1_VARS_INIT))\
# Find save language-specific driver and module sources and targets
$(eval $1_DRV_SRC := $(filter $(DRIVER_DIR)/%,$($1_SOURCES)))
$(eval $1_DRV_TRG := $(patsubst %.$1,$(ROOT_DIR)/%$($1_OUT),$($1_DRV_SRC)))
$(module)_SRC += $($(module)_$1_SRC)
$(module)_TRG += $($(module)_$1_TRG)
)
-# Add these targest to the language's target list
-$(eval
-$1_TARGETS += $($(module)_TRG)
-)
# For every source file, create a build rule for it for our language
$(foreach src,$(filter $(module)/%,$($1_MOD_SRC)),\
$(eval $(call SRC_LANG_RULE,$(src),$1))\
$(foreach module,$(MODULES),\
$(eval $(call MODULE_ARCRULE,$(module)))\
)
+$(if $(c_DBG),$(eval MAKE_DIRS += .$(c_DBG)/))
# Create lang-specific rules for producing final (linked) targets
$(foreach lang,$(LANGS),\
$(eval $(call SRC_LANG_DRVRULE,$(drvsrc),$(lang)))\
))
-# Make any dirs that we're in charge of
-$(MAKE_DIRS):
- @mkdir -p $@
-
-# Source-to-source build rules
-# Compilers that don't specify an output location can be made to change
-# directories with 'cd' to the target file's directory, update the command line
-# source files, and allow the compiler to output in its default current working
-# directory 'cwd'. this is done by setting the $1_CHDIR flag to 't'
-define SRCLANG_TRGLANG_BUILDRULE =
-%$($1_STEM:%=.%).$2$(if $($1_DUP), %$($1_STEM:%=.%).$($1_DUP)): %.$1
- $(if $($1_CHDIR),cd $$(shell dirname $$@) && )$$($1_C) $$($1_FLAGS)$(if $($1_CHDIR),\
-$$(shell echo $$@ | sed -e 's@^.*/\([^\.]*\).*@\1@').$1,\
-$$<)
-endef
-# Create rules for all the source-to-source compilation, and poll all of our
-# make targets while we're at it
-$(foreach lang,$(LANGS),\
-$(foreach srcl,$($(lang)_SRCL),\
-$(eval $(call SRCLANG_TRGLANG_BUILDRULE,$(srcl),$(lang)))\
-$(eval MAKE_TARGETS += $($(srcl)_TARGETS))\
-)\
-$(eval MAKE_TARGETS += $($(lang)_TARGETS))\
-)
-
# Create driver rules for each driver we found, let users call make specifying
-# the basename of the driver, and just route to the correct linkrule we made in
-# the last paragraph
+# the basename of the driver file, and just route to the correct linkrule we
+# made in the last paragraph
DRV_FNAMES := $(notdir $(DRV_SRC))
.PHONY: all $(basename $(DRV_NAMES))
$(foreach fname,$(DRV_FNAMES),\
all: $(basename $(DRV_FNAMES))
@echo Build Complete
+# Rule to make any dirs that we're in charge of
+$(MAKE_DIRS):
+ @mkdir -p $@
+
+# Cleaning rules.
+# Clean destroys all object files and internal module archives.
+CLEAN_TARGETS := $(sort $(foreach mtarg,$(MAKE_TARGETS),$(if $(wildcard $(mtarg)),$(mtarg))))
clean: $(BUILTLIBS:%=clean_%)
- rm -f $(MAKE_TARGETS)
+ $(if $(CLEAN_TARGETS),rm $(CLEAN_TARGETS))
+# Scrub destroys all distributable binaries
+SCRUB_TARGETS := $(sort $(foreach starg,$(SCRUB_TARGETS),$(if $(wildcard $(starg)),$(starg))))
scrub: clean
+ $(if $(SCRUB_TARGETS),rm $(SCRUB_TARGETS))
+
+# Purge destroys all distributables created by a distributable binary
+# (e.g. assets)
+
+# Uninstall destroys all objects and directories that cannot be recreated by
+# this make file
+uninstall: scrub
rm -Rf $(MAKE_DIRS)
projects / henge / webcc.git / commitdiff