Make Build Tool

  1. Managing Complex Projects
    1. Project Structure Organization
      1. Directory Layout Strategies
        1. Source File Organization
          1. Build Output Management
            1. Separating Source and Build Trees
            2. Handling Source Files in Subdirectories
              1. Using VPATH and vpath
                1. VPATH Variable Syntax
                  1. vpath Directive Usage
                    1. Search Path Ordering
                      1. Limitations and Pitfalls
                      2. Explicitly Specifying Paths
                        1. Relative Path Usage
                          1. Absolute Path Considerations
                            1. Path Portability Issues
                              1. Cross-Platform Path Handling
                              2. Subdirectory Build Strategies
                                1. Flat Build Structure
                                  1. Hierarchical Build Structure
                                    1. Mixed Approaches
                                  2. Including Other Makefiles
                                    1. The include Directive
                                      1. Basic Include Syntax
                                        1. Multiple File Inclusion
                                          1. Conditional Inclusion
                                            1. Error Handling
                                            2. Include Path Resolution
                                              1. Search Path Rules
                                                1. Relative vs. Absolute Includes
                                                  1. Include File Dependencies
                                                  2. Managing Configuration Files
                                                    1. Separating Configuration from Logic
                                                      1. Environment-specific Settings
                                                        1. User Configuration Files
                                                          1. Default Configuration Handling
                                                          2. Modular Makefile Design
                                                            1. Component-based Organization
                                                              1. Shared Rule Libraries
                                                                1. Configuration Modules
                                                              2. Automatic Dependency Generation
                                                                1. The C/C++ Header File Problem
                                                                  1. Header Dependency Tracking
                                                                    1. Incomplete Build Issues
                                                                      1. Manual Dependency Maintenance
                                                                      2. Compiler-assisted Dependency Generation
                                                                        1. GCC/Clang Dependency Flags
                                                                          1. -MMD Flag Usage
                                                                            1. -MP Flag Benefits
                                                                              1. -MF Flag for Output Files
                                                                              2. Generating .d Files
                                                                                1. Dependency File Format
                                                                                  1. Including Generated Dependencies
                                                                                    1. -include Directive
                                                                                      1. Conditional Inclusion
                                                                                        1. Error Handling
                                                                                      2. Advanced Dependency Techniques
                                                                                        1. Dependency File Cleanup
                                                                                          1. Incremental Dependency Updates
                                                                                            1. Cross-compilation Dependencies
                                                                                          2. Build System Architecture
                                                                                            1. Recursive vs. Non-Recursive Make
                                                                                              1. The Recursive Make Approach
                                                                                                1. Directory-based Recursion
                                                                                                  1. Parent-Child Communication
                                                                                                    1. Variable Passing
                                                                                                      1. Pros and Cons
                                                                                                      2. The Non-Recursive Make Approach
                                                                                                        1. Single Top-Level Makefile
                                                                                                          1. Centralized Target Management
                                                                                                            1. Include-based Organization
                                                                                                              1. Pros and Cons
                                                                                                            2. Hybrid Approaches
                                                                                                              1. Selective Recursion
                                                                                                                1. Component-based Builds
                                                                                                                  1. Mixed Strategies

                                                                                                              Previous

                                                                                                              6. Conditional Processing

                                                                                                              Go to top

                                                                                                              Next

                                                                                                              8. Advanced Topics and Best Practices