kmk Quick Reference

This is an attempt at summarizing all directives, functions, special variables, +special targets, built-in commands, external commands, and kmk-expressions. +Since all the features are included, the quickness of this reference can be +disputed. ;-)

Directives

Here is a summary of the directives kmk recognizes:

+
Define a multi-line, recursively-expanded variable:
+
+define variable
+endef
+
+
Conditionally evaluate part of the makefile:
+
+ifdef variable
+ifndef variable
+ifeq (a,b)
+ifeq "a" "b"
+ifeq 'a' 'b'
+ifneq (a,b)
+ifneq "a" "b"
+ifneq 'a' 'b'
+if1of (set-a,set-b)             [1]
+ifn1of (set-a,set-b)            [1]
+if expression                   [1]
+else
+endif
+
+
Include another makefile:
+
+include file
+-include file
+sinclude file
+
+
Include another dependency file [1]:
+
+includedep file
+
+
Define a variable, overriding any previous definition, even one from the +command line:
+
+override variable = value
+override variable := value
+override variable += value
+override variable <= value      [1]
+override variable ?= value
+override define variable
+endef
+
+
Tell kmk to export all variables to child processes by default:
+
+export
+
+
Tell kmk whether or not to export a particular variable to child +processes:
+
+export variable
+export variable = value
+export variable := value
+export variable += value
+export variable <= value        [1]
+export variable ?= value
+unexport variable
+
+
Define a variable in the local context instead of the global one [1]:
+
+local variable = value
+local variable := value
+local variable += value
+local variable <= value
+local variable ?= value
+local define variable
+endef
+
+
Specify a search path for files matching a % pattern:
+
+vpath pattern path
+
+
Remove all search paths previously specified for pattern:
+
+vpath pattern
+
+
Remove all search paths previously specified in any vpath directive:
+
+vpath
+
+

Automatic variables

Here is a summary of the automatic variables.

+ ++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Variable	Description
`$@`	The file name of the target.
`$<`	The name of the first prerequisite.
`$?`	The names of all the prerequisites that are newer than the +target, with spaces between them.
`$^`	The names of all the prerequisites, duplicates omitted.
`$+`	The names of all the prerequisites, duplicates and order +preserved
`$*`	The stem with which an implicit rule matches.
`$\|`	The name of all the order only prerequisites.
`$(@D)`	The directory part of `$@`.
`$(<D)`	The directory part of `$<`.
`$(?D)`	The directory part of `$?`.
`$(^D)`	The directory part of `%^`.
`$(+D)`	The directory part of `$+`.
`$(*D)`	The directory part of `$*`.
`$(\|D)`	The directory part of `$\|`.
`$(@F)`	The file-within-directory part of `$@`.
`$(<F)`	The file-within-directory part of `$<`.
`$(?F)`	The file-within-directory part of `$?`.
`$(^F)`	The file-within-directory part of `$^`.
`$(+F)`	The file-within-directory part of `$+`.
`$(*F)`	The file-within-directory part of `$*`.
`$(\|F)`	The file-within-directory part of `$\|`.

Special variables

All variables starting with a . is reserved by kmk. The following +variables are specially used or/and defined by kmk:

+ ++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Variable	Description
`.DEFAULT_GOAL`	The makefile default goal. You can set this in +the makefile, if you don't it will default to +the first target that is encountered.
`.FEATURES`	List of GNU `make` features. Do not set this.
`.INCLUDE_DIRS`	List of include directories, `-I` arguments +and defaults. Do not set this.
`.RECIPEPREFIX`	Recipe prefix, defaults to tab.
`.VARIABLES`	Special variable which exands to the list of +variable. Do not set this.
`CURDIR`	Set to the pathname of the current working +directory (after all `-C` options are +processed, if any). Do not set this.
`KBUILD_VERSION`, +`KBUILD_VERSION_MAJOR`, +`KBUILD_VERSION_MINOR`, +`KBUILD_VERSION_PATCH`, +`KBUILD_KMK_REVISION`	The kBuild version string and the break down +into individual components. [1]
`KBUILD_HOST` [1]	The host operating system.
`KBUILD_HOST_ARCH` [1]	The host architecture.
`KBUILD_HOST_CPU` [1]	The host CPU `kmk` is built for, set to +`blend` if not any particular CPU.
`KBUILD_PATH` [1]	Where the kBuild scripts are.
`KBUILD_BIN_PATH` [1]	Where the host specific kBuild binaries are.
`KMK` [1], +`MAKE`	The name with which `kmk` was invoked. Using +this variable in recipes has special meaning.
`KMK_BUILTIN` [1]	List of built-in commands.
`KMK_FEATURES` [1]	List of `kmk` specific features.
`KMK_FLAGS` [1]	The flags given to `kmk`. You can set this in +the environment or a makefile to set flags. + It is never appropriate to use `KMK_FLAGS` +directly in a recipe line: its contents may not +be quoted correctly for use in the shell. Always +allow recursive `kmk`'s to obtain these values +through the environment from its parent. +
`KMK_LEVEL` [1]	The number of levels of recursion (sub-makes).
`KMK_VERSION` [1]	The GNU `make` version number.
`MAKECMDGOALS`	The targets given to `kmk` on the command line. +Do not set this.
`MAKEFILES`	Makefiles to be read on every invocation of +`kmk`.
`MAKEFILE_LIST`	List of the makefiles that `kmk` has opened.
`MAKESHELL`	OS/2 and MS-DOS only, the name of the command +interpreter that is to be used by `kmk`. This +value takes precedence over the value of SHELL.
`SHELL`	The name of the default command interpreter, +kmk_ash. You can set SHELL in the makefile to +change the shell used to run recipes. The SHELL +variable is handled specially when importing +from and exporting to the environment.
`SUFFIXES`	The default list of suffixes before `kmk` +reads any makefiles (always empty).
`VPATH`	Directory search path for files not found in the +current directory.

The following variables reflects kmk options. Do not set these. [1]

+ ++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Variable	Description
`KMK_OPTS_JOBS`	-j slots, `0` if not given.
`KMK_OPTS_KEEP_GOING`	-k indictor (`0`/`1`).
`KMK_OPTS_JUST_PRINT`	-n indicator (`0`/`1`).
`KMK_OPTS_PRORITY`	--priority level, `0` if not given.
`KMK_OPTS_AFFINITY`	--affinity mask, `0` if not given.
`KMK_OPTS_STATISTICS`	--statistics indicator (`0`/`1`).
`KMK_OPTS_PRINT_TIME`	The --print-time value.
`KMK_OPTS_PRETTY_COMMAND_PRINTING`	--pretty-command-printing indicator.

Special Targets

Certain names have special meanings if they appear as targets.

+ ++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Target	Description
`.DEFAULT`	The recipe is used for any target for which +no rules are found.
`.DELETE_ON_ERROR`	If mentioned, `kmk` will delete the +targets of a rule if it has changed and its +recipe fails or is interrupted.
`.EXPORT_ALL_VARIABLES`	If mentioned, all variables will by default +be exported to child processes.
`.IGNORE`	Ignore errors in the execution of the recipe +for the targets `.IGNORE` depends on, if +no prequisites all targets are affected.
`.INTERMEDIATE`	The prerequisites are treated as +intermediate files (implicite rules).
`.LOW_RESOLUTION_TIME`	`kmk` will assume prerequisite files are +created with low resolution time stamps.
`.NOTPARALLEL`	If mentioned without any prerequisites, +`kmk` will run serially as if -j1 was +given. If it has prerequisites `kmk` [1] +will only do this for the targets among +them.
`.PHONY`	The prerequisites are considered phony and +will be rebuilt unconditionally.
`.PRECIOUS`	The targets which `.PRECIOUS` depends +will to be deleted if `kmk` is killed or +interrupted while their building.
`.SECONDARY`	The prerequisites are treated as +intermediate files, except that they are +never automatically deleted. If used with +no prerequisites all targets gets this +treatement.
`.SECONDEXPANSION`	If mentioned, all prerequisite lists after +it will be expanded a second time after all +makefiles have been read.
`.SECONDTARGETEXPANSION` +[1]	If mentioned, all targets after it will be +expanded a second time after all makefiles +have been read.
`.SILENT`	`kmk` will not print the recipe for +targets listed as prerequisites, if none +then it applies to all targets.
`.SUFFIXES`	The prerequisites are the list of suffixes +used in checking for suffix rules. If it +appears without prerequisites it the suffix +will be cleared.

Commands

Builtin commands [1] all start with kmk_builtin_, so in order to save +space this prefix has been omitted in the table below. All commands comes in an +external edition that can be used by/in the shell, these are prefixed kmk_.

+ ++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Command	Description
`append`	Append text to a file. The builtin version can output the +value of a variable or the commands of a target.
`cat`	The BSD `cat` command.
`chmod`	The BSD `chmod` command.
`cmp`	The BSD `cmp` command.
`cp`	The BSD `cp` command with some twaking.
`echo`	The BSD `echo` command.
`expr`	The BSD `expr` command.
`install`	The BSD `install` command with some tweaking.
`kDepIDB`	Extract dependencies from a Visual C++ .IDB file.
`ln`	The BSD `ln` command.
`md5sum`	Typical MD5 sum program, custom kBuild version.
`mkdir`	The BSD `mkdir` command.
`mv`	The BSD `mv` command with some tweaking.
`printf`	The BSD `printf` command.
`rm`	The BSD `rm` command with some tweaking.
`rmdir`	The BSD `rmdir` command with some tweaking.
`sleep`	Typical `sleep` program, custom kBuild version.
`test`	The BSD `test` program with some tweaking.

Some additional external commands are available in the kmk / kBuild +environment (kSomething command are not prefixed with kmk_):

+ ++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Command	Description
`kDepPre`	Extract dependencies from the C/C++ preprocessor output.
`kObjCache`	Simple object file cache program.
`ash`	Almquist's shell (NetBSD variant).
`gmake`	Vanilla GNU `make` from same sources as `kmk`.
`redirect`	Shell avoidance tool. Sets up file descriptors, environment +variables and current directory before kicking of program.
`sed`	GNU `sed` with some tweaks to avoid involving the shell.
`time`	Stopwatch utility for measuring program execution time(s).

kmk-expression

kmk-expressions [1] are related to the C/C++ preprocessor in some ways as +well as nmake and BSD make. There are however some peculiarities +because of the way GNU make choose to represent booleans in its function +library, so, strings can be turned into boolean by taking any non-empty string +as true.

Quoting using single quotes results in hard strings, while double quotes and +unquoted string results in soft strings that can be converted to number or +boolean to fit the situation.

Here's the operator table in decending precedence order:

+ +++++ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Operator	Type	Description
`defined`	Unary	Checks if the following variable exists.
`exists`		Checks if the following file exists.
`target`		Checks if the following target exists.
`bool`		Casts the following value to boolean.
`num`		Casts the following value to a number.
`str`		Casts the following value to a string.
`!`	Unary	Logical NOT.
`+`		Pluss prefix.
`-`		Minus prefix.
`~`		Bitwise one's complement.
`*`	Binary	Multiplication (product).
`/`		Division (quotient).
`%`		Modulus (remainder).
`+`	Binary	Addition (sum).
`-`	Binary	Subtraction (difference).
`<<`	Binary	Bitwise left shift.
`>>`	Binary	Bitwise right shift.
`<=`	Binary	Less or equal than.
`<`		Less than.
`>=`		Greater or equal than.
`>`		Greater than.
`==`	Binary	Equal to.
`!=`	Binary	Not equal to.
`&`	Binary	Bitwise AND.
`^`	Binary	Bitwise XOR.
`\|`	Binary	Bitwise OR.
`&&`	Binary	Logical AND.
`\|\|`	Binary	Logical OR.

Built-in functions

String Manipulation Functions:

+
Replace from with to in text:
+
+$(subst from,to,text)
+
+
Replace words matching pattern with replacement in text:
+
+$(patsubst pattern,replacement,text)
+
+
Remove excess whitespace characters from string:
+
+$(strip string)
+
+
Locate find in text, returning find if found:
+
+$(findstring find,text)
+
+
Select words in text that match one of the pattern words:
+
+$(filter pattern...,text)
+
+
Select words in text that do not match any of the pattern words:
+
+$(filter-out pattern...,text)
+
+
Sort the words in list lexicographically, removing duplicates:
+
+$(sort list)
+
+
Sort the words in list lexicographically in reserve order, removing +duplicates [1]:
+
+$(rsort list)
+
+
Count the number of words in text:
+
+$(words text)
+
+
Extract the nth word (one-origin) of text:
+
+$(word n,text)
+
+
Returns the list of words in text from s to e (one-origin):
+
+$(wordlist s,e,text)
+
+
Extract the first word of names:
+
+$(firstword names...)
+
+
Extract the last word of names:
+
+$(lastword names...)
+
+
Join two parallel lists of words:
+
+$(join list1,list2)
+
+
Fold text to upper case [1]:
+
+$(toupper text)
+
+
Fold text to lower case [1]:
+
+$(tolower text)
+
+
String formatting a la the unix printf command [1]:
+
+$(printf fmt, arg...)
+
+
Return the length of a string or a (unexpanded) variable [1]:
+
+$(length string)
+$(length-var var)
+
+
Find the position of needle in haystack, returns 0 if not found. +Negative start indices are relative to the end of haystack, while +positive ones are one based [1]:
+
+$(pos needle, haystack[, start])
+$(lastpos needle, haystack[, start])
+
+
Returns the specified substring. The start works like with $(pos ). +If the substring is partially outside the string the result will be +padded with pad if present [1]:
+
+$(substr string, start[, length[, pad]])
+
+
Insert in into str at the specified position. n works like with +$(pos ), except that 0 is the end of the string [1]:
+
+$(insert in, str[, n[, length[, pad]]])
+
+
Translate string exchanging characters in from-set with to-set, +optionally completing to-set with pad-char if specified. If no +pad-char characters absent in to-set will be deleted [1]:
+
+$(translate string, from-set[, to-set[, pad-char]])
+
+

Functions for file names:

+
Extract the directory part of each file name:
+
+$(dir names...)
+
+
Extract the non-directory part of each file name:
+
+$(notdir names...)
+
+
Extract the suffix (the last . and following characters) of each file +name:
+
+$(suffix names...)
+
+
Extract the base name (name without suffix) of each file name:
+
+$(basename names...)
+
+
Extract the root specification of each file name (a bit complicated on +Windows & OS/2) [1]:
+
+$(root names...)
+
+
Append suffix to each word in names:
+
+$(addsuffix suffix,names...)
+
+
Prepend prefix to each word in names:
+
+$(addprefix prefix,names...)
+
+
Find file names matching a shell file name pattern (not a % +pattern):
+
+$(wildcard pattern...)
+
+
For each file name in names, expand to an absolute name that does not +contain any ., .., nor symlinks:
+
+$(realpath names...)
+
+
For each file name in names, expand to an absolute name that does not +contain any . or .. components, but preserves symlinks:
+
+$(abspath names...)
+
+
Same as $(abspath ) except that the current directory can be +specified as curdir [1]:
+
+$(abspathex names...[, curdir])
+
+

Arithmetic Functions:

+
Returns the sum of the arguments [1]:
+
+$(int-add addend1, addend2[, addendN])
+
+
Returns the difference between the first argument and the sum of the +rest [1]:
+
+$(int-sub minuend, subtrahend[, subtrahendN])
+
+
Returns the product of the arguments [1]:
+
+$(int-mul factor1, factor2[, factorN])
+
+
Returns the quotient of first argument and the rest [1]:
+
+$(int-div dividend, divisor[, divisorN])
+
+
Returns the modulus of the two arguments [1]:
+
+$(int-mod dividend, divisor)
+
+
Returns the bitwise two-complement of argument [1]:
+
+$(int-not val)
+
+
Returns the result of a bitwise AND of the arguments [1]:
+
+$(int-and val1, val2[, valN])
+
+
Returns the result of a bitwise OR of the arguments [1]:
+
+$(int-or val1, val2[, valN])
+
+
Returns the result of a bitwise XOR of the arguments [1]:
+
+$(int-xor val1, val2[, valN])
+
+
Returns the kmk boolean (true = non-empty, false = empty) result +of val1 == val2 [1]:
+
+$(int-eq val1, val2)
+
+
Returns the kmk boolean result of val1 != val2 [1]:
+
+$(int-ne val1, val2)
+
+
Returns the kmk boolean result of val1 > val2 [1]:
+
+$(int-gt val1, val2)
+
+
Returns the kmk boolean result of val1 >= val2 [1]:
+
+$(int-ge val1, val2)
+
+
Returns the kmk boolean result of val1 < val2 [1]:
+
+$(int-lt val1, val2)
+
+
Returns the kmk boolean result of val1 <= val2 [1]:
+
+$(int-le val1, val2)
+
+

Boolean and Conditional Functions:

+
Condition is false if the condition evaluates to an empty string +(stripped). Evaluate the true-part if the condition is true, otherwise +the false-part:
+
+$(if condition,true-part[,false-part])
+
+
Test if any of the conditions evalues to non-empty string, returning the +first one:
+
+$(or condition1[,condition2[,condition3[...]]])
+
+
Test if all of the conditions evaluates to non-empty strings, returning the +last one:
+
+$(and condition1[,condition2[,condition3[...]]])
+
+
Test if the two strings are identical, returning kmk boolean (true = +non-empty, false = empty) [2]:
+
+$(eq str1, str2)
+
+
Invert a kmk boolean value [2]:
+
+$(not val)
+
+
Test if variable is defined, returning a kmk boolean value [1]:
+
+$(defined variable)
+
+
Test if set-a and set-b intersects, returning a kmk boolean +value [1]:
+
+$(intersects set-a, set-b)
+
+
Same as $(if ) execpt that the condition is a kmk-expression [1]:
+
+$(if-expr kmk-expression,true-part[,false-part])
+
+
Select the first true condition (kmk-expression) and expand the +following body. Special condition strings default and +otherwise [1]:
+
+$(select when1-cond, when1-body[, whenN-cond, whenN-body])
+
+
Evalutate the kmk-expression returning what it evalues as. This is +the preferred way of doing arithmentic now [1]:
+
+$(expr kmk-expression)
+
+

Stack Fuctions:

+
Push item onto the stack-var, returning the empty string [1]:
+
+$(stack-push stack-var, item)
+
+
Pop the top item off the stack-var [1]:
+
+$(stack-pop stack-var)
+
+
Pop the top item off the stack-var, returning the empty string [1]:
+
+$(stack-popv stack-var)
+
+
Get the top item of the stack-var, returning the empty string [1]:
+
+$(stack-top stack-var)
+
+

Advanced Functions:

+
Evaluates to the contents of the variable var, with no expansion +performed on it:
+
+$(value var)
+
+
Evaluate body with var bound to each word in words, and +concatenate the results (spaced):
+
+$(foreach var,words,body)
+
+
C-style for-loop. Start by evaluating init. Each iteration will +first check whether the condition (kmk-expression) is true, +then expand body concatenating the result to the previous iterations +(spaced), and finally evaluate next [1]:
+
+$(for init,conditions,next,body)
+
+
C-style while-loop. Each iteration will check whether the condition +(kmk-expression) is true, then expand body concatenating the +result to the previous iterations [1]:
+
+$(while conditions,body)
+
+
Evaluate the variable var replacing any references to $(1), +$(2) with the first, second, etc. param values:
+
+$(call var,param,...)
+
+
Evaluate text then read the results as makefile commands. Expands +to the empty string:
+
+$(eval text)
+
+
Same as $(eval text) except that the text is expanded in its +own variable context [1]:
+
+$(evalctx text)
+
+
Same as $(eval $(value var)) [1]:
+
+$(evalval var)
+
+
Same as $(evalctx $(value var)) [1]:
+
+$(evalvalctx var)
+
+
A combination of $(eval ), $(call ) and $(value ) [1]:
+
+$(evalcall var)
+
+
A combination of $(eval ) and $(call ) [1]:
+
+$(evalcall var)
+
+
Remove comments and blank lines from the variable var. Expands to +the empty string [1]:
+
+$(eval-opt-var var)
+
+
Returns accessing $< of target, either retriving the whole thing +or the file at pos (one-origin) [1]:
+
+$(deps target[, pos])
+
+
Returns accessing $+ (order + duplicates) of target, either +retriving the whole thing or the file at pos (one-origin) [1]:
+
+$(deps-all target[, pos])
+
+
Returns accessing $? of target, either retriving the whole +thing or the file at pos (one-origin) [1]:
+
+$(deps-newer target[, pos])
+
+
Returns accessing $| (order only) of target, either retriving the +whole thing or the file at pos (one-origin) [1]:
+
+$(deps-oo target[, pos])
+
+

Command Functions:

+
Create one or more command lines avoiding the max argument +length restriction of the host OS [1]:
+
+$(xargs ar cas mylib.a,$(objects))
+$(xargs ar cas mylib.a,ar as mylib.a,$(objects))
+
+
Returns the commands for the specified target separated by new-line, space, +or a user defined string. Note that this might not produce the 100% correct +result if any of the prerequisite automatic variables are used [1]:
+
+$(commands target)
+$(commands-sc target)
+$(commands-usr target,sep)
+
+
Compares two commands returning the empty string if equal and the 3rd +argument if not. This differs from $(comp-vars v1,v2,ne) in that +line by line is stripped of leading spaces, command prefixes and +trailing spaces before comparing [1]:
+
+$(comp-cmds cmds-var1, cmds-var2, ne)
+$(comp-cmds-ex cmds1, cmd2, ne)
+
+
Compares the values of the two variables returning the empty string if +equal and the 3rd argument if not. Leading and trailing spaces is +ignored [1]:
+
+$(comp-var var1, var2, ne)
+
+

Utility functions:

+
When this function is evaluated, kmk generates a fatal error with the +message text:
+
+$(error text...)
+
+
When this function is evaluated, kmk generates a warning with the +message text:
+
+$(warning text...)
+
+
When this function is evaluated, kmk generates a info with the +message text:
+
+$(info text...)
+
+
Execute a shell command and return its output:
+
+$(shell command)
+
+
Return a string describing how the kmk variable variable was defined:
+
+$(origin variable)
+
+
Return a string describing the flavor of the kmk variable variable:
+
+$(flavor variable)
+
+
Returns the current local time and date formatted in the strftime +style specifier fmt. fmt defaults to %Y-%m-%dT%H:%M:%S when +not specified [1]:
+
+$(date fmt)
+
+
Returns the current UTC time and date formatted in the strftime +style specifier fmt. fmt defaults to %Y-%m-%dT%H:%M:%SZ when +not specified [1]:
+
+$(date-utc fmt)
+
+
Reformats the in time and date using fmt. The in-fmt defaults +to fmt if not specified. While fmt defaults to +%Y-%m-%dT%H:%M:%SZ if not specified [1]:
+
+$(date-utc fmt,time,in-fmt)
+
+
Returns the current nanosecond timestamp (monotonic when possible) [1]:
+
+$(nanots )
+
+
Returns the size of the specified file, or -1 if the size could not +be obtained. This can be used to check if a file exist or not [1]:
+
+$(file-size file)
+
+
Searches the PATH kmk variable for the specified files [1]:
+
+$(which files...)
+
+
OS/2: Returns the specified LIBPATH variable value [1]:
+
+$(libpath var)
+
+
OS/2: Sets the specified LIBPATH variable value, returning the empty +string [1]:
+
+$(libpath var,value)
+
+

Debugging Functions:

+
Returns various make statistics, if no item is specified a default +selection is returned [1]:
+
+$(make-stats item[,itemN])
+
+
Raise a debug breakpoint. Used for debugging kmk makefile +parsing [1]:
+
+$(breakpoint )
+
+

Recipes

+
A typical recipe takes one of the two following forms:
+
+targets : normal-prerequisites | order-only-prerequisites
+        command
+        ...
+
+targets : normal-prerequisites | order-only-prerequisites ; command
+        command
+        ...
+
+
Specifying more than one file in the targets lists is the same as +repeating the recipe for each of the files.
+
Use + and +| in the list of targets to tell kmk that the +recipe has more than one output. [1] The files after a + will +always be remade, while the files after a +| don't have to be remade. +The latter is frequently employed to update files which prerequisites +change wihtout the output files necessarily changing. See also +kmk_cp --changed.
+

Double colon recipes

+Double colon recipes are written with :: instead of : and are +handled differently from ordinary recipes if the target appears in more +than one recipe. First, all the recipes must be of the double colon type. +Second, the recipes are executed individually and may be omitted depending +on the state of their prerequisites. Double colon recipes without any +prerequisites will always be executed.

Pattern rules

+
A couple of examples:
+
+%.o : %.c
+        gcc -o $@ $<
+%.tab.c %.tab.h : %.y
+        bison -d $<
+
+
The latter has two outputs.
+

+ + + + + +

[1] (1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81) kmk only feature.

+ + + + + +

[2]	(1, 2) Experimental GNU `make` feature that is not enabled by default.

+ +++ + + + + + +

Status:

Status:	$Id: QuickReference-kmk.html 2340 2009-04-18 12:05:47Z bird $ +
Copyright:	Copyright (C) 1988, 1989, 1990, 1991, 1992, 1993, 1994, 1995, +1996, 1997, 1998, 1999, 2000, 2002, 2003, 2004, 2005, 2006, +2007 Free Software Foundation, Inc. + Copyright (c) 2008-2009 knut st. osmundsen +

$Id: QuickReference-kmk.html 2340 2009-04-18 12:05:47Z bird $