makedepf90 - Online na nuvem

PROGRAMA:

NOME

makedepf90 - cria uma lista de dependências Makefile para arquivos fonte Fortran.

SINOPSE

makedepf90 [-h] [-V] [-W|-A saudade] [-Confuso] [-m fmt] [-u nome do módulo] [-d lima] [-r
governar] [-R lima governar] [-fixo|-livre] [-o nome-do-executável] [-coco] [-D NOME] [-b caminho]
[-I PATH1: PATH2: ...] [-nosrc] Arquivos Fonte)

DESCRIÇÃO

makedepf90 é um programa para a criação automática de listas de dependências e regras de compilação
para Makefiles.

A ideia original era fornecer a mesma funcionalidade para Fortran que

gcc -MM * .c

faz para C. Hoje em dia o makedepf90 realmente substitui essa funcionalidade, me fazendo pensar
se eu deveria estender makedepf90 para suportar C e C ++ também ;-).

makedepf90 suporta ambos módulos, incluir: s, cpp(1) #include: s, f90ppr(1) $ incluir:areia
coco(1) ?? inclui e set-files.

makedepf90 lê arquivos de origem Fortran fornecidos na linha de comando e grava uma dependência
lista para saída padrão; para cada arquivo, ele grava uma linha com o seguinte formato:

tem como alvo : pré-requisitos

Alvos são os arquivos que serão o resultado da compilação do arquivo com o -c opção,
e pré-requisitos são arquivos necessários para compilar o arquivo. Além disso, makedepf90
pode, opcionalmente, criar a linha de dependência e a regra de criação necessária para vincular o
executável.

Fortran dependências
Os arquivos necessários para compilar um arquivo, ou seja, o pré-requisitos do arquivo são:

- O próprio arquivo de origem

- Arquivos com informações de interface sobre módulos USEd, criados pelo compilador enquanto
compilar os módulos (frequentemente chamados nome do módulo.mod ou algo semelhante, daqui em diante
chamado arquivos mod).

- Arquivos incluídos (incluindo arquivos incluídos e arquivos mod dos módulos USEd destes
incluir arquivos).

- Coco set-files, se coco(1) está sendo usado e os arquivos de configuração existem.

Uma vez que diferentes compiladores usam diferentes convenções de nomenclatura para os arquivos mod, listá-los
na lista de dependências resulta em makefiles não portáteis. Portanto, é uma prática comum
para listar o arquivo objeto (nome do arquivo.o) correspondente ao arquivo-fonte contendo o USEd
módulos em vez disso. Este é o comportamento padrão de makedepf90. Para mudar isso, use o -m
opção (por exemplo -m "% m.mod" se o seu compilador nomear os arquivos mod nome do módulo.mod)

Incluir arquivos não encontrados no diretório de trabalho não serão listados na dependência
lista, supondo que eles façam parte de uma biblioteca (que raramente muda) que não faz parte do programa.
Nem os arquivos mod de módulos cujas definições não foram encontradas serão listados pelo mesmo
razão.

OPÇÕES

Essas opções podem ser fornecidas em qualquer lugar, em qualquer ordem, na linha de comando. Espaço entre um
opção e seu argumento é opcional. As opções não podem ser agrupadas (-hW Não é a mesma coisa
coisa como -h -W).

-h or --Socorro
Imprima uma mensagem curta de ajuda para stdout e saia.

-V or --versão
Versão impressa e informações de direitos autorais para stdout e sair

-W or -A saudade
Imprimir avisos sobre módulos ausentes e incluir arquivos

-Confuso
Imprimir avisos quando estiver confuso (por causa de bugs no próprio makedepf90, ou
por causa de coisas estranhas em seus arquivos de origem). Se makedepf90 perder algum
dependências, ou fazer outras coisas estranhas, esta opção pode dar alguma idéia sobre o que
acontecendo.

-m fmt Avisar makedepf90 que os arquivos mod terão nomes do formato fmt. fmt pode conter
os modificadores %f para nome do arquivo (sem nome de arquivo .suffix), %m para nome do módulo (em
minúsculas), %M para NOME DO MÓDULO (em maiúsculas) e %% para '%'. O padrão é "% fo".

-u nome do módulo
Ignorar todos os módulos nomeados nome do módulo.

-d lima
Tornar todos os alvos dependentes de lima.

-r governar
Adicionar governar (recuado por uma tabulação) para todas as linhas de dependência, exceto linhas dadas regra (s)
com o -R opção.

governar pode conter os seguintes modificadores: %f para o nome do arquivo fonte
(sem sufixo) a linha de dependência é criada para, e %% para '%'.

-R 'padronizar' 'regra'
Compilar os arquivos que correspondem ao padrão do shell de cinto de segurança usando a regra governar. em de cinto de segurança,
os seguintes curingas podem ser usados: * = qualquer número de quaisquer caracteres, ? = qualquer
personagem e [abc] = qualquer um de a, b or c. Observe que a correspondência de padrões deve ser
executado por makedepf90, não a concha. Portanto de cinto de segurança deve ser colocado em
citações (" or '). Para governar aplica as mesmas regras que para -r acima.

Observe que há uma diferença sutil entre "-r governar"E"-R '*' governar". No
ex caso governar será aplicado apenas a linhas sem qualquer regra usando -R, enquanto
no último caso, governar será aplicado a todos os Linhas.

-fixo / -livre
Trate os arquivos como formato de origem fixa / livre. Se ambas as opções forem fornecidas, a última
é usado. Padrão: arquivos com sufixos .f, .F, .para, .PARA or .ftn são tratados como
formato fixo e .f90, .F90, .f95 or .F95 são tratados como formato livre.

-o nome
Esta opção irá causar makedepf90 para definir a macro Makefile FOBJ=arquivos de objetos,
e uma linha de dependência + regra para o processo de ligação final para criar o executável
nome. Para definir a regra de vinculação, use a opção -l.

-l governar
Use governar ao vincular o executável. O padrão é
$ (FC) -o $@ $ (FFLAGS) $ (LDFLAGS) $ (FOBJ) $ (LIBS).
Esta opção não tem efeito a menos -o é usado.

-coco Procurar coco(1) arquivos de conjunto (coco ?? incluem: s são suportados automaticamente). Esse
opção implica -livre.

-D NOME
Defina o símbolo do pré-processador NOME.

-b caminho
A árvore de dependência e a regra de link irão assumir que os objetos são colocados em caminho. Isto é
útil se a construção colocar os arquivos de objeto em um diretório diferente do de origem
arquivos.

-I lista de caminhos
Procure por arquivos de origem / inclua no lista de caminhos, se não for encontrado no trabalho atual
diretório. Aqui, lista de caminhos é uma lista separada por dois pontos de nomes de caminhos.

-nosrc Não liste o arquivo de origem entre os pré-requisitos.

EXEMPLOS

Basico Uso
Aqui está um exemplo de base makedepf90 uso junto com fazer(1). Crie um arquivo chamado
Makefile com o seguinte conteúdo:

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

# FC = o compilador a ser usado
FC = f90

# Opções do compilador
FFLAGS = -O

# Liste as bibliotecas usadas pelo programa aqui
LIBS =

# Suffix-rules: Comece jogando fora todos os sufixos antigos-
# regras e, em seguida, crie novas para compilar
# * .f90-files.
.SUFIXOS:
.SUFIXOS: .f90 .o

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

# Incluir a lista de dependências criada por makedepf90 abaixo
incluir .depend

# target 'clean' para exclusão de objeto- * .mod- e outro
# arquivos indesejados
limpar \ limpo:
núcleo rm -f * .o * .mod

# Crie uma lista de dependências usando makedepf90. Todos os arquivos
# que precisa ser compilado para construir o programa,
# isto é, todos os arquivos de origem, exceto os de inclusão, devem
# ser fornecido na linha de comando para makedepf90.
#
# O argumento para a opção '-o' será o nome do
# programa resultante ao executar 'make', neste caso
# 'foobar'
depende .depende:
makedepf90 -o foobar * .f90> .depend

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

(Observe que todas as linhas recuadas devem ser recuadas com tabulações, não espaços)

Com este makefile, o comando fazer deve executar todos os comandos necessários para compilar e
ligue o programa foobar de todos os arquivos * .f90 no diretório de trabalho.

A lista de dependências .depender será (re) criado se .depender não existe, ou se o
comando fazer depender é executado. Isso deve ser feito sempre que mudanças forem feitas no
programa que afeta as dependências dos arquivos (por exemplo, se novos arquivos de origem foram adicionados
para o projeto).

Exemplo Com o Coco
Se você estiver usando um pré-processador, as coisas podem ficar mais complicadas. Se você é sortudo,
seu compilador suporta seu pré-processador e o executa em seu código automaticamente, mas se
não faz, você tem que dar os comandos para rodar o pré-processador você mesmo. Abaixo está um
exemplo de um Makefile para coco(1) -usuários.

-----------------------
FC = f90
FFLAGS = -O
PREPROCESSOR = coco

.SUFIXOS:
.SUFIXOS: .f .f90 .o

# Arquivos que terminam em .f90 são compilados diretamente ...
.f90.o:
$ (FC) -c $ (FFLAGS) $

# ... enquanto aqueles que terminam em .f são pré-processados ​​primeiro.
.fo:
$ (PREPROCESSADOR) $ *; $ (FC) -c $ (FFLAGS) $ *. F90

incluir .depend

limpar \ limpo:
núcleo rm -f * .o * .mod

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

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

NOTA: Algumas implementações de fazer(1) não executará nenhum comando - nem mesmo fazer depender
- com os Makefiles acima, a menos que exista um arquivo chamado .depender. Para superar isso
problema, quer correr makedepf90 manualmente, ou comece criando um vazio .depender arquivo com
o comando tocar .depender.

DIAGNÓSTICO

A maioria das mensagens de erro e aviso são autoexplicativas, mas algumas delas podem precisar de algum
mais explicações:

AVISO: recursão limitar alcançado in lima nome do arquivo
Ao analisar recursivamente os arquivos de inclusão, makedepf90 atingiu o limite de recursão.
Os possíveis motivos são: ou você tem algum clientes sistemas complicados de incluir
arquivos, ou você tem inclusões recursivas (por exemplo, um arquivo de inclusão que inclui a si mesmo).
No último caso; conserte, seu compilador Fortran também não gostará.

Use makedepf90 online usando serviços onworks.net