Archives/falk-werner_webfuse-provider
1
0
Fork 0
mirror of https://github.com/falk-werner/webfuse-provider synced 2024-10-27 20:44:10 +00:00
Code Issues Releases Wiki Activity
5727ad7415
falk-werner_webfuse-provider/build/dobuild/defaults.mk

682 lines
25 KiB
Makefile
Raw Blame History

#
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This file is part of dobuild.
# Copyright (c) 2019 Contributors as noted in the AUTHORS file.
#
# SPDX-License-Identifier: MPL-2.0
ifndef defaults_include_guard
defaults_include_guard := 1
current_makefile := $(word $(words $(MAKEFILE_LIST)),$(MAKEFILE_LIST))
#######################################################################################################################
# Overridable common defaults
# NOTE: default assumes first loaded makefile is located in root directory of project
MAKEFILE ?= $(firstword $(MAKEFILE_LIST))
MAKEFILE := $(MAKEFILE)
DOBUILD_TOPDIR ?= $(PROJECTDIR)
DOBUILD_PROJECTDIR ?= $(patsubst %/,%,$(dir $(MAKEFILE)))
DOBUILD_PROJECTNAME ?= $(notdir $(shell cd $(PROJECTDIR) && pwd))
DOBUILD_PROJECTVERSIONFILE ?= $(PROJECTDIR)/VERSION
DOBUILD_PROJECTVERSION ?= $(shell cat '$(VERSIONFILE)' 2>/dev/null)
DOBUILD_OUTDIR ?= $(BUILDDIR)/.build
DOBUILD_BUILDDIR ?= $(PROJECTDIR)
DOBUILD_BUILDVERBOSE ?=
DOBUILD_TESTVERBOSE ?=
DOBUILD_BUILDTESTING ?= 1
DOBUILD_USERID ?= $(shell id -u)
DOBUILD_HOSTCONTAINER ?= $(shell $(DOBUILDDIR)/bin/get_container_id.sh)
DOBUILD_JOBSLOTS ?= $(call jobslots,$(make_cmdline))
DOBUILD_SKIPMD5SUM ?= $(call filter_not_found,md5sum)
DOBUILD_SKIPCURL ?= $(call filter_not_found,curl)
DOBUILD_SKIPDEFAULTTARGET ?= $(or $(HOSTMARCH),$(MARCH),$(DISTRIB_ID),$(DISTRIB_VERSION),$(SYS),$(ABI),$(ID),$(VARIANT),$(call not,$(DEFAULTTARGET)))
DOBUILD_SKIPEXTERNSYNC ?=
DOBUILD_FILTER ?= $(call target_properties_combine, \
$(or $(HOSTMARCH),%), \
$(or $(MARCH),%), \
$(or $(DISTRIB_ID),%), \
$(or $(SYS),%), \
$(or $(ABI),%), \
$(or $(ID),%), \
$(or $(DISTRIB_VERSION),%), \
$(or $(VARIANT),%) \
)
DOBUILD_EXCLUDEFILTER ?= $(if $(strip \
$(or $(EXCLUDE_HOSTMARCH),$(EXCLUDE_MARCH),$(EXCLUDE_DISTRIB_ID),$(EXCLUDE_SYS),$(EXCLUDE_ABI),$(EXCLUDE_ID),$(EXCLUDE_DISTRIB_VERSION),$(EXCLUDE_VARIANT)) \
), \
$(call target_properties_combine, \
$(or $(EXCLUDE_HOSTMARCH),%), \
$(or $(EXCLUDE_MARCH),%), \
$(or $(EXCLUDE_DISTRIB_ID),%), \
$(or $(EXCLUDE_SYS),%), \
$(or $(EXCLUDE_ABI),%), \
$(or $(EXCLUDE_ID),%), \
$(or $(EXCLUDE_DISTRIB_VERSION),%), \
$(or $(EXCLUDE_VARIANT),%)\
) \
)
DOBUILD_FILTERMEMCHECK ?= $(call target_properties_format_args,$(or $(machine),%),$(or $(machine),%),%,%,%,%,%,%)
DOBUILD_CGROUPPARENT ?=
DOBUILD_COLOR ?= $(shell { command -v tput >/dev/null 2>&1 && test "$$(tput $(addprefix -T,$(TERM)) colors)" -ge 8 2>/dev/null; } && echo '1')
DOBUILD_EXTDIR ?= $(PROJECTDIR)/dobuild-extensions
BUILDKIT_PROGRESS ?= plain
DOCKER_BUILDKIT ?= 1
DESTDIR ?=
TERM ?= linux
REGISTRY_PREFIX ?=
VERBOSE ?=
COLOR = $(call memorize,COLOR,$(DOBUILD_COLOR))
PREPARE_TARGETS = $(EXTRACT_TARGETS)
RULE_TARGETS =
BUILD_TARGETS =
CHECK_TARGETS =
MEMCHECK_TARGETS =
LINT_TARGETS =
RUN_TARGETS =
CLEAN_TARGETS =
EXTRACT_TARGETS =
DIST_TARGETS =
DISTCLEAN_TARGETS =
INSTALL_TARGETS =
TARGETS =
OUTDIRS =
BUILDTARGET = $(warning: deprecated use DEFAULTTARGET instead)
DOCKER_RUNFLAGS =
DOCKER_BUILDFLAGS =
IMAGE_BUILDARGS =
CURLFLAGS =
MAKEFILE_DEPS =
#######################################################################################################################
# Common macros
# caches a value lazily - at it's first evaluation
# $(call memorize,VAR,value...)
memorize = $(eval $1 := $$2)$2
# asserts value is not empty, evaluates to value or reports an error message on failure and aborts build
# $(call assert,value,message)
assert = $(or $1,$(error assertion failed: $2))
# asserts value is not empty, evaluates to value or reports a warning message on failure and continues build
# $(call expect,value,message)
expect = $(or $1,$(warning expectation failed: $2))
# asserts value is of scalar type, evaluates to value or reports an error message on failure
# $(call assert_scalar,value...,message)
assert_scalar = $(if $(call eq_s,1,$(words $1)),$1,$(error assertion failed: $2))
# filters out all commands found on host, resulting in a list of unavailable commands
# $(call filter_not_found,command...)
filter_not_found = $(filter $1,$(foreach cmd,$1,$(shell command -v $(cmd) >/dev/null 2>&1 || echo $(cmd))))
# escapes a character in string
# $(call escape,string,char)
escape = $(subst $2,$(\\)$2,$1)
# filters all elements matching any of the given regular expressions
# $(call filter_by_regex,regex...,element...)
filter_by_regex = $(shell printf '%s\n' $2 | sed -n$(foreach regex,$1, -e 's!$(call escape,$(regex),!)!\0!p'))
# parses the target properties [host-arch arch_sub vendor_or_distrib_id sys abi id distrib_version variant] for given name
# $(call target_properties_parse,target-name)
target_properties_parse = $(shell $(DOBUILDDIR)/bin/parse_target_properties.sh $1)
# retrieves the target properties
# $(call target_properties,target-name)
target_properties = $(or $($1),$(call target_properties_parse,$1))
# formats a list of target properties as string
# $(call target_properties_format,property...)
target_properties_format = $(call target_properties_format_args, \
$(call target_property_host_arch,$1), \
$(call target_property_arch_sub,$1), \
$(call target_property_vendor_or_distrib_id,$1), \
$(call target_property_sys,$1), \
$(call target_property_abi,$1), \
$(call target_property_id,$1), \
$(call target_property_distrib_version,$1), \
$(call target_property_variant,$1) \
)
# formats target name by its properties as separated arguments - each may be empty
# $(call target_properties_format_args,host_arch,arch_sub,distrib,sys,abi,id,distrib_version,variant)
target_properties_format_args = $(call join_s,$1 $(call join_s,$2 $(call join_s,$3 $7,@) $4 $5,-) $(call join_s,$6 $8,@),+)
# tests each target property matches associated pattern
# $(call target_properties_matches,pattern...,property...)
target_properties_matches = $(call eq,$1,$2,filter)
# retrieves the target property host-arch from the list of properties
# $(call target_property_host_arch,property...)
target_property_host_arch = $(word 1,$1)
# retrieves the target property arch_sub from the list of properties
# $(call target_property_arch_sub,property...)
target_property_arch_sub = $(word 2,$1)
# retrieves the target property vendor_or_distrib_id from the list of properties
# $(call target_property_vendor_or_distrib_id,property...)
target_property_vendor_or_distrib_id = $(word 3,$1)
# retrieves the target property sys from the list of properties
# $(call target_property_sys,property...)
target_property_sys = $(word 4,$1)
# retrieves the target property abi from the list of properties
# $(call target_property_abi,property...)
target_property_abi = $(word 5,$1)
# retrieves the target property id from the list of properties
# $(call target_property_id,property...)
target_property_id = $(word 6,$1)
# retrieves the target property distrib_version from the list of properties
# $(call target_property_distrib_version,property...)
target_property_distrib_version = $(word 7,$1)
# retrieves the target property variant from the list of properties
# $(call target_property_variant,property...)
target_property_variant = $(word 8,$1)
# retrieves the target host-arch
# $(call target_host_arch,target-name)
target_host_arch = $(call target_property_host_arch,$(call target_properties,$1))
# retrieves the target arch_sub
# $(call target_arch_sub,target-name)
target_arch_sub = $(call target_property_arch_sub,$(call target_properties,$1))
# retrieves the target vendor_or_distrib_id
# $(call target_vendor_or_distrib_id,target-name)
target_vendor_or_distrib_id = $(call target_property_vendor_or_distrib_id,$(call target_properties,$1))
# retrieves the target sys
# $(call target_sys,target-name)
target_sys = $(call target_property_sys,$(call target_properties,$1))
# retrieves the target abi
# $(call target_abi,target-name)
target_abi = $(call target_property_abi,$(call target_properties,$1))
# retrieves the target id
# $(call target_id,target-name)
target_id = $(call target_property_id,$(call target_properties,$1))
# retrieves the target id
# $(call target_variant,target-name)
target_variant = $(call target_property_variant,$(call target_properties,$1))
# retrieves the target distribution version
# $(call target_distrib_version,target-name)
target_distrib_version = $(call target_property_distrib_version,$(call target_properties,$1))
# retrieves the target distribution id and version
# $(call target_distrib,target-name)
target_distrib = $(addsuffix $(addprefix @,$(call target_distrib_version,$1)),$(call target_vendor_or_distrib_id,$1))
# retrieves the target distribution id
# $(call target_distrib_id,target-name)
target_distrib_id = $(call target_vendor_or_distrib_id,$1)
# tests target properties matches given pattern
# $(call target_matches,target-name,pattern...)
target_matches = $(call target_properties_matches,$2,$(call target_properties,$1))
# filters all targets which properties matches given patterns
# $(call target_filter_by_properties,pattern...,target-name...)
target_filter_by_properties = $(call filter_p,$2,target_matches,$1)
# filters all targets which properties matches given include-pattern and not the given exclude-pattern strings
# $(call target_filter,inlcude-pattern-string...,target-name...[,exclude-pattern-string...])
target_filter = \
$(filter-out \
$(foreach pattern,$3,$(call target_filter_by_properties,$(call target_properties_parse,$(pattern)),$2)),\
$(foreach pattern,$1,$(call target_filter_by_properties,$(call target_properties_parse,$(pattern)),$2))\
)
# replaces template values in string list with target properties
# $(call target_subst,target-name[,values...,])
target_subst = $(strip \
$(subst %TARGET%,$1, \
$(subst %OUTDIR%,$(OUTDIR), \
$(subst %HOSTMARCH%,$(call target_host_arch,$1), \
$(subst %MARCH%,$(call target_arch_sub,$1), \
$(subst %DISTRIB%,$(call target_distrib,$1), \
$(subst %DISTRIB_ID%,$(call target_distrib_id,$1), \
$(subst %DISTRIB_VERSION%,$(call target_distrib_version,$1), \
$(subst %SYS%,$(call target_sys,$1), \
$(subst %ABI%,$(call target_abi,$1), \
$(subst %ID%,$(call target_id,$1), \
$(subst %VARIANT%,$(call target_variant,$1),$2) \
) \
) \
) \
) \
) \
) \
) \
) \
) \
) \
)
# replaces template values of target field with target properties
# $(call target_subst_cmd,target-name,field[,default-value])
target_get_and_subst = $(call target_subst,$1,$(or $(call $1.$2,$1),$3))
# replaces template values of target field with target properties and resolves result against given search
# paths, returning a list of existing resolved paths
# $(call target_subst_and_resolve,target-name,field,path...)
target_subst_and_resolve = $(wildcard $(addsuffix /$(call target_get_and_subst,$1,$2,),$3))
# generates target names by combining elements of list properties
# $(call target_properties_combine,host_arch1...,arch_sub1..,distrib1...,sys1...,abi1...,id1...,distrib_version1...,variant1...)
target_properties_combine = $(call combine,target_properties_format_args,$1,$2,$3,$4,$5,$6,$7,$8)
# tests scalar values on equality, returns the value or empty if non-equal
# $(call eq_s,value1,value2)
eq_s = $(and $(findstring $1,$2),$(findstring $2,$1))
# tests scalar values on inequality, returns non empty value if values are unequal
# $(call ne_s,value1,value2)
ne_s = $(call not,$(call eq_s,$1,$2))
# negates value, returns empty for non-empty value and vice versa
# $(call not,value)
not = $(if $(strip $1),,1)
# compares number values, returns negative value if num1 is less than num2,
# a positive value if num1 is greather than 2 and 0 if both are equal
# $(call compare,num1,num2)
compare = $(call bc,$1-$2)
# tests if num1 is less than num2
# $(call lt,num1,num2)
lt = $(if $(findstring -,$(call compare,$1,$2)),1)
# tests if num1 is greater than num2
# $(call gt,num1,num2)
gt = $(call not,$(or $(call lt,$1,$2),$(call eq_s,$1,$2)))
# tests if num1 is greater than or equal to num2
# $(call ge,num1,num2)
ge = $(call not,$(call lt,$1,$2))
# tests if version parts (major, minor, patch) are greater or equal to required version parts
# $(call ge_version,[major minor patch],[required-major required-minor required-patch])
ge_version = $(strip \
$(or \
$(call gt,$(or $(firstword $1),0),$(or $(firstword $2),0)), \
$(if $(call eq_s,$(or $(firstword $1),0),$(or $(firstword $2),0)), \
$(or \
$(call gt,$(or $(word 2,$1),0),$(or $(word 2,$2),0)) \
$(if $(call eq_s,$(or $(word 2,$1),0),$(or $(word 2,$2),0)), \
$(call ge,$(or $(word 3,$1),0),$(or $(word 3,$2),0)) \
) \
) \
) \
) \
)
# sorts numbers
# $(call sort_n,value...)
sort_n = $(shell LANG=C LC_ALL=C printf '%s\n' $1 | sort -n)
# caluclates minimum of numeric values
# $(call min,values...)
min = $(firstword $(call sort_n,$1))
# caluclates maximum of numeric values
# $(call max,values...)
max = $(call lastword,$(call sort_n,$1))
# caluclates the value of an arithmetic expression
# $(call bc,expr...)
bc = $(shell echo "$$(($1))")
# returns the tail of a list, removing its first element
# $(call tail,element...)
tail = $(wordlist 2,$(words $1),$1)
# returns the last element of a list (implemented for backward compatiblity with gnu make 3.8)
# $(call lastword,element...)
ifneq ($(lastword 0 1),1)
lastword = $(if $1,$(word $(words $1),$1),)
endif
# removes whitespace characters between positional argument and its value
# $(call normalize_args,arg...,cmdline)
normalize_args = $(if $1,$(call normalize_args,$(call tail,$1),$(subst $(firstword $1)$( ),$(firstword $1),$2)),$2)
# parses the number of available job slots (-jx | --jobs X)
# $(call jobslots,mflags...)
jobslots = $(call lastword,$(shell printf '%s\n' $(call normalize_args,-j --jobs,$1) | sed -n -e 's@^\(--jobs=\?\|-j\)\([0-9]\+\)@\2@p'))
# creates a colored message
# $(call color,color-name,value...)
color = '$(tc_$1)'$2'$(tc_reset)'
$(COLOR)color = $2
# creates a command that prints a message when VERBOSE is disabled
# $(call echo_if_silent_cmd,value...)
echo_if_silent_cmd = VERBOSE=1
$(VERBOSE)echo_if_silent_cmd = { printf '$(DEFAULT_FMT) ' $1 && printf '\n'; }
# creates a command which is printed before it is executed
# $(call echo_cmd,command[,args...][,output-command])
echo_cmd = $(call echo_if_silent_cmd,$(or $3,$1) $2) && $1 $2
# creates a command which changes its working directory before it is executed
# $(call chdir_cmd,target-name,workdir,command[,args...][,output-command])
chdir_cmd = \
$(call echo_if_silent_cmd,$(call color,green,$(addprefix TARGET=,$1) WORKDIR='$2') $(or $5,$3) $4) \
&& (cd '$2' && PATH='$(cache.$1.env_path)' $3 $4)
# overridable helper to create a command which is executed as part of a target rule
# $(call run_cmd,target-name,command[,args...][,output-command])
run_cmd = $(call chdir_cmd,$1,$(OUTDIR)/$1,$2,$3,$4)
# retrieves the host path environment variable value with optional target specific extensions
# $(call env_host_path[,target-name])
env_host_path = $(call join_s,\
$(realpath \
$(cache.$1.extdir) \
$(addprefix $(DOBUILDDIR)/assets/adapters/,$(cache.$1.adapter)) \
) \
$(PATH),\
: \
)
# overridable helper to retrieve the target default path environment variable value
# $(call env_default_path,target-name)
env_default_path = $(call env_host_path,$1)
# retrieves the last modification time of each files in seconds since epoch
# $(call mtime,file...)
mtime = $(if $1,$(shell stat -c '%Y' $1))
# joins a list to a string
# $(call join_s,element...[,separator])
join_s = $(subst $( ),$(strip $2),$(strip $1))
# splits a string to a list
# $(call split_s,element...[,separator])
split_s = $(subst $(strip $2),$( ),$(strip $1))
# identity function
# $(call identity,element...)
identity = $1
# filters all elements matching given predicate
# $(call filter_p,element...,predicate[,predicate-context])
filter_p = $(foreach elm,$1,$(if $(strip $(call $2,$(elm),$3)),$(elm),))
# tests inequality of list 1 and list 2
# $(call ne,elem1...,elem2...[,predicate])
ne = $(call not,$(call eq,$1,$2,$3))
# tests equality of list 1 and list 2
# $(call eq,elem1...,elem2...[,predicate])
eq = $(strip \
$(if \
$(call eq_s,$(words $1),$(words $2)), \
$(call eq_each,$1,$2,$(or $3,eq_s)) \
) \
)
# tests equality of elements in list 1 and list 2
# $(call eq_each,list1_elem...,list2_elem...,predicate)
eq_each = $(strip \
$(if $(strip $1),\
$(if \
$(call $3,$(firstword $1),$(firstword $2)), \
$(call eq_each,$(call tail,$1),$(call tail,$2),$3), \
), \
1 \
) \
)
# encodes string to a valid make identifier
# $(call id,string...)
id = $(subst $( ),~,$(subst $(=),_,$(call base64_encode,$1)))
# encodes string to base64
# $(call base64_encode,string...)
base64_encode = $(shell echo $1 | base64)
# decodes string from base64
# $(call base64_decode,string...)
base64_decode = $(shell echo $1 | base64 -d)
# replaces all elements which equals oldvalue with newvalue
# $(call replace_all,element...,oldvalue,newvalue)
replace_all = $(foreach elm,$1,$(if $(call eq_s,$(elm),$2),$3,$(elm)))
# internal helper to generate the cartesian product of list1 to list8 using mapping function fn
# $(call cartesian_product_helper,fn,emptylist_placeholder,elem1...,elem2..,elem3...,elem4...,elem5...,elem6...,elem7...,elem8...)
cartesian_product_helper = $(strip \
$(foreach f1,$3,\
$(foreach f2,$4,\
$(foreach f3,$5,\
$(foreach f4,$6,\
$(foreach f5,$7,\
$(foreach f6,$8,\
$(foreach f7,$9,\
$(foreach f8,$(10),\
$(call $1,\
$(call replace_all,$(f1),$2,),\
$(call replace_all,$(f2),$2,),\
$(call replace_all,$(f3),$2,),\
$(call replace_all,$(f4),$2,),\
$(call replace_all,$(f5),$2,),\
$(call replace_all,$(f6),$2,),\
$(call replace_all,$(f7),$2,),\
$(call replace_all,$(f8),$2,)\
) \
) \
) \
) \
) \
) \
) \
) \
) \
)
# generates the cartesian product of list1 to list8 using mapping function fn, mapping empty list to place holder value
# $(call cartesian_product,fn,emptylist_placeholder,elem1...,elem2..,elem3...,elem4...,elem5...,elem6...,elem7...,elem8...)
cartesian_product = $(call cartesian_product_helper,$1,$2,\
$(or $(strip $3),$2),\
$(or $(strip $4),$2),\
$(or $(strip $5),$2),\
$(or $(strip $6),$2),\
$(or $(strip $7),$2),\
$(or $(strip $8),$2),\
$(or $(strip $9),$2),\
$(or $(strip $(10)),$2)\
)
# combines elements of list1 to list8 using mapping function fn
# $(call combine,fn,elem1...,elem2..,elem3...,elem4...,elem5...,elem6...,elem7...,elem8...)
combine = $(call cartesian_product,$1,~EmptyList~,$2,$3,$4,$5,$6,$7,$8,$9)
# retrieves the version parts (major, minor) of a make version string
# $(call make_version_parts,version-string)
make_version_parts = $(shell echo '$1' | sed -ne 's![0]*\([^.]\+\).[0]*\([^.]\+\).*!\1 \2!p')
# tests if make version is greater or equal to required version
# $(call make_version_ge,required-version-string)
make_version_ge = \
$(call ge_version, \
$(call make_version_parts,$(make_version)),\
$(call make_version_parts,$1)\
)
#######################################################################################################################
# Common defaults
TOPDIR = $(call memorize,TOPDIR,$(DOBUILD_TOPDIR))
PROJECTDIR = $(call memorize,PROJECTDIR,$(DOBUILD_PROJECTDIR))
PROJECTNAME = $(call memorize,PROJECTNAME,$(DOBUILD_PROJECTNAME))
DOBUILDDIR := $(patsubst %/,%,$(dir $(current_makefile)))
OUTDIR = $(call memorize,OUTDIR,$(DOBUILD_OUTDIR))
BUILDDIR = $(call memorize,BUILDDIR,$(DOBUILD_BUILDDIR))
EXTDIR = $(call memorize,EXTDIR,$(DOBUILD_EXTDIR))
BUILDVERBOSE = $(call memorize,BUILDVERBOSE,$(DOBUILD_BUILDVERBOSE))
TESTVERBOSE = $(call memorize,TESTVERBOSE,$(DOBUILD_TESTVERBOSE))
BUILDSILENT = $(if $(BUILDVERBOSE),,1)
TESTSILENT = $(if $(TESTVERBOSE),,1)
BUILD_TESTING = $(call memorize,BUILD_TESTING,$(DOBUILD_BUILDTESTING))
VERSIONFILE = $(call memorize,VERSIONFILE,$(DOBUILD_PROJECTVERSIONFILE))
VERSION = $(call memorize,VERSION,$(DOBUILD_PROJECTVERSION))
USERID = $(call memorize,USERID,$(DOBUILD_USERID))
HOST_CONTAINER = $(call memorize,HOST_CONTAINER,$(DOBUILD_HOSTCONTAINER))
SOURCE_DATE_EPOCH ?= $(call memorize,SOURCE_DATE_EPOCH,$(shell $(DOBUILDDIR)/bin/get_source_date_epoch $(TOPDIR)))
BUILDTIME = $(call memorize,BUILDTIME,$(shell date -u -d '@$(SOURCE_DATE_EPOCH)' --rfc-3339 ns 2>/dev/null))
JOBSLOTS_DEFAULT = $(if $(findstring --jobserver-,$(make_cmdline)),2,$(shell nproc 2>/dev/null || echo '2'))
JOBSLOTS = $(call memorize,JOBSLOTS,$(or $(DOBUILD_JOBSLOTS),$(JOBSLOTS_DEFAULT)))
SKIP_MD5SUM = $(call memorize,SKIP_MD5SUM,$(DOBUILD_SKIPMD5SUM))
SKIP_CURL = $(call memorize,SKIP_CURL,$(DOBUILD_SKIPCURL))
SKIP_DEFAULTTARGET = $(call memorize,SKIP_DEFAULTTARGET,$(DOBUILD_SKIPDEFAULTTARGET))
SKIP_EXTERNSYNC = $(call memorize,SKIP_EXTERNSYNC,$(DOBUILD_SKIPEXTERNSYNC))
DEFAULTTARGET = $(BUILDTARGET)
HOSTMARCH =
MARCH =
VENDOR =
DISTRIB_ID = $(VENDOR)
SYS =
ABI =
DISTRIB_VERSION =
ID =
VARIANT =
EXCLUDE_HOSTMARCH =
EXCLUDE_MARCH =
EXCLUDE_VENDOR =
EXCLUDE_DISTRIB_ID = $(EXCLUDE_VENDOR)
EXCLUDE_SYS =
EXCLUDE_ABI =
EXCLUDE_DISTRIB_VERSION =
EXCLUDE_ID =
EXCLUDE_VARIANT =
FILTER = $(call memorize,FILTER,$(DOBUILD_FILTER))
EXCLUDEFILTER = $(call memorize,EXCLUDEFILTER,$(DOBUILD_EXCLUDEFILTER))
MEMCHECKFILTER = $(call memorize,MEMCHECKFILTER,$(DOBUILD_FILTERMEMCHECK))
$(VERBOSE)SILENT := @
make_pid = $(call memorize,make_pid,$(shell echo "$$PPID"))
make_cmdline = $(call memorize,make_cmdline,$(shell set -- $$(ps T 2>/dev/null | sed -n -e 's!^\s*$(make_pid)\s\+.*\($(call escape,$(MAKE),!)\s\+.*\)!\1!p') && echo "$$@"))
machine = $(call memorize,machine,$(shell uname -m 2>/dev/null))
make_version = $(MAKE_VERSION)
make_version_req = 3.81
# defines $, $; $% $= $: $(\#) $(\\) $($$) $( ) variables.
# NOTE: $(,) has to be used within macros to avoid conflict with argument spliting operator ,
, := ,
; := ;
% := %
esc_slash := \\
$(esc_slash) := \\
esc_hash := \\\#
$(esc_hash) := \#
esc_equal := =
$(esc_equal) := =
esc_colon := :
$(esc_colon) := :
esc_dollar := $$
$(esc_dollar) := $$
esc_space :=
esc_space +=
$(esc_space) :=
$(esc_space) +=
define n
endef
DEFAULT_FMT := %s
ifneq ($(COLOR),)
DEFAULT_FMT := %b
tc_red := \033[0;31m
tc_green := \033[0;32m
tc_brown := \033[0;33m
tc_blue := \033[0;34m
tc_purple := \033[0;35m
tc_cyan := \033[0;36m
tc_light_gray := \033[0;37m
tc_dark_gray := \033[1;30m
tc_light_green := \033[1;32m
tc_yellow := \033[1;33m
tc_light_blue := \033[1;34m
tc_light_purple := \033[1;35m
tc_light_cyan := \033[1;36m
tc_reset := \033[0m
endif
docker_runflags =
docker_buildflags =
image_buildargs =
project_targets =
#######################################################################################################################
# Makefile dependencies
MAKEFILE_DEPS += cat
MAKEFILE_DEPS += id
MAKEFILE_DEPS += echo
MAKEFILE_DEPS += sed
MAKEFILE_DEPS += pwd
MAKEFILE_DEPS += cd
MAKEFILE_DEPS += sort
MAKEFILE_DEPS += printf
MAKEFILE_DEPS += test
MAKEFILE_DEPS += base64
MAKEFILE_DEPS += stat
#######################################################################################################################
# Basic assertions
ASSERTIONS += $(call assert_scalar,$(PROJECTDIR),Project directory PROJECTDIR='$(PROJECTDIR)' should not contain whitespaces)
ASSERTIONS += $(call assert_scalar,$(OUTDIR),Output directory OUTDIR='$(OUTDIR)' should not contain whitespaces)
ASSERTIONS += $(call assert_scalar,$(DOBUILDDIR),Script directory DOBUILDDIR='$(DOBUILDDIR)' should not contain whitespaces)
ASSERTIONS += $(call assert,$(call not,$(filter $(abspath $(PROJECTDIR)),$(abspath $(sort $(OUTDIR) $(OUTDIRS))))),Project \
location PROJECTDIR='$(abspath $(PROJECTDIR))' should not point to one of the output locations:$n \
$(addsuffix $n,$(abspath $(sort $(OUTDIR) $(OUTDIRS)))))
ASSERTIONS += $(call assert,$(SOURCE_DATE_EPOCH),Value of variable SOURCE_DATE_EPOCH should not be empty)
ASSERTIONS += $(call assert,$(or $(SKIP_DEFAULTTARGET),$(filter $(DEFAULTTARGET),$(project_targets))),Default \
target TARGET='$(DEFAULTTARGET)' is not contained in the list of project targets:$n \
$(addsuffix $n,$(sort $(project_targets))))
ASSERTIONS += $(call assert,$(or $(call not,$(project_targets)),$(strip $(TARGETS))),No target matches$(,) with include \
FILTER=[$(call join_s,$(FILTER),$(,))] and exclude filter EXCLUDEFILTER=[$(call join_s,$(EXCLUDEFILTER),$(,))]$(,) \
one of the project targets:$n $(addsuffix $n,$(sort $(project_targets))))
EXPECTATIONS += $(call expect,$(call make_version_ge,$(make_version_req)),Using old make version=$(make_version)$(,) \
consider upgrading to a newer version >= $(make_version_req))
endif
Reference in New Issue View Git Blame Copy Permalink