There is only one “data type” in
make: a string. GNU Guile,
on the other hand, provides a rich variety of different data types.
An important aspect of the interface between
make and GNU Guile
is the conversion of Guile data types into
This conversion is relevant in two places: when a makefile invokes the
guile function to evaluate a Guile expression, the result of
that evaluation must be converted into a make string so it can be
further evaluated by
make. And secondly, when a Guile script
invokes one of the procedures exported by
make the argument
provided to the procedure must be converted into a string.
The conversion of Guile types into
make strings is as below:
False is converted into the empty string: in
the empty string is considered false.
True is converted to the string ‘#t’: in
any non-empty string is considered true.
A symbol or number is converted into the string representation of that symbol or number.
A printable character is converted to the same character.
A string containing only printable characters is converted to the same string.
A list is converted recursively according to the above rules. This
implies that any structured list will be flattened (that is, a result
of ‘'(a b (c d) e)’ will be converted to the
‘a b c d e’).
Any other Guile type results in an error. In future versions of
make, other Guile types may be converted.
The translation of ‘#f’ (to the empty string) and ‘#t’ (to
the non-empty string ‘#t’) is designed to allow you to use Guile
boolean results directly as
make boolean conditions. For
$(if $(guile (access? "myfile" R_OK)),$(info myfile exists))
As a consequence of these conversion rules you must consider the
result of your Guile script, as that result will be converted into a
string and parsed by
make. If there is no natural result for
the script (that is, the script exists solely for its side-effects),
you should add ‘#f’ as the final expression in order to avoid
syntax errors in your makefile.