jmake - Online nel cloud

PROGRAMMA:

NOME

jmake - un generatore di makefile generico

SINOSSI

jmake [ cpp Opzioni ]

DESCRIZIONE

Jmake costruisce un makefile da una descrizione di livello piuttosto alto contenuta in a Jmakefile file.
Il file generato è a Makefile.SH piuttosto che un semplice makefile, il che significa che è pronto
da usare insieme a metaconfig. In particolare, parametri come "dove
install executables" sarà determinato automaticamente da Configurazione e solo il necessario
si terrà conto dei parametri.

Per utilizzare jmake devi scrivere a Jmakefile primo, che descrive il modo in cui le cose devono essere
costruito. Tuo Jmakefile sarà incluso all'interno di un template generico attraverso il C pre-
processore. Ciò significa che puoi usare i soliti commenti C /**/, ma non la shell #
Commenti. I commenti C non appariranno nel file generato Makefile.SH ma le righe iniziano
con ;# appariranno finalmente come commenti di shell. Se devi scrivere la stringa /* nel
generato Makefile.SH allora devi scappare (altrimenti jmake lo penserà come il
inizio di un commento in C). Metti semplicemente un # davanti a *, come in /#*.

Hai una serie di macro a tua disposizione e tutte queste macro sono elencate nell'Indice
file, insieme al pezzo di codice in cui si espanderanno. Di solito, a Jmakefile è abbastanza
piccolo e quindi più facile da mantenere di un enorme Makefile. Alcuni potenti comandi interni
consentono di scrivere facilmente makefile portatili, senza dover spendere molti sforzi,
perché qualcun altro ha già fatto il lavoro per te :-).

Quando vuoi generare il tuo makefile, di solito non lo esegui jmake ma usa il jmkmf
script che è un wrapper e invocherà jmake con le opzioni corrette.

Tutta la conoscenza di jmake è contenuto in due file: il modello Jmake.tmpl e la macro
file di definizione Jmake.regole. Il primo file include il secondo, insieme al
Jmakefile. A volte è necessario sapere come funzionano le cose per poterle usare correttamente
tutte le funzionalità fornite. Ad esempio, potresti dover scrivere le tue regole per a
progetto specifico. Sebbene non sia possibile sovrascrivere le regole predefinite, è possibile estendere le
Jmake.regole file o semplicemente aggiungi le tue macro nel tuo Jmakefile. Puoi anche usare #includere
istruzioni quando si desidera condividere queste macro e non si desidera duplicare il codice.

La sintassi in Jmake.rules non è per niente elegante, ma:

- È facile da analizzare (come sendmail.cf o file troff).
- Le regole non dovrebbero cambiare molto spesso.
- È abbastanza semplice da padroneggiare in cinque minuti. :-)

Ecco una piccola descrizione:

1) Per affrontare vari cpp implementazioni:

· Final @!\ significa: fine della riga, la riga successiva inizia dal margine sinistro.
· Final @@\ significa: fine riga, la riga successiva deve essere rientrata di una tabulazione.

Ci dovrebbe sempre essere uno di @!\ o @@\ alla fine di ogni riga. Il solo
l'eccezione è per le macro che devono essere utilizzate come parte del corpo di una regola (ad es
Rimuovi programma di destinazione). In tal caso, la prima riga (che contiene la #define) dovrebbero
terminare con una sola barra rovesciata.

2) Definizioni dei simboli:

· >SIMBOLO: definisce il simbolo.
· ?SIMBOLO: : mantiene se SYMBOL è definito.
· %SIMBOLO: : mantiene se il SIMBOLO non è definito.

Il ?SYM può essere annidato (AND logico), come in:

?SIMBOLO:%TOKEN:testo

che manterrà il testo se SYMBOL è definito e TOKEN non è definito. Per implementare un
OR logico, vedere sotto.

3) Test di destinazione Makefile:

· ?bersaglio?: : mantiene se bersaglio è definito.
·%bersaglio%: : mantiene se bersaglio non è definito.

Un makefile bersaglio è definito come un obiettivo autonomo, ad esempio il
dipende.locale obiettivo, che sarebbe definito come:

dipendenza.locale:

Si noti inoltre che è valido solo per obiettivi definiti so lontano nel generato
makefile. Non è un predicato che può essere utilizzato per testare obiettivi che
sarà infine definito più avanti nella generazione.

4) Comandi:

I comandi possono essere passati a jmake. Iniziano con un '|' iniziale. Comandi disponibili
siamo:

· |suffisso : aggiunge alla lista .SUFFIXES: nel makefile.

· |regola: : aggiunge alla sezione regolamento edilizio.

· |regola: : come prima, con una tabulazione iniziale.

· |skip: salta il testo finché non viene trovata una riga che inizia con '-skip'.

· |subst: inizia la sezione in cui le righe saranno soggette a sostituzione variabile,
finché non viene trovato '-subst'. Ciò significa che quando viene eseguito il Makefile.SH, all
istanze di $var all'interno di subst la sezione sarà sostituita dalla shell.

· |shell: emette la sezione finché non corrisponde a '-shell' così com'è nel generato
Makefile.SH. Questo può essere utile per preparare |caso sezioni. Non è
permesso di nidificare conchiglia .

· |case: questo comando deve essere seguito dal nome di una variabile di shell (senza il suo
segno '$' iniziale) e un modello in stile case, ad esempio la stringa "var in
f*". Genererà il test "caso" corrispondente nel Makefile.SH on
il valore "$var" e solo se questo test è vero la sezione fino al
'-case' corrispondente viene generato nel Makefile quando viene eseguito Makefile.SH. Esso
è possibile nidificare Custodie sezioni liberamente.

· |espandi : espandi le righe fino a '-espandi' con . Un completo
l'esempio è mostrato di seguito.

· |una volta : il testo fino a '-once' appare solo la prima volta.

Il '|' i comandi non possono essere nidificati, se non diversamente specificato. In particolare, a causa di
la semplice implementazione di | salta, è impossibile mettere | salta all'interno di un saltato
parte. Tuttavia, a | una volta la sezione potrebbe avere | salta sezioni. È permesso nidificare
|caso sezioni a piacimento.

Ecco un modo per implementare un OR logico:

/* Implementa SYMBOL o non TOKEN */
?SYMBOL:text /* Mantiene il testo se SYMBOL */
%SYMBOL:|salta
%TOKEN:text /* Mantiene il testo se non TOKEN */
-Salta

In realtà, questo è brutto, perché il testo deve apparire due volte. Per fortuna l'ho fatto
non usare quel costrutto. :-)

Infatti, come avrai sicuramente già intuito, il modo migliore per implementare un OR logico
è usare la legge di De Morgan:

not (p o q) <=> non p e non q

/* Implementa SYMBOL o non TOKEN (tentativo #2) */
%SYMBOL:?TOKEN:|salta
testo /* Se SIMBOLO o non TOKEN */
-Salta

Chi ha detto che non gli importa della logica? ;-)

L'espansione viene eseguita con il espandere comando. È stato fornito per evitare alcuni
scritture ingombranti nei makefile quando devi ripetere alcune righe stupide che solo
differiscono nei nomi dei file, per esempio. Vediamo prima un esempio:

|espandi un!foo bar! b! si no!
!un::
eco !a, !b
-espandere

Quindi verranno stampate due regole e i valori di (a, b) per la prima saranno (pippo,
sì), per il secondo (bar, no). La sostituzione è controllata dal '!' carattere.
Se la parola da sostituire fa parte di un'altra, staccare con il costrutto ^^
come in: !b^^c. È possibile utilizzare le macro Makefile nel , e loro
sarà ampliato da jmake. Se questo non è quello che vuoi, evita il primo segno '$'
(questo è un escape Makefile, cioè devi raddoppiare il '$', non precederlo con a
barra rovesciata). A // sta per il valore di sostituzione nullo.
Il costrutto ^^^ si comporta come ^^, cioè viene rimosso, ma rimuove anche qualsiasi
dopo lo spazio bianco dopo ^^^. Se anteponi qualcosa a un argomento macro,
e quell'argomento macro è stato scritto con spazi prima di esso, quindi questo ti permetterà
concatena qualcosa subito prima del valore finale di quell'argomento.

Ecco un altro esempio che mostra come può essere utilizzata la macro Expand. è
definito in Jmake.regole come:

#define Expand(regola, modello) @!\
|espandi modello @!\
regola @!\
-espandere

Quindi possiamo scrivere in Jmakefile:

| salta
A = pippo bar
-Salta

#definisci la regola @!\
$(DIR)/!a^^.o: !a^^.o @@\
$(CC) -c !a^^.c @@\
$(MV) !a^^.o $(DIR)

Espandi(Regola, a!$(A)!)

che genererà in Makefile.SH:

$(DIR)/pippo.o: pippo.o
$(CC) -c pippo.c
$(MV) pippo.o $(DIR)

$(DIR)/bar.o: bar.o
$(CC) -c barra.c
$(MV) bar.o $$(DIR)

La dichiarazione "A" è stata circondata da Salta, in modo che non appaia nel
ha generato Makefile.SH, ma sarà preso in considerazione da jmake per l'
sostituzione nel modello.

Il numero di espansioni è determinato dal numero di possibili valori per il
prima di tutto parametro. Se altri parametri hanno meno valori di sostituzione, otterranno
quelli vuoti.

È possibile aggiungere un'espressione regolare alla fine di '-expand'. Questo regolare
l'espressione verrà rimossa dall'insieme finale di espansione alla fine di ogni riga.
È anche possibile effettuare sostituzioni nell'elemento espanso, utilizzando la sintassi
(se 'f' è la variabile espansa) !f:= where ed sono due regolari
espressioni (senza spazi). Il modello sarà sostituito dal modello
(verrà sostituita solo la prima occorrenza).

Infine, puoi fare riferimento nella sezione espansa alle variabili il cui valore è calcolato
tramite un'altra espansione, che facilita la definizione di generic Jmakefile.

Esempio:

SRC = foo.c bar.c
OGG = \
|espandi f!$(SRC)!
!f:\.c=\.o \
-espandi \\
INC = \
|espandi f!$(OBJ)!
!f:\.o=\.h \
-espandi \\

che genererà in Makefile.SH:

SRC = foo.c bar.c
OGG = \
pippo.o \
bar.o
INC = \
pippo.h \
bar.h

Non dimenticare di proteggere i caratteri speciali nelle espressioni regolari come
barra rovesciata, punto, ecc...

I una volta comando è contrassegnato con un nome. La prima volta che appare il nome, la volta
il costrutto viene ignorato e il testo fino a '-once' verrà copiato nel file generato
Makefile.SH. Tuttavia, le occorrenze future con lo stesso nome verranno ignorate (una volta
si comporterà come Salta).

Esempio:

|una volta che questo_è_un_nome

-una volta

I conchiglia Il comando può essere utilizzato per generare un frammento di shell nel Makefile.SH. Per
esempio, la seguente sezione nel Jmakefile:

|conchiglia
caso "$d_usegtk1" in
definisci) glib=1; gtk=1;;
che C
-conchiglia

causerà il calcolo della generazione del frammento racchiuso nel Makefile.SH
i valori di disinvolto ed gtk variabili basate sulla variabile di configurazione
d_usegtk1 impostato eseguendo Configura.

A sua volta, questo può essere utilizzato in seguito Custodie sezioni per attivare parti del
Makefile solo quando si compila per GTK1 usando glib-1.x:

|caso glib in 1
display:
echo "Costruire per glib-1.x"
-Astuccio

Questa sezione genererà qualcosa di simile nel Makefile.SH:

!NO!SOTTOSTANTI!
case "$glib" in
1)
$spitshell >>Makefile <<'!NO!SUBS!'
display:
echo "Costruire per glib-1.x"
!NO!SOTTOSTANTI!
;;
che C
$spitshell >>Makefile <<'!NO!SUBS!'

E quando si esegue Makefile.SH, la regola "display" sopra apparirà solo quando
edificio per glib-1.x. La forma della finale Makefile può quindi dipendere dal
opzioni di configurazione scelte quando Configurazione è stato eseguito.

5) Inizializzazioni:

· + : inserisce l'intera riga nella sezione di inizializzazione.
· ++SIMBOLO : Aggiunge alla macro SIMBOLO.

6) Variabili definite dall'utente:

L'utente può definire CFLAGS, LDFLAGS o DPFLAGS come flag aggiuntivi da utilizzare in C
compilazione, fase di collegamento o destinazione dipendente. È così possibile aggiungere qualche extra
flag come -I o librerie per Makefile in sottodirectory specifiche.

Usa jmake online usando i servizi onworks.net