File: autoconf.info,  Node: Shell Script Compiler,  Next: Autoconf Language,  Up: Writing Autoconf Input

3.1.1 A Shell Script Compiler
-----------------------------

Just as for any other computer language, in order to properly program
‘configure.ac’ in Autoconf you must understand _what_ problem the
language tries to address and _how_ it does so.

   The problem Autoconf addresses is that the world is a mess.  After
all, you are using Autoconf in order to have your package compile easily
on all sorts of different systems, some of them being extremely hostile.
Autoconf itself bears the price for these differences: ‘configure’ must
run on all those systems, and thus ‘configure’ must limit itself to
their lowest common denominator of features.

   Naturally, you might then think of shell scripts; who needs
‘autoconf’?  A set of properly written shell functions is enough to make
it easy to write ‘configure’ scripts by hand.  Sigh!  Unfortunately,
even in 2008, where shells without any function support are far and few
between, there are pitfalls to avoid when making use of them.  Also,
finding a Bourne shell that accepts shell functions is not trivial, even
though there is almost always one on interesting porting targets.

   So, what is really needed is some kind of compiler, ‘autoconf’, that
takes an Autoconf program, ‘configure.ac’, and transforms it into a
portable shell script, ‘configure’.

   How does ‘autoconf’ perform this task?

   There are two obvious possibilities: creating a brand new language or
extending an existing one.  The former option is attractive: all sorts
of optimizations could easily be implemented in the compiler and many
rigorous checks could be performed on the Autoconf program (e.g.,
rejecting any non-portable construct).  Alternatively, you can extend an
existing language, such as the ‘sh’ (Bourne shell) language.

   Autoconf does the latter: it is a layer on top of ‘sh’.  It was
therefore most convenient to implement ‘autoconf’ as a macro expander: a
program that repeatedly performs “macro expansions” on text input,
replacing macro calls with macro bodies and producing a pure ‘sh’ script
in the end.  Instead of implementing a dedicated Autoconf macro
expander, it is natural to use an existing general-purpose macro
language, such as M4, and implement the extensions as a set of M4
macros.