Concept¶

The basic idea was inspired by Make. When we look at Make, we notice sort oftwo languages in one. One language describes dependency graphs consisting oftargets and prerequisites. The other is a macro language for performing textualsubstitution.

There is clear distinction between the two language stages. For example, youcan write a makefile like follows:

APP := fooSRC := foo.cCC := gcc$(APP): $(SRC)        $(CC) -o $(APP) $(SRC)

The macro language replaces the variable references with their expanded form,and handles as if the source file were input like follows:

foo: foo.c        gcc -o foo foo.c

Then, Make analyzes the dependency graph and determines the targets to beupdated.

The idea is quite similar in Kconfig - it is possible to describe a Kconfigfile like this:

CC := gccconfig CC_HAS_FOO        def_bool $(shell, $(srctree)/scripts/gcc-check-foo.sh $(CC))

The macro language in Kconfig processes the source file into the followingintermediate:

config CC_HAS_FOO        def_bool y

Then, Kconfig moves onto the evaluation stage to resolve inter-symboldependency as explained inKconfig Language.

Variables¶

Like in Make, a variable in Kconfig works as a macro variable. A macrovariable is expanded “in place” to yield a text string that may then beexpanded further. To get the value of a variable, enclose the variable name in$( ). The parentheses are required even for single-letter variable names; $X isa syntax error. The curly brace form as in ${CC} is not supported either.

There are two types of variables: simply expanded variables and recursivelyexpanded variables.

A simply expanded variable is defined using the := assignment operator. Itsrighthand side is expanded immediately upon reading the line from the Kconfigfile.

A recursively expanded variable is defined using the = assignment operator.Its righthand side is simply stored as the value of the variable withoutexpanding it in any way. Instead, the expansion is performed when the variableis used.

There is another type of assignment operator; += is used to append text to avariable. The righthand side of += is expanded immediately if the lefthandside was originally defined as a simple variable. Otherwise, its evaluation isdeferred.

The variable reference can take parameters, in the following form:

$(name,arg1,arg2,arg3)

You can consider the parameterized reference as a function. (more precisely,“user-defined function” in contrast to “built-in function” listed below).

Useful functions must be expanded when they are used since the same function isexpanded differently if different parameters are passed. Hence, a user-definedfunction is defined using the = assignment operator. The parameters arereferenced within the body definition with $(1), $(2), etc.

In fact, recursively expanded variables and user-defined functions are the sameinternally. (In other words, “variable” is “function with zero argument”.)When we say “variable” in a broad sense, it includes “user-defined function”.

Built-in functions¶

Like Make, Kconfig provides several built-in functions. Every function takes aparticular number of arguments.

In Make, every built-in function takes at least one argument. Kconfig allowszero argument for built-in functions, such as $(filename), $(lineno). You couldconsider those as “built-in variable”, but it is just a matter of how we callit after all. Let’s say “built-in function” here to refer to natively supportedfunctionality.

Kconfig currently supports the following built-in functions.

• $(shell,command)

The “shell” function accepts a single argument that is expanded and passedto a subshell for execution. The standard output of the command is then readand returned as the value of the function. Every newline in the output isreplaced with a space. Any trailing newlines are deleted. The standard erroris not returned, nor is any program exit status.

• $(info,text)

The “info” function takes a single argument and prints it to stdout.It evaluates to an empty string.

• $(warning-if,condition,text)

The “warning-if” function takes two arguments. If the condition part is “y”,the text part is sent to stderr. The text is prefixed with the name of thecurrent Kconfig file and the current line number.

• $(error-if,condition,text)

The “error-if” function is similar to “warning-if”, but it terminates theparsing immediately if the condition part is “y”.

• $(filename)

The ‘filename’ takes no argument, and $(filename) is expanded to the filename being parsed.

• $(lineno)

The ‘lineno’ takes no argument, and $(lineno) is expanded to the line numberbeing parsed.

Make vs Kconfig¶

Kconfig adopts Make-like macro language, but the function call syntax isslightly different.

A function call in Make looks like this:

$(func-name arg1,arg2,arg3)

The function name and the first argument are separated by at least onewhitespace. Then, leading whitespaces are trimmed from the first argument,while whitespaces in the other arguments are kept. You need to use a kind oftrick to start the first parameter with spaces. For example, if you wantto make “info” function print “ hello”, you can write like follows:

empty :=space := $(empty) $(empty)$(info $(space)$(space)hello)

Kconfig uses only commas for delimiters, and keeps all whitespaces in thefunction call. Some people prefer putting a space after each comma delimiter:

$(func-name, arg1, arg2, arg3)

In this case, “func-name” will receive “ arg1”, “ arg2”, “ arg3”. The presenceof leading spaces may matter depending on the function. The same applies toMake - for example, $(subst .c, .o, $(sources)) is a typical mistake; itreplaces “.c” with “ .o”.

In Make, a user-defined function is referenced by using a built-in function,‘call’, like this:

$(call my-func,arg1,arg2,arg3)

Kconfig invokes user-defined functions and built-in functions in the same way.The omission of ‘call’ makes the syntax shorter.

In Make, some functions treat commas verbatim instead of argument separators.For example, $(shell echo hello, world) runs the command “echo hello, world”.Likewise, $(info hello, world) prints “hello, world” to stdout. You could saythis is _useful_ inconsistency.

In Kconfig, for simpler implementation and grammatical consistency, commas thatappear in the $( ) context are always delimiters. It means:

$(shell, echo hello, world)

is an error because it is passing two parameters where the ‘shell’ functionaccepts only one. To pass commas in arguments, you can use the following trick:

comma := ,$(shell, echo hello$(comma) world)

Caveats¶

A variable (or function) cannot be expanded across tokens. So, you cannot usea variable as a shorthand for an expression that consists of multiple tokens.The following works:

RANGE_MIN := 1RANGE_MAX := 3config FOO        int "foo"        range $(RANGE_MIN) $(RANGE_MAX)

But, the following does not work:

RANGES := 1 3config FOO        int "foo"        range $(RANGES)

A variable cannot be expanded to any keyword in Kconfig. The following doesnot work:

MY_TYPE := tristateconfig FOO        $(MY_TYPE) "foo"        default y

Obviously from the design, $(shell command) is expanded in the textualsubstitution phase. You cannot pass symbols to the ‘shell’ function.

The following does not work as expected:

config ENDIAN_FLAG        string        default "-mbig-endian" if CPU_BIG_ENDIAN        default "-mlittle-endian" if CPU_LITTLE_ENDIANconfig CC_HAS_ENDIAN_FLAG        def_bool $(shell $(srctree)/scripts/gcc-check-flag ENDIAN_FLAG)

Instead, you can do like follows so that any function call is staticallyexpanded:

config CC_HAS_ENDIAN_FLAG        bool        default $(shell $(srctree)/scripts/gcc-check-flag -mbig-endian) if CPU_BIG_ENDIAN        default $(shell $(srctree)/scripts/gcc-check-flag -mlittle-endian) if CPU_LITTLE_ENDIAN