Make Build Tool

  1. Advanced Topics and Best Practices
    1. Command-Line Options and Flags
      1. File and Directory Options
        1. -f file (Specify Makefile)
          1. -C dir (Change Directory)
            1. -I dir (Include Directory)
            2. Execution Control Options
              1. -n (Dry Run)
                1. -k (Keep Going)
                  1. -S (Cancel Keep Going)
                    1. -j [N] (Parallel Execution)
                      1. -l [N] (Load Average Limit)
                      2. Build Behavior Options
                        1. -B (Unconditional Make)
                          1. -t (Touch Targets)
                            1. -q (Question Mode)
                              1. -W file (What If)
                              2. Information and Debugging Options
                                1. -d (Debug Output)
                                  1. -p (Print Database)
                                    1. -v (Version Information)
                                      1. --trace
                                      2. Variable and Environment Options
                                        1. -e (Environment Override)
                                          1. -i (Ignore Errors)
                                            1. -s (Silent Mode)
                                            2. Combining Multiple Flags
                                              1. Flag Interaction Rules
                                                1. Common Flag Combinations
                                              2. Recipe Control and Formatting
                                                1. Recipe Prefixes
                                                  1. @ (Suppress Command Echoing)
                                                    1. Selective Echo Suppression
                                                      1. Use Cases and Best Practices
                                                      2. - (Ignore Errors)
                                                        1. Error Handling Strategies
                                                          1. Conditional Error Ignoring
                                                          2. + (Execute Regardless of -n)
                                                            1. Dry Run Exceptions
                                                              1. Essential Command Execution
                                                            2. Multiline Recipes
                                                              1. Line Continuation Syntax
                                                                1. Shell Behavior Across Lines
                                                                  1. Variable Scope in Multiline Recipes
                                                                    1. Complex Command Sequences
                                                                    2. Recipe Execution Environment
                                                                      1. Shell Selection
                                                                        1. Environment Variable Inheritance
                                                                          1. Working Directory Context
                                                                        2. Advanced Rule Types
                                                                          1. Double-Colon Rules
                                                                            1. Syntax and Semantics
                                                                              1. Multiple Rule Definitions
                                                                                1. Use Cases and Limitations
                                                                                  1. Interaction with Single-Colon Rules
                                                                                  2. Order-Only Prerequisites
                                                                                    1. Definition and Syntax (|)
                                                                                      1. Use Cases
                                                                                        1. Directory Creation
                                                                                          1. Tool Dependencies
                                                                                            1. Configuration Dependencies
                                                                                            2. Interaction with Regular Prerequisites
                                                                                            3. Grouped Targets
                                                                                              1. Multiple Target Rules
                                                                                                1. Shared Recipe Execution
                                                                                                  1. Target Synchronization
                                                                                                2. Debugging and Troubleshooting
                                                                                                  1. Makefile Debugging Techniques
                                                                                                    1. Using $(info) and $(warning)
                                                                                                      1. Variable Value Inspection
                                                                                                        1. Rule Execution Tracing
                                                                                                        2. Dependency Analysis
                                                                                                          1. Analyzing the Dependency Graph
                                                                                                            1. Circular Dependency Detection
                                                                                                              1. Missing Dependency Identification
                                                                                                              2. Performance Analysis
                                                                                                                1. Build Time Profiling
                                                                                                                  1. Bottleneck Identification
                                                                                                                    1. Parallel Build Optimization
                                                                                                                    2. Common Error Patterns
                                                                                                                      1. Syntax Errors
                                                                                                                        1. Missing Tab Characters
                                                                                                                          1. Undefined Variables
                                                                                                                            1. Circular Dependencies
                                                                                                                              1. File Permission Issues
                                                                                                                              2. Debugging Tools and Flags
                                                                                                                                1. --debug Options
                                                                                                                                  1. Trace Output Analysis
                                                                                                                                2. Make Flavors and Compatibility
                                                                                                                                  1. GNU Make
                                                                                                                                    1. GNU-specific Features
                                                                                                                                      1. Extension Functions
                                                                                                                                        1. Advanced Capabilities
                                                                                                                                          1. Version Differences
                                                                                                                                          2. BSD Make
                                                                                                                                            1. BSD Make Syntax
                                                                                                                                              1. Differences from GNU Make
                                                                                                                                                1. Compatibility Issues
                                                                                                                                                  1. Migration Strategies
                                                                                                                                                  2. POSIX Standard for Make
                                                                                                                                                    1. POSIX Compliance Requirements
                                                                                                                                                      1. Portable Makefile Writing
                                                                                                                                                        1. Feature Limitations
                                                                                                                                                          1. Cross-Platform Considerations
                                                                                                                                                          2. Other Make Implementations
                                                                                                                                                            1. Microsoft NMAKE
                                                                                                                                                              1. Solaris Make
                                                                                                                                                                1. Feature Comparison Matrix

                                                                                                                                                            Previous

                                                                                                                                                            7. Managing Complex Projects

                                                                                                                                                            Go to top

                                                                                                                                                            Next

                                                                                                                                                            9. Make Beyond Compilation