Скачать или смотреть How to Perform a Conditional Replacement of a File in C Using Makefile

Discover a step-by-step approach to conditionally compile C files using GNU Make while avoiding multiple definitions of functions.
---
This video is based on the question https://stackoverflow.com/q/76236878/ asked by the user 'ice-wind' ( https://stackoverflow.com/u/10981696/ ) and on the answer https://stackoverflow.com/a/76237652/ provided by the user 'ice-wind' ( https://stackoverflow.com/u/10981696/ ) at 'Stack Overflow' website. Thanks to these great users and Stackexchange community for their contributions.

Visit these links for original content and any more details, such as alternate solutions, latest updates/developments on topic, comments, revision history etc. For example, the original title of the Question was: Conditonal replacement of a file in C

Also, Content (except music) licensed under CC BY-SA https://meta.stackexchange.com/help/l...
The original Question post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license, and the original Answer post is licensed under the 'CC BY-SA 4.0' ( https://creativecommons.org/licenses/... ) license.

If anything seems off to you, please feel free to write me at vlogize [AT] gmail [DOT] com.
---
Introduction

When working on C projects that involve comparing different data structures, such as arrays and trees, you might find the need to conditionally compile and use different implementations of the same interface. If you're using GNU Make and GCC, this task can be tricky, especially when dealing with source files that implement the same functionality.

In this guide, we will tackle the problem of conditionally including either array_storage.c or tree_storage.c based on a compiler flag. For those who may not be familiar, array_storage.c and tree_storage.c both implement the same interface defined in storage.h. Let's explore how to set up your Makefile to achieve this goal without errors or duplicate function definitions.



Understanding the Problem

In your existing Makefile, you've attempted to filter out certain source files based on the passed arguments. You wanted to exclude one of the C files depending on a -l flag. However, instead of isolating the other file correctly, the existing setup led to compilation errors due to function redefinitions.

The Key Issue

You faced a common problem - GCC complains about functions being defined twice because the filtering did not effectively exclude the right files before the compilation step.



Solution to Conditional Compilation

The solution to this issue is two-pronged and involves the correct order of operations and the proper syntax. Here’s what you need to do:

1. Remove the $() Around the Variables

It’s important to maintain the correct syntax when modifying variables. The first modification involves ensuring that you don’t mistakenly apply the variable reference inside the filter expression.

2. Filter SOURCES Before Defining OBJECTS

By filtering your SOURCES variable before you define OBJECTS, you can ensure that the correct source files are included and avoid any duplication.

How to Implement the Changes

Here's how to structure your Makefile with the necessary adjustments:

[[See Video to Reveal this Text or Code Snippet]]

Explanation:

Filtering with filter-out: This command is used to exclude specific files from the list of source files. Ensure that you are directly modifying the SOURCES variable used for generating OBJECTS.

Order of Operations: Make sure that the filtering of SOURCES occurs before it is translated into OBJECTS. This guarantees that only the desired source files participate in the build process.



Additional Insights

You may have noticed that filter-out appears to work only when a single wildcard is present. This can be an expected limitation as filter-out compares items as individual entities, and the use of multiple wildcards could complicate matching. If anyone has additional insights on this behavior, sharing them could be beneficial for the community.



Conclusion

Conditionally compiling C files using a Makefile can be challenging, but with the right approach, you can easily manage file inclusion based on your specific needs. By correctly filtering the SOURCES before defining the OBJECTS, you can avoid issues such as function redefinitions, making your builds smoother and more manageable.

Feel free to share your thoughts or ask questions regarding conditional compilation or GNU Make practices!