Aucune règle pour rendre consoleio.c cible

Question

Dans un numéro récent , j'ai découvert que DJGPP ne pouvait que accepte la limite de caractères de la ligne de commande DOS. Pour contourner cette limitation, j'ai décidé d'essayer d'écrire un fichier Make pour me permettre de passer des chaînes plus longues . En train de pirater un fichier makefile et de le tester, j'ai rencontré une erreur étrange. Le fichier make est le suivant:

AS  :=  nasm
CC  :=  gcc
LD  :=  ld

TARGET      :=  $(shell basename $(CURDIR))
BUILD       :=  build
SOURCES     :=  source

CFLAGS  :=  -Wall -O -fstrength-reduce -fomit-frame-pointer -finline-functions \
            -nostdinc -fno-builtin -I./include
ASFLAGS :=  -f aout

export OUTPUT   :=  $(CURDIR)/$(TARGET)

CFILES      :=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.c)))
SFILES      :=  $(foreach dir,$(SOURCES),$(notdir $(wildcard $(dir)/*.s)))

SOBJS   :=  $(SFILES:.s=.o)
COBJS   :=  $(CFILES:.c=.o)
OBJS    :=  $(SOBJS) $(COBJS)

build   :   $(TARGET).img

$(TARGET).img   :   $(TARGET).bin
    concat.py

$(TARGET).bin   :   $(OBJS)
    $(LD) -T link.ld -o $@ $^

$(SOBJS)    :   %.o :   %.asm
    $(AS) $(ASFLAGS) $< -o $@

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

En essayant de l'exécuter, je reçois le message d'erreur suivant:

make: *** No rule to make target `consoleio.c', needed by `consoleio.o'.  Stop.

Ce que je ne comprends pas, c'est pourquoi il essaie de trouver une règle pour les fichiers .c. D'après ce que je comprends, si le fichier est là, il devrait simplement l'utiliser. Comment faire pour ne pas avoir besoin d'une règle pour les fichiers .c?

Answer 1

Ce que vous essayez de faire ne fonctionnera pas sans VPATH, et puisque vous êtes encore en train d’apprendre les makefiles, j’éviterai d’utiliser VPATH.

La règle recherche & "consoleio.c &"; qui, si j’ai bien compris votre makefile, n’existe pas; ce qui existe est & "; source / consoleio.c &"; Vous devriez probablement le changer en quelque chose comme & Quot; $ (SOURCES) /%. C & Quot; au lieu de "% c ".

Cependant, je n'ai pas vérifié votre syntaxe pour cette règle. Si elle est incorrecte, la valeur intégrée & ";%. O:% .c &"; règle sera utilisé à la place, ce qui aurait le même problème.

Cependant, ce que vous faites n’est pas le comportement habituel. La manière habituelle est de:

• Créer une règle implicite ".%. o:% .c " (ou dans votre cas "%. o: $ (SOURCES) /%. c ")
• Liste explicite des dépendances pour chaque fichier: " foo.o: foo.c bar.h baz.h " (sans commande, la règle implicite a la commande)

Answer 2

Essayons une réponse sans commentaire ...

Possibilité A:

• Votre macro pour SFILES recherche des fichiers se terminant par '.s'.
• Votre règle de compilation de SOBJS recherche les fichiers se terminant par '.asm'.

Possibilité B:

• Votre règle pour SOBJS et COBJS est dans une notation que je ne reconnais pas.

• Selon le manuel GNU Make, vous pouvez écrire des règles implicites sous la forme suivante:

  %. o:% .c; commande

Vous semblez avoir une liste de cibles $ (SOBJS) qui dépend de '%.o : %.asm'. Je ne sais pas comment make interprétera cela.

Personnellement, je ne ferais pas confiance aux wild-cards dans les règles de construction. Je préférerais de beaucoup passer le temps à répertorier exactement les fichiers source nécessaires à la génération du code. En conséquence, je ne rencontre pas souvent ce problème.

Answer 3

@CesarB semble avoir résolu le problème, je vais juste ajouter quelques observations.

1. Je vous déconseille vivement d'utiliser des caractères génériques dans les règles de construction. Les règles de construction doivent clairement définir exactement ce qui est construit et ne pas dépendre des fichiers présents dans le répertoire.

2. Je vous recommande également de ne pas utiliser VPATH sauf si vous (1) créez un répertoire de construction séparé ou (2) répartissez vos fichiers source sur un grand nombre de répertoires. Si toutes vos sources sont dans un seul répertoire, l’utilisation de VPATH ne fera que créer de la confusion.

3. Le formulaire d'affectation: = n'est généralement utilisé que lorsque l'évaluation de la variable est connue pour durer longtemps, par exemple lors de l'utilisation d'un $ (shell ...). Sinon, & Quot; = & Quot; est préférable.

4. Utilisation de " export " propager OUTDIR à concat.py (ce que je suppose, car concat.py ne prend aucun paramètre) est une odeur de code. Si possible, transmettez-le en tant que paramètre.