Table of Contents

1. Introduction

1.1 What this book is
1.2 What the book is not
1.3 Who should read this book
1.4 How this book is organized

2. History

2.1 The Diversity of Unix Systems
2.2 The First Configure Programs
2.3 Configure Development
2.4 Automake Development
2.5 Libtool Development
2.6 Microsoft Windows

3. How to run configure and make

3.1 Configuring
3.2 Files generated by configure
3.3 The most useful Makefile targets
3.4 Configuration Names

4. Introducing `Makefile's

4.1 Targets and dependencies
4.2 Makefile syntax
4.3 Macros
4.4 Suffix rules

5. A Minimal GNU Autotools Project

5.1 User-Provided Input Files
5.2 Generated Output Files
5.3 Maintaining Input Files
5.4 Packaging Generated Files
5.5 Documentation and ChangeLogs

6. Writing `configure.in'

6.1 What is Portability?
6.2 Brief introduction to portable sh
6.3 Ordering Tests
6.4 What to check for
6.5 Using Configuration Names

7. Introducing GNU Automake

7.1 General Automake principles
7.2 Introduction to Primaries
7.3 The easy primaries
7.4 Programs and libraries
7.5 Frequently Asked Questions
7.6 Multiple directories
7.7 Testing

8. Bootstrapping
9. A Small GNU Autotools Project

9.1 GNU Autotools in Practice

9.1.1 Project Directory Structure
9.1.2 C Header Files
9.1.3 C++ Compilers
9.1.4 Function Definitions
9.1.5 Fallback Function Implementations
9.1.6 K&R Compilers

9.2 A Simple Shell Builders Library

9.2.1 Portability Infrastructure

9.2.1.1 Error Management
9.2.1.2 Memory Management
9.2.1.3 Generalised List Data Type

9.2.2 Library Implementation

9.2.2.1 `sic.c' & `sic.h'
9.2.2.2 `builtin.c' & `builtin.h'
9.2.2.3 `eval.c' & `eval.h'
9.2.2.4 `syntax.c' & `syntax.h'

9.2.3 Beginnings of a `configure.in'

9.3 A Sample Shell Application

9.3.1 `sic_repl.c'
9.3.2 `sic_syntax.c'
9.3.3 `sic_builtin.c'
9.3.4 `sic.c' & `sic.h'

10. Introducing GNU Libtool

10.1 Creating libtool
10.2 The Libtool Library

10.2.1 Position Independent Code
10.2.2 Creating Shared Libraries
10.2.3 Creating Static Libraries
10.2.4 Creating Convenience Libraries

10.3 Linking an Executable
10.4 Linking a Library

10.4.1 Inter-library Dependencies
10.4.2 Using Convenience Libraries

10.5 Executing Uninstalled Binaries
10.6 Installing a Library
10.7 Installing an Executable
10.8 Uninstalling

11. Using GNU Libtool with `configure.in' and `Makefile.am'

11.1 Integration with `configure.in'

11.1.1 Extra Configure Options
11.1.2 Extra Macros for Libtool

11.2 Integration with `Makefile.am'

11.2.1 Creating Libtool Libraries with Automake
11.2.2 Linking against Libtool Libraries with Automake

11.3 Using libtoolize
11.4 Library Versioning
11.5 Convenience Libraries

12. A Large GNU Autotools Project

12.1 Using Libtool Libraries
12.2 Removing `--foreign'
12.3 Installing Header Files
12.4 Including Texinfo Documentation
12.5 Adding a Test Suite

13. Rolling Distribution Tarballs

13.1 Introduction to Distributions
13.2 What goes in
13.3 The distcheck rule
13.4 Some caveats
13.5 Implementation

14. Installing and Uninstalling Configured Packages

14.1 Where files are installed
14.2 Fine-grained control of install
14.3 Install hooks
14.4 Uninstall

15. Writing Portable C with GNU Autotools

15.1 C Language Portability

15.1.1 ISO C
15.1.2 C Data Type Sizes
15.1.3 C Endianness
15.1.4 C Structure Layout
15.1.5 C Floating Point
15.1.6 GNU cc Extensions

15.2 Cross-Unix Portability

15.2.1 Cross-Unix Function Calls
15.2.2 Cross-Unix System Interfaces

15.3 Unix/Windows Portability

15.3.1 Unix/Windows Emulation
15.3.2 Unix/Windows Portable Scripting Language
15.3.3 Unix/Windows User Interface Library
15.3.4 Unix/Windows Specific Code
15.3.5 Unix/Windows Issues

15.3.5.1 Text and Binary Files
15.3.5.2 File system Issues
15.3.5.3 DOS Filename Restrictions
15.3.5.4 Windows File Name Case
15.3.5.5 Whitespace in File Names
15.3.5.6 Windows Separators and Drive Letters
15.3.5.7 Miscellaneous Issues

16. Writing Portable C++ with GNU Autotools

16.1 Brief History of C++
16.2 Changeable C++

16.2.1 Built-in bool type
16.2.2 Exceptions
16.2.3 Casts
16.2.4 Variable Scoping in For Loops
16.2.5 Namespaces
16.2.6 The explicit Keyword
16.2.7 The mutable Keyword
16.2.8 The typename Keyword
16.2.9 Runtime Type Identification (RTTI)
16.2.10 Templates
16.2.11 Default template arguments
16.2.12 Standard library headers
16.2.13 Standard Template Library

16.3 Compiler Quirks

16.3.1 Template Instantiation
16.3.2 Name Mangling

16.4 How GNU Autotools Can Help

16.4.1 Testing C++ Implementations with Autoconf
16.4.2 Automake C++ support
16.4.3 Libtool C++ support

16.5 Further Reading

17. Dynamic Loading

17.1 Dynamic Modules
17.2 Module Access Functions
17.3 Finding a Module
17.4 A Simple GNU/Linux Module Loader
17.5 A Simple GNU/Linux Dynamic Module

18. Using GNU libltdl

18.1 Introducing libltdl
18.2 Using libltdl

18.2.1 Configury
18.2.2 Memory Management
18.2.3 Module Loader
18.2.4 Dependent Libraries
18.2.5 Dynamic Module

18.3 Portable Library Design
18.4 dlpreopen Loading
18.5 User Module Loaders

18.5.1 Loader Mechanism
18.5.2 Loader Management
18.5.3 Loader Errors

19. Advanced GNU Automake Usage

19.1 Conditionals
19.2 Language support
19.3 Automatic dependency tracking

20. A Complex GNU Autotools Project

20.1 A Module Loading Subsystem

20.1.1 Initialising the Module Loader
20.1.2 Managing Module Loader Errors
20.1.3 Loading a Module
20.1.4 Unloading a Module

20.2 A Loadable Module
20.3 Interpreting Commands from a File
20.4 Integrating Dmalloc

21. M4

21.1 What does M4 do?
21.2 How GNU Autotools uses M4
21.3 Fundamentals of M4 processing

21.3.1 Token scanning
21.3.2 Macros and macro expansion
21.3.3 Quoting

21.4 Features of M4

21.4.1 Discarding input
21.4.2 Macro management
21.4.3 Conditionals
21.4.4 Looping
21.4.5 Diversions
21.4.6 Including files

21.5 Writing macros within the GNU Autotools framework

21.5.1 Syntactic conventions
21.5.2 Debugging with M4

22. Writing Portable Bourne Shell

22.1 Why Use the Bourne Shell?
22.2 Implementation

22.2.1 Size Limitations
22.2.2 #!
22.2.3 :
22.2.4 ()
22.2.5 .
22.2.6 [
22.2.7 $
22.2.8 * versus .*

22.3 Environment
22.4 Utilities

23. Writing New Macros for Autoconf

23.1 Autoconf Preliminaries
23.2 Reusing Existing Macros
23.3 Guidelines for writing macros

23.3.1 Non-interactive behavior
23.3.2 Testing system features at application runtime
23.3.3 Output from macros
23.3.4 Naming macros
23.3.5 Macro interface

23.4 Implementation specifics

23.4.1 Writing shell code
23.4.2 Using M4 correctly
23.4.3 Caching results

23.5 Future directions for macro writers

23.5.1 Autoconf macro archive
23.5.2 Primitive macros to aid in building macros

24. Migrating an Existing Package to GNU Autotools

24.1 Why autconfiscate
24.2 Overview of the Two Approaches
24.3 Example: Quick And Dirty
24.4 Example: The Full Pull

25. Using GNU Autotools with Cygnus Cygwin

25.1 Preliminaries
25.2 Installing GNU Autotools on Cygwin
25.3 Writing A Cygwin Friendly Package

25.3.1 Text vs Binary Modes
25.3.2 File System Limitations

25.3.2.1 8.3 Filenames
25.3.2.2 Separators and Drive Letters

25.3.3 Executable Filename Extensions

25.4 DLLs with Libtool

25.4.1 DLL Support with GNU Autotools
25.4.2 A Makefile.am for DLLs
25.4.3 A configure.in for DLLs
25.4.4 Handling Data Exports from DLLs
25.4.5 Runtime Loading of DLLs

25.5 Package Installation

26. Cross Compilation with GNU Autotools

26.1 Host and Target
26.2 Specifying the Target
26.3 Using the Target Type
26.4 Building with a Cross Compiler

26.4.1 Canadian Cross Example
26.4.2 Canadian Cross Concepts
26.4.3 Build Cross Host Tools
26.4.4 Build and Host Options
26.4.5 Canadian Cross Tools
26.4.6 Supporting Building with a Cross Compiler

26.4.6.1 Supporting Building with a Cross Compiler in Configure Scripts
26.4.6.2 Supporting Building with a Cross Compiler in Makefiles

A. Installing GNU Autotools

A.1 Prerequisite tools
A.2 Downloading GNU Autotools
A.3 Installing the tools

B. PLATFORMS
C. Generated File Dependencies

C.1 aclocal
C.2 autoheader
C.3 automake and libtoolize
C.4 autoconf
C.5 configure
C.6 make

D. Autoconf Macro Reference
E. OPL
Index