makedepf90 - Online en la nube

PROGRAMA:

NOMBRE

makedepf90: crea una lista de dependencias Makefile para los archivos fuente de Fortran.

SINOPSIS

hacerdepf90 [-h] [-V] [-W|-Wmissing] [-Confundido] [-m fmt] [-u Nombre del módulo] [-d presentar] [-r
gobernar] [-R presentar gobernar] [-fijo|Sin] [-o nombre-del-ejecutable] [-Coco] [-D NOMBRE] [-b camino]
[-I RUTA1: RUTA2: ...] [-nosrc] archivos fuente)

DESCRIPCIÓN

hacerdepf90 es un programa para la creación automática de listas de dependencias y reglas de compilación
para Makefiles.

La idea original era proporcionar la misma funcionalidad para Fortran que

gcc -MM * .c

hace para C. Hoy en día, makedepf90 reemplaza esta funcionalidad, lo que me hace preguntarme
si debo extender makedepf90 para que sea compatible con C y C ++ también ;-).

hacerdepf90 apoya a ambos módulos, incluir:s, cpp(1) #incluir:s, f90ppr(1) $ incluir:arena
Coco(1) ?? incluye y archivos de configuración.

hacerdepf90 lee los archivos fuente de Fortran proporcionados en la línea de comando y escribe una dependencia
lista a salida estándar; para cada archivo escribe una línea con el siguiente formato:

tiene como objetivo : requisitos previos

Orden de Targets o Metas son los archivos que serán el resultado de compilar el archivo con el -c opción,
y requisitos previos son archivos necesarios para compilar el archivo. Además, hacerdepf90
Opcionalmente, puede crear la línea de dependencia y la regla de creación necesaria para vincular la
ejecutable.

Fortran dependencias
Los archivos necesarios para compilar un archivo, es decir, el requisitos previos del archivo son:

- El archivo fuente en sí

- Archivos con información de interfaz sobre módulos USEd, creados por el compilador mientras
compilar los módulos (a menudo llamados Nombre del módulo.mod o algo similar, en adelante
, que son archivos mod).

- Incluir archivos (incluidos los archivos incluidos y los archivos mod de los módulos UTILIZADOS de estos
incluir-archivos).

- Coco set-files, si Coco(1) se está utilizando y existen archivos de configuración.

Dado que los diferentes compiladores usan diferentes convenciones de nomenclatura para los archivos mod, enumerarlos
en la lista de dependencias da como resultado archivos MAKE no portátiles. Por lo tanto, es una práctica común
para listar el archivo objeto (nombre de archivo.o) correspondiente al archivo fuente que contiene el USEd
módulos en su lugar. Este es el comportamiento predeterminado de hacerdepf90. Para cambiar esto, use el -m
opción (p. ej. -m "% m.mod" si su compilador nombra los archivos mod Nombre del módulo.modificación)

Los archivos incluidos que no se encuentran en el directorio de trabajo no se incluirán en la dependencia
lista, asumiendo que son parte de una biblioteca (que rara vez cambia) que no forma parte del programa.
Tampoco los archivos mod de módulos cuyas definiciones no se encuentran serán listados por el mismo
razón.

OPCIONES

Estas opciones se pueden dar en cualquier lugar, en cualquier orden, en la línea de comando. Espacio entre un
opción y su argumento es opcional. Las opciones no pueden agruparse (-hw no es lo mismo
cosa como -h -W).

-h or --ayuda
Imprima un breve mensaje de ayuda para stdout y salga.

-V or --versión
Imprima la versión y la información de derechos de autor para stdout y salga

-W or -Wmissing
Imprima advertencias sobre módulos faltantes e incluya archivos

-Confundido
Imprima advertencias cuando se confunda (ya sea debido a errores en el propio makedepf90 o
debido a cosas extrañas en sus archivos fuente). Si makedepf90 pierde algunos
dependencias, o hacer otras cosas extrañas, esta opción puede dar una idea de lo que
pasando.

-m fmt Tell hacerdepf90 que los archivos mod tendrán nombres del formato fmt. fmt puede contener
los modificadores %f para nombre de archivo (sin nombre de archivo .sufijo), %m para Nombre del módulo (en
minúsculas), %M para NOMBRE DEL MÓDULO (en mayúsculas) y %% por '%'. El valor predeterminado es "% fo".

-u Nombre del módulo
Ignorar todos los módulos nombrados Nombre del módulo.

-d presentar
Hacer que todos los objetivos dependan de presentar.

-r gobernar
Agregar gobernar (sangrado por una tabulación) a todas las líneas de dependencia excepto las líneas con regla (s)
con el -R .

gobernar puede contener los siguientes modificadores: %f para el nombre del archivo fuente
(sin sufijo) la línea de dependencia se crea para, y %% por '%'.

-R 'patrón' 'regla'
Compilar archivos que coincidan con el patrón de shell patrón usando la regla gobernar. En patrón,
se pueden utilizar los siguientes comodines: * = cualquier número de caracteres, ? = cualquiera
personaje y [a B C] = cualquiera de a, b or c. Tenga en cuenta que la coincidencia de patrones debe ser
interpretado por hacerdepf90, no el caparazón. Por lo tanto patrón debe estar encerrado en
citas (" or '). por gobernar aplica las mismas reglas que para -r anterior.

Tenga en cuenta que existe una sutil diferencia entre "-r gobernar"Y"-R '*' gobernar". En el
caso anterior gobernar se aplicará solo a las líneas a las que no se les haya dado ninguna regla utilizando -R, mientras
En este último caso, gobernar se aplicará a que todas líneas.

-fijo / Sin
Trate los archivos como formato de fuente fija / libre. Si se dan ambas opciones, la última
se utiliza. Predeterminado: archivos con sufijos .F, .F, .por, .POR or .ftn son tratados como
formato fijo y .f90, .F90, .f95 or .F95 se tratan como formato libre.

-o nombre
Esta opción causará hacerdepf90 para definir la macro Makefile FOBJ=archivos de objetos,
y una línea de dependencia + regla para el proceso de vinculación final para crear el ejecutable
nombre . Para establecer la regla de vinculación, use la opción -l.

-l gobernar
Utilice gobernar al vincular el ejecutable. El valor predeterminado es
$ (FC) -o $@ $ (FFLAGS) $ (LDFLAGS) $ (FOBJ) $ (LIBS).
Esta opción no tiene ningún efecto a menos que -o se utiliza.

-Coco Busque Coco(1) archivos de configuración (Coco ?? include: s se admiten automáticamente). Esta
la opción implica Sin.

-D NOMBRE
Definir el símbolo del preprocesador NOMBRE.

-b camino
El árbol de dependencia y la regla de enlace supondrán que los objetos se colocan en camino. Es
útil si la compilación coloca los archivos de objeto en un directorio diferente al de origen
archivos.

-I lista-de-rutas
Busque archivos de origen / inclusión en el lista-de-rutas, si no se encuentra en el trabajo actual
directorio. Aquí, lista-de-rutas es una lista de nombres de ruta separados por dos puntos.

-nosrc No incluya el archivo de origen entre los requisitos previos.

EJEMPLOS

Básico Uso
Aquí hay un ejemplo de básico hacerdepf90 uso junto con “piensen de nuevo sobre los incrementos de precio”(1). Crea un archivo llamado
Makefile con los siguientes contenidos:

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

# FC = el compilador a usar
FC = f90

# Opciones del compilador
FFLAGS = -O

# Enumere las bibliotecas utilizadas por el programa aquí
LIBS =

# Suffix-rules: Empiece por desechar todos los sufijos antiguos.
# reglas, y luego crea nuevas para compilar
# * .f90-archivos.
.SUFIJOS:
.SUFIJOS: .f90 .o

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

# Incluya la lista de dependencias creada por makedepf90 a continuación
incluir .depend

# objetivo 'limpio' para eliminar objeto- * .mod- y otros
# archivos no deseados
limpiar:
rm -f * .o * .mod core

# Cree una lista de dependencias usando makedepf90. Todos los archivos
# que debe compilarse para construir el programa,
# es decir, todos los archivos de origen, excepto los archivos de inclusión, deben
# se dará en la línea de comando para makedepf90.
#
# El argumento de la opción '-o' será el nombre del
# programa resultante al ejecutar 'make', en este caso
# 'foobar'
dependen .depend:
makedepf90 -o foobar * .f90> .depend

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

(Tenga en cuenta que todas las líneas sangradas deben estar sangradas con tabulaciones, no con espacios)

Con este archivo MAKE, el comando “piensen de nuevo sobre los incrementos de precio” debe realizar todos los comandos necesarios para compilar y
vincular el programa Foobar de todos los archivos * .f90 en el directorio de trabajo.

La lista de dependencias .depender será (re) creado si .depender no existe, o si el
comando “piensen de nuevo sobre los incrementos de precio” depender se ejecuta. Esto debe hacerse cada vez que se realicen cambios en el
programa que afecta a las dependencias de los archivos (por ejemplo, si se han agregado nuevos archivos fuente
al proyecto).

Ejemplo Con Coco
Si está utilizando un preprocesador, las cosas pueden complicarse más. Si tienes suerte,
su compilador es compatible con su preprocesador y lo ejecuta en su código automáticamente, pero si
no es así, debe dar los comandos para ejecutar el preprocesador usted mismo. A continuación se muestra un
ejemplo de un Makefile para Coco(1) -usuarios.

-----------------------
FC = f90
FFLAGS = -O
PREPROCESADOR = coco

.SUFIJOS:
.SUFIJOS: .f .f90 .o

# Los archivos que terminan en .f90 se compilan directamente ...
.f90.o:
$ (FC) -c $ (FFLAGS) $

# ... mientras que los que terminan en .f se preprocesan primero.
.fo:
$ (PREPROCESADOR) $ *; $ (FC) -c $ (FFLAGS) $ *. F90

incluir .depend

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

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

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

NOTA: Algunas implementaciones de “piensen de nuevo sobre los incrementos de precio”(1) no ejecutará ningún comando, ni siquiera “piensen de nuevo sobre los incrementos de precio” depender
- con los Makefiles anteriores a menos que exista un archivo llamado .depender. Para superar esto
problema, ya sea ejecutar hacerdepf90 manualmente, o comience creando un vacío .depender archivo con
el comando contacto .depender.

La diagnostica

La mayoría de los mensajes de error y advertencia se explican por sí mismos, pero algunos de ellos pueden necesitar algunos
más explicaciones:

ADVERTENCIA: recursividad límitar alcanzado in presentar nombre de archivo
Cuando se analizan recursivamente archivos de inclusión, makedepf90 ha alcanzado el límite de recursividad.
Las posibles razones son: o tiene algunos realmente sistemas complicados de incluir
archivos, o tiene inclusiones recursivas (por ejemplo, un archivo de inclusión que se incluye a sí mismo).
En este último caso; arréglalo, a tu compilador de Fortran tampoco le gustará.

Utilice makedepf90 en línea utilizando los servicios de onworks.net