Post History

If _your_ goal is just to temporarily see what a file looks like without certain headers,
and the headers themselves do not depend on each other,
then you can either temporarily comment them out, or declare a "guard" macro for them

---

Let me explain header "guards"

When creating a header file, these lines are almost always written:

```c
#ifndef _LIB_NAME_H
#define _LIB_NAME_H



#endif /* _LIB_NAME_H */
```

They provide protection against including the same header twice

---

Example:

There is another header:

```c
#ifndef _LIB_2_H
#define _LIB_2_H

/* some code here */
#include "lib_name.h"

#endif /* _LIB_2_H */
```

And in the main file we do:

```c
#include "lib_name.h"
#include "lib_2.h"

/* ... */
```

If in `lib_name.h` we had, for example, `typedef int some_t` and there were no guards,
then we would define the same `some_t` twice, which is already an error

So we check whether the macro is defined - _"has this header already been included?"_

If not, we provide the code and define the macro, so the next time the code will not be inserted again

This is implemented by using `#ifndef` directive (if not defined)

---

In this case, this can be used to trick headers into thinking they were already included

To do this, we need to define the macros of the headers we don't need before including them

In principle, the macro name can be anything, but a common convention is:

```c
_HEADER_NAME_H
```

It starts with `_`, then the header name in uppercase, and at the end `.h` is replaced with `_H` (if the file has that extension)

---

You can define these macros either before including the unwanted headers:

```c
#define _ENORMOUS_LIBRARY
#include <enormous_library> /* This library will be ignored */

#include <some_other_library>
#embed "embedded_literals.txt"

int main(void){
    set_baud_rate(baud_rate)
}
```

Or directly when running the command:

```bash
$ gcc -D_ENORMOUS_LIBRARY file.c
```

`-D` defines a macro

---

Speaking of `#embed`, honestly, I don’t know what this directive does

Nevertheless, you can write a similar "wrapper" so that this directive is either executed or not:

```c
#ifndef DO_NOT_EMBED_LITERALS
#embed "embedded_literals.txt"
#endif /* DO_NOT_EMBED_LITERALS */
```

Here we again use `#ifndef`, i.e. we check that such a macro is **NOT** defined

If we define `DO_NOT_EMBED_LITERALS` before this check,
then the `#embed` directive will not be executed

This can be done either by defining it in the code, or by defining it via a command:

```bash
$ gcc -DDO_NOT_EMBED_LITERALS file.c
```