makedepf90 - Online nel cloud

PROGRAMMA:

NOME

makedepf90 - crea un elenco di dipendenze Makefile per i file sorgente Fortran.

SINOSSI

makedepf90 [-h] [-V] [-W|-Mancante] [-Wconfuso] [-m FMT] [-u nomemodulo] [-d filetto] [-r
regola] [-R filetto regola] [-fisso|Senza] [-o nome-di-eseguibile] [-cocco] [-D NOME] [-b sentiero]
[-I PERCORSO1:PERCORSO2:...] [-nosrc] file sorgenti)

DESCRIZIONE

makedepf90 è un programma per la creazione automatica di liste di dipendenze e regole di compilazione
per Makefile.

L'idea originale era di fornire la stessa funzionalità per Fortran come

gcc -MM *.c

fa per C. Al giorno d'oggi makedepf90 sostituisce effettivamente questa funzionalità, facendomi domandare
se dovessi estendere makedepf90 per supportare anche C e C++ ;-).

makedepf90 supporta entrambi moduli, includere:S, cpp(1) #includere:S, f90pp(1) $ incl:sabbia
cocco(1) ??include e set-file.

makedepf90 legge i file sorgente Fortran forniti sulla riga di comando e scrive una dipendenza
lista allo stdout; per ogni file scrive una riga con il seguente formato:

obiettivi : prerequisiti

Obiettivi sono i file che saranno il risultato della compilazione del file con il -c opzione,
che a prerequisiti sono file necessari per compilare il file. Inoltre, makedepf90
può opzionalmente creare la linea di dipendenza e la regola necessaria per collegare il finale
eseguibile.

Fortran dipendenze
I file necessari per compilare un file, ovvero il prerequisiti del file sono:

- Il file sorgente stesso

- File con informazioni di interfaccia sui moduli USEd, creati dal compilatore mentre
compilare i moduli (spesso chiamati nomemodulo.mod o qualcosa di simile, in seguito
detto file-mod).

- File di inclusione (inclusi i file inclusi e i file di modifica dei moduli UTILIZZATI da questi
include-file).

- Coco file-set, se cocco(1) è in uso ed esistono file di set.

Poiché diversi compilatori utilizzano convenzioni di denominazione diverse per i file mod, elencarli
nell'elenco delle dipendenze risulta in makefile non portabili. Quindi è pratica comune
per elencare il file oggetto (Nome del file.o) corrispondente al file sorgente contenente l'USEd
moduli invece. Questo è il comportamento predefinito di makedepf90. Per cambiarlo, usa il -m
opzione (es -m "%m.mod" se il tuo compilatore nomina i file mod nomemodulo.mod)

I file di inclusione non trovati nella directory di lavoro non verranno elencati nella dipendenza
list, assumendo che facciano parte di una libreria (che cambia raramente) non parte del programma.
Né i file mod dei moduli le cui definizioni non vengono trovate saranno elencati dallo stesso
ragionare.

VERSIONI

Queste opzioni possono essere fornite ovunque, in qualsiasi ordine, sulla riga di comando. Spazio tra an
opzione e il suo argomento è facoltativo. Le opzioni non possono essere raggruppate (-hw non è lo stesso
cosa come -h -W).

-h or --Aiuto
Stampa un breve messaggio di aiuto su stdout ed esci.

-V or --versione
Stampa la versione e le informazioni sul copyright su stdout ed esci

-W or -Mancante
Stampa avvisi sui moduli mancanti e includi file

-Wconfuso
Stampa avvisi quando è confuso (a causa di bug in makedepf90 stesso o
a causa di cose strane nei tuoi file sorgente). Se a makedepf90 manca qualcosa
dipendenze, o fare altre cose strane, questa opzione potrebbe dare un'idea di cosa?
in corso.

-m FMT Dire makedepf90 che i file mod avranno i nomi del formato FMT. FMT potrebbe contenere
i modificatori %f per Nome del file (senza nome file .suffisso), %m per nomemodulo (in
minuscolo), %M per NOMEMODULO (in maiuscolo) e %% per '%'. Il valore predefinito è "%fo".

-u nomemodulo
Ignora tutti i moduli nominati nomemodulo.

-d filetto
Rendi tutti i bersagli dipendenti da filetto.

-r regola
Aggiungi regola (rientrato da una tabulazione) a tutte le linee di dipendenza eccetto le linee date le regole
con la -R opzione.

regola può contenere i seguenti modificatori: %f per il nome del file sorgente
(senza suffisso) viene creata la linea di dipendenza per, e %% per '%'.

-R 'modello' 'regola'
Compila i file che corrispondono al modello della shell modello usando la regola regola. in modello,
possono essere utilizzati i seguenti caratteri jolly: * = qualsiasi numero di qualsiasi carattere, ? = qualsiasi
carattere e [ABC] = qualsiasi di a, b or c. Si noti che l'abbinamento dei modelli deve essere
eseguito da makedepf90, non il guscio. Perciò modello dovrebbe essere racchiuso in
citazioni (" or '). Per regola applica le stesse regole di -r sopra.

Nota che c'è una sottile differenza tra "-r regola" e "-R '*' regola". Nel
caso precedente regola verrà applicato solo alle righe a cui non è stata assegnata alcuna regola utilizzando -R mentre la lavorazione del prodotto finito avviene negli stabilimenti del nostro partner
nel secondo caso, regola verrà applicato a contro tutti i Linee.

-fisso / Senza
Tratta i file come formato sorgente fisso/libero. Se vengono date entrambe le opzioni, quest'ultima
viene utilizzato. Predefinito: file con suffissi .F, .F, .per, .PER or .ftn sono trattati come
formato fisso e .f90, .F90, .f95 or .F95 sono trattati come formato libero.

-o Nome
Questa opzione causerà makedepf90 per definire la macro Makefile FOBJ=file oggetto,
e una linea di dipendenza + regola per il processo di collegamento finale per creare l'eseguibile
Nome. Per impostare la regola di collegamento, usa l'opzione -l.

-l regola
Usa il regola quando si collega l'eseguibile. L'impostazione predefinita è
$(FC) -o $@ $(FLAGS) $(LDFLAG) $(FOBJ) $(librerie).
Questa opzione non ha effetto a meno che -o viene utilizzato.

-cocco Cercare cocco(1) set-file (cocco ??include:s sono supportati automaticamente). Questo
opzione implica Senza.

-D NOME
Definire il simbolo del preprocessore NOME.

-b sentiero
L'albero delle dipendenze e la regola di collegamento presumeranno che gli oggetti siano posizionati dentro sentiero. Questo è
utile se la build posiziona i file oggetto in una directory diversa da quella sorgente
File.

-I lista-di-percorsi
Cerca i file sorgente/include nel lista-di-percorsi, se non trovato nell'attuale funzionamento
directory. Qui, lista-di-percorsi è un elenco separato da due punti di nomi di percorso.

-nosrc Non elencare il file sorgente tra i prerequisiti.

ESEMPI

Basic Impiego
Ecco un esempio di base makedepf90 utilizzo insieme a make(1). Crea un file chiamato
Makefile con i seguenti contenuti:

----------------------

# FC = il compilatore da usare
FC=f90

# Opzioni del compilatore
FLAG=-O

# Elenca qui le librerie utilizzate dal programma
LIBRI=

# Regole sui suffissi: inizia buttando via tutti i vecchi suffissi-
# regole, quindi crearne di nuove per la compilazione
# *.f90-file.
.SUFFISSI:
.SUFFISSI: .f90 .o

.f90.o:
$(FC) -c $(FFLAGS) $

# Includere l'elenco delle dipendenze creato da makedepf90 di seguito
includi .dipende

# target 'clean' per eliminare object- *.mod- e altro
# file indesiderati
pulito:
rm -f *.o *.mod core

# Crea un elenco di dipendenze usando makedepf90. Tutti i files
# che deve essere compilato per compilare il programma,
# cioè tutti i file sorgente tranne i file include, dovrebbero
# essere dato sulla riga di comando a makedepf90.
#
# L'argomento dell'opzione '-o' sarà il nome del
# programma risultante durante l'esecuzione di 'make', in questo caso
# 'foobar'
dipende .dipende:
makedepf90 -o foobar *.f90 > .depend

-----------------------

(Nota che tutte le righe rientrate dovrebbero essere rientrate con tabulazioni, non spazi)

Con questo makefile, il comando make dovrebbe eseguire tutti i comandi necessari per compilare e
linka il programma foobar tra tutti i file *.f90 nella directory di lavoro.

L'elenco delle dipendenze .dipendere sarà (ri)creato se .dipendere non esiste, o se il
command make dipendere viene eseguito. Questo dovrebbe essere fatto ogni volta che sono state apportate modifiche al
programma che influenza le dipendenze dei file (ad esempio se sono stati aggiunti nuovi file sorgente
al progetto).

Esempio Con Coco
Se stai usando un pre-processore, le cose potrebbero diventare più complicate. Se sei fortunato,
il tuo compilatore supporta il tuo preprocessore e lo esegue automaticamente sul tuo codice, ma se
non è così, devi dare i comandi per eseguire tu stesso il pre-processore. Di seguito è riportato un
esempio di Makefile per cocco(1)-utenti.

-----------------------
FC=f90
FLAG=-O
PREPROCESSORE=cocco

.SUFFISSI:
.SUFFISSI: .f .f90 .o

# I file che terminano con .f90 vengono compilati direttamente ...
.f90.o:
$(FC) -c $(FFLAGS) $

# ... mentre quelli che terminano con .f vengono preelaborati per primi.
.ns:
$(PREPROCESSORE) $*; $(FC) -c $(FFLAGS) $*.f90

includi .dipende

pulito:
rm -f *.o *.mod core

dipende .dipende:
makedepf90 -coco -o foobar *.f90 *.f > .depend

-----------------------

NOTA: Alcune implementazioni di make(1) non eseguirà alcun comando, nemmeno make dipendere
— con i Makefile sopra a meno che non esista un file chiamato .dipendere. Per superare questo
problema, o corri makedepf90 manualmente o inizia creando un vuoto .dipendere file con
il comando toccare .dipendere.

DIAGNOSTICA

La maggior parte dei messaggi di errore e di avviso sono autoesplicativi, ma alcuni potrebbero averne bisogno
ulteriori spiegazioni:

ATTENZIONE: ricorsione limitare a raggiunto in filetto Nome del file
Quando si analizzano ricorsivamente i file include, makedepf90 ha raggiunto il limite di ricorsione.
Le possibili ragioni sono: o ne hai qualcuna veramente complicati sistemi di inclusione
file o si dispone di include ricorsive (ad esempio un file di inclusione che include se stesso).
Nel secondo caso; correggilo, non piacerà nemmeno al tuo compilatore Fortran.

Usa makedepf90 online utilizzando i servizi onworks.net