From b513e9a11e246deaf305b214f2840475daa0ede2 Mon Sep 17 00:00:00 2001 From: ken Date: Mon, 26 Sep 2016 12:15:57 -0700 Subject: [PATCH] ++debug mode --- src/Makefile | 369 +++++++++++++++++++++++++++++++++------------------ 1 file changed, 237 insertions(+), 132 deletions(-) diff --git a/src/Makefile b/src/Makefile index c481287..83fb20f 100644 --- a/src/Makefile +++ b/src/Makefile @@ -12,6 +12,8 @@ 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. @@ -26,8 +28,7 @@ go_FLAGS := $(c_FLAGS) 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). @@ -35,11 +36,13 @@ cc_OBJ := o 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 @@ -78,12 +81,6 @@ c_OBJ := $($(c_C)_OBJ) # 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 @@ -99,6 +96,62 @@ awk \ ' 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 @@ -107,66 +160,118 @@ endef # 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 @@ -174,10 +279,18 @@ 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###################################################### @@ -185,10 +298,12 @@ endef # 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)) @@ -217,12 +332,32 @@ $(LIB_DIR)/lib$2.$($1_AROBJ): $(LIBDEPS:%=$(LIB_DIR)/lib%.$($1_AROBJ)) | $(LIBDL 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 @@ -240,22 +375,21 @@ define LANG_LIB_INIT = # 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 @@ -265,9 +399,9 @@ $(eval include $2.mk) 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 @@ -297,32 +431,14 @@ endef # 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))) @@ -348,10 +464,6 @@ $(eval $(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))\ @@ -381,6 +493,7 @@ $(eval $(lang)_LIBS := $(shell echo $($(lang)_LIBS) | $(call AWK_REVERSE_SQUASH) $(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),\ @@ -388,34 +501,9 @@ $(foreach drvsrc,$($(lang)_DRV_SRC),\ $(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),\ @@ -425,8 +513,25 @@ $(filter %/$(basename $(fname))$($(lastword $(subst ., ,$(fname))_OUT)),$(DRV_TR 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) -- 2.18.0