Subversion Repositories scarts

\input texinfo

@c %**start of header

@setfilename configure.info

@settitle The GNU configure and build system

@setchapternewpage off

@c %**end of header

@dircategory GNU admin

@direntry

* configure: (configure).       The GNU configure and build system

@end direntry

@ifnottex

This file documents the GNU configure and build system.

Copyright (C) 1998 Cygnus Solutions.

Permission is granted to make and distribute verbatim copies of

this manual provided the copyright notice and this permission notice

are preserved on all copies.

@ignore

Permission is granted to process this file through TeX and print the

results, provided the printed document carries copying permission

notice identical to this one except for the removal of this paragraph

@end ignore

Permission is granted to copy and distribute modified versions of this

manual under the conditions for verbatim copying, provided that the entire

resulting derived work is distributed under the terms of a permission

notice identical to this one.

Permission is granted to copy and distribute translations of this manual

into another language, under the above conditions for modified versions,

except that this permission notice may be stated in a translation approved

by the Foundation.

@end ifnottex

@titlepage

@title The GNU configure and build system

@author Ian Lance Taylor

@page

@vskip 0pt plus 1filll

Copyright @copyright{} 1998 Cygnus Solutions

Permission is granted to make and distribute verbatim copies of

this manual provided the copyright notice and this permission notice

are preserved on all copies.

Permission is granted to copy and distribute modified versions of this

manual under the conditions for verbatim copying, provided that the entire

resulting derived work is distributed under the terms of a permission

notice identical to this one.

Permission is granted to copy and distribute translations of this manual

into another language, under the above conditions for modified versions,

except that this permission notice may be stated in a translation

approved by the Free Software Foundation.

@end titlepage

@ifnottex

@node Top

@top GNU configure and build system

The GNU configure and build system.

@menu

* Introduction::                Introduction.

* Getting Started::             Getting Started.

* Files::                       Files.

* Configuration Names::         Configuration Names.

* Cross Compilation Tools::     Cross Compilation Tools.

* Canadian Cross::              Canadian Cross.

* Cygnus Configure::            Cygnus Configure.

* Multilibs::                   Multilibs.

* FAQ::                         Frequently Asked Questions.

* Index::                       Index.

@end menu

@end ifnottex

@node Introduction

@chapter Introduction

This document describes the GNU configure and build systems.  It

describes how autoconf, automake, libtool, and make fit together.  It

also includes a discussion of the older Cygnus configure system.

This document does not describe in detail how to use each of the tools;

see the respective manuals for that.  Instead, it describes which files

the developer must write, which files are machine generated and how they

are generated, and where certain common problems should be addressed.

@ifnothtml

This document draws on several sources, including the autoconf manual by

David MacKenzie (@pxref{Top, , autoconf overview, autoconf, Autoconf}),

the automake manual by David MacKenzie and Tom Tromey (@pxref{Top, ,

automake overview, automake, GNU Automake}), the libtool manual by

Gordon Matzigkeit (@pxref{Top, , libtool overview, libtool, GNU

libtool}), and the Cygnus configure manual by K. Richard Pixley.

@end ifnothtml

@ifhtml

This document draws on several sources, including

@uref{http://www.delorie.com/gnu/docs/autoconf/autoconf_toc.html, the

autoconf manual} by David MacKenzie,

@uref{http://www.delorie.com/gnu/docs/automake/automake_toc.html, the

automake manual} by David MacKenzie and Tom Tromey,

@uref{http://www.delorie.com/gnu/docs/libtool/libtool_toc.html, the

libtool manual} by Gordon Matzigkeit, and the Cygnus configure manual by

K. Richard Pixley.

@end ifhtml

@menu

* Goals::                       Goals.

* Tools::                       The tools.

* History::                     History.

* Building::                    Building.

@end menu

@node Goals

@section Goals

@cindex goals

The GNU configure and build system has two main goals.

The first is to simplify the development of portable programs.  The

system permits the developer to concentrate on writing the program,

simplifying many details of portability across Unix and even Windows

systems, and permitting the developer to describe how to build the

program using simple rules rather than complex Makefiles.

The second is to simplify the building of programs distributed as source

code.  All programs are built using a simple, standardized, two step

process.  The program builder need not install any special tools in

order to build the program.

@node Tools

@section Tools

The GNU configure and build system is comprised of several different

tools.  Program developers must build and install all of these tools.

People who just want to build programs from distributed sources normally

do not need any special tools beyond a Unix shell, a make program, and a

C compiler.

@table @asis

@item autoconf

provides a general portability framework, based on testing the features

of the host system at build time.

@item automake

a system for describing how to build a program, permitting the developer

to write a simplified @file{Makefile}.

@item libtool

a standardized approach to building shared libraries.

@item gettext

provides a framework for translation of text messages into other

languages; not really discussed in this document.

@item m4

autoconf requires the GNU version of m4; the standard Unix m4 does not

suffice.

@item perl

automake requires perl.

@end table

@node History

@section History

@cindex history

This is a very brief and probably inaccurate history.

As the number of Unix variants increased during the 1980s, it became

harder to write programs which could run on all variants.  While it was

often possible to use @code{#ifdef} to identify particular systems,

developers frequently did not have access to every system, and the

characteristics of some systems changed from version to version.

By 1992, at least three different approaches had been developed:

@itemize @bullet

@item

The Metaconfig program, by Larry Wall, Harlan Stenn, and Raphael

Manfredi.

@item

The Cygnus configure script, by K. Richard Pixley, and the gcc configure

script, by Richard Stallman.  These use essentially the same approach,

and the developers communicated regularly.

@item

The autoconf program, by David MacKenzie.

@end itemize

The Metaconfig program is still used for Perl and a few other programs.

It is part of the Dist package.  I do not know if it is being developed.

In 1994, David MacKenzie and others modified autoconf to incorporate all

the features of Cygnus configure.  Since then, there has been a slow but

steady conversion of GNU programs from Cygnus configure to autoconf. gcc

has been converted, eliminating the gcc configure script.

GNU autoconf was regularly maintained until late 1996.  As of this

writing in June, 1998, it has no public maintainer.

Most programs are built using the make program, which requires the

developer to write Makefiles describing how to build the programs.

Since most programs are built in pretty much the same way, this led to a

lot of duplication.

The X Window system is built using the imake tool, which uses a database

of rules to eliminate the duplication.  However, building a tool which

was developed using imake requires that the builder have imake

installed, violating one of the goals of the GNU system.

The new BSD make provides a standard library of Makefile fragments,

which permits developers to write very simple Makefiles.  However, this

requires that the builder install the new BSD make program.

In 1994, David MacKenzie wrote the first version of automake, which

permitted writing a simple build description which was converted into a

Makefile which could be used by the standard make program.  In 1995, Tom

Tromey completely rewrote automake in Perl, and he continues to enhance

it.

Various free packages built libraries, and by around 1995 several

included support to build shared libraries on various platforms.

However, there was no consistent approach.  In early 1996, Gordon

Matzigkeit began working on libtool, which provided a standardized

approach to building shared libraries.  This was integrated into

automake from the start.

The development of automake and libtool was driven by the GNITS project,

a group of GNU maintainers who designed standardized tools to help meet

the GNU coding standards.

@node Building

@section Building

Most readers of this document should already know how to build a tool by

running @samp{configure} and @samp{make}.  This section may serve as a

quick introduction or reminder.

Building a tool is normally as simple as running @samp{configure}

followed by @samp{make}.  You should normally run @samp{configure} from

an empty directory, using some path to refer to the @samp{configure}

script in the source directory.  The directory in which you run

@samp{configure} is called the @dfn{object directory}.

In order to use a object directory which is different from the source

directory, you must be using the GNU version of @samp{make}, which has

the required @samp{VPATH} support.  Despite this restriction, using a

different object directory is highly recommended:

@itemize @bullet

@item

It keeps the files generated during the build from cluttering up your

sources.

@item

It permits you to remove the built files by simply removing the entire

build directory.

@item

It permits you to build from the same sources with several sets of

configure options simultaneously.

@end itemize

If you don't have GNU @samp{make}, you will have to run @samp{configure}

in the source directory.  All GNU packages should support this; in

particular, GNU packages should not assume the presence of GNU

@samp{make}.

After running @samp{configure}, you can build the tools by running

@samp{make}.

To install the tools, run @samp{make install}.  Installing the tools

will copy the programs and any required support files to the

@dfn{installation directory}.  The location of the installation

directory is controlled by @samp{configure} options, as described below.

In the Cygnus tree at present, the info files are built and installed as

a separate step.  To build them, run @samp{make info}.  To install them,

run @samp{make install-info}. The equivalent html files are also built

and installed in a separate step. To build the html files, run

@samp{make html}. To install the html files run @samp{make install-html}.

All @samp{configure} scripts support a wide variety of options.  The

most interesting ones are @samp{--with} and @samp{--enable} options

which are generally specific to particular tools.  You can usually use

the @samp{--help} option to get a list of interesting options for a

particular configure script.

The only generic options you are likely to use are the @samp{--prefix}

and @samp{--exec-prefix} options.  These options are used to specify the

installation directory.

The directory named by the @samp{--prefix} option will hold machine

independent files such as info files.

The directory named by the @samp{--exec-prefix} option, which is

normally a subdirectory of the @samp{--prefix} directory, will hold

machine dependent files such as executables.

The default for @samp{--prefix} is @file{/usr/local}.  The default for

@samp{--exec-prefix} is the value used for @samp{--prefix}.

The convention used in Cygnus releases is to use a @samp{--prefix}

option of @file{/usr/cygnus/@var{release}}, where @var{release} is the

name of the release, and to use a @samp{--exec-prefix} option of

@file{/usr/cygnus/@var{release}/H-@var{host}}, where @var{host} is the

configuration name of the host system (@pxref{Configuration Names}).

Do not use either the source or the object directory as the installation

directory.  That will just lead to confusion.

@node Getting Started

@chapter Getting Started

To start using the GNU configure and build system with your software

package, you must write three files, and you must run some tools to

manually generate additional files.

@menu

* Write configure.in::          Write configure.in.

* Write Makefile.am::           Write Makefile.am.

* Write acconfig.h::            Write acconfig.h.

* Generate files::              Generate files.

* Getting Started Example::     Example.

@end menu

@node Write configure.in

@section Write configure.in

@cindex @file{configure.in}, writing

You must first write the file @file{configure.in}.  This is an autoconf

input file, and the autoconf manual describes in detail what this file

should look like.

You will write tests in your @file{configure.in} file to check for

conditions that may change from one system to another, such as the

presence of particular header files or functions.

For example, not all systems support the @samp{gettimeofday} function.

If you want to use the @samp{gettimeofday} function when it is

available, and to use some other function when it is not, you would

check for this by putting @samp{AC_CHECK_FUNCS(gettimeofday)} in

@file{configure.in}.

When the configure script is run at build time, this will arrange to

define the preprocessor macro @samp{HAVE_GETTIMEOFDAY} to the value 1 if

the @samp{gettimeofday} function is available, and to not define the

macro at all if the function is not available.  Your code can then use

@samp{#ifdef} to test whether it is safe to call @samp{gettimeofday}.

If you have an existing body of code, the @samp{autoscan} program may

help identify potential portability problems, and hence configure tests

that you will want to use.

@ifnothtml

@xref{Invoking autoscan, , , autoconf, the autoconf manual}.

@end ifnothtml

@ifhtml

See @uref{http://www.delorie.com/gnu/docs/autoconf/autoconf_4.html, the

autoscan documentation}.

@end ifhtml

Another handy tool for an existing body of code is @samp{ifnames}.  This

will show you all the preprocessor conditionals that the code already

uses.

@ifnothtml

@xref{Invoking ifnames, , , autoconf, the autoconf manual}.

@end ifnothtml

@ifhtml

See @uref{http://www.delorie.com/gnu/docs/autoconf/autoconf_5.html, the

ifnames documentation}.

@end ifhtml

Besides the portability tests which are specific to your particular

package, every @file{configure.in} file should contain the following

macros.

@table @samp

@item AC_INIT

@cindex @samp{AC_INIT}

This macro takes a single argument, which is the name of a file in your

package.  For example, @samp{AC_INIT(foo.c)}.

@item AC_PREREQ(@var{VERSION})

@cindex @samp{AC_PREREQ}

This macro is optional.  It may be used to indicate the version of

@samp{autoconf} that you are using.  This will prevent users from

running an earlier version of @samp{autoconf} and perhaps getting an

invalid @file{configure} script.  For example, @samp{AC_PREREQ(2.12)}.

@item AM_INIT_AUTOMAKE

@cindex @samp{AM_INIT_AUTOMAKE}

This macro takes two arguments: the name of the package, and a version

number.  For example, @samp{AM_INIT_AUTOMAKE(foo, 1.0)}.  (This macro is

not needed if you are not using automake).

@item AM_CONFIG_HEADER

@cindex @samp{AM_CONFIG_HEADER}

This macro names the header file which will hold the preprocessor macro

definitions at run time.  Normally this should be @file{config.h}.  Your

sources would then use @samp{#include "config.h"} to include it.

This macro may optionally name the input file for that header file; by

default, this is @file{config.h.in}, but that file name works poorly on

DOS filesystems.  Therefore, it is often better to name it explicitly as

@file{config.in}.

This is what you should normally put in @file{configure.in}:

@example

AM_CONFIG_HEADER(config.h:config.in)

@end example

@cindex @samp{AC_CONFIG_HEADER}

(If you are not using automake, use @samp{AC_CONFIG_HEADER} rather than

@samp{AM_CONFIG_HEADER}).

@item AM_MAINTAINER_MODE

@cindex @samp{AM_MAINTAINER_MODE}

This macro always appears in Cygnus configure scripts.  Other programs

may or may not use it.

If this macro is used, the @samp{--enable-maintainer-mode} option is

required to enable automatic rebuilding of generated files used by the

configure system.  This of course requires that developers be aware of,

and use, that option.

If this macro is not used, then the generated files will always be

rebuilt automatically.  This will cause problems if the wrong versions

of autoconf, automake, or others are in the builder's @samp{PATH}.

(If you are not using automake, you do not need to use this macro).

@item AC_EXEEXT

@cindex @samp{AC_EXEEXT}

@cindex @samp{AM_EXEEXT}

Either this macro or @samp{AM_EXEEXT} always appears in Cygnus configure

files.  Other programs may or may not use one of them.

This macro looks for the executable suffix used on the host system.  On

Unix systems, this is the empty string.  On Windows systems, this is

@samp{.exe}.  This macro directs automake to use the executable suffix

as appropriate when creating programs.  This macro does not take any

arguments.

The @samp{AC_EXEEXT} form is new, and is part of a Cygnus patch to

autoconf to support compiling with Visual C++.  Older programs use

@samp{AM_EXEEXT} instead.

(Programs which do not use automake use neither @samp{AC_EXEEXT} nor

@samp{AM_EXEEXT}).

@item AC_PROG_CC

@cindex @samp{AC_PROG_CC}

If you are writing C code, you will normally want to use this macro.  It

locates the C compiler to use.  It does not take any arguments.

However, if this @file{configure.in} file is for a library which is to

be compiled by a cross compiler which may not fully work, then you will

not want to use @samp{AC_PROG_CC}.  Instead, you will want to use a

variant which does not call the macro @samp{AC_PROG_CC_WORKS}.  Examples

can be found in various @file{configure.in} files for libraries that are

compiled with cross compilers, such as libiberty or libgloss.  This is

essentially a bug in autoconf, and there will probably be a better

workaround at some point.

@item AC_PROG_CXX

@cindex @samp{AC_PROG_CXX}

If you are writing C++ code, you will want to use this macro.  It

locates the C++ compiler to use.  It does not take any arguments.  The

same cross compiler comments apply as for @samp{AC_PROG_CC}.

@item AM_PROG_LIBTOOL

@cindex @samp{AM_PROG_LIBTOOL}

If you want to build libraries, and you want to permit them to be

shared, or you want to link against libraries which were built using

libtool, then you will need this macro.  This macro is required in order

to use libtool.

@cindex @samp{AM_DISABLE_SHARED}

By default, this will cause all libraries to be built as shared

libraries.  To prevent this--to change the default--use

@samp{AM_DISABLE_SHARED} before @samp{AM_PROG_LIBTOOL}.  The configure

options @samp{--enable-shared} and @samp{--disable-shared} may be used

to override the default at build time.

@item AC_DEFINE(_GNU_SOURCE)

@cindex @samp{_GNU_SOURCE}

GNU packages should normally include this line before any other feature

tests.  This defines the macro @samp{_GNU_SOURCE} when compiling, which

directs the libc header files to provide the standard GNU system

interfaces including all GNU extensions.  If this macro is not defined,

certain GNU extensions may not be available.

@item AC_OUTPUT

@cindex @samp{AC_OUTPUT}

This macro takes a list of file names which the configure process should

produce.  This is normally a list of one or more @file{Makefile} files

in different directories.  If your package lives entirely in a single

directory, you would use simply @samp{AC_OUTPUT(Makefile)}.  If you also

have, for example, a @file{lib} subdirectory, you would use

@samp{AC_OUTPUT(Makefile lib/Makefile)}.

@end table

If you want to use locally defined macros in your @file{configure.in}

file, then you will need to write a @file{acinclude.m4} file which

defines them (if not using automake, this file is called

@file{aclocal.m4}).  Alternatively, you can put separate macros in an

@file{m4} subdirectory, and put @samp{ACLOCAL_AMFLAGS = -I m4} in your

@file{Makefile.am} file so that the @samp{aclocal} program will be able

to find them.

The different macro prefixes indicate which tool defines the macro.

Macros which start with @samp{AC_} are part of autoconf.  Macros which

start with @samp{AM_} are provided by automake or libtool.

@node Write Makefile.am

@section Write Makefile.am

@cindex @file{Makefile.am}, writing

You must write the file @file{Makefile.am}.  This is an automake input

file, and the automake manual describes in detail what this file should

look like.

The automake commands in @file{Makefile.am} mostly look like variable

assignments in a @file{Makefile}.  automake recognizes special variable

names, and automatically add make rules to the output as needed.

There will be one @file{Makefile.am} file for each directory in your

package.  For each directory with subdirectories, the @file{Makefile.am}

file should contain the line

@smallexample

SUBDIRS = @var{dir} @var{dir} @dots{}

@end smallexample

@noindent

where each @var{dir} is the name of a subdirectory.

For each @file{Makefile.am}, there should be a corresponding

@file{Makefile} in the @samp{AC_OUTPUT} macro in @file{configure.in}.

Every @file{Makefile.am} written at Cygnus should contain the line

@smallexample

AUTOMAKE_OPTIONS = cygnus

@end smallexample

@noindent

This puts automake into Cygnus mode.  See the automake manual for

details.

You may to include the version number of @samp{automake} that you are

using on the @samp{AUTOMAKE_OPTIONS} line.  For example,

@smallexample

AUTOMAKE_OPTIONS = cygnus 1.3

@end smallexample

@noindent

This will prevent users from running an earlier version of

@samp{automake} and perhaps getting an invalid @file{Makefile.in}.

If your package builds a program, then in the directory where that

program is built you will normally want a line like

@smallexample

bin_PROGRAMS = @var{program}

@end smallexample

@noindent

where @var{program} is the name of the program.  You will then want a

line like

@smallexample

@var{program}_SOURCES = @var{file} @var{file} @dots{}

@end smallexample

@noindent

where each @var{file} is the name of a source file to link into the

program (e.g., @samp{foo.c}).

If your package builds a library, and you do not want the library to

ever be built as a shared library, then in the directory where that

library is built you will normally want a line like

@smallexample

lib_LIBRARIES = lib@var{name}.a

@end smallexample

@noindent

where @samp{lib@var{name}.a} is the name of the library.  You will then

want a line like

@smallexample

lib@var{name}_a_SOURCES = @var{file} @var{file} @dots{}

@end smallexample

@noindent

where each @var{file} is the name of a source file to add to the

library.

If your package builds a library, and you want to permit building the

library as a shared library, then in the directory where that library is

built you will normally want a line like

@smallexample

lib_LTLIBRARIES = lib@var{name}.la

@end smallexample

The use of @samp{LTLIBRARIES}, and the @samp{.la} extension, indicate a

library to be built using libtool.  As usual, you will then want a line

like

@smallexample

lib@var{name}_la_SOURCES = @var{file} @var{file} @dots{}

@end smallexample

The strings @samp{bin} and @samp{lib} that appear above in

@samp{bin_PROGRAMS} and @samp{lib_LIBRARIES} are not arbitrary.  They

refer to particular directories, which may be set by the @samp{--bindir}

and @samp{--libdir} options to @file{configure}.  If those options are

not used, the default values are based on the @samp{--prefix} or

@samp{--exec-prefix} options to @file{configure}.  It is possible to use

other names if the program or library should be installed in some other

directory.

The @file{Makefile.am} file may also contain almost anything that may

appear in a normal @file{Makefile}.  automake also supports many other

special variables, as well as conditionals.

See the automake manual for more information.

@node Write acconfig.h

@section Write acconfig.h

@cindex @file{acconfig.h}, writing

If you are generating a portability header file, (i.e., you are using

@samp{AM_CONFIG_HEADER} in @file{configure.in}), then you will have to

write a @file{acconfig.h} file.  It will have to contain the following

lines.

@smallexample

/* Name of package.  */

#undef PACKAGE

/* Version of package.  */

#undef VERSION

@end smallexample

This requirement is really a bug in the system, and the requirement may

be eliminated at some later date.

The @file{acconfig.h} file will also similar comment and @samp{#undef}

lines for any unusual macros in the @file{configure.in} file, including

any macro which appears in a @samp{AC_DEFINE} macro.

In particular, if you are writing a GNU package and therefore include

@samp{AC_DEFINE(_GNU_SOURCE)} in @file{configure.in} as suggested above,

you will need lines like this in @file{acconfig.h}:

@smallexample

/* Enable GNU extensions.  */

#undef _GNU_SOURCE

@end smallexample

Normally the @samp{autoheader} program will inform you of any such

requirements by printing an error message when it is run.  However, if

you do anything particular odd in your @file{configure.in} file, you

will have to make sure that the right entries appear in

@file{acconfig.h}, since otherwise the results of the tests may not be

available in the @file{config.h} file which your code will use.

(Thee @samp{PACKAGE} and @samp{VERSION} lines are not required if you

are not using automake, and in that case you may not need a

@file{acconfig.h} file at all).

@node Generate files

@section Generate files

Once you have written @file{configure.in}, @file{Makefile.am},

@file{acconfig.h}, and possibly @file{acinclude.m4}, you must use

autoconf and automake programs to produce the first versions of the

generated files.  This is done by executing the following sequence of

commands.

@smallexample

aclocal

autoconf

autoheader

automake

@end smallexample

The @samp{aclocal} and @samp{automake} commands are part of the automake

package, and the @samp{autoconf} and @samp{autoheader} commands are part

of the autoconf package.

If you are using a @file{m4} subdirectory for your macros, you will need

to use the @samp{-I m4} option when you run @samp{aclocal}.

If you are not using the Cygnus tree, use the @samp{-a} option when

running @samp{automake} command in order to copy the required support

files into your source directory.

If you are using libtool, you must build and install the libtool package

with the same @samp{--prefix} and @samp{--exec-prefix} options as you

used with the autoconf and automake packages.  You must do this before

running any of the above commands.  If you are not using the Cygnus

tree, you will need to run the @samp{libtoolize} program to copy the

libtool support files into your directory.

Once you have managed to run these commands without getting any errors,

you should create a new empty directory, and run the @samp{configure}

script which will have been created by @samp{autoconf} with the

@samp{--enable-maintainer-mode} option.  This will give you a set of

Makefiles which will include rules to automatically rebuild all the

generated files.

After doing that, whenever you have changed some of the input files and

want to regenerated the other files, go to your object directory and run

@samp{make}.  Doing this is more reliable than trying to rebuild the

files manually, because there are complex order dependencies and it is

easy to forget something.

@node Getting Started Example

@section Example

Let's consider a trivial example.

Suppose we want to write a simple version of @samp{touch}.  Our program,

which we will call @samp{poke}, will take a single file name argument,

and use the @samp{utime} system call to set the modification and access

times of the file to the current time.  We want this program to be

highly portable.

We'll first see what this looks like without using autoconf and

automake, and then see what it looks like with them.

@menu

* Getting Started Example 1::           First Try.

* Getting Started Example 2::           Second Try.

* Getting Started Example 3::           Third Try.

* Generate Files in Example::           Generate Files.

@end menu

@node Getting Started Example 1

@subsection First Try

Here is our first try at @samp{poke.c}.  Note that we've written it

without ANSI/ISO C prototypes, since we want it to be highly portable.

@example

#include <stdio.h>

#include <stdlib.h>

#include <sys/types.h>

#include <utime.h>

int

main (argc, argv)

     int argc;

     char **argv;

@{

  if (argc != 2)

    @{

      fprintf (stderr, "Usage: poke file\n");

      exit (1);

    @}

  if (utime (argv[1], NULL) < 0)

    @{

      perror ("utime");

      exit (1);

    @}

  exit (0);

@}

@end example

We also write a simple @file{Makefile}.

@example

CC = gcc

CFLAGS = -g -O2

all: poke

poke: poke.o

        $(CC) -o poke $(CFLAGS) $(LDFLAGS) poke.o

@end example

So far, so good.

Unfortunately, there are a few problems.

On older Unix systems derived from BSD 4.3, the @samp{utime} system call

does not accept a second argument of @samp{NULL}.  On those systems, we

need to pass a pointer to @samp{struct utimbuf} structure.

Unfortunately, even older systems don't define that structure; on those

systems, we need to pass an array of two @samp{long} values.

The header file @file{stdlib.h} was invented by ANSI C, and older

systems don't have a copy.  We included it above to get a declaration of

@samp{exit}.

We can find some of these portability problems by running

@samp{autoscan}, which will create a @file{configure.scan} file which we

can use as a prototype for our @file{configure.in} file.  I won't show

the output, but it will notice the potential problems with @samp{utime}

and @file{stdlib.h}.

In our @file{Makefile}, we don't provide any way to install the program.

This doesn't matter much for such a simple example, but a real program

will need an @samp{install} target.  For that matter, we will also want

a @samp{clean} target.

@node Getting Started Example 2

@subsection Second Try

Here is our second try at this program.

We modify @file{poke.c} to use preprocessor macros to control what

features are available.  (I've cheated a bit by using the same macro

names which autoconf will use).

@example

#include <stdio.h>

#ifdef STDC_HEADERS

#include <stdlib.h>

#endif

#include <sys/types.h>

#ifdef HAVE_UTIME_H

#include <utime.h>

#endif

#ifndef HAVE_UTIME_NULL

#include <time.h>

#ifndef HAVE_STRUCT_UTIMBUF

struct utimbuf

@{

  long actime;

  long modtime;

@};

#endif

static int

utime_now (file)

     char *file;

@{

  struct utimbuf now;

  now.actime = now.modtime = time (NULL);

  return utime (file, &now);

@}

#define utime(f, p) utime_now (f)

#endif /* HAVE_UTIME_NULL  */

int

main (argc, argv)

     int argc;

     char **argv;

@{

  if (argc != 2)

    @{

      fprintf (stderr, "Usage: poke file\n");

      exit (1);

    @}

  if (utime (argv[1], NULL) < 0)

    @{

      perror ("utime");

      exit (1);

    @}

  exit (0);

@}

@end example

Here is the associated @file{Makefile}.  We've added support for the

preprocessor flags we use.  We've also added @samp{install} and

@samp{clean} targets.

@example

# Set this to your installation directory.

bindir = /usr/local/bin

# Uncomment this if you have the standard ANSI/ISO C header files.

# STDC_HDRS = -DSTDC_HEADERS

# Uncomment this if you have utime.h.

# UTIME_H = -DHAVE_UTIME_H

# Uncomment this if utime (FILE, NULL) works on your system.

# UTIME_NULL = -DHAVE_UTIME_NULL

# Uncomment this if struct utimbuf is defined in utime.h.

# UTIMBUF = -DHAVE_STRUCT_UTIMBUF

CC = gcc

CFLAGS = -g -O2

ALL_CFLAGS = $(STDC_HDRS) $(UTIME_H) $(UTIME_NULL) $(UTIMBUF) $(CFLAGS)

all: poke

poke: poke.o

        $(CC) -o poke $(ALL_CFLAGS) $(LDFLAGS) poke.o

.c.o:

        $(CC) -c $(ALL_CFLAGS) poke.c

install: poke

        cp poke $(bindir)/poke

clean:

        rm poke poke.o

@end example

Some problems with this approach should be clear.

Users who want to compile poke will have to know how @samp{utime} works

on their systems, so that they can uncomment the @file{Makefile}

correctly.

The installation is done using @samp{cp}, but many systems have an

@samp{install} program which may be used, and which supports optional

features such as stripping debugging information out of the installed

binary.

The use of @file{Makefile} variables like @samp{CC}, @samp{CFLAGS} and

@samp{LDFLAGS} follows the requirements of the GNU standards.  This is

convenient for all packages, since it reduces surprises for users.

However, it is easy to get the details wrong, and wind up with a

slightly nonstandard distribution.

@node Getting Started Example 3

@subsection Third Try

For our third try at this program, we will write a @file{configure.in}

script to discover the configuration features on the host system, rather

than requiring the user to edit the @file{Makefile}.  We will also write

a @file{Makefile.am} rather than a @file{Makefile}.

The only change to @file{poke.c} is to add a line at the start of the

file:

@smallexample

#include "config.h"

@end smallexample

The new @file{configure.in} file is as follows.