Comando make de Linux
En Tipo Unix sistemas operativos, fabricar es un utilidad para construir y mantener grupos de programas (y otros tipos de archivos) del código fuente.
Esta página cubre el GNU / Linux versión de fabricar .
- Descripción
- Sintaxis
- Ejemplos de
- Comandos relacionados
- Ayuda de comandos de Linux
Descripción
El propósito de fabricar La utilidad es determinar automáticamente qué partes de un programa grande deben volver a compilado y emitir los comandos necesarios para volver a compilarlos. Esta documentación describe la implementación GNU de fabricar , que fue escrito por Richard Stallman y Roland McGrath, y actualmente es mantenido por Paul Smith. Muchos de los ejemplos que se enumeran a continuación muestran C programas, ya que son los más comunes, pero puede utilizar fabricar con cualquier lenguaje de programación cuyo compilador se pueda ejecutar con un comando de shell. De echo, fabricar no se limita a los programas. Puede usarlo para describir cualquier tarea en la que algunos archivos deban actualizarse automáticamente desde otros siempre que los otros cambien.
Prepararse para usar fabricar , debe escribir un archivo llamado makefile que describe las relaciones entre los archivos de su programa y establece los comandos para actualizar cada archivo. En un programa, normalmente el archivo ejecutable se actualiza a partir de archivos objeto, que a su vez se crean compilando fuente archivos.
Una vez que existe un archivo MAKE adecuado, cada vez que cambie algunos archivos fuente, este sencillo comando de shell:
|_+_|es suficiente para realizar todas las recopilaciones necesarias. La fabricar El programa utiliza la base de datos de archivos MAKE y los tiempos de última modificación de los archivos para decidir cuál de los archivos necesita actualizarse. Para cada uno de esos archivos, emite los comandos registrados en la base de datos.
fabricar ejecuta comandos en el archivo MAKE para actualizar uno o más nombres de destino, donde nombre es típicamente un programa. Si no -F la opción está presente, fabricar buscará los archivos MAKE GNUmakefile , makefile , y Makefile , en ese orden.
Normalmente deberías llamar a tu archivo MAKE makefile o Makefile . (El nombre recomendado oficialmente es Makefile porque aparece de manera prominente cerca del comienzo de un directorio listado, cerca de otros archivos importantes como README .) El primer nombre marcado, GNUmakefile , no se recomienda para la mayoría makefiles . Debe usar este nombre si tiene un archivo MAKE específico de GNU. fabricar , y no será entendido por otras versiones de fabricar . Si makefile es un guión (' - '), la entrada estándar es leído.
fabricar actualiza un destino si depende de los archivos de requisitos previos que se han modificado desde la última modificación del destino, o si el destino no existe.
Sintaxis
|_+_|Opciones
| -b , -metro | Estas opciones se ignoran, pero se incluyen por compatibilidad con otras versiones de fabricar . |
| -B , - siempre-hacer | Haz incondicionalmente todos los objetivos. |
| -C para ti , --directory = para ti | Cambiar a directorio para ti antes de leer los archivos MAKE o hacer cualquier otra cosa. Si es múltiple -C se especifican opciones, cada una se interpreta en relación con la anterior: -C / -C, etc. es equivalente a -C / etc . Esto se usa típicamente con recursivo invocaciones de fabricar . |
| -D | Imprime información de depuración además del procesamiento normal. La información de depuración dice qué archivos se están considerando para rehacer, qué tiempos de archivo se están comparando y con qué resultados, qué archivos realmente necesitan rehacerse, qué reglas implícitas se consideran y cuáles se aplican; todo lo interesante sobre como fabricar decide qué hacer. |
| --depurar [ = BANDERAS] | Imprime información de depuración además del procesamiento normal. Si se omiten las BANDERAS, entonces el comportamiento es el mismo que si -D fue especificado. LAS BANDERAS pueden ser a para toda la salida de depuración (igual que usar -D ), b para depuración básica, v para una depuración básica más detallada, I por mostrar reglas implícitas, j para obtener detalles sobre la invocación de comandos, y metro para depurar mientras se rehacen los archivos MAKE. |
| -es , --environment-overrides | Dar variables tomadas de la ambiente precedencia sobre las variables de los archivos MAKE. |
| -F expediente , --file = expediente , --makefile = expediente | Usar expediente como un archivo MAKE. |
| -I , --ignore-errors | Ignore todos los errores en los comandos ejecutados para rehacer archivos. |
| -I para ti , --include-dir = para ti | Especifica un directorio para ti para buscar archivos MAKE incluidos. Si varios -I Las opciones se utilizan para especificar varios directorios, los directorios se buscan en el orden especificado. A diferencia de los argumentos de otras banderas de fabricar , directorios dados con -I las banderas pueden ir directamente después de la bandera: -I para ti está permitido, así como -I para ti . Esta sintaxis está permitida por compatibilidad con el preprocesador de C -I bandera. |
| -j [ trabajos ], --trabajos [ = trabajos ] | Especifica el número de trabajos (comandos) para que se ejecuten simultáneamente. Si hay mas de uno -j opción, la última es efectiva. Si el -j la opción se da sin un argumento, fabricar no limitará la cantidad de trabajos que se pueden ejecutar simultáneamente. |
| -a , --sigue adelante | Continúe tanto como sea posible después de un error. Si bien el objetivo que falló (y los que dependen de él) no se puede rehacer, las otras dependencias de estos objetivos se pueden procesar de todos modos. |
| -l [ carga ], --promedio de carga [ = carga ] | Especifica que no se deben iniciar nuevos trabajos (comandos) si hay otros trabajos en ejecución y el promedio de carga es al menos carga (un número de coma flotante). Sin argumento, elimina un límite de carga anterior. |
| -L , --check-symlink-times | Utilice la última hora de modificación entre enlaces simbólicos y objetivo. |
| -norte , - solo imprimir , - corrida en seco , --recon | Imprima los comandos que se ejecutarían, pero no los ejecute. |
| -o expediente , --old-file = expediente , --assume-old = expediente | No rehacer el archivo expediente incluso si es más antiguo que sus dependencias, y no rehaga nada debido a cambios en el archivo. Básicamente, el archivo se trata como muy antiguo y se ignoran sus reglas. |
| -pag , - base de datos de impresión | Imprime la base de datos (reglas y valores variables) que resulta de leer los archivos MAKE; luego ejecute como de costumbre o como se especifique de otra manera. Esto también imprime la información de la versión proporcionada por el -v interruptor (ver más abajo). Para imprimir la base de datos sin intentar rehacer ningún archivo, utilice hacer -p -f / dev / null . |
| -q , --pregunta | 'Modo de pregunta'. No ejecute ningún comando ni imprima nada; simplemente devuelva un estado de salida que sea cero si los objetivos especificados ya están actualizados, o distinto de cero en caso contrario. |
| -r , --no-reglas-integradas | Elimine el uso de las reglas implícitas integradas. Además, borre la lista predeterminada de sufijos para las reglas de sufijos. |
| -R , --no-variables-integradas | No defina ninguna variable incorporada. |
| -s , --silencio , --tranquilo | Operación silenciosa; no imprima los comandos mientras se ejecutan. |
| -S , --no sigue , --detener | Cancelar el efecto del -a opción. Esto nunca es necesario excepto en una marca recursiva donde -a podría heredarse de la marca de nivel superior a través de MAKEFLAGS o si establece -a en MAKEFLAGS en su entorno. |
| -t , --tocar | Toque archivos (márquelos actualizados sin cambiarlos realmente) en lugar de ejecutar sus comandos. Esto se usa para fingir que los comandos se realizaron, para engañar futuras invocaciones de fabricar . |
| -v , --versión | Imprime la versión de fabricar ; también un Copyright, una lista de autores y un aviso de que no hay garantía. |
| -en , --directorio de impresión | Imprima un mensaje que contenga el directorio de trabajo antes y después de otro procesamiento. Esto puede ser útil para rastrear errores de complicados nidos de recursivos. fabricar comandos. |
| --no-directorio-de-impresión | Apagar -en , incluso si estaba activado implícitamente. |
| -EN expediente , - qué-si = expediente , --nuevo-archivo = expediente , --assume-new = expediente | Imagina que el archivo de destino acaba de ser modificado. Cuando se usa con el -norte flag, esto le muestra lo que sucedería si modificara ese archivo. Sin -norte , es casi lo mismo que ejecutar un tocar comando en el archivo dado antes de ejecutar fabricar , excepto que la hora de modificación se cambia solo internamente dentro de fabricar . |
| --advertir-variables-indefinidas | Advertir cuando se hace referencia a una variable indefinida. |
Uso típico
fabricar se utiliza normalmente para construir ejecutable programas y bibliotecas del código fuente. Generalmente hablando, fabricar es aplicable a cualquier proceso que implique la ejecución de comandos arbitrarios para transformar un archivo de origen en un resultado de destino. Por ejemplo, fabricar podría usarse para detectar un cambio realizado en un archivo de imagen (la fuente) y las acciones de transformación podrían ser convertir el archivo a algún formato específico, copiar el resultado en un sistema de administración de contenido y luego enviar un correo electrónico a un conjunto predefinido de los usuarios que se realizaron las acciones anteriores.
fabricar se invoca con una lista de nombres de archivos de destino para construir como línea de comando argumentos:
|_+_|Sin argumentos fabricar construye el primer objetivo que aparece en su archivo MAKE, que tradicionalmente es un objetivo llamado todas .
fabricar decide si un objetivo debe regenerarse comparando el archivo tiempos de modificación . Esto resuelve el problema de evitar la construcción de archivos que ya están actualizados, pero falla cuando un archivo cambia pero su tiempo de modificación permanece en el pasado. Dichos cambios pueden deberse a la restauración de una versión anterior de un archivo fuente, o cuando un la red sistema de archivos es una fuente de archivos y su reloj o zona horaria no está sincronizado con la máquina en ejecución fabricar . El usuario debe manejar esta situación forzando una compilación completa. Por el contrario, si la hora de modificación de un archivo de origen es en el futuro, puede desencadenar una reconstrucción innecesaria.
Makefiles
fabricar busca el directorio actual para utilizar el archivo MAKE. ÑU fabricar busca archivos para un archivo llamado uno de GNUmakefile , makefile , y entonces Makefile y ejecuta los destinos especificados desde ese archivo.
La makefile El lenguaje es similar a la programación declarativa, en la que se describen las condiciones finales necesarias, pero el orden en el que se deben tomar las acciones no es importante. Esto puede resultar confuso para los programadores acostumbrados a la programación imperativa, que describe explícitamente cómo se alcanzará el resultado final.
Un problema en la automatización de la construcción es la adaptación de un proceso de construcción a un determinado plataforma . Por ejemplo, el compilador utilizado en una plataforma puede que no acepte las mismas opciones que el utilizado en otra. Esto no está bien manejado por fabricar por sí mismo. Este problema generalmente se maneja generando instrucciones de compilación específicas de la plataforma separadas, que a su vez pueden ser procesadas por fabricar . Las herramientas comunes para este proceso son autoconf y hacer .
Reglas
Un archivo MAKE consiste esencialmente en reglas . Cada regla comienza con una línea de dependencia que define un objetivo seguido de dos puntos (' : ') y, opcionalmente, una enumeración de componentes (archivos u otros destinos) de los que depende el destino. La línea de dependencia está organizada de modo que el objetivo (mano izquierda de los dos puntos) dependa de los componentes (mano derecha de los dos puntos). Es común referirse a los componentes como requisitos previos del objetivo.
|_+_|Aquí, es el carácter de tabulación. Por lo general, cada regla tiene un único objetivo único, en lugar de varios objetivos.
Por ejemplo, una C .o el archivo de objeto se crea a partir de .c archivos, entonces .c los archivos vienen primero (es decir, el destino del archivo de objeto específico depende de un archivo de origen C y archivos de encabezado). Porque fabricar en sí mismo no comprende, reconoce o distingue diferentes tipos de archivos, esto abre la posibilidad de error humano. Una dependencia olvidada o adicional puede no ser inmediatamente obvia y puede resultar en sutiles insectos en el software generado. Es posible escribir archivos MAKE que generen estas dependencias llamando a herramientas de terceros y algunos generadores de archivos MAKE, como GNU automake toolchain, puede hacerlo automáticamente.
Después de cada línea de dependencia, puede seguir una serie de líneas de comando que definen cómo transformar los componentes (generalmente archivos fuente) en el destino (generalmente la 'salida'). Si se ha modificado alguno de los componentes, se ejecutan las líneas de comando.
Con GNU fabricar , el primer comando puede aparecer en la misma línea después de los requisitos previos, separados por un punto y coma:
|_+_|por ejemplo:
|_+_|Cada línea de comando debe comenzar con un carácter de tabulación para que se reconozca como un comando. La pestaña es una espacio en blanco carácter, pero el carácter de espacio no tiene el mismo significado especial. Esto es problemático, ya que puede no haber diferencia visual entre una pestaña y una serie de caracteres de espacio. Este aspecto de la sintaxis de los archivos MAKE a menudo está sujeto a críticas y es importante tomar nota.
Sin embargo, GNU fabricar (desde la versión 3.82) permite al usuario elegir cualquier símbolo (un carácter) como prefijo de receta usando el .RECIPEPREFIX variable especial, por ejemplo:
|_+_|Cada comando es ejecutado por un intérprete de línea de comandos o shell independiente. Dado que los sistemas operativos utilizan diferentes intérpretes de línea de comandos, esto puede llevar a archivos MAKE no portátiles. Por ejemplo, GNU fabricar por defecto ejecuta comandos con / bin / sh , que es el caparazón donde Unix comandos como cp se utilizan normalmente.
Una regla puede no tener líneas de comando definidas. La línea de dependencia puede constar únicamente de componentes que hacen referencia a destinos, por ejemplo:
|_+_|Las líneas de comando de una regla generalmente se organizan para que generen el objetivo. Un ejemplo: si ' file.html 'es más reciente, se convierte en texto. El contenido del archivo MAKE:
|_+_|La regla anterior se activará cuando fabricar actualizaciones ' file.txt '.
En la siguiente invocación, fabricar normalmente usaría esta regla para actualizar el ' file.txt 'objetivo si' file.html 'eran más nuevos:
|_+_|Las líneas de comando pueden tener uno o más de los siguientes tres prefijos:
- un guión menos - ), especificando que los errores se ignoran
- un signo de arroba @ ), especificando que el comando no se imprime en la salida estándar antes de ejecutarse
- un signo más + ), el comando se ejecuta incluso si fabricar se invoca en un modo de 'no ejecutar'
Ignorando los errores y silenciando a todos echo La salida también se puede obtener a través de los objetivos especiales .IGNORAR ' y ' .SILENCIO ', respectivamente.
Macros
Un archivo MAKE puede contener definiciones de macros . Las macros generalmente se denominan variables cuando contienen definiciones de cadena simples, como ' CC = sonido metálico ', que especificaría sonido metálico como el compilador de C. Las macros en archivos MAKE se pueden anular en los argumentos de la línea de comandos pasados al fabricar utilidad. Variables de entorno también están disponibles como macros.
Las macros permiten a los usuarios especificar los programas invocados y otros comportamientos personalizados durante el proceso de compilación. Por ejemplo, como se acaba de mostrar, la macro ' CC 'se usa con frecuencia en archivos MAKE para referirse a la ubicación de un compilador de C.
Las nuevas macros se definen tradicionalmente con letras mayúsculas:
|_+_|Se utiliza una macro expandiéndola. Tradicionalmente, esto se hace encerrando su nombre dentro $() . Una forma equivalente usa llaves en lugar de paréntesis, es decir, ${} , que es el estilo utilizado en BSD sistemas operativos.
|_+_|Las macros pueden estar compuestas por comandos de shell utilizando el operador de sustitución de comandos, indicado por comillas invertidas (' ' ' ').
|_+_|El contenido de la definición se almacena 'tal cual'. Se usa la evaluación diferida, lo que significa que las macros normalmente se expanden solo cuando sus expansiones son realmente necesarias, como cuando se usan en las líneas de comando de una regla. Por ejemplo:
|_+_|La sintaxis genérica para anular macros en la línea de comando es:
|_+_|Makefiles puede acceder a cualquiera de una serie de macros internas predefinidas, con ' ? ' y ' @ 'siendo el más común.
|_+_|Reglas de sufijo
Las reglas de sufijo tienen 'objetivos' con nombres en el formulario .FROM.TO y se utilizan para lanzar acciones basadas en extensión de archivo . En las líneas de comando de las reglas de sufijos, POSIX especifica que la macro interna ' $< 'se refiere al primer requisito previo y' [correo electrónico protegido] 'se refiere al objetivo. En este ejemplo, que convierte cualquier HTML archivo en texto, el token de redirección de shell ' > 'es parte de la línea de comando mientras que' $< 'es una macro que hace referencia al archivo HTML:
|_+_|Cuando se llama desde la línea de comando, el ejemplo anterior expande el comando:
|_+_|dentro:
|_+_|Otros elementos
- Linea sola comentarios comienzan con el símbolo de almohadilla (' # ').
- Algunas directivas en archivos MAKE pueden incluir otros archivos MAKE.
- La continuación de la línea se indica con una barra invertida (' ') carácter al final de una línea, como en el siguiente:
Estado de salida
ÑU fabricar salidas con un estado de:
- 0 si todos los archivos MAKE se analizaron correctamente y no fallaron los destinos que se crearon;
- 1 Si el -q se usó la bandera y fabricar determina que un objetivo necesita ser reconstruido; y
- 2 si se encontraron errores.
Ejemplos de
Los Makefiles se utilizan tradicionalmente para compilar código ( *.c , *.cc , *.C , etc.), pero también se pueden utilizar para proporcionar comandos para automatizar tareas comunes.
Aquí hay un ejemplo de tres formas de ejecutar fabricar dado un determinado archivo MAKE. La fabricar Los comandos se enumeran primero, y luego el archivo MAKE:
|_+_|Sin ningún argumento, fabricar ejecutará el primer objetivo;
|_+_|Cuando se le da el ayuda argumento, fabricar mostrará los objetivos disponibles;
|_+_|Cuando se le da el argumento dist , fabricar creará un archivo de lanzamiento desde el directorio actual.
Aquí está el archivo MAKE para lo anterior fabricar comandos:
|_+_|A continuación, aquí hay un archivo MAKE muy simple que por defecto (el ' todas 'regla, que se enumera primero) compila un archivo fuente llamado' helloworld.c 'usando el compilador C del sistema, y también proporciona un' limpio 'objetivo para eliminar los archivos generados si el usuario quiere empezar de nuevo. La [correo electrónico protegido] y $< son dos macros internas (también conocidas como variables automáticas) que representan el nombre de destino y la fuente implícita, respectivamente. En el siguiente ejemplo, $^ se expande a un espacio delimitado lista de los requisitos previos.
Aquí está el archivo MAKE:
|_+_|Muchos sistemas vienen con predefinidos fabricar reglas y macros para especificar tareas comunes como la compilación basada en el sufijo del archivo. Esto permite al usuario omitir las instrucciones reales (a menudo imposibles de transportar) de cómo generar el objetivo a partir de la (s) fuente (s). En un sistema de este tipo, el archivo MAKE anterior podría modificarse de la siguiente manera:
|_+_|Usando este archivo MAKE, el hecho de que ' helloworld.o ' depende de ' helloworld.c 'ahora es manejado automáticamente por fabricar . En este simple ejemplo, esto apenas importa, pero el poder real de las reglas de sufijos se hace evidente cuando la cantidad de archivos fuente en un proyecto de software comienza a crecer. Uno solo tiene que escribir una regla para el paso de vinculación y declarar los archivos objeto como requisitos previos. fabricar Entonces determinará implícitamente cómo hacer todos los archivos de objeto y buscará cambios en todos los archivos de origen.
Las reglas de sufijos simples funcionan bien siempre que los archivos de origen no dependan unos de otros ni de otros archivos, como los archivos de encabezado. Otra ruta para simplificar el proceso de compilación es utilizar reglas de coincidencia de patrones que se pueden combinar con la generación de dependencias asistida por el compilador.
El siguiente ejemplo requiere el compilador gcc. Es un archivo MAKE genérico que compila todos los archivos C en una carpeta a los archivos objeto correspondientes y luego los vincula al ejecutable final. Antes de que se lleve a cabo la compilación, las dependencias se recopilan en un formato compatible con archivos MAKE en un archivo oculto ' .depender 'que luego se incluye en el archivo MAKE.
|_+_|Comandos relacionados
cd - Cambiar el directorio de trabajo.
sh - El intérprete de comandos del shell Bourne.