Comment puis-je configurer mon makefile pour les versions de débogage et de publication?

J'ai le makefile suivant pour mon projet et j'aimerais le configurer pour les versions de version et de débogage. Dans mon code, j'ai beaucoup de #ifdef DEBUGmacros en place, il s'agit donc simplement de définir cette macro et d'ajouter le-g3 -gdwarf2 indicateurs aux compilateurs. Comment puis-je faire ceci?

$(CC) = g++ -g3 -gdwarf2
$(cc) = gcc -g3 -gdwarf2

all: executable

executable: CommandParser.tab.o CommandParser.yy.o Command.o
    g++ -g -o output CommandParser.yy.o CommandParser.tab.o Command.o -lfl

CommandParser.yy.o: CommandParser.l 
    flex -o CommandParser.yy.c CommandParser.l
    gcc -g -c CommandParser.yy.c

CommandParser.tab.o: CommandParser.y
    bison -d CommandParser.y
    g++ -g -c CommandParser.tab.c

Command.o: Command.cpp
    g++ -g -c Command.cpp

clean:
    rm -f CommandParser.tab.* CommandParser.yy.* output *.o

Juste pour clarifier, quand je parle de versions de version / débogage, je veux pouvoir simplement taper makeet obtenir une version de version ou make debuget obtenir une version de débogage, sans commenter manuellement les choses dans le fichier makefile.

Vous pouvez utiliser des valeurs de variable spécifiques à la cible . Exemple:

CXXFLAGS = -g3 -gdwarf2
CCFLAGS = -g3 -gdwarf2

all: executable

debug: CXXFLAGS += -DDEBUG -g
debug: CCFLAGS += -DDEBUG -g
debug: executable

executable: CommandParser.tab.o CommandParser.yy.o Command.o
    $(CXX) -o output CommandParser.yy.o CommandParser.tab.o Command.o -lfl

CommandParser.yy.o: CommandParser.l 
    flex -o CommandParser.yy.c CommandParser.l
    $(CC) -c CommandParser.yy.c

N'oubliez pas d'utiliser $ (CXX) ou $ (CC) dans toutes vos commandes de compilation.

Ensuite, «make debug» aura des indicateurs supplémentaires comme -DDEBUG et -g alors que «make» ne le sera pas.

D'un autre côté, vous pouvez rendre votre Makefile beaucoup plus concis comme d'autres articles l'avaient suggéré.

Cette question est souvent apparue lors de la recherche d'un problème similaire, je pense donc qu'une solution entièrement mise en œuvre est justifiée. D'autant plus que moi (et je suppose que d'autres) ont eu du mal à rassembler toutes les différentes réponses.

Voici un exemple de Makefile qui prend en charge plusieurs types de build dans des répertoires séparés. L'exemple illustré montre les versions de débogage et de publication.

Les soutiens ...

• répertoires de projet séparés pour des versions spécifiques
• sélection facile d'une construction cible par défaut
• cible de préparation silencieuse pour créer les répertoires nécessaires à la construction du projet
• indicateurs de configuration du compilateur spécifiques à la construction
• La méthode naturelle de GNU Make pour déterminer si un projet nécessite une reconstruction
• règles de modèle plutôt que les règles de suffixe obsolètes

#
# Compiler flags
#
CC     = gcc
CFLAGS = -Wall -Werror -Wextra

#
# Project files
#
SRCS = file1.c file2.c file3.c file4.c
OBJS = $(SRCS:.c=.o)
EXE  = exefile

#
# Debug build settings
#
DBGDIR = debug
DBGEXE = $(DBGDIR)/$(EXE)
DBGOBJS = $(addprefix $(DBGDIR)/, $(OBJS))
DBGCFLAGS = -g -O0 -DDEBUG

#
# Release build settings
#
RELDIR = release
RELEXE = $(RELDIR)/$(EXE)
RELOBJS = $(addprefix $(RELDIR)/, $(OBJS))
RELCFLAGS = -O3 -DNDEBUG

.PHONY: all clean debug prep release remake

# Default build
all: prep release

#
# Debug rules
#
debug: $(DBGEXE)

$(DBGEXE): $(DBGOBJS)
    $(CC) $(CFLAGS) $(DBGCFLAGS) -o $(DBGEXE) $^

$(DBGDIR)/%.o: %.c
    $(CC) -c $(CFLAGS) $(DBGCFLAGS) -o $@ $<

#
# Release rules
#
release: $(RELEXE)

$(RELEXE): $(RELOBJS)
    $(CC) $(CFLAGS) $(RELCFLAGS) -o $(RELEXE) $^

$(RELDIR)/%.o: %.c
    $(CC) -c $(CFLAGS) $(RELCFLAGS) -o $@ $<

#
# Other rules
#
prep:
    @mkdir -p $(DBGDIR) $(RELDIR)

remake: clean all

clean:
    rm -f $(RELEXE) $(RELOBJS) $(DBGEXE) $(DBGOBJS)

Si par configure release / build, vous voulez dire que vous n'avez besoin que d'une seule configuration par makefile, alors c'est simplement une question et découpler CC et CFLAGS:

CFLAGS=-DDEBUG
#CFLAGS=-O2 -DNDEBUG
CC=g++ -g3 -gdwarf2 $(CFLAGS)

Selon que vous pouvez utiliser gnu makefile, vous pouvez utiliser conditionnel pour rendre cela un peu plus sophistiqué et le contrôler à partir de la ligne de commande:

DEBUG ?= 1
ifeq ($(DEBUG), 1)
    CFLAGS =-DDEBUG
else
    CFLAGS=-DNDEBUG
endif

.o: .c
    $(CC) -c $< -o $@ $(CFLAGS)

puis utilisez:

make DEBUG=0
make DEBUG=1

Si vous avez besoin de contrôler les deux configurations en même temps, je pense qu'il est préférable d'avoir des répertoires de construction et un répertoire de construction / config.

Notez que vous pouvez également simplifier votre Makefile, en même temps:

DEBUG ?= 1
ifeq (DEBUG, 1)
    CFLAGS =-g3 -gdwarf2 -DDEBUG
else
    CFLAGS=-DNDEBUG
endif

CXX = g++ $(CFLAGS)
CC = gcc $(CFLAGS)

EXECUTABLE = output
OBJECTS = CommandParser.tab.o CommandParser.yy.o Command.o
LIBRARIES = -lfl

all: $(EXECUTABLE)

$(EXECUTABLE): $(OBJECTS)
    $(CXX) -o $@ $^ $(LIBRARIES)

%.yy.o: %.l 
    flex -o $*.yy.c $<
    $(CC) -c $*.yy.c

%.tab.o: %.y
    bison -d $<
    $(CXX) -c $*.tab.c

%.o: %.cpp
    $(CXX) -c $<

clean:
    rm -f $(EXECUTABLE) $(OBJECTS) *.yy.c *.tab.c

Vous n'avez plus besoin de répéter les noms de fichiers partout. Tous les fichiers .l passeront par flex et gcc, tous les fichiers .y passeront par bison et g ++, et tous les fichiers .cpp par uniquement g ++.

Listez simplement les fichiers .o avec lesquels vous vous attendez à vous retrouver, et Make se chargera de déterminer quelles règles peuvent satisfaire les besoins ...

pour mémoire:

• $@ Le nom du fichier cible (celui avant les deux-points)

• $< Le nom du premier (ou seul) fichier de prérequis (le premier après les deux points)

• $^ Les noms de tous les fichiers prérequis (séparés par des espaces)

• $*La racine (le bit qui correspond au %caractère générique dans la définition de règle.

vous pouvez avoir une variable

DEBUG = 0

alors vous pouvez utiliser une instruction conditionnelle

  ifeq ($(DEBUG),1)

  else

  endif

Compléter les réponses précédentes ... Vous devez référencer les variables que vous définissez info dans vos commandes ...

DEBUG ?= 1
ifeq (DEBUG, 1)
    CFLAGS =-g3 -gdwarf2 -DDEBUG
else
    CFLAGS=-DNDEBUG
endif

CXX = g++ $(CFLAGS)
CC = gcc $(CFLAGS)

all: executable

executable: CommandParser.tab.o CommandParser.yy.o Command.o
    $(CXX) -o output CommandParser.yy.o CommandParser.tab.o Command.o -lfl

CommandParser.yy.o: CommandParser.l 
    flex -o CommandParser.yy.c CommandParser.l
    $(CC) -c CommandParser.yy.c

CommandParser.tab.o: CommandParser.y
    bison -d CommandParser.y
    $(CXX) -c CommandParser.tab.c

Command.o: Command.cpp
    $(CXX) -c Command.cpp

clean:
    rm -f CommandParser.tab.* CommandParser.yy.* output *.o

Vous pouvez également ajouter quelque chose de simple à votre Makefile tel que

ifeq ($(DEBUG),1)
   OPTS = -g
endif

Puis compilez-le pour le débogage

make DEBUG=1