You are previewing The GNU Make Book.
O'Reilly logo
The GNU Make Book

Book Description

GNU Make Book is a practical, thorough guide to GNU Make basics, solutions, and advanced uses.

Table of Contents

  1. The GNU Make Book
  2. About the Author
  3. About the Technical Reviewer
  4. Preface
  5. 1. The Basics Revisited
    1. Getting Environment Variables into GNU make
    2. Setting Variables from Outside the Makefile
    3. The Environment Used by Commands
    4. The $(shell) Environment
    5. Target-Specific and Pattern-Specific Variables
      1. Target-Specific Variables
      2. Pattern-Specific Variables
    6. Version Checking
      1. MAKE_VERSION
      2. .FEATURES
      3. Detecting $(eval)
    7. Using Boolean Values
      1. Undefined Variables in Conditionals
      2. Consistent Truth Values
    8. Logical Operations Using Boolean Values
      1. User-Defined Logical Operators
      2. Built-in Logical Operators (GNU make 3.81 and Later)
    9. Command Detection
    10. Delayed Variable Assignment
    11. Simple List Manipulation
    12. User-Defined Functions
      1. The Basics
      2. Argument-Handling Gotchas
      3. Calling Built-in Functions
    13. Recent GNU make Versions: 3.81, 3.82, and 4.0
      1. What’s New in GNU make 3.81
        1. .SECONDEXPANSION
          1. else
          2. The -L Command Line Option
        2. .INCLUDE_DIRS
        3. .FEATURES
        4. .DEFAULT_GOAL
        5. MAKE_RESTARTS
          1. New Functions
      2. What’s New in GNU make 3.82
        1. Backward Incompatibilities
        2. New Command Line Option: --eval
        3. New Special Variables: .RECIPEPREFIX and .SHELLFLAGS
        4. The .ONESHELL Target
        5. Changing Variables with the private and undefine Keywords
      3. What’s New in GNU make 4.0
        1. GNU Guile
        2. Loading Dynamic Objects
        3. Syncing Output with --output-sync
        4. The --trace Command Line Option
        5. New Assignment Operators: != and ::=
        6. The $(file) Function
      4. What’s New in GNU make 4.1
  6. 2. Makefile Debugging
    1. Printing the Value of a Makefile Variable
    2. Dumping Every Makefile Variable
    3. Tracing Variable Values
      1. Tracing Variable Use
      2. How the Variable Tracer Works
    4. Tracing Rule Execution
      1. An Example
      2. The SHELL Hack
      3. An Even Smarter SHELL Hack
      4. GNU make 4.0 Tracing
    5. Makefile Assertions
      1. assert
      2. assert_exists
      3. assert_target_directory
    6. An Interactive GNU make Debugger
      1. The Debugger in Action
      2. Breakpoints in Patterns
      3. Breakpoints in Makefiles
      4. Debugger Internals
    7. Dynamic Breakpoints in the GNU make Debugger
      1. Dynamic Breakpoints in Action
      2. The Easy Part
      3. The Trick
      4. Rocket Science
    8. An Introduction to remake
      1. Just Print and Trace
      2. Debugging
      3. Targets, Macro Values, and Expansion
  7. 3. Building and Rebuilding
    1. Rebuilding When CPPFLAGS Changes
      1. An Example Makefile
      2. Changing Our Example Makefile
      3. How Signature Works
      4. Limitations
    2. Rebuilding When a File’s Checksum Changes
      1. An Example Makefile
      2. Digesting File Contents
      3. The Modified Makefile
      4. The Hack in Action
      5. Improving the Code
    3. Automatic Dependency Generation
      1. An Example Makefile
      2. makedepend and make depend
      3. Automating makedepend and Removing make depend
      4. Making Deleted Files Disappear from Dependencies
      5. Doing Away with makedepend
      6. Using gcc -MP
    4. Atomic Rules in GNU make
      1. What Not to Do
      2. Using Pattern Rules
      3. Using a Sentinel File
    5. Painless Non-recursive make
      1. A Simple Recursive Make
      2. A Flexible Non-recursive make System
      3. Using the Non-recursive make System
      4. What About Submodules?
  8. 4. Pitfalls and Problems
    1. GNU make Gotcha: ifndef and ?=
      1. What ?= Does
      2. What ifndef Does
    2. $(shell) and := Go Together
      1. $(shell) Explained
      2. The Difference Between = and :=
      3. The Hidden Cost of =
    3. $(eval) and Variable Caching
      1. About $(eval)
      2. An $(eval) Side Effect
      3. Caching Variable Values
      4. Speed Improvements with Caching
      5. A Caching Function
      6. Wrapping Up
    4. The Trouble with Hidden Targets
      1. An Unexpected Error if the Hidden Target Is Missing
      2. The -n Option Fails
      3. You Can’t Parallelize make
      4. make Does the Wrong Work if the Hidden Target Is Updated
      5. You Can’t Direct make to Build foo.o
    5. GNU make’s Escaping Rules
      1. Dealing with $
      2. Playing with %
      3. Wildcards and Paths
      4. Continuations
      5. Comments
      6. I Just Want a Newline!
      7. Function Arguments: Spaces and Commas
      8. The Twilight Zone
    6. The Trouble with $(wildcard)
      1. $(wildcard) Explained
      2. Unexpected Results
      3. Unexpected Results Explained
    7. Making Directories
      1. An Example Makefile
      2. What Not to Do
      3. Solution 1: Build the Directory When the Makefile Is Parsed
      4. Solution 2: Build the Directory When all Is Built
      5. Solution 3: Use a Directory Marker File
      6. Solution 4: Use an Order-Only Prerequisite to Build the Directory
      7. Solution 5: Use Pattern Rules, Second Expansion, and a Marker File
      8. Solution 6: Make the Directory in Line
    8. GNU make Meets Filenames with Spaces
      1. An Example Makefile
      2. Escape Spaces with \
      3. Turn Spaces into Question Marks
      4. My Advice
    9. Path Handling
      1. Target Name Matching
      2. Working with Path Lists
      3. Lists of Paths in VPATH and vpath
      4. Using / or \
      5. Windows Oddity: Case Insensitive but Case Preserving
      6. Built-in Path Functions and Variables
      7. Useful Functions in 3.81: abspath and realpath
    10. Usman’s Law
      1. The Human Factor
      2. Poor Naming
      3. Silent Failure
      4. Recursive Clean
    11. Pitfalls and Benefits of GNU make Parallelization
      1. Using -j (or -jobs)
      2. Missing Dependencies
      3. The Hidden Temporary File Problem
      4. The Right Way to Do Recursive make
      5. Amdahl’s Law and the Limits of Parallelization
    12. Making $(wildcard) Recursive
    13. Which Makefile Am I In?
  9. 5. Pushing the Envelope
    1. Doing Arithmetic
      1. Addition and Subtraction
      2. Multiplication and Division
      3. Using Our Arithmetic Library: A Calculator
    2. Making an XML Bill of Materials
      1. An Example Makefile and BOM
      2. How It Works
      3. Gotchas
    3. Advanced User-Defined Functions
      1. Getting Started Modifying GNU make
      2. Anatomy of a Built-In Function
      3. Reverse a String
    4. GNU make 4.0 Loadable Objects
    5. Using Guile in GNU make
    6. Self-Documenting Makefiles
      1. Documenting Makefiles with print-help
      2. The Complete help-system.mak
  10. 6. The GNU Make Standard Library
    1. Importing the GMSL
    2. Calling a GMSL Function
    3. Checking the GMSL Version
    4. Example Real-World GMSL Use
      1. Case-Insensitive Comparison
      2. Finding a Program on the Path
      3. Using Assertions to Check Inputs
      4. Is DEBUG Set to Y?
      5. Is DEBUG Set to Y or N?
      6. Using Logical Operators in the Preprocessor
      7. Removing Duplicates from a List
      8. Automatically Incrementing a Version Number
    5. GMSL Reference
      1. Logical Operators
        1. not
        2. and
        3. or
        4. xor
        5. nand
        6. nor
        7. xnor
      2. Integer Arithmetic Functions
        1. int_decode
        2. int_encode
        3. int_plus
        4. plus
        5. int_subtract
        6. subtract
        7. int_multiply
        8. multiply
        9. int_divide
        10. divide
        11. int_max and int_min
        12. max and min
        13. int_inc
        14. inc
        15. int_dec
        16. dec
        17. int_double
        18. double
        19. int_halve
        20. halve
      3. Integer Comparison Functions
      4. Miscellaneous Integer Functions
        1. sequence
        2. dec2hex, dec2bin, and dec2oct
      5. List Manipulation Functions
        1. Applying a Function to a List with map
        2. Making a reduce Function
        3. Summing a List of Numbers Using reduce
        4. Mapping a Function Across a Pair of Lists
        5. first
        6. last
        7. rest
        8. chop
        9. map
        10. pairmap
        11. leq
        12. lne
        13. reverse
        14. uniq
        15. length
      6. String Manipulation Functions
        1. Splitting CSV Data into a GNU make List
        2. Making a PATH from a List of Directories
        3. Translating Characters Using tr
        4. seq
        5. sne
        6. streln
        7. substr
        8. split
        9. merge
        10. tr
        11. uc
        12. lc
      7. Set Manipulation Functions
        1. set_create
        2. set_insert
        3. set_remove
        4. set_is_member
        5. set_union
        6. set_intersection
        7. set_is_subset
        8. set_equal
      8. Associative Arrays
        1. set
        2. get
        3. keys
        4. defined
      9. Named Stacks
        1. traverse-tree
        2. dump-tree
        3. push
        4. pop
        5. peek
        6. depth
      10. Function Memoization
      11. Miscellaneous and Debugging Facilities
        1. gmsl_compatible
        2. gmsl-print-%
        3. assert
        4. assert_exists
      12. Environment Variables
  11. A. Updates
  12. Index
  13. Copyright