Blocchi di descrizione
I blocchi di descrizione costituiscono il nucleo di un makefile. Descrivono le destinazioni o i file da creare e le relative dipendenze, i file necessari per creare le destinazioni. Un blocco di descrizione può includere comandi che descrivono come creare le destinazioni dalle dipendenze. Un blocco di descrizione è una riga di dipendenza, seguita facoltativamente da un blocco di comandi:
targets... : dependents...
commands...
Righe di dipendenza
Una riga di dipendenza specifica una o più destinazioni e zero o più dipendenti. Se una destinazione non esiste o ha un timestamp precedente rispetto a un dipendente, NMAKE esegue i comandi nel blocco di comandi. NMAKE esegue anche il blocco di comandi se la destinazione è uno pseudotarget. Ecco una riga di dipendenza di esempio:
hi_bye.exe : hello.obj goodbye.obj helper.lib
In questa riga di dipendenza è hi_bye.exe la destinazione. Le relative dipendenze sono hello.obj, goodbye.obje helper.lib. La riga di dipendenza indica a NMAKE di compilare la destinazione ogni volta che hello.obj, goodbye.objo helper.lib è cambiato più di recente di hi_bye.exe.
Una destinazione deve essere all'inizio della riga. Non può essere rientrato con spazi o schede. Usare due punti (:) per separare le destinazioni dai dipendenti. Gli spazi o le schede sono consentiti tra le destinazioni, il separatore dei due punti (:) e i dipendenti. Per dividere la riga di dipendenza, usare una barra rovesciata (\) dopo una destinazione o dipendente.
Prima di eseguire blocchi di comandi, NMAKE analizza tutte le dipendenze e tutte le regole di inferenza applicabili per compilare un albero delle dipendenze. Un albero delle dipendenze specifica i passaggi necessari per aggiornare completamente la destinazione. NMAKE controlla in modo ricorsivo se un dipendente è una destinazione in un altro elenco di dipendenze. Dopo aver compilato l'albero delle dipendenze, NMAKE controlla i timestamp. Se gli eventuali dipendenti nell'albero sono più recenti della destinazione, NMAKE compila la destinazione.
Target
La sezione destinazioni di una riga di dipendenza specifica una o più destinazioni. Una destinazione può essere qualsiasi nome file, nome di directory o pseudotarget valido. Separare più destinazioni usando uno o più spazi o schede. Le destinazioni non fanno distinzione tra maiuscole e minuscole. I percorsi sono consentiti con nomi di file. Una destinazione e il relativo percorso non possono superare i 256 caratteri. Se la destinazione precedente i due punti è un singolo carattere, usare uno spazio di separazione. In caso contrario, NMAKE interpreta la combinazione di lettere-due punti come identificatore di unità.
Destinazioni multiple
NMAKE valuta più destinazioni in una singola dipendenza come se ognuna fosse specificata in un blocco di descrizione separato.
Ad esempio, questa regola:
bounce.exe leap.exe : jump.obj
echo Building...
viene valutato come:
bounce.exe : jump.obj
echo Building...
leap.exe : jump.obj
echo Building...
Dipendenze cumulative
Le dipendenze sono cumulative in un blocco di descrizione, se una destinazione viene ripetuta.
Ad esempio, questo set di regole,
bounce.exe : jump.obj
bounce.exe : up.obj
echo Building bounce.exe...
viene valutato come:
bounce.exe : jump.obj up.obj
echo Building bounce.exe...
Quando sono presenti più destinazioni in più righe di dipendenza in un singolo blocco di descrizione, NMAKE le valuta come se ognuna fosse specificata in un blocco di descrizione separato. Tuttavia, solo le destinazioni nell'ultima riga di dipendenza usano il blocco dei comandi. NMAKE tenta di usare una regola di inferenza per le altre destinazioni.
Ad esempio, questo set di regole,
leap.exe bounce.exe : jump.obj
bounce.exe climb.exe : up.obj
echo Building bounce.exe...
viene valutato come:
leap.exe : jump.obj
# invokes an inference rule
bounce.exe : jump.obj up.obj
echo Building bounce.exe...
climb.exe : up.obj
echo Building bounce.exe...
Destinazioni in più blocchi di descrizione
Per aggiornare una destinazione in più blocchi di descrizione usando comandi diversi, specificare due punti consecutivi (::) tra destinazioni e dipendenti.
target.lib :: one.asm two.asm three.asm
ml one.asm two.asm three.asm
lib target one.obj two.obj three.obj
target.lib :: four.c five.c
cl /c four.c five.c
lib target four.obj five.obj
Effetti collaterali delle dipendenze
È possibile specificare una destinazione con due punti (:) in due righe di dipendenza in posizioni diverse. Se i comandi vengono visualizzati dopo una sola riga, NMAKE interpreta le dipendenze come se le righe fossero adiacenti o combinate. Non richiama una regola di inferenza per la dipendenza senza comandi. NMAKE presuppone invece che le dipendenze appartengano a un blocco di descrizione ed esegue i comandi specificati con l'altra dipendenza. Si consideri questo set di regole:
bounce.exe : jump.obj
echo Building bounce.exe...
bounce.exe : up.obj
viene valutato come:
bounce.exe : jump.obj up.obj
echo Building bounce.exe...
Questo effetto non si verifica se si usano due punti (::). Ad esempio, questo set di regole:
bounce.exe :: jump.obj
echo Building bounce.exe...
bounce.exe :: up.obj
viene valutato come:
bounce.exe : jump.obj
echo Building bounce.exe...
bounce.exe : up.obj
# invokes an inference rule
Pseudo-destinazioni
Uno pseudotarget è un'etichetta usata al posto di un nome file in una riga di dipendenza. Viene interpretato come un file che non esiste e quindi non è aggiornato. NMAKE presuppone che il timestamp di uno pseudotarget sia uguale a quello più recente di tutti i relativi dipendenti. Se non ha dipendenze, si presuppone l'ora corrente. Se uno pseudotarget viene usato come destinazione, i relativi comandi vengono sempre eseguiti. Uno pseudotarget usato come dipendente deve essere visualizzato anche come destinazione in un'altra dipendenza. Tuttavia, tale dipendenza non deve avere un blocco di comandi.
I nomi pseudotarget seguono le regole di sintassi del nome file per le destinazioni. Tuttavia, se il nome non ha un'estensione, può superare il limite di 8 caratteri per i nomi file e può avere una lunghezza massima di 256 caratteri.
Gli pseudotarget sono utili quando si vuole che NMAKE crei automaticamente più di una destinazione. NMAKE compila solo le destinazioni specificate nella riga di comando. In alternativa, se non viene specificata alcuna destinazione della riga di comando, compila solo la prima destinazione nella prima dipendenza nel makefile. È possibile indicare a NMAKE di compilare più destinazioni senza elencarle singolarmente nella riga di comando. Scrivere un blocco di descrizione con una dipendenza contenente uno pseudotarget ed elencare le destinazioni da compilare come dipendenti. Inserire quindi prima questo blocco di descrizione nel makefile o specificare lo pseudotarget nella riga di comando di NMAKE.
In questo esempio UPDATE è uno pseudotarget.
UPDATE : *.*
COPY $** c:\product\release
Quando UPDATE viene valutato, NMAKE copia tutti i file nella directory corrente nell'unità e nella directory specificata.
Nel makefile seguente, lo pseudotarget all compila entrambi project1.exe e project2.exe se all nella riga di comando non è specificata alcuna destinazione. Lo pseudotarget setenv modifica la variabile di ambiente LIB prima dell'aggiornamento dei .exe file:
all : setenv project1.exe project2.exe
project1.exe : project1.obj
LINK project1;
project2.exe : project2.obj
LINK project2;
setenv :
set LIB=\project\lib
Dipendenti
In una riga di dipendenza specificare zero o più dipendenti dopo i due punti (:) o due punti (::), usando qualsiasi nome file o pseudotarget valido. Separare più dipendenti usando uno o più spazi o schede. I dipendenti non fanno distinzione tra maiuscole e minuscole. I percorsi sono consentiti con nomi di file.
Dipendenti dedotti
Insieme ai dipendenti elencati in modo esplicito nella riga di dipendenza, NMAKE può presupporre un dipendente dedotto. Un dipendente dedotto deriva da una regola di inferenza e viene valutato prima di dipendenti espliciti. Quando un dipendente dedotto non è aggiornato rispetto alla destinazione, NMAKE richiama il blocco di comandi per la dipendenza. Se un dipendente dedotto non esiste o non è aggiornato rispetto ai propri dipendenti, NMAKE aggiorna innanzitutto il dipendente dedotto. Per altre informazioni sui dipendenti dedotti, vedere Regole di inferenza.
Percorsi di ricerca dei dipendenti
È possibile specificare un percorso di ricerca facoltativo per ogni dipendente. Ecco la sintassi per specificare un set di directory da cercare:
{directory[;directory...]}dipendente
Racchiudere i nomi di directory tra parentesi graffe ({ }). Separare più directory con un punto e virgola (;). Non sono consentiti spazi o schede. NMAKE cerca prima il dipendente nella directory corrente e quindi nell'elenco delle directory nell'ordine specificato. È possibile utilizzare una macro per specificare parte o tutto un percorso di ricerca. Solo il dipendente specificato usa questo percorso di ricerca.
Esempio di percorso di ricerca della directory
Questa riga di dipendenza mostra come creare una specifica di directory per una ricerca:
reverse.exe : {\src\omega;e:\repo\backwards}retro.obj
La destinazione reverse.exe ha un oggetto dipendente, retro.obj. L'elenco racchiuso tra parentesi graffe specifica due directory. NMAKE cerca retro.obj prima nella directory corrente. Se non è presente, NMAKE cerca la \src\omega directory, quindi la e:\repo\backwards directory.