> For the complete documentation index, see [llms.txt](https://linux-tutorial-cli.gitbook.io/linux-cli-tutorial/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://linux-tutorial-cli.gitbook.io/linux-cli-tutorial/txt-files/make.md).

# make

## make

The `make` command is a build automation tool that automatically builds executable programs and libraries from source code by reading files called Makefiles which specify how to derive the target program. The `make` command is essential for compiling software in Unix-like operating systems, including Linux.

#### Key Concepts of `make`

1. **Makefile**: A file named `Makefile` (or `makefile`) that contains rules defining how to build the targets. It specifies the dependencies between files and the commands needed to create or update each target.
2. **Targets**: The file or files to be built or the actions to be taken. Each target is typically an executable program or an object file.
3. **Dependencies**: Files that a target depends on. If any of these files change, the target must be rebuilt.
4. **Rules**: Instructions that define how to build the targets. A rule consists of a target, dependencies, and a command to build the target.

#### Basic Structure of a Makefile

A simple Makefile typically has the following structure:

```make
target: dependencies
    command
```

* `target`: The file to be created or the action to be performed.
* `dependencies`: The files that the target depends on.
* `command`: The command to be executed to build the target. This must be preceded by a tab character.

#### Example Makefile

Consider a simple C project with the following files:

* `main.c`
* `utils.c`
* `utils.h`

A corresponding Makefile might look like this:

```make
# Compiler and flags
CC = gcc
CFLAGS = -Wall -g

# Targets
all: myprogram

myprogram: main.o utils.o
    $(CC) $(CFLAGS) -o myprogram main.o utils.o

main.o: main.c utils.h
    $(CC) $(CFLAGS) -c main.c

utils.o: utils.c utils.h
    $(CC) $(CFLAGS) -c utils.c

clean:
    rm -f myprogram *.o
```

#### Commands in the Example

* `all`: The default target. It depends on `myprogram`.
* `myprogram`: The executable to be created. It depends on `main.o` and `utils.o`.
* `main.o`: An object file created from `main.c`. It depends on `main.c` and `utils.h`.
* `utils.o`: An object file created from `utils.c`. It depends on `utils.c` and `utils.h`.
* `clean`: A utility target to remove generated files. It does not create a file named `clean`.

#### Running `make`

To use the Makefile, simply run:

```bash
make
```

This will execute the first target in the Makefile (usually `all`). To execute a specific target, specify it as an argument:

```bash
make clean
```

#### Variables in Makefiles

Makefiles can use variables to simplify the code and make it more maintainable. For example:

```make
CC = gcc
CFLAGS = -Wall -g
OBJ = main.o utils.o

all: myprogram

myprogram: $(OBJ)
    $(CC) $(CFLAGS) -o myprogram $(OBJ)

main.o: main.c utils.h
    $(CC) $(CFLAGS) -c main.c

utils.o: utils.c utils.h
    $(CC) $(CFLAGS) -c utils.c

clean:
    rm -f myprogram $(OBJ)
```

#### Useful `make` Options

* `-f FILE`: Use `FILE` as the Makefile.
* `-C DIR`: Change to directory `DIR` before reading the Makefile.
* `-j [N]`: Allow `N` jobs at once; infinite jobs with no argument.
* `-k`: Continue as much as possible after an error.
* `-n`: Print the commands that would be executed, but do not execute them.

#### Conclusion

The `make` command is a powerful and flexible tool for automating the build process of software projects. By defining rules and dependencies in a Makefile, `make` can efficiently compile and link programs, rebuild only the necessary components, and simplify the management of complex build processes. Understanding `make` and writing effective Makefiles is a valuable skill for developers working in Unix-like environments.

## help

```
Usage: make [options] [target] ...
Options:
  -b, -m                      Ignored for compatibility.
  -B, --always-make           Unconditionally make all targets.
  -C DIRECTORY, --directory=DIRECTORY
                              Change to DIRECTORY before doing anything.
  -d                          Print lots of debugging information.
  --debug[=FLAGS]             Print various types of debugging information.
  -e, --environment-overrides
                              Environment variables override makefiles.
  -E STRING, --eval=STRING    Evaluate STRING as a makefile statement.
  -f FILE, --file=FILE, --makefile=FILE
                              Read FILE as a makefile.
  -h, --help                  Print this message and exit.
  -i, --ignore-errors         Ignore errors from recipes.
  -I DIRECTORY, --include-dir=DIRECTORY
                              Search DIRECTORY for included makefiles.
  -j [N], --jobs[=N]          Allow N jobs at once; infinite jobs with no arg.
  -k, --keep-going            Keep going when some targets can't be made.
  -l [N], --load-average[=N], --max-load[=N]
                              Don't start multiple jobs unless load is below N.
  -L, --check-symlink-times   Use the latest mtime between symlinks and target.
  -n, --just-print, --dry-run, --recon
                              Don't actually run any recipe; just print them.
  -o FILE, --old-file=FILE, --assume-old=FILE
                              Consider FILE to be very old and don't remake it.
  -O[TYPE], --output-sync[=TYPE]
                              Synchronize output of parallel jobs by TYPE.
  -p, --print-data-base       Print make's internal database.
  -q, --question              Run no recipe; exit status says if up to date.
  -r, --no-builtin-rules      Disable the built-in implicit rules.
  -R, --no-builtin-variables  Disable the built-in variable settings.
  -s, --silent, --quiet       Don't echo recipes.
  --no-silent                 Echo recipes (disable --silent mode).
  -S, --no-keep-going, --stop
                              Turns off -k.
  -t, --touch                 Touch targets instead of remaking them.
  --trace                     Print tracing information.
  -v, --version               Print the version number of make and exit.
  -w, --print-directory       Print the current directory.
  --no-print-directory        Turn off -w, even if it was turned on implicitly.
  -W FILE, --what-if=FILE, --new-file=FILE, --assume-new=FILE
                              Consider FILE to be infinitely new.
  --warn-undefined-variables  Warn when an undefined variable is referenced.

```