Make?

ath0

Well-Known Member
Was für ein (ich nenne es mal) build-util würdet Ihr mir empfehlen?
Meine Ansprüche sind:

1. Möglichst einfache Wartung also nicht 2000 Dateien in denen etwas geändert werden muss, nur weil eine source Datei dazu kommt
2. Gut Portierbar für alle Unix Systeme, Win**** kann vernachlässigt werden da bricht man sich eh einen ab
3. möglichst wenig over head

Ich habe bis jetzt die GNU autotools benutzt, ich denke aber das es da etwas besseres geben wird das Ihr mir empfehlen könnt.

Ich bin für alle Vorschläge dankbar.
 
Wenn du kein eigenes Makefile von Hand schreiben willst, was gerade bei kleineren Projekten durchaus nicht abwegig ist, ein Wort: cmake. Einfach zu verstehen, einfach anzuwenden, plattformunabhängig und generell auch aus Anwendersicht wenig frickelig. Funktioniert halt einfach. Erzeugt Makefiles in diversen Formaten, darunter pmake (FreeBSD), gmake (GNU), nmake (Microsoft), XCode, etc.
 
Ja ich habe auch schon überlegt ob ich das per Hand mache, aber das Projekt könnte größer werden, wenn ich zwischendurch nicht wieder andere Flausen in Kop bekomme :) .
 
Da ich gerade in einer großen CMAKE - Debugging-Orgie bin, würde ich davon dringend abraten.

Ich generiere Makefiles mit einem Shellskript, dass die includes aus den Dateien grept. Das geht natürlich nur gut, wenn man beim Programmieren nicht herum pfuscht.
 
autotools versuchen ein Problem zu lösen, das es schon eine ganze Weile nicht mehr gibt (d.h. krasse Unterschiede auch bei vielen grundlegenden Dingen zwischen verschiedenen Unixen) und sind heutzutage eher ein Quell von Problemen. Falls irgendetwas nicht läuft, dann hat mal locker 20.000 Zeilen generierten Mist vor sich, den man durchkämmen muss.

Am portabelsten ist effektiv ein einfaches GNU Makefile, da das für fast jedes System verfügbar ist und üblicherweiße auch schon installiert ist. Zudem bietet es (im Gegensatz zu SUS make) ausreichend Mechanismen an, um einigermaßen bequem seine Bauanweisungen zu formulieren.

Hier mal mein Standard-Makefile:
Code:
CFG ?= default
-include config.$(CFG)

PROG     ?= prog
BUILDDIR ?= build/$(CFG)

SDL_CONFIG ?= sdl-config
ifndef SDL_CFLAGS
  SDL_CFLAGS := $(shell $(SDL_CONFIG) --cflags)
endif
ifndef SDL_LDFLAGS
  SDL_LDFLAGS := $(shell $(SDL_CONFIG) --libs)
endif

CFLAGS   += $(SDL_CFLAGS) -Wall -W -Werror -std=c99
CXXFLAGS += $(SDL_CFLAGS) -Wall -W -Werror
LDFLAGS  += $(SDL_LDFLAGS)

SRCS :=
SRCS += main.cc
SRCS += util.c

Q ?= @

OBJS := $(patsubst %, $(BUILDDIR)/%.o, $(basename $(SRCS)))
DEPS := $(OBJS:%.o=%.d)
DIRS := $(sort $(dir $(OBJS)))

# Make build directories
DUMMY := $(shell mkdir -p $(DIRS))

.PHONY: all clean

all: $(BUILDDIR)/$(PROG)

-include $(DEPS)

$(BUILDDIR)/$(PROG): $(OBJS)
  @echo "===> LD $@"
  $(Q)$(CXX) $(CFLAGS) $(LDFLAGS) $(OBJS) -o $@

$(BUILDDIR)/%.o: %.c
  @echo "===> CC $<"
  $(Q)$(CC) $(CFLAGS) -MMD -c -o $@ $<

$(BUILDDIR)/%.o: %.cc
  @echo "===> CXX $<"
  $(Q)$(CXX) $(CXXFLAGS) -MMD -c -o $@ $<

clean:
  @echo "===> CLEAN"
  $(Q)rm -fr $(BUILDDIR)

Es bietet folgendes:
  • Einfaches hinzufügen von Quelldateien mittels SRCS += bla.c
  • Zeigt standardmäßig nur knappe Ausgaben (===> CXX bla.c) an; bei Bedarf einfach (g)make Q= zum Anzeigen der Befehle
  • Automatisches Berechnen und behandeln von Header-Abhängigkeiten (benötigt einen GCC-kompatiblen Übersetzer, z.B. auch ICC oder clang)
  • Mehrere Konfigurationen parallel benutzbar, z.B. Debug-Version, Mit-Feature-X usw., da in jeweils ein Unterverzeichnis build/$(CFG) gebaut wird; einfach eine Konfigurationsdtei bla.cfg mit den gewünschten Einstellungen darin anlegen und (g)make CFG=bla aufrufen (ohne Angabe wird default.cfg verwendet) und das Ergebnis landet in build/bla.
  • Einfache Konfiguration diverser Einstellungen über die Konfigurationsdatei, hier im Beispiel falls sdl-config anders heißt genügt eine Zeile SDL_CONFIG := /sonstwo/sdl-sontewas-config in der default.cfg.
 
Also doch selbst bauen. Na gut dann werde ich mal meine recht beschränkten Make Kenntnisse erweitern.

Vielen Dank euch allen!
 
Back
Top