Pfad include und src-Verzeichnis makefile

Dein tutorial fördert schlechte Praktiken, die Sie vermeiden sollten es IMHO.

In der Regel hier:

$(ODIR)/%.o: %.c $(DEPS)

Sagst du zu schauen, in das aktuelle Verzeichnis, während Ihre source-Dateien sind in der src - Verzeichnis, damit dieses Muster wird nie verwendet werden, und Sie haben keine passende ein.

Stellen Sie sicher, organisieren Sie Ihre Projekt-Verzeichnis wie diese :

+ include/
|-- all .h files here
+ lib/
|-- all thirdparty library files (.a files) here
+ obj/
|-- all .o files will be placed here
+ src/
|-- all .c files here
+ Makefile

Dann nehmen wir den Prozess Schritt für Schritt, mit guten Praktiken.

Erstens nicht definieren, alles, wenn Sie nicht brauchen, um. Machen hat eine Menge von vordefinierten Variablen und Funktionen, die Sie nutzen sollten, bevor Sie versuchen, es manuell zu tun. In der Tat, er hat so viele, dass man kompilieren kann ein einfaches Projekt, ohne auch nur ein Makefile in dem Verzeichnis überhaupt !

1. Namen Ihrem letzten Ziel, das heißt, Ihre ausführbaren Datei:

   EXE = hellomake

2. Liste der Quell-und build-output-Verzeichnisse:

   SRC_DIR = src
   OBJ_DIR = obj

3. Liste der Quelldateien:

   SRC = $(wildcard $(SRC_DIR)/*.c)

4. Den Quellcode-Dateien, Liste der object-Dateien:

   OBJ = $(SRC:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o) # patsubst is far less readable
   # You can also do it like that
   OBJ = $(addprefix $(OBJ_DIR)/, $(notdir $(SRC)))

5. Habe einige Präprozessor-flags übergeben werden? Gehen auf.

   CPPFLAGS += -Iinclude # -I is a preprocessor flag, not a compiler flag

6. Habe einige compiler flags hinzufügen? Hier gehen Sie.

   CFLAGS += -Wall # some warnings about bad code

7. Habe einige linker flags?

   LDFLAGS += -Llib # -L is a linker flag

8. Habe einige thirdparty Bibliotheken link gegen?

   LDLIBS += -lm # Left empty if no libs are needed

Ok, jetzt Rollen einige Rezepte nun, da sich die Variablen sind richtig gefüllt.

Ist es weit verbreitet, dass die Standard-Ziel genannt werden sollte all. Für Einfachheit, es ist das erste Ziel im Makefile, und deren Voraussetzungen wird das Ziel, das Sie bauen möchten, die beim schreiben make auf der Kommandozeile:

all: $(EXE)

Nun die Voraussetzungen für die Erstellung Ihrer Datei, und füllen Sie Ihr Rezept, das zu sagen, was zu tun mit diesen:

$(EXE): $(OBJ)
    $(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

Einige kurze Hinweise:

• $(CC) ist eine built-in variable schon enthalten, was Sie benötigen, wenn Sie kompilieren und linken in C,
• Zu vermeiden linker-Fehler, den Sie sollte setzen $(LDFLAGS) vor Ihre Objekt-Dateien und $(LDLIBS) nach.
• $(CPPFLAGS) und $(CFLAGS) sind nutzlos hier die Zusammenstellung phase ist schon vorbei, es ist die Verknüpfung der phase hier.

Nächste Schritt, da der Quell-und Objekt-Dateien, die nicht teilen, die das gleiche prefix, müssen Sie sagen genau, was zu tun ist, da seine eingebauten Regeln nicht abdecken, Ihrem konkreten Fall:

$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
    $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

Ok, nun die ausführbare Datei aufbauen sollte, schön, wir können reinigen Sie die build-Verzeichnis, wenn wir wollen:

clean:
    $(RM) $(OBJ)

Letzte Sache. Sie sollten angeben, wenn in der Regel erzeugt keine Ziel-Ausgabe mit den .PHONY sepcial Regel:

.PHONY: all clean

Endergebnis:

EXE = hellomake

SRC_DIR = src
OBJ_DIR = obj

SRC = $(wildcard $(SRC_DIR)/*.c)
OBJ = $(SRC:$(SRC_DIR)/%.c=$(OBJ_DIR)/%.o)

CPPFLAGS += -Iinclude
CFLAGS += -Wall
LDFLAGS += -Llib
LDLIBS += -lm

.PHONY: all clean

all: $(EXE)

$(EXE): $(OBJ)
    $(CC) $(LDFLAGS) $^ $(LDLIBS) -o $@

$(OBJ_DIR)/%.o: $(SRC_DIR)/%.c
    $(CC) $(CPPFLAGS) $(CFLAGS) -c $< -o $@

clean:
    $(RM) $(OBJ)

make-utility, mit keine spezifischen 'target' wird das erste Ziel in der Datei.

Das erste Ziel ist in der Regel mit dem Namen 'alle'

Für die Datei geschrieben werden, wird die Objekt-Dateien und wird nicht fortgesetzt, um die ausführbare Datei, wenn das Ziel nicht in der Befehlszeile angegebene

Folgendes vorschlagen:

SHELL := /bin/sh

# following so could define executable name on command line
# using the '-D' parameter
#ifndef $(NAME)
    NAME := hellomake
#endif

# use ':=' so macros only evaluated once


MAKE    :=  /usr/bin/make
CC      :=  /usr/bin/gcc

CFLAGS  := -g -Wall -Wextra -pedantic
LFLAGS  :=

ODIR    := obj
IDIR    := ../include
LIBS    :=
LIBPATH := ../lib

DEPS    := $(wildcard $(IDIR)/*.h)
SRCS    := $(wildcard *.c)
OBJS    := $(SRCS:.c=.o)

.PHONY: all
all: $(NAME) $(OBJS)

$(ODIR)/%.o: %.c $(DEPS)
    $(CC) $(CFLAGS) -c -o $@ $< -I$(DEPS)

$(NAME): $(OBJS)
    $(CC) $(LFLAGS) -o $@ $^ -L$(LIBPATH) -l$(LIBS)

.PHONY: clean
clean:
    rm -f $(ODIR)/*.o
    rm -f $(NAME)


however, in your proposed project,
not every source file needs every header file
so should use either gcc or sed to generate the dependency files
then use makefile rules similar to the following,
which may need a little 'tweaking' for your project
because the include files are not in the same directory
as the source files:

DEP := $(SRCS:.c=.d)

#
#create dependency files
#
%.d: %.c 
    # 
    # ========= START $< TO $@ =========
    $(CC) -M $(CPPFLAGS) $< > $@.$$$$;                      \
    sed 's,\($*\)\.o[ :]*,\1.o $@ : ,g' < $@.$$$$ > $@;     \
    rm -f $@.$$$$
    # ========= END $< TO $@ =========

# 
# compile the .c files into .o files using the compiler flags
#
%.o: %.c %.d 
     # 
     # ========= START $< TO $@ =========
     $(CC) $(CCFLAGS) -c $< -o $@ -I$(IDIR) 
     # ========= END $< TO $@ =========
     # 

# include the contents of all the .d files
# note: the .d files contain:
# <filename>.o:<filename>.c plus all the dependencies for that .c file 
# I.E. the #include'd header files
# wrap with ifneg... so will not rebuild *.d files when goal is 'clean'
#
ifneq "$(MAKECMDGOALS)" "clean"
-include $(DEP)
endif