forma - Online nel Cloud

PROGRAMMA:

NOME

forma - identifica e crea configurazioni di programma da versioni di oggetti sorgente

SINOSSI

forma
[ -f <descrizione file> ]
[ -R <versione prodotti regola> ] [ -V <variant nome> ]
[ -eco <macro nome> ] [ -vigore ] [ -ricostruire ]
[ - dDehiknprs ]
[ -bct ] [ -Aiuto ] [ -nomsg ] [ -novclass ] [ -versione ] [ -xpoff ] [ -xpon ]
[ target1 target2 ... ] [ macro=valore ... ] [ macro+=valore ... ]

DESCRIZIONE

Shape consente di compilare in modo trasparente oggetti sorgente che sono file regolari o
oggetto sorgente versioni nella versione ShapeTools oggetto base. Più in generale, forma
produce un insieme di derivati oggetti (``obiettivi'') da versioni opportunamente selezionate di
corrispondenti oggetti sorgente secondo una descrizione delle dipendenze tra
oggetti. Shape tiene traccia dei parametri rilevanti per le compilazioni (versioni sorgente,
versioni del compilatore, switch del compilatore ecc.) e quindi fornisce una build sicura ed efficiente
macchinari.

Quando la forma compila gli oggetti sorgente, memorizza gli oggetti derivati ​​risultanti insieme a
i parametri di compilazione effettivi nel suo derivati oggetto nascondiglio. Prima della derivazione
il processo per un oggetto richiesto è effettivamente avviato, la forma tenta di trovare un oggetto esistente
oggetto derivato che corrisponde ai requisiti della destinazione, nella cache degli oggetti derivati.
La memorizzazione nella cache e il ripristino di oggetti derivati ​​da versioni immutabili consentono
sviluppatori di trarre profitto dalle build precedenti di altri membri del team. Costi di compilazione complessivi in
i progetti sono notevolmente ridotti.

Quando si serve una richiesta di build, Shape considera un numero potenzialmente elevato di versioni che sono
memorizzato per un oggetto. Quale versione particolare è legato al nome di un oggetto in
file di descrizione, è determinato da versione prodotti norme.

Shape può gestire build di diverse varianti di un sistema in parallelo. Shape utilizza
potenziale combinato di selezione dinamica della versione, ridefinizione dinamica delle macro e derivato
gestione degli oggetti per gestire le build varianti. Poiché la maggior parte, se non tutti, gli oggetti e
i parametri coinvolti in una build sono definiti come macro, la forma fornisce una grande quantità di
flessibilità consentendo di modificare alcune o tutte le macro in modo dinamico, a seconda di quale
variante deve essere costruita. Il concetto di variante definizione nel file di descrizione della forma
offre un punto focale chiaro per tutte le definizioni rilevanti per una determinata variante.

VERSIONI

-f <descrizione file>
forma utilizza l'argomento fornito come nome del file di descrizione da utilizzare per
costruire. Se no -f se l'opzione è specificata, la forma tenta di trovare un file di descrizione sotto
uno dei nomi ``Shapefile'', ``shapefile'', ``Makefile'' e ``makefile'' (da
da sinistra a destra). Se non è possibile trovare alcun file regolare con uno di questi nomi, ma
le versioni dei rispettivi file sono disponibili nella base dell'oggetto versione, la forma sarà
utilizzare la versione più recente. Quando più di una -f <descrizione file> argomento
appare la coppia, la forma legge a turno ogni file di descrizione. Se il nome del
il file di descrizione è specificato come ``-'', shape leggerà la descrizione del sistema da
input standard. È possibile specificare il file di descrizione nella versione associata
notazione, ad esempio Shapefile[2.8] or Shapefile[Versione 4] (Vedi vbind(1) per dettagli
sulla notazione della versione vincolata).

-R <selection regola nome>
attiva la regola di selezione specificata come associazione della versione iniziale per la sorgente
oggetti. Se il -R l'opzione è presente e una regola di selezione è definita come la prima
dipendenza del primo target, la forma utilizzerà la regola di selezione passata tramite
riga di comando e ignorare la prima (e solo la prima) attivazione della regola di selezione
all'interno del file di descrizione. L'opzione è utile per sovrascrivere il valore predefinito iniziale
regole di selezione, specificate nel file di descrizione, dalla riga di comando.

-V <variant nome>
attiva la variante specificata da <variant nome>. Possono essere diverse varianti
attivati ​​simultaneamente dalla riga di comando specificando il -V opzione multipla
volte. Tutte le definizioni specifiche delle varianti saranno in vigore non appena la forma verrà letta
la definizione della variante corrispondente nel file di descrizione.

-vigore
forza la forma a costruire l'obiettivo specificato incondizionatamente, cioè anche se un
esiste un oggetto adatto, precedentemente costruito.

-eco <macro nome>
il valore della macro <macro nome> viene scritto sull'output standard. Questa opzione è
utile per estrarre informazioni dal file di descrizione del sistema (ad esempio shape -echo
FONTI, o SOTTOSISTEMI di eco di forma), o per controllare l'effetto della variante
attivazioni.

-ricostruire
tentare una ricostruzione precisa di bersaglio secondo a legato configurazione filo,
fornito in un file denominato .bct (vedi descrizione di -bct interruttore).

-d Esegui la forma in modalità debug. Stampa informazioni dettagliate sulle dipendenze degli oggetti
e attributi.

-D stampa informazioni dettagliate sul processo di associazione della versione e sul ragionamento della forma
per quanto riguarda le (ri)costruzioni degli obiettivi o i recuperi dalla cache degli oggetti derivati. Questo
switch è utile per scoprire le ragioni esatte per cui la forma ridetermina un bersaglio
(o no).

-e definizioni macro importate dall'ambiente (vedere la descrizione di
macro speciale IMPORTARE, di seguito) sovrascrivere le definizioni macro nel file di descrizione (da
per impostazione predefinita, le definizioni macro nel file di descrizione hanno la precedenza sulle importazioni
dall'ambiente).

-h stampa le informazioni sull'utilizzo sull'output standard (questa è un'abbreviazione per -Aiuto
interruttore, vedi sotto).

-i ignora i codici di errore restituiti dai comandi.

-k quando uno stato di errore diverso da zero viene restituito da un comando richiamato, il lavoro su
l'obiettivo attuale è abbandonato ma la forma continua con altri rami che non lo sono
dipendono dall'obiettivo fallito.

-n nessuna modalità di esecuzione. Shape stampa i comandi, ma non li esegue. Anche
Vengono stampate le righe di comando che iniziano con @. Se un comando contiene la macro $(MAKE)
riferimento, tuttavia, quella linea viene sempre eseguita per consentire il tracciamento di
processi di compilazione ricorsivi.

-p stampare il set completo di definizioni macro, descrizioni di destinazione e regole
definizioni, rispettivamente.

-r non utilizzare le regole implicite integrate nella forma. Regole implicite definite in
il file di descrizione rimane valido.

-s eseguito in modalità silenziosa. Shape non stampa i comandi prima di eseguirli.

-bct registrare la build in un legato configurazione filo file. Un thread di configurazione della forma
contiene definizioni precise di tutte le versioni sorgente, le loro dipendenze, il
strumenti coinvolti e opzioni correlate che erano in vigore per una build. Il
thread di configurazione per un target di primo livello prodotto (il primo target nel
file di descrizione o un target richiesto dalla riga di comando) è memorizzato in un file
detto .bctI thread di configurazione vincolati possono essere utilizzati come input per le ricostruzioni
(vedi opzione -ricostruire, sopra). Se il contesto della versione sorgente di un bct-build è
non sicuro, la forma registrerà tale fatto nel bct e invierà un messaggio di avviso.

-Aiuto stampa le informazioni sull'utilizzo sull'output standard.

-nomsg disattivare la funzione di tracciamento msg nelle regole di selezione della versione.

-novclass
disabilitare il controllo di incompatibilità delle varianti attivate.

-versione
stampa l'identificazione della versione del programma di forma.

-xpoff disattivare l'espansione degli attributi nelle versioni sorgente recuperate dalla base dell'oggetto. Da
di default, l'espansione degli attributi è attivata per tutti gli oggetti sorgente che sono direttamente
recuperato dalla base dell'oggetto e disattivato per gli oggetti sorgente che sono regolari
file (vedi ritorno(1) per i dettagli sull'espansione degli attributi).

-xpon attiva l'espansione degli attributi per tutti gli oggetti sorgente, anche nei file normali.
per impostazione predefinita, l'espansione degli attributi è disattivata per gli oggetti sorgente che sono regolari
file e attivato per tutti gli oggetti sorgente che vengono recuperati direttamente dal
base dell'oggetto.

bersaglio ...
Un elenco di nomi di destinazione può essere passato a shape tramite la riga di comando. Se non è presente alcuna destinazione
dato sulla riga di comando e il target speciale .DEFAULT non è definito all'interno
il file di descrizione, shape tenta di produrre il primo target definito nel
file di descrizione.

<macro definizione>
È possibile definire o modificare le macro nel file di descrizione dal comando
riga. Le macro definite in questo modo hanno la precedenza su tutte le altre definizioni.
Le definizioni delle macro della riga di comando possono avere due forme:

NAME = VALUE
e
NOME+=VALORE

con NOME essendo una parola e VALORE una stringa arbitraria. Se VALORE contiene spazi vuoti, crea
assicurati di citarlo. La prima forma di definizione di macro da riga di comando imposta NOME ai
sostituzione VALORE. Se VALORE è vuoto, la macro viene reimpostata. La seconda forma aggiunge VALORE
con un personaggio spaziale protagonista corrente sostituzione of NOME. L'attuale
la sostituzione può essere definita nel file di descrizione o tramite un'impostazione precedente sul
riga di comando. Per dettagli sulla semantica delle definizioni e delle sostituzioni delle macro, vedere
le rispettive sezioni sottostanti.

DESCRIZIONE FILE

Il funzionamento della forma è controllato da un file di descrizione del sistema (solitamente un Makefile)
che fornisce informazioni strutturali sul sistema da gestire. Oltre a make(1),
la forma funziona sopra AtFS (Atattribuito Fs System), un repository di oggetti con versione,
piuttosto che file semplici. Pertanto, i file di descrizione delle forme originali (solitamente chiamati file di forma)
regole di selezione della versione delle funzionalità e definizioni delle varianti oltre al Makefile standard
regole di dipendenza. Il file di descrizione di Shape è un'estensione compatibile con le versioni successive di make(1)'s
file di descrizione, il Makefile. Una convenzione strutturale utile per la descrizione delle forme
file è quello di mantenere un Makefile e uno Shapefile in parallelo. Solo la forma originale
i costrutti (come le regole di selezione della versione o le definizioni delle varianti) vengono mantenuti in
file di forma, mentre la maggior parte delle definizioni delle regole e delle macro di destinazione viene mantenuta in Makefile.
Il Makefile deve essere incluso in file di forma (vedi descrizione di includere direttiva, di seguito).
Questa convenzione di strutturazione ha il vantaggio che i programmi che sono stati sviluppati con
il supporto del sistema ShapeTools può essere spedito come distribuzione sorgente a siti che non
utilizzare ShapeTools.

Sebbene la forma sia ampiamente compatibile con il programma originale, dovrebbe essere
ha notato che diverse estensioni popolari del programma make originale, come GNU Make o
Sun Make, fornisce funzionalità non è un presente in forma. Vedi la sezione su noto
incompatibilità di seguito.

Il file di descrizione fornisce una base informativa centrale ideale per tutti i tipi di prodotto
definizioni correlate. La forma incoraggia lo sviluppo di un insieme di (progetto o
convenzioni specifiche dell'organizzazione per la descrizione del sistema e fornisce un modo semplice per
estrarre queste informazioni per utilizzarle con altri strumenti (vedere -eco opzione, sopra). La descrizione
la sintassi del file non serve solo a specificare le dipendenze dei componenti rilevanti per la compilazione
processi, ma consente una definizione generale e gerarchica delle attività orientate al prodotto. Il
il concetto di dipendenze ricorsive si collega direttamente a un raffinamento graduale dell'attività
definizioni. Tali attività possono essere completamente, parzialmente o per niente automatizzate, a seconda dei casi.
Pertanto, alcune attività possono essere automatizzate e standardizzate, mentre altre attività sono
solo informalmente descritti per documentarli o per ragionare su di essi (vedi
forma_rms(1) per esempio).

sintattico Structure

La struttura sintattica di base del file di descrizione della forma è composta da:

Commenti
I commenti iniziano con il carattere ``#'' e si estendono fino alla fine della riga. In
Negli shapefile, la fine di una riga è definita come una nuova riga senza escape (``\''),
o la fine del file. Il carattere di commento non può essere sottoposto a escape, ma può essere racchiuso tra virgolette
tra virgolette singole o doppie. Caratteri di commento nelle righe di comando delle regole di destinazione
vengono ignorati dalla forma.

direttive
Le direttive sono parole chiave speciali, note per la loro forma. Le direttive iniziano dalla colonna 0 di un
linea e si estendono fino alla fine della linea. Attualmente, l'unica direttiva riconosciuta dalla forma
is

includere <elenco of filetto nomi>

Macro Definizioni
Le definizioni macro hanno la forma generale:

NOME <macro definizione simbolo> VALORE

NOME deve essere una singola parola composta da una sequenza di caratteri del nome. Caratteri del nome
sono tutti caratteri stampabili eccetto i seguenti:

$ # : = ; \t \n

Il simbolo di definizione della macro è ``='', ``+='' o ``:=''. VALORE è arbitrario
stringa terminata dalla fine della riga o da un commento. Le definizioni delle macro di solito iniziano con
la prima colonna di una riga, ma può essere preceduta da caratteri iniziali caratteri. Macro
le definizioni non devono contenere iniziali personaggi (vedi sezione su Macro Definizioni,
di seguito, per maggiori dettagli).

Macro Bibliografia
I riferimenti macro hanno una delle seguenti forme:

$(<macro nome>)
${<macro nome>}
$<single carattere nome>

L'operatore di sostituzione macro (``$'') non può essere sottoposto a escape, ma può essere rappresentato da
sostituzione ``$$''. La sostituzione macro avviene ovunque nel file di descrizione, tranne in
commenti, nomi macro, lati sinistri della regola di selezione della versione e definizione della variante
intestazioni (vedere la sezione successiva) e definizioni di classi varianti (vedere la sezione su Macro
Sostituzioni, di seguito, per maggiori dettagli).

Regole Le regole sono composte da un regola testata, e un facoltativo regola stile di vitaL'intestazione della regola
consiste in un a sinistra cura lato, una regola definizione simbolo, e un facoltativo right cura
latoIl lato sinistro di solito inizia nella colonna 0 di una riga e può essere preceduto
guidando caratteri. I lati sinistri delle intestazioni delle regole non devono contenere
principale caratteri. Il lato destro facoltativo di un'intestazione di regola si estende a
la fine della riga o l'inizio del corpo della regola. Un corpo della regola è costituito da
righe consecutive che iniziano con a carattere. Il corpo di una regola è
terminato dalla riga successiva che non inizia con a personaggio, o la fine del
file.

La forma riconosce tre diversi tipi di regole, distinti dai rispettivi
simboli di definizione delle regole:

·
bersaglio normeLe regole di destinazione hanno un singolo carattere due punti (``:'') come regola
simbolo di definizione. Il lato sinistro delle intestazioni delle regole di destinazione è uno spazio-
elenco separato di nomi. Il lato destro facoltativo è costituito da uno spazio-
elenco separato di nomi, seguito da un elenco facoltativo di ingredienti di produzione
(vedi sezione su Target Regole, sotto).

·
versione prodotti normeLe regole di selezione della versione hanno il simbolo di definizione della regola
``:-''. L'intestazione della regola di selezione della versione ha una singola parola alla sua sinistra
lato destro e nessun lato destro (vedere la sezione su Versione Selezione Regole,
sotto).

·
variante definizioniSebbene le definizioni varianti siano - come suggerisce il nome -
definizioni, non regole (da un punto di vista semantico), la loro sintassi
la rappresentazione è quella di una regola. Le definizioni varianti hanno la definizione di regola
simbolo ``:+''. L'intestazione della regola di una definizione di variante ha una singola parola al suo interno
lato sinistro e nessun lato destro (vedere la sezione su Variante Definizioni,
sotto).

Variante Classe Definizioni
Le definizioni delle classi varianti hanno la forma

vclass ::= (variante 1, variante 2, ...)

(vedi sezione su Varianti, sotto).

Line Continuazioni
Se la fine di una riga di input è preceduta da una barra rovesciata (``\''), la riga successiva è
considerata come una riga di continuazione. La sequenza di caratteri di nuova riga con barra rovesciata è
sostituito da uno spazio.

Macro Definizioni

Le definizioni macro associano i nomi alle stringhe che verranno sostituite ovunque il nome
della macro è referenziata (vedere la sezione successiva). Le macro sono utili per scrivere codice manutenibile,
e file di descrizione piuttosto generici. Anche i progetti di medie dimensioni lo troveranno
estremamente gratificante definire convenzioni per la denominazione e l'utilizzo di determinate macro
in tutto il file di descrizione del prodotto.

Esistono tre diversi tipi di definizioni di macro:

Semplice Macro Definizioni

Una semplice definizione macro appare così

NOME = <qualsiasi stringa>

La stringa associata al nome della macro può contenere riferimenti a macro. Se una macro
è definito più volte all'interno di un file di descrizione, l'ultima definizione sarà
efficace. Le macro definite sulla riga di comando hanno la precedenza sulle definizioni della stessa
macro nel file di descrizione.

additivi Macro Definizioni

Questo tipo di definizione macro appare come

NOME += <qualsiasi stringa>

La stringa sul lato destro della definizione viene aggiunta a qualsiasi valore esistente
associato NOME, separati da uno spazio. Definizioni di macro additive multiple
sono concatenati nell'ordine in cui appaiono nel file di descrizione. Se un additivo
la definizione della macro avviene sulla riga di comando, l'ultimo valore stringa definito in
il file di descrizione viene anteposto al valore stringa definito sulla riga di comando. Additivo
le definizioni macro nel file di descrizione vengono aggiunte ai valori stringa definiti su
riga di comando.

Valutativa Macro Definizioni

Le macro valutative sono definite nel modo seguente:

NOME := <qualsiasi stringa>

Innanzitutto, il valore della stringa è associato a NOME allo stesso modo della macro semplice
definizioni. Quando NOME viene sostituito per la prima volta, il lato destro del
la definizione viene valutata e il risultato di questa valutazione sostituisce la stringa originale
valore associato a NOMEPertanto, la valutazione del lato destro avviene esattamente una volta.
Ciò è particolarmente utile se la stringa di definizione è una sostituzione di comando (vedere il prossimo
sezione).

Macro Sostituzioni

La sostituzione macro è il processo di sostituzione di un macro riferimento dal valore della stringa
associato a un nome di macro. I riferimenti a macro non definite vengono sostituiti da un campo vuoto
stringa. I riferimenti macro hanno una delle seguenti forme:

$(NOME)
${NOME}
$<qualsiasi singolo carattere>

Di seguito sono riportati i riferimenti macro validi:

$(CFLAG)
$7
${FILE-ORIGINALI}
$(X)
$X

Gli ultimi due riferimenti hanno sostituzioni identiche. Il riferimento macro

$$

sostituirà un singolo simbolo del dollaro.

Prima che un riferimento macro venga sostituito, verrà valutata la stringa associata.
La valutazione di un valore stringa include

-
sostituzione di tutti i riferimenti macro nel valore stringa

-
sostituzione di comando. Qualsiasi sottostringa del valore stringa racchiusa tra virgolette inverse (```'')
verrà passato come comando alla shell e sostituito dallo standard del comando
produzione.

-
sostituzione di stringa. Se un riferimento macro ha la forma

$(NOME:=)

il riferimento verrà sostituito dal valore valutato di NOME, con tutte le occorrenze di
la stringa sostituito dalla stringa Ciò è particolarmente utile per mantenere
elenchi correlati, come CSOURCES e OGGETTI ad esempio, automaticamente:

CSOURCES := `echo *.c`
OGGETTI := $(CSOURCES:.c=.o)

La forma sostituisce i riferimenti macro il più tardi possibile. I riferimenti macro che si verificano in un
la definizione della macro viene sostituita solo quando la macro definita stessa viene sostituita. Macro
i riferimenti sul lato delle dipendenze delle regole di destinazione vengono sostituiti quando la regola è
valutati. I riferimenti macro sul lato target delle regole target vengono sostituiti immediatamente
dopo che shape ha letto il file di descrizione, cioè prima che venga avviata qualsiasi produzione. Macro
i riferimenti nelle direttive include vengono sostituiti quando la direttiva viene eseguita mentre
shape legge il file di descrizione.

Built-in e Special Missione Macro

Per fornire la parametrizzazione delle regole implicite integrate della forma, un certo numero di
Le macro predefinite sono fornite per convenzione. Queste macro hanno valori iniziali significativi
che possono essere modificati dall'utente. Ci sono anche diverse macro che hanno un significato speciale
per la forma.

Macro Missione Iniziale APPREZZIAMO osservazione

@ nome completo dell'attuale la nostra speciale
bersaglio

? elenco delle dipendenze di destinazione la nostra speciale

< nome del primo target la nostra speciale
dipendenza

* prefisso condiviso dal target la nostra speciale
e i nomi dei file dipendenti

# id versione vincolata della versione corrente la nostra speciale
dipendenza

$ il carattere ``$'' $

+ nome dell'oggetto da associare la nostra speciale
a una versione (regole di selezione
soltanto!)

Programma AS per eseguire l'assemblaggio in modo convenzionale

ASFLAGS Flag per l'assemblatore convenzionale

Programma CC per la compilazione di C ccconventional
programmi

Flag CFLAGS per il compilatore C convenzionale

Programma FC per la compilazione di Fortran f77conventional
programmi

Flag FFLAGS per il compilatore Fortran convenzionale

HOSTTYPE Architettura host del la nostra speciale
computer che esegue la forma.
Il valore di questa macro è
utilizzato dalla forma per costruire
l'attributo chiave di derivazione
per oggetti derivati

IMPORTA Elenco delle variabili di ambiente la nostra speciale
che deve essere importato come
definizioni macro

Programma LD per collegare i programmi ldconventional

Flag LDFLAGS per il linker convenzionale

Programma LEX per trasformare le grammatiche Lex in lexconventional
nei programmi C o Ratfor

Flag LFLAGS per l'analizzatore lessicale convenzionale
lex

LOGNAME Il nome o l'ID di rete sotto la nostra speciale
che l'utente che possiede il
il processo di forma è registrato

Programma M2C per la compilazione di Modula2 m2cconventional
programmi

Flag M2FLAGS per il compilatore Modula2 convenzionale

MAKE La riga di comando con cui la forma $(MAKEFLAGS)special
è stata invocata la forma.
Questa macro viene utilizzata per
chiamate ricorsive per dare forma

MAKEFLAGS Flag della riga di comando rilevanti <defined dala nostra speciale
per chiamate ricorsive alla forma command linea>

Programma per PC per la compilazione di Pascal pcconventional
programmi

Flag PFLAGS per il compilatore Pascal convenzionale

Flag RFLAGS per il compilatore Fortran convenzionale
per i programmi Ratfor

SHAPEPID L'ID del processo del la nostra speciale
programma di forma fisica in esecuzione

SHAPEVERSION L'ID della versione di theshape_CM-4.4special
programma di forma (o superiore)

SHELL Il processore dei comandi per /bin/shspecial
il comando della regola di destinazione
linee. Il comando a cui si fa riferimento
il processore deve essere in grado di
prendi i suoi comandi da
input standard (vedere la sezione
on Comando esecuzione,
di seguito)

Estensione del percorso di ricerca VPATH per la nostra speciale
localizzazione dei componenti sorgente

Programma YACC per trasformare le grammatiche Yacc in yaccconventional
nei programmi C

YFLAGS Bandiere per yacc convenzionale

vpath Estensione del percorso di ricerca dinamica la nostra speciale
per varianti di componenti sorgente

La funzione delle macro per scopi speciali TIPO HOST, IMPORTARE, FARE, VPATHe percorso virtuale sono
descritto nelle sezioni FUNZIONAMENTO e Varianti di seguito.

Target Regole

Una regola di destinazione definisce come e in quali condizioni un obiettivo viene derivato da un insieme di
oggetti sorgente e/o altri target. Un target è un nome che può fare riferimento a un file ma che necessita
di non farlo. Le regole di destinazione hanno il seguente formato:

... : [ vincolante>] [+ ...] [ ...] \
[: ...] [; ]
\T[ ]
...

L'intestazione di una regola di destinazione (vedere sintattico Structure, sopra) è costituito da un elenco di
obiettivi, terminato da due punti, seguito da un elenco facoltativo di dipendenze, E un
elenco opzionale di produzione ingredienti, iniziando dopo un secondo carattere due punti. Il
l'intestazione della regola termina con una nuova riga o un punto e virgola ed è seguita dalla regola facoltativa
corpo. Il corpo della regola è costituito da command Linee che vengono eseguiti quando è necessario raggiungere un obiettivo
rederived. La prima riga di comando può seguire immediatamente il punto e virgola che termina
l'intestazione della regola. Le righe di comando successive devono iniziare con un carattere. Il bersaglio
il corpo della regola termina con la prima riga che non inizia con a , o alla fine
del file.

Obiettivi

Quando più target appaiono sul lato sinistro di un'intestazione di regola e la derivazione
il processo deve essere avviato, la forma deriverà tutti gli obiettivi in ​​un'unica esecuzione.

dipendenze

Shape controlla le dipendenze di un target da sinistra a destra. Viene esaminata la prima dipendenza
se è il nome di una regola di selezione della versione. In tal caso, la forma imposta la selezione
regola attiva (eclissando tutte le precedenti attivazioni della regola di selezione) e procede alla successiva
dipendenza. Successivamente, la forma controlla se la dipendenza è un'attivazione variante. Se la
la dipendenza inizia con un carattere ``+'' seguito dal nome di una variante, la variante è
attivato (vedere la sezione su Varianti, sotto). La forma procede a controllare la variante
attivazioni finché non viene trovata la prima dipendenza che non sia un'attivazione variante. Successivamente,
la forma procede attraverso l'elenco delle dipendenze rimanenti e si lega (o derivati) ciascuno di
se necessario, eseguendo una traversata in profondità del grafico delle dipendenze (vedere
sezione su FUNZIONAMENTO, sotto).

Produzione Ingredienti

Dopo che tutte le dipendenze sono state vincolate, la forma costruisce il derivazione chiave per l'
target. La chiave di derivazione è un attributo che definisce l'insieme completo dei parametri
che determinano se un target deve essere ricostruito. Oltre a tutte le dipendenze vincolate,
la chiave di derivazione contiene il produzione ingredienti che sono stati specificati nella regola di destinazione
intestazione. Gli ingredienti di produzione sono in genere definizioni complete delle macro che sono
referenziato nelle righe di comando del corpo della regola. Pertanto, le versioni e gli switch degli strumenti
che influenzano il funzionamento di uno strumento possono essere resi parte dei parametri di derivazione di un
target. Per includere le definizioni macro nella chiave di derivazione di un target, il
riferimento speciale

+(NOME1) +(NOME2) ...

deve avvenire al posto degli ingredienti di produzione.

Comando Linee

Quando la forma conclude che un target deve essere (ri-)derivato, i comandi nel target
vengono eseguiti i corpi delle regole. Il corpo delle regole è costituito da righe consecutive che vengono trattate come
comandi separati. Ogni riga di comando viene valutata come descritto nella sezione su Macro
Sostituzione, sopra, e passato all'interprete dei comandi definito dalla macro SHELL.
Ogni riga di comando viene eseguita come un processo separato. Se sono necessari comandi complessi che
non rientrano in una singola riga, o se il sovraccarico delle ripetute invocazioni di processo deve essere
evitato, una riga di comando logica può essere estesa eseguendo l'escape della nuova riga con una barra rovesciata
carattere (\), e continuandolo sulla riga fisica successiva.

Le righe di comando possono essere precedute da uno o due caratteri speciali:

- shape ignora qualsiasi codice di errore diverso da zero restituito da una riga di comando per il quale il primo
carattere è un segno meno. Il segno meno non viene passato alla shell. Quando un
il comando restituisce uno stato di ritorno diverso da zero, la forma di solito considera la derivazione
processo per il target come fallimento e termina, a meno che il -i or -k interruttori, o
, il .IGNORARE è in vigore un obiettivo speciale.

@ Se il primo carattere di un comando è ``@'', shape non stampa il comando
prima di eseguirlo. Il carattere ``@'' non viene passato alla shell.

@- Se i primi due non- i caratteri sono ``@-'', la forma ignora il ritorno diverso da zero
codici e sopprime la stampa della riga di comando.

Se la forma viene invocata in no esecuzione modo (-n), le righe di comando valutate vengono stampate su
output standard, che mostra quale forma sarebbe fare se invocato senza -n. Righe di comando che
contengono il riferimento macro $(FARE) vengono sempre eseguiti, anche se -n è impostato. Questo è fatto
per consentire la simulazione di build ricorsive che possono estendersi su sottodirectory. Il riferimento
$(FARE) viene sostituito da un'invocazione del comando shape con tutta la riga di comando pertinente
interruttori impostati.

All'interno delle righe di comando del corpo della regola, alcune parti dell'intestazione della regola di destinazione possono essere
referenziato dinamicamente. Quando viene valutata una riga di comando, vengono effettuate le seguenti sostituzioni
possibile

Referenze Sostituzione
$@ nome completo del target corrente
$? elenco delle dipendenze
$< nome della prima dipendenza
$* prefisso condiviso dal nome file corrente e da quelli dipendenti
$# id versione vincolato della dipendenza corrente
(solo regole implicite)

Implicito Regole

Le regole target di Shape sono di due tipi: esplicite e implicite. Regole implicite
possono essere visti come modelli che definiscono modelli di dipendenza che si applicano alla maggior parte degli obiettivi di un
dato tipo. Per questo motivo, le regole implicite sono talvolta chiamate modello norme. Forma
converte le regole implicite di vecchio stile di make (ad esempio .co:) in regole di pattern mentre legge il
file di descrizione. Un tipico schema di dipendenza è, ad esempio, la dipendenza dei file
contenente codice oggetto collegabile, ad esempio modulo.o ai file corrispondenti contenenti la fonte
codice, ad esempio modulo.cIl processo di derivazione per la maggior parte di queste coppie sorgente/derivato è
identici. Piuttosto che scrivere regole separate per tutte le dipendenze sorgente/derivate di un
sistema, è possibile scrivere una singola regola generica, chiamata regola implicita. Una regola implicita
la regola ha il seguente formato:

%[. ] %[. ] ... : %[. ] %[. ]... \
[: ...] [; ]
\T[ ]
\T[ ]
...

Mentre la struttura delle regole implicite è la stessa descritta sopra, i nomi degli obiettivi
e le dipendenze vengono sostituite rispettivamente dai modelli di destinazione e dai modelli di dipendenza.
Il carattere percentuale in un modello di destinazione funge da carattere jolly che viene confrontato con tutti gli
il nome di un target fino al suffisso finale facoltativo. Per la forma, un nome di oggetto suffisso is
la sequenza di caratteri racchiusa dall'ultimo carattere punto (``.'') all'interno del nome,
e la carattere che termina il nome. L'esempio seguente illustra la forma
concetto di suffissi:

Nome Suffisso
campione.cde cde
campione.xycc
campione_c
.esempio.c c

Di seguito è riportato un esempio di regola implicita che deriva il codice oggetto collegabile da
file sorgente C corrispondenti:

%.o : %.c : +(CC) +(CFLAGS)
\t@echo shape - esecuzione: $(CC) -c $(CFLAGS) $#;
\t@$(CC) $(CFLAGS) -E %.c |
sed 's;^\(# [0-9][0-9]* \"\)%.c\(\".*\)$$;e1$#\2;' > %.i;
\t@$(CC) -c $(CFLAGS) %.i;
\t@rm %.i;

NOTA: questa regola è la regola implicita integrata di Shape per compilare i file sorgente C. La regola criptica
la sequenza di comandi ha lo scopo di codificare l'ID completo della versione del file nell'oggetto
codice (ad esempio sample.c[3.4] anziché sample.c). Questo è estremamente utile in combinazione
con con il -g passaggio della maggior parte dei compilatori C e dei debugger sensibili alla versione, come
vdb.

Se un target viene derivato utilizzando regole implicite, il nome del target viene confrontato con
modelli di destinazione delle regole implicite. Se una regola corrisponde, la porzione corrispondente della
nome del bersaglio (il stelo, indicato con ``%'') viene sostituito in modo coerente per tutti gli altri
occorrenze del carattere jolly in tutta la regola. Una volta fatto ciò, l'implicito
la regola viene trattata come una regola target esplicita.

Esplicito Regole

Le regole esplicite associano nomi di destinazione espliciti a dipendenze esplicite. Regole esplicite
sono più tipicamente utilizzati per specificare dipendenze che non possono essere coperte da regole implicite,
come derivare un programma eseguibile collegando molti moduli di codice oggetto. In molti
casi, vengono utilizzate regole esplicite per specificare solo quelle dipendenze di destinazione che non sono
implicito da una regola implicita (come includere dipendenze per file oggetto), mentre il
Si presuppone che le dipendenze ``naturali'' siano presenti. Se un file di descrizione contiene solo
questo tipo di dipendenze esplicite, le dipendenze implicite omesse (e un applicabile
corpo della regola) vengono aggiunti automaticamente in base alla forma all'elenco totale delle dipendenze di destinazione.

Built-in Implicito Regole

Shape fornisce una serie di regole di destinazione implicite predefinite che coprono molti aspetti comuni
derivazioni sorgente/destinazione. La tabella seguente elenca i modelli di destinazione e le dipendenze
modelli per le regole implicite integrate nella forma.

Target Dipendenza Derivazione
%.a %.c Compila la libreria di archivio dal codice sorgente C
%.c %.l Genera programmi C dalla grammatica Lex
%.c %.y Genera programmi C dalla grammatica Yacc
%.o %.l Compila il codice oggetto dalla grammatica Lex
%.o %.y Compila il codice oggetto dalla grammatica Yacc
%.o %.s Traduce il programma assembler in codice oggetto
%.o %.r Compila Ratfor sorgente
%.o %.F Compila il codice sorgente Fortran
%.o %.f Compila il codice sorgente Fortran
%.sym %.def Compila i moduli di definizione Modula
%.o %.mod Compila i moduli di implementazione di Modula
%.o %.p Compila il codice sorgente Pascal
%.o %.c Compila il codice sorgente C
% %.sh Crea un programma eseguibile dallo script della shell
% %.r Crea un programma eseguibile dal codice sorgente di Ratfor
% %.F Crea un programma eseguibile dal codice sorgente Fortran
% %.f Crea un programma eseguibile dal codice sorgente Fortran
% %.p Crea un programma eseguibile dal codice sorgente Pascal
% %.mod Crea un programma eseguibile dal codice sorgente di Modula
% %.c Crea un programma eseguibile dal codice sorgente C

Per una definizione completa delle regole implicite integrate di shape, eseguire shape -p.

Special Missione Obiettivi

Diversi aspetti del funzionamento della forma sono controllati da obiettivi speciali che possono essere
inserito nel file di descrizione. Per convenzione, gli obiettivi per scopi speciali iniziano con un punto
carattere e non hanno comandi associati.

Target Missione

.DEFAULT: comandi nel corpo della regola del .PREDEFINITO le regole di destinazione vengono eseguite per tutti
obiettivi che non possono essere derivati ​​da regole di destinazione esplicite o implicite. Se no
tutti i comandi devono essere eseguiti per una regola ma .PREDEFINITO è necessario per altri
obiettivi, a quella regola può essere dato un comando vuoto (sia un ``;'' alla fine di
l'intestazione della regola o una riga vuota che inizia con ). Se .PREDEFINITO ha
dipendenze e non vengono richiesti target dalla riga di comando, questi
le dipendenze vengono trattate come se fossero obiettivi richiesti dal comando
linea.

.IGNORE: fa sì che shape ignori i codici di ritorno diversi da zero dei comandi invocati. Equivalente
ai -i interruttore

.SILENT: esecuzione silenziosa del comando. Le righe di comando non vengono visualizzate prima dell'esecuzione.
Equivalente a -s interruttore

.BPOOL: solo le dipendenze associate a questa destinazione vengono memorizzate nel derivato
cache degli oggetti

.NOBPOOL: le dipendenze associate a questo target sono non è un memorizzato nell'oggetto derivato
cache.

Se entrambi, .BPOOLe .NOBPOOL sono definiti, solo l'insieme delle differenze di entrambe le dipendenze
gli elenchi verranno memorizzati nella cache degli oggetti derivati.

Versione Selezione Regole

Quando la forma costruisce un bersaglio, usa versione prodotti norme per associare una versione unica a
ogni nome degli oggetti sorgente prerequisiti. Le regole di selezione della versione sono costituite da un nome,
e un insieme associato di predicato list nel corpo della regola. Il formato della selezione della versione
le regole sono:
[( , ,...)] :-
\T[ ,] (...), (...);
\T[ ,] (...), (...);
...
\T.
Il corpo di una regola di selezione della versione è costituito da una sequenza di alternative, divisi da
punto e virgola. Ciascuna delle alternative è un modello facoltativo, seguito da un punto e virgola separato
lista di predicatiLa regola di selezione termina con un punto. Il punto e virgola-
sequenza separata di alternative in una regola di selezione della versione costituisce una logica OR
espressione. L'elenco di predicati separati da virgole in un'alternativa costituisce un'espressione logica
E espressione.

Versione Rilegatura

Il binding della versione è il processo di determinazione di una sola versione di un dato oggetto sorgente
dall'insieme di tutte le versioni disponibili. Si dice che il binding della versione avere successo se uno dei
Le alternative di regola hanno successo. Un'alternativa ha successo se porta all'identificazione di
esattamente una versione. Si dice che fallire altrimenti. Quando la forma lega una versione al nome
di un oggetto sorgente, prova ogni alternativa con un modello corrispondente, finché il nome non è
vincolato in modo univoco a una versione. Se il modello viene omesso, verrà provata l'alternativa
incondizionatamente.

Il funzionamento delle regole di selezione della versione è uno degli aspetti più importanti della forma, ma anche il più
aspetti sottili. Al fine di fornire una base per una comprensione intuitiva del
meccanismo di regola di selezione, viene descritto un esempio. La regola più_recenti, di seguito, lega:
- file che sono stati estratti per la modifica dall'utente che ha richiamato la forma
- versioni dei file che sono stati modificati di recente (→ stato salvato) dallo stesso utente
- la versione proposta più di recente (→ stato proposto) di file modificati da altri utenti,
- oppure la versione del file dell'ultima versione.

LASTRELEASE := `lastrelease`# "lastrelease" restituisce il nome
# dell'ultima versione
più_recenti :-
eq (stato, occupato), esiste ($+[locked_by($(LOGNAME)):]);
ge (stato, salvato), max (mtime),
max (versione), eq (autore, $(LOGNAME));
ge (stato, proposto), max (mtime),
max (versione);
eq (__NomeSimbolico__, $(LASTRELEASE));
cut ($_rule$: impossibile associare $+ come richiesto!).

bloccato_da (ID_utente) :-
max (versione), eq (armadietto, $_user_id$).

Per una descrizione più dettagliata della sintassi, della semantica e dell'elenco delle regole di selezione della versione
di predicati incorporati, vedere Regole di associazione(7).

Attivazione of Versione Selezione Regole

Una selezione di versione per un determinato target viene richiamata specificando il nome del
regola di selezione come prima dipendenza di un target, oppure fornendo un nome di regola di selezione come
argomento al -R opzione. Se non viene specificata esplicitamente alcuna regola di selezione, la forma utilizza la sua
regola di selezione della versione integrata che tenta di associare un file normale o il più recente
versione del nome di un oggetto.

Varianti

Il termine variante si riferisce all'intenzione di gestire un prodotto che deve essere conforme a
diversi insiemi di vincoli esterni variabili come un'unità. Indipendentemente da particolari
semantica che potrebbe essere associata alla nozione di variante, esiste un piccolo numero di
Tecniche per implementare la variazione del software a livello tecnico. Queste tecniche sono:

Fisico separazione di componenti varianti. Ciò si ottiene mantenendo copie separate
di componenti in directory diverse, o mantenendo rami specifici delle varianti in
sistemi di controllo delle versioni;

source pre-elaborazione di componenti varianti. Con questa tecnica, più varianti logiche
di un componente sorgente sono mantenuti in un singolo file che contiene il preprocessore
istruzioni. Prima che una particolare variante possa essere accessibile, un preprocessore deve estrarla
dalla fonte comune. Un esempio popolare di questa tecnica è condizionale compilazione,
controllato dalle istruzioni #if e #ifdef all'interno del dominio della programmazione C/C++;

composizione variazione di varianti di prodotto complesse. Questa tecnica affronta il caso in cui
diverse varianti di un prodotto complesso (come un programma) sono composte da diversi
set di componenti;

derivazione variazione (o variazione del processo) che produce diverse varianti di
oggetti derivati ​​dallo stesso insieme di sorgenti modificando i parametri della derivazione
processo. Un esempio tipico di questo caso è la compilazione incrociata delle stesse fonti per
diverse piattaforme di destinazione o strumentazione del codice per vari scopi, come
debug, test, profilazione o ottimizzazione.

A seconda delle particolari esigenze di un progetto, tutte queste tecniche possono essere in
uso simultaneo e possono verificarsi mescolati in modo appropriato. La forma consente di associare
nomi di varianti logiche con un insieme di definizioni che controllano tutto quanto sopra menzionato
tecniche, rendendo possibile richiedere build di particolari varianti di sistema (e
combinazioni di varianti compatibili) senza la necessità di preoccuparsi di come queste varianti
sono realizzati tecnicamente.

Variante Definizioni

La forma trae la sua flessibilità dall'utilizzo macro sostituzione nel file di descrizione
ove possibile. Le definizioni delle varianti di forma sono fondamentalmente gruppi di definizioni macro
che hanno effetto quando la variante viene attivata per una build. Una definizione di variante ha la
seguente formato:

:+
\T nome1>=
...

Quando una variante viene attivata, le definizioni macro associate alla variante diventano
efficace. Qualsiasi definizione precedente di una macro fatta nel file di descrizione, o sul
la riga di comando viene sostituita dalla variante di sostituzione macro. Se una macro è definita in
più varianti che vengono attivate insieme, i rispettivi valori vengono concatenati.

Individuazione fisicamente separato Variante Fonte Oggetti

La forma fornisce una macro speciale, percorso virtuale, che è destinato ad essere utilizzato nelle definizioni delle varianti.
. percorso virtuale la macro definisce la precedenza di ricerca della forma quando gli archivi della versione sorgente sono
situato. Se percorso virtuale non è vuoto, la forma cerca di trovare qualsiasi oggetto sorgente referenziato in
directory vpath prima. Se più varianti attivate definiscono vpath, la ricerca delle varianti
il percorso viene concatenato e ricercato da destra a sinistra, ovvero l'ultima variante che è stata
attivato ha la precedenza. Solo se un componente sorgente referenziato non può essere trovato in nessuno dei
le directory vpath, viene cercata la directory corrente. Se un oggetto sorgente è stato
trovato, sarà vincolato dalla regola di selezione della versione corrente e sarà temporaneamente
installato nella directory di build. Ciò significa che i componenti che vengono mantenuti in un
La sottodirectory vpath viene temporaneamente spostata nella directory principale. Pertanto, non è
necessario fare riferimento a un percorso di sottodirectory vpath nelle regole di destinazione.

Variante Attivazione

Quando un prodotto viene configurato e costruito, le varianti vengono in genere attivate fornendo un
nome della variante come argomento per -V opzioni.

Le varianti possono anche essere attivate per un dato target specificando il rispettivo prefisso ``+''
nomi di varianti come dipendenze (vedere la sezione sulle regole di destinazione, sopra). Attivazioni di varianti
perché un target deve verificarsi prima di qualsiasi dipendenza di un oggetto reale sulla linea di dipendenza, e
dopo l'attivazione della regola di selezione della versione facoltativa.

Variante Classe Definizioni

Con Variante classe definizioni, la forma offre un costrutto che permette di definire
incompatibile varianti, cioè varianti che non possono essere attivate contemporaneamente. Forma
le definizioni delle classi varianti hanno il seguente formato:

vclass ::= ( , ...)

Lo stesso nome di variante può comparire in più definizioni di classi di varianti. Se una combinazione
di varianti è richiesto con due nomi di varianti che sono membri della stessa variante
classe, la forma emetterà un messaggio di errore e terminerà. Il controllo delle classi varianti può
essere disabilitato specificando il -novclass passare dalla riga di comando.

NOTA: le definizioni delle classi varianti devono essere presenti nel file di descrizione prima qualsiasi variante
definizione a cui si fa riferimento in una classe variante. Classi varianti definite dopo
le varianti referenziate non possono imporre l'esclusione reciproca delle varianti incompatibili.

An Esempio

L'esempio seguente illustrerà l'uso delle definizioni di varianti e varianti
classi:

compilatore vclass ::= (gnu, prop)

gnu:+
CC = gcc -Wall
OTTIMIZZA = -O2 -funzioni in linea
DEBUG = -g -g3
PROFILO = -pg -a
STDC = -ansi

oggetto di scena:+
CC = cc
OTTIMIZZA = +O3
DEBUG = -g -z +Y
PROFILO = -G
DCST = -Aa

qualità vclass ::= (debug, profilo, ottimizzazione)

debug:+
VARCFLAGS = $(DEBUG)

profilo:+
VARCFLAGS = $(PROFILO)

ottimizzare:+
VARCFLAGS = $(OTTIMIZZA)

CFLAGS += $(VARCFLAGS)

Se una variante richiede la modifica di macro con significato predefinito, a volte è
una buona idea non è un per ridefinire la macro stessa nella sezione variante. In tal caso è
è possibile aumentare un valore macro esistente utilizzando la definizione macro additiva della forma
struttura e una macro dalla definizione della variante definita per questo scopo (ad esempio VARCFLAGS
nell'esempio sopra).

FUNZIONAMENTO

Quando viene richiamato, shape analizza prima la riga di comando. Shape registra i nomi delle varianti
da attivare dalla riga di comando tramite -V opzione. Successivamente, la forma inizializza l'
macro integrate e speciali. Inoltre, vengono inizializzate le regole di derivazione integrate della forma.

Lettura , il Descrizione Compila il

Dopodiché, tutte le definizioni macro effettuate sulla riga di comando vengono rese effettive. Modella quindi
individua e apre il suo file di descrizione. Se non viene specificato alcun file di descrizione come argomento di
, il -f opzione, la forma prova a trovare uno dei file file di forma, shapefile, Makefile, o
makefilePer ciascuno di questi nomi, shape cerca prima di trovare un file regolare e, se non lo trova,
tale file esiste, per trovare la versione più recente di quel file in un controllo di versione
archivio. Se non viene trovata alcuna versione, shape prova il nome successivo.

Quando shape legge il file di descrizione, raccoglie tutte le definizioni macro e le rende
immediatamente efficace, a meno che non sia stata definita una macro con lo stesso nome sul comando
linea. Se la macro speciale IMPORTARE viene rilevato, le variabili di ambiente elencate sono
definite come macro. Se si verificano macro con lo stesso nome di una variabile d'ambiente importata
nel file di descrizione ha la precedenza sulla definizione dell'ambiente,
a meno che il -e l'interruttore è in vigore.

Quando la forma legge un includere direttiva, valuta il resto della riga (cioè la
caratteri che seguono immediatamente la direttiva), e interpreta ogni parola come il nome di
un file da leggere. Ciascuno dei nomi di file è associato a un file normale o al più
versione recente del file. Shape apre ciascuno dei file inclusi, sospende la lettura del
file di descrizione corrente e continua a leggere il contenuto dei file inclusi,
prima di riprendere la lettura del file di controllo originale. Se sono presenti più nomi di file
specificato in una direttiva include, shape legge ciascuno dei file a turno, iniziando con
quello più a sinistra e che termina con il nome del file più a destra. Se un file incluso non poteva essere
aperto, la forma emette un avviso.

Mentre la forma legge i suoi file di descrizione, le regole di selezione della versione e le regole di destinazione sono
raccolto. Loro sono definito solo dopo che shape ha terminato di leggere il file di descrizione.
Le definizioni di macro, varianti e classi varianti diventano effettive non appena sono state
stato riconosciuto.

. Silhouette Processo

Dopo che il file di descrizione è stato letto, la forma determina quali obiettivi sono stati
richiesto. Se sono stati richiesti degli obiettivi dalla riga di comando, la forma tenterà di
costruisci ognuno di essi, iniziando con l'obiettivo più a sinistra e procedendo verso l'
più a destra. Se non è stato richiesto alcun target dalla riga di comando, shape cerca
file di descrizione per un target denominato .PREDEFINITOSe un tale obiettivo esiste, e ce ne sono
dipendenze ad esso associate, la forma tenterà di costruire ciascuna di queste dipendenze,
da sinistra a destra. Se no .PREDEFINITO la regola di destinazione è stata definita nel file di descrizione,
la forma tenterà di costruire il prima di tutto bersaglio definito in , il descrizione filetto.

Quando la forma costruisce un bersaglio, procede come segue:

1)
determinare i nomi degli oggetti sorgente per un dato target attraversando il
grafico delle dipendenze, utilizzando regole di destinazione integrate e fornite dall'utente. Il grafico delle dipendenze
viene attraversato in profondità. Vengono registrati gli ID di tutte le regole applicate.

2)
per ogni oggetto sorgente richiesto, individuare l'archivio della versione sorgente nel repository.
L'individuazione degli archivi delle versioni sorgente richiede la corrente percorso virtuale in considerazione.

3)
associare ciascuno dei nomi dell'oggetto sorgente a una versione appropriata come implicito da
regola di selezione della versione attualmente attiva. Registra l'ID di ogni dipendenza associata. Se un
la dipendenza è essa stessa un oggetto derivato, usa il suo nascondiglio chiave come id.

4)
costruire il derivazione chiave per l'obiettivo corrente dal nome dell'obiettivo e dal
registrazioni risultanti dai passaggi 1) e 3).

5)
cerca nella cache degli oggetti derivati ​​un oggetto che abbia una chiave di derivazione identica a
la chiave costruita nel passaggio 4).

6)
se è stato trovato un oggetto derivato appropriato, una copia di esso viene installata nella build
directory, anziché ricavarla dalle sue fonti.

6b)
se non è stato trovato alcun oggetto derivato appropriato, viene creato derivandolo dal suo
parti. L'oggetto derivato risultante viene inserito nella cache degli oggetti derivati ​​e
associato alla chiave di derivazione risultante dal passaggio 4).

I target con un elenco vuoto di dipendenze, e quindi una chiave di derivazione vuota, sono sempre
(ri-)derivato.

Quando la forma determina le dipendenze di un target richiesto, lo fa valutando
o regole di destinazione esplicite, o applicando regole implicite, eventualmente integrate. Se
le regole di destinazione esplicite specificano le dipendenze degli oggetti ma nessuno script di derivazione nella regola
corpo, forma tenterà di fornire uno script di derivazione predefinito appropriato. Quando
cercando uno script di derivazione predefinito, shape cerca di trovare un implicito applicabile
regola per l'obiettivo corrente. Una regola implicita è considerata applicabile se ha la
target corrente nel suo elenco di target (dopo la sostituzione del pattern) e tutti - espliciti,
e implicite - esistono dipendenze. Se non si trova alcuna regola implicita applicabile, la forma
cerca il .PREDEFINITO regola di destinazione. Se tale regola esiste e se è associata
script di derivazione nel suo corpo di regola, questo script verrà fornito come derivazione predefinita
script. Se nessuna delle due possibilità porta a uno script di derivazione predefinito, forma
si arrende.

derivato Oggetto Caching

Prima di avviare il processo di derivazione per un target richiesto, si tenta di trovare un
oggetto derivato idoneo nella cache degli oggetti derivati ​​che corrisponde alle proprietà richieste.
La forma è basata su derivazione chiave concetto per gli oggetti target. La chiave di derivazione è
costruito secondo l'algoritmo descritto sopra. Parametri rilevanti che entrano in
la chiave di derivazione è la stratagemma of dipendenza ids, l' bersaglio regola id, l' stratagemma of
produzione ingredienti, l' costruire piattaforma (solitamente definito dalla macro TIPO HOST; se questo
la macro non è definita, la forma prende l'ID host come piattaforma di build) e attributo
espansione status di ogni oggetto sorgente. Quando un oggetto è stato derivato, la forma lo memorizza
nella cache degli oggetti derivati ​​e lo contrassegna con l'attributo chiave di derivazione. Per un
traccia dettagliata della gestione della cache degli oggetti derivati ​​dalla forma e dell'uso delle chiavi di derivazione,
forma di corsa con il -D interruttore.

Comando

Quando un target deve essere (ri-)derivato, shape esegue i comandi associati al
target. Prima che i comandi vengano eseguiti, shape imposta il contesto di esecuzione del comando. Il
gli oggetti versione delle dipendenze della destinazione vengono installati come file regolari nel file
sistema. Se necessario, Shape recupera gli oggetti sorgente dall'archivio di controllo della versione. Se
un file con il nome dell'oggetto esiste già nel posto in cui deve essere creata una versione
installato, la forma lo sposterà temporaneamente nella AtFS sottodirectory. Dopo il comando
Una volta completato lo script, Shape ripristinerà lo stato originale di tutte le directory interessate.

Shape esegue una riga di comando avviando il programma a cui si fa riferimento nel $(SHELL) macro,
e aprendo una pipeline verso il processo risultante. La riga di comando viene scritta nella pipeline e
così inviato al $(SHELL) input standard del processo.

Ciascuna delle righe di comando in un corpo di regola viene eseguita da un processo separato. Pertanto,
Lo stato di esecuzione dei singoli comandi non viene preservato. Se sono necessari più comandi
che si basano sullo stato di esecuzione dei comandi precedenti, tutti questi comandi devono essere eseguiti in un
singola riga di comando. Questo è possibile con linea continuazioni (vedi sezione su sintattico
Structure, sopra).
NOTA: molti interpreti di comandi utilizzano il carattere ``$'' come simbolo speciale (tipicamente come
riferimento variabile). Assicurati di passare i caratteri ``$'' nei comandi al $(SHELL)
processo utilizzando la macro speciale ``$$'' (vedere la sezione su Macro Bibliografia, sopra).

INCOMPATIBILITÀ

Per facilitare la migrazione da make(1), la forma è stata progettata per essere compatibile con le versioni successive
con i Makefile. Sebbene la maggior parte delle funzionalità del file di descrizione di Make siano presenti in forma,
ci sono una serie di incompatibilità di cui potrebbe essere necessario occuparsi. Esiste
anche un certo numero di estensioni popolari del programma make originale (ad esempio Make di Sun, Make di HP
Make, GNU Make, nmake ecc.) che offrono varie funzionalità speciali che non sono supportate da
altre estensioni di make, o per forma. Quando è pianificata una migrazione da make a shape,
è opportuno verificare se vengono utilizzate estensioni speciali o funzionalità incompatibili.

Caratteristiche non è un supportato by forma

Doppio colon norme
Le regole dei doppi due punti associano lo stesso target a diversi script di derivazione.
Questo tipo di regola è utile per supportare diverse derivazioni per un target a seconda
su quali dipendenze sono obsolete. Poiché la forma basa la sua decisione se
derivare dal derivazione chiave, piuttosto che semplici timestamp di modifica dei file,
questo tipo di regola non ha senso nella forma.

Archivio membro obiettivi
Gli obiettivi dei membri dell'archivio sono oggetti che risiedono in un file di archivio (vedere ar(1)) piuttosto
rispetto al file system. All'interno di questi archivi, make basa le sue decisioni su
timestamp di modifica dei file sorgente e date di registrazione degli archivi. Non c'è modo
per simulare il concetto di chiavi di derivazione per i membri dell'archivio.
La manutenzione degli archivi, tuttavia, è facile con la forma, perché tutti i dati per compilato
I file oggetto vengono mantenuti nella cache degli oggetti derivati. Se l'origine di un oggetto
che è memorizzato in un archivio viene modificato, la forma può ridisegnare questo oggetto e
sostituire selettivamente la voce nell'archivio.

CSSC roba
Per fornire un supporto di base ai processi di sviluppo orientati al team, effettuare
consente di recuperare la versione più recente dei file sorgente dagli archivi SCCS.
A causa della scomoda convenzione di denominazione per i file di archivio della versione SCCS, speciali
il supporto per la gestione di questi archivi doveva essere integrato in make. Poiché la forma è
strettamente integrato con il AtFS repository di oggetti versione, non c'è bisogno di
qualsiasi supporto speciale SCCS.

Special obiettivi
La forma non riconosce i bersagli speciali .PREZIOSO:e .SUFFISSI:.
Il target .PRECIOUS nei Makefile ha lo scopo di impedire l'eliminazione di dati costosi
obiettivi intermedi derivati ​​(per impostazione predefinita, make elimina gli obiettivi intermedi).
Poiché la forma memorizza i target intermedi nella cache degli oggetti derivati, non c'è
necessità della funzionalità .PRECIOUS. Per impedire la memorizzazione nella cache di dati potenzialmente grandi e inutili
obiettivi intermedi, utilizzare il .NOBPOOL: obiettivo speciale (vedere la sezione su Special
Obiettivi, sopra). L'obiettivo .SUFFIXES nei Makefile ha lo scopo di introdurre nuovi
tipi di suffisso nel motore di derivazione di make e per determinare l'ordine in cui
regole implicite (suffisso norme nella terminologia make) vengono applicati. Nella forma, nuovo suffisso
i tipi possono essere aggiunti dinamicamente, semplicemente introducendo nuove regole implicite. Inoltre,
shape ha un algoritmo intelligente che determina la regola implicita applicabile.

Caratteristiche con diverso semantica

Ambiente Variabili
Molti programmi importano l'intero set di variabili d'ambiente come macro
definizioni nel processo di compilazione. Questo a volte può produrre risultati sorprendenti.
Nella forma, le variabili di ambiente vengono importate esplicitamente con IMPORTARE la nostra speciale
macro.

? Macro
Nelle regole di destinazione di make, il riferimento macro speciale $? viene sostituito dai nomi
di quei nomi di file di dipendenza che sono stati aggiornati da quando è stato creato il target corrente
è stato derivato. Poiché la forma basa la sua decisione se derivare sul concetto di
derivazione chiave, piuttosto che semplici timestamp di modifica dei file, il ? la macro non può
essere definito correttamente. Invece, la forma sostituisce l'intero elenco di dipendenze
nomi - aggiornati o meno.

Utilizzare la forma online utilizzando i servizi onworks.net