De Wikipedia, la enciclopedia libre
  (Redirigido desde Makefile )
Saltar a navegación Saltar a búsqueda
Fabricar
Paradigmamacro , declarativo
Diseñada porStuart Feldman
Apareció por primera vezAbril de 1976 ; Hace 45 años (4 de abril de 1976 )
Lenguaje de implementaciónC
SOInferno , tipo Unix
Formatos de archivoMakefile
Implementaciones importantes
BSD, GNU, nmake
Dialectos
Marca BSD, marca GNU, Microsoft nmake
Influenciado
Ant , Rake , MSBuild y otros

En el desarrollo de software , Make es una automatización de acumulación herramienta que automáticamente genera los programas ejecutables y bibliotecas de código fuente mediante la lectura de archivos llamados Makefile que especifican cómo derivar el programa de destino. A pesar de los entornos de desarrollo integrados y de lenguaje específico de compilador características también se pueden utilizar para gestionar un proceso de construcción, Hacer sigue siendo ampliamente utilizados, sobre todo en Unix y Unix-como sistemas operativos .

Además de crear programas, Make se puede utilizar para gestionar cualquier proyecto en el que algunos archivos deban actualizarse automáticamente desde otros siempre que los otros cambien.

Origen [ editar ]

Ahora hay una serie de utilidades de compilación de seguimiento de dependencias, pero Make es una de las más extendidas, principalmente debido a su inclusión en Unix , comenzando con PWB / UNIX 1.0, que presentaba una variedad de herramientas dirigidas a tareas de desarrollo de software. [1] Fue creado originalmente por Stuart Feldman en abril de 1976 en Bell Labs . [2] [3] [1] Feldman recibió el premio ACM Software System Award 2003 por la creación de esta amplia herramienta. [4]

Feldman se inspiró para escribir Make por la experiencia de un compañero de trabajo al depurar inútilmente un programa suyo en el que el ejecutable no se actualizaba accidentalmente con cambios:

Make se originó con una visita de Steve Johnson (autor de yacc, etc.), irrumpiendo en mi oficina, maldiciendo a los Fates que le habían hecho perder una mañana depurando un programa correcto (el error se había solucionado, el archivo no se había compilado, cc *.opor lo tanto, no se vio afectado). Como había pasado parte de la noche anterior lidiando con el mismo desastre en un proyecto en el que estaba trabajando, surgió la idea de una herramienta para resolverlo. Comenzó con una idea elaborada de un analizador de dependencias, se redujo a algo mucho más simple y se convirtió en Make ese fin de semana. El uso de herramientas que aún estaban húmedas era parte de la cultura. Los Makefiles eran archivos de texto, no binarios codificados mágicamente, porque ese era el espíritu de Unix: material imprimible, depurable y comprensible.

-  Stuart Feldman, El arte de la programación Unix , Eric S. Raymond 2003

Antes de la introducción de Make, el sistema de compilación Unix consistía más comúnmente en scripts de shell "make" e "install" dependientes del sistema operativo que acompañaban al código fuente de su programa. Poder combinar los comandos para los diferentes objetivos en un solo archivo y poder abstraer el seguimiento de dependencias y el manejo de archivos fue un paso importante en la dirección de los entornos de construcción modernos.

Derivados [ editar ]

Make ha pasado por una serie de reescrituras , incluida una serie de variantes desde cero que utilizaban el mismo formato de archivo y principios algorítmicos básicos y también proporcionaban una serie de sus propias mejoras no estándar. Algunos de ellos son:

  • Sun DevPro Make apareció en 1986 con SunOS-3.2. Con SunOS-3.2, se entregó como programa opcional; con SunOS-4.0, SunPro Make se convirtió en el programa Make predeterminado. [5] [Se necesita una mejor fuente ] En diciembre de 2006, Sun DevPro Make se convirtió en código abierto como parte de los esfuerzos para abrir Solaris . [6] [7]
  • dmake o Marca distribuida que venía con Sun Solaris Studio como Marca predeterminada, pero no la predeterminada en el sistema operativo Solaris (SunOS). Originalmente se requería para construir OpenOffice, pero en 2009 [8] el sistema de construcción fue reescrito para usar GNU Make. Si bien Apache OpenOffice todavía contiene una mezcla de ambos sistemas de compilación, [9] LibreOffice, mucho más desarrollado, ahora solo usa el modernizado "gbuild". [8]
  • BSD Make ( pmake , [10] bmake [11] o fmake [12] ), que se deriva del trabajo de Adam de Boor en una versión de Make capaz de construir objetivos en paralelo , y sobrevive con diversos grados de modificación en FreeBSD , [ 11] NetBSD [13] y OpenBSD . [14] De manera distintiva, tiene ciclos condicionales e iterativos que se aplican en la etapa de análisis y se pueden usar para construir condicional y programáticamente el archivo MAKE, [15] incluida la generación de objetivos en tiempo de ejecución. [ cita requerida ]
  • GNU Make (abreviado gmake ) es la implementación estándar de Make para Linux y macOS. [16] Proporciona varias extensiones sobre la Marca original, como condicionales. También proporciona muchas funciones integradas que se pueden usar para eliminar la necesidad de utilizar scripts de shell en las reglas del archivo make, así como para manipular las variables establecidas y utilizadas en el archivo make. [17] Por ejemplo, la función foreach puede usarse para iterar sobre una lista de valores, como los nombres de archivos en un directorio dado. [18] GNU Make es necesario para construir muchos sistemas de software, incluido GCC (desde la versión 3.4 [19] ), el kernel de Linux, [20] [21]Apache OpenOffice, [9] LibreOffice, [8] y Mozilla Firefox . [22]
  • Rocky Bernstein's Remake [23] es una bifurcación de GNU Make y proporciona varias extensiones sobre GNU Make, como mejores informes de ubicación y ubicación de errores, seguimiento de ejecución, creación de perfiles de ejecución y contiene un depurador.
  • Nmake [24] de Glenn Fowler no está relacionado con el programa de Microsoft del mismo nombre. Su entrada es similar a Make, pero no compatible. Este programa proporciona accesos directos y funciones integradas, que según sus desarrolladores reducen el tamaño de los archivos MAKE en un factor de 10.
  • Microsoft nmake , una herramienta de línea de comandos que normalmente forma parte de Visual Studio . [25] Soporta directivas de preprocesador como inclusiones y expresiones condicionales que usan variables establecidas en la línea de comandos o dentro de los archivos MAKE. [26] [27] Las reglas de inferencia difieren de Make; por ejemplo, pueden incluir rutas de búsqueda. [28] La herramienta Make suministrada con los productos Embarcadero tiene una opción de línea de comandos que "hace que MAKE imite el NMAKE de Microsoft". [29] . La herramienta Jom de Qt Project es un clon de nmake. [30]
  • Mk reemplazó a Make in Research Unix , a partir de la versión 9. [31] Un rediseño de la herramienta original por el programador de Bell Labs, Andrew G. Hume, presenta una sintaxis diferente. Mk se convirtió en la herramienta de construcción estándar en Plan 9 , el sucesor previsto de Bell Labs para Unix. [32]
  • Kati es el reemplazo de GNU Make de Google, que se utiliza en las compilaciones del sistema operativo Android . Traduce el archivo MAKE a ninja para compilaciones incrementales más rápidas. [33]

POSIX incluye la estandarización de las características básicas y el funcionamiento de la utilidad Make, y se implementa con diversos grados de integridad en las versiones de Make basadas en Unix. En general, se pueden usar archivos MAKE simples entre varias versiones de Make con un éxito razonable. GNU Make, Makepp y algunas versiones de BSD. Por defecto, buscar primero los archivos llamados "GNUmakefile", [34] "Makeppfile" [35] y "BSDmakefile" [36] respectivamente, lo que permite poner archivos MAKE que utilizan archivos de implementación definidos. comportamiento en lugares separados.

Comportamiento [ editar ]

Make se utiliza normalmente para crear programas ejecutables y bibliotecas a partir del código fuente. Sin embargo, en general, Make 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, Make 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 usuarios que indica que se realizaron las acciones anteriores.

Make se invoca con una lista de nombres de archivos de destino para construir como argumentos de línea de comandos :

hacer [ OBJETIVO ... ]

Sin argumentos, Make construye el primer objetivo que aparece en su archivo MAKE, que tradicionalmente es un objetivo simbólico "falso" llamado all .

Make decide si es necesario volver a generar un objetivo comparando los tiempos de modificación del archivo. [37] 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 sistema de archivos de red es una fuente de archivos y su reloj o zona horaria no está sincronizado con la máquina que ejecuta Make. 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, desencadena una reconstrucción innecesaria, lo que puede incomodar a los usuarios.


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. Uno de esos archivos MAKE se llama desde la línea de comando:

make # Sin argumento se ejecuta primero TARGET
make help  # Muestra los OBJETIVOS disponibles
make dist # Crea un archivo de lanzamiento desde el directorio actual

Makefile [ editar ]

Make busca en el directorio actual para el makefile a usar, por ejemplo GNU Make busca archivos en orden para un archivo llamado GNUmakefile , makefile o Makefile y luego ejecuta el destino especificado (o predeterminado) desde (solo) ese archivo.

El lenguaje Makefile es similar a la programación declarativa . [38] [39] [40] Esta clase de lenguaje, en la que se describen las condiciones finales necesarias pero el orden en el que se deben tomar las acciones no es importante, a veces confunde a los programadores acostumbrados a la programación imperativa .

Un problema en la automatización de la construcción es la adaptación de un proceso de construcción a una plataforma determinada . Por ejemplo, es posible que el compilador utilizado en una plataforma no acepte las mismas opciones que el que se utiliza en otra. Make no lo maneja bien. Este problema generalmente se maneja generando instrucciones de compilación específicas de la plataforma, que a su vez son procesadas por Make. Las herramientas comunes para este proceso son Autoconf , CMake o GYP (o NG más avanzado ).

Los archivos Makefiles pueden contener cinco tipos de cosas: [41]

  1. Una regla explícita dice cuándo y cómo rehacer uno o más archivos, llamados objetivos de la regla. Enumera los otros archivos de los que dependen los objetivos, denominados requisitos previos del objetivo, y también puede proporcionar una receta para usar para crear o actualizar los objetivos.
  2. Una regla implícita dice cuándo y cómo rehacer una clase de archivos según sus nombres. Describe cómo un objetivo puede depender de un archivo con un nombre similar al objetivo y proporciona una receta para crear o actualizar dicho objetivo.
  3. Una definición de variable es una línea que especifica un valor de cadena de texto para una variable que se puede sustituir en el texto más adelante.
  4. Una directiva es una instrucción para que make haga algo especial mientras lee el archivo MAKE, como leer otro archivo MAKE.
  5. Las líneas que comienzan con #se utilizan para comentarios .

Reglas [ editar ]

Un archivo MAKE consta de reglas . Cada regla comienza con una línea de dependencia textual que define un objetivo seguido de dos puntos (:) y, opcionalmente, una enumeración de componentes (archivos u otros objetivos) de los que depende el objetivo. 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. [42]

objetivo [objetivo ...]: [componente ...] Tab ↹[comando 1] . . .Tab ↹[comando n]

Por lo general, cada regla tiene un único objetivo único, en lugar de varios objetivos.

Por ejemplo, un archivo de objeto C .o se crea a partir de archivos .c, por lo que los archivos .c son lo primero (es decir, el destino del archivo de objeto específico depende de un archivo de origen C y archivos de encabezado ). Debido a que Make en sí mismo no comprende, reconoce o distingue diferentes tipos de archivos, esto abre una posibilidad de error humano. Una dependencia olvidada o adicional puede no ser inmediatamente obvia y puede resultar en errores sutiles en el software generado. Es posible escribir archivos MAKE que generan estas dependencias llamando a herramientas de terceros, y algunos generadores de archivos MAKE, como la cadena de herramientas Automake proporcionada por el Proyecto GNU , pueden hacerlo automáticamente.

Cada línea de dependencia puede ir seguida de una serie de líneas de comando con sangría TAB que definen cómo transformar los componentes (generalmente archivos fuente) en el destino (generalmente la "salida"). Si alguno de los requisitos previos tiene una fecha de modificación más reciente que la del destino, se ejecutan las líneas de comando. La documentación de GNU Make se refiere a los comandos asociados con una regla como una "receta".

El primer comando puede aparecer en la misma línea después de los requisitos previos, separados por un punto y coma,

objetivos :  requisitos previos  ; mando

por ejemplo,

hola :  ; @ echo " hola "

Make puede decidir por dónde empezar a través de la clasificación topológica .

Cada línea de comando debe comenzar con un carácter de tabulación para que se reconozca como un comando. La tabulación es un carácter de espacio en blanco , 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 suele ser objeto de críticas; ha sido descrito por Eric S. Raymond como "uno de los peores errores de diseño en la historia de Unix" [43] y El manual de los que odian a Unix dice que "usar pestañas como parte de la sintaxis es como una de esas trampas de pungee stick en Los boinas verdes ". Feldman explica que la elección fue causada por una solución alternativapara una dificultad de implementación temprana preservada por un deseo de compatibilidad con versiones anteriores con los primeros usuarios:

¿Por qué la pestaña en la columna 1? Yacc era nuevo, Lex era nuevo. Yo tampoco lo había intentado, así que pensé que sería una buena excusa para aprender. Después de que me enredaran con mi primera puñalada a Lex, hice algo simple con la pestaña de nueva línea del patrón. Funcionó, se quedó. Y luego, unas semanas más tarde, tenía una población de usuarios de aproximadamente una docena, la mayoría de ellos amigos, y no quería arruinar mi base integrada. El resto, lamentablemente, es historia.

-  Stuart Feldman [43]

Sin embargo, GNU Make desde la versión 3.82 permite elegir cualquier símbolo (un carácter) como prefijo de receta usando la variable especial .RECIPEPREFIX, por ejemplo:

.RECIPEPREFIX  : =  : all :: @echo  "el símbolo de prefijo de receta se establece en '$ (. RECIPEPREFIX)'"

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 Make (todas las marcas POSIX) por defecto ejecuta comandos con / bin / sh , donde normalmente se usan comandos Unix como cp . En contraste con eso, nmake de Microsoft ejecuta comandos con cmd.exe donde los comandos por lotes como copiar están disponibles pero no necesariamente cp.

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:

realclean :  clean  distclean

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 a texto. El contenido del archivo MAKE:

file.txt :  archivo . htmllynx -dump file.html> file.txt

La regla anterior se activará cuando realice actualizaciones "file.txt". En la siguiente invocación, Make normalmente usaría esta regla para actualizar el destino "file.txt" si "file.html" fuera más reciente.

hacer file.txt

Las líneas de comando pueden tener uno o más de los siguientes tres prefijos:

  • un guión menos (-), que especifica que los errores se ignoran
  • un signo arroba (@), que especifica que el comando no se imprime en la salida estándar antes de ejecutarse
  • un signo más (+), el comando se ejecuta incluso si Make se invoca en un modo "no ejecutar"

Ignorar errores y silenciar el eco se puede obtener alternativamente a través de los objetivos especiales .IGNOREy .SILENT. [44]

NMAKE de Microsoft tiene reglas predefinidas que se pueden omitir de estos archivos MAKE, por ejemplo .c.obj $(CC)$(CFLAGS)

Macros [ editar ]

Un archivo MAKE puede contener definiciones de macros. Las macros generalmente se denominan variables cuando contienen definiciones de cadena simples, como {{{1}}}. Las macros en archivos MAKE se pueden anular en los argumentos de la línea de comandos pasados ​​a la utilidad Make. Las 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, la macro CCse usa con frecuencia en archivos MAKE para referirse a la ubicación de un compilador de C , y el usuario puede querer especificar un compilador en particular para usar.

Las nuevas macros (o "variables" simples) se definen tradicionalmente con letras mayúsculas:

MACRO  = definición

Se utiliza una macro expandiéndola. Tradicionalmente, esto se hace encerrando su nombre en el interior $(). (Omitir los paréntesis hace que Make interprete la siguiente letra después de $como el nombre completo de la variable). Una forma equivalente usa llaves en lugar de paréntesis, es decir ${}, que es el estilo que se usa en los BSD .

NEW_MACRO  =  $ ( MACRO ) - $ ( MACRO2 )

Las macros pueden estar compuestas por comandos de shell utilizando el operador de sustitución de comandos , indicado por comillas invertidas ( `).

AAAAMMDD  =  ' fecha '

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. Un ejemplo extendido:

PAQUETE  = paquete VERSIÓN  =  ` fecha + "% Y.% m% d "  ` ARCHIVO  =  $ ( PAQUETE ) - $ ( VERSIÓN )dist : # Observe que solo ahora las macros se expanden para que el shell las interprete: # tar -cf package-`date + "% Y% m% d" `.tartar -cf $ ( ARCHIVO ) .tar.

La sintaxis genérica para anular macros en la línea de comando es:

hacer MACRO = "valor"  [ MACRO = "valor" ... ] OBJETIVO [ OBJETIVO ... ]

Makefiles puede acceder a cualquiera de una serie de macros internas predefinidas , siendo ?y @son las más comunes.

objetivo :  componente 1 componente 2 # contiene aquellos componentes que necesitan atención (es decir, SON MÁS JOVENES que el OBJETIVO actual). echo  $?  # se evalúa como el nombre TARGET actual de entre los que quedan a la izquierda de los dos puntos. echo  $ @

Una expansión de sintaxis algo común es el uso de + = , ? = Y ! = En lugar del signo igual. Funciona tanto en BSD como en GNU. [45]

Reglas de sufijo [ editar ]

Las reglas de sufijo tienen "objetivos" con nombres en el formulario .FROM.TOy se utilizan para iniciar acciones según la extensión del archivo. En las líneas de comando de las reglas de sufijo, POSIX especifica [46] que la macro interna se $<refiere al primer prerrequisito y se $@refiere al destino. En este ejemplo, que convierte cualquier archivo HTML 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:

.SUFIJOS : . txt . html# De .html a .txt .html.txt :	lynx -dump $ <> $ @

Cuando se llama desde la línea de comando, el ejemplo anterior se expande.

$ make -n archivo.txtlynx -dump file.html> file.txt

Reglas de patrones [ editar ]

Las reglas de sufijo no pueden tener requisitos previos propios. [47] Si tienen alguno, se tratan como archivos normales con nombres inusuales, no como reglas de sufijo. GNU Make admite reglas de sufijos para la compatibilidad con archivos MAKE antiguos, pero por lo demás fomenta el uso de reglas de patrones . [48]

Una regla de patrón parece una regla ordinaria, excepto que su destino contiene exactamente un %carácter dentro de la cadena. El objetivo se considera un patrón para hacer coincidir nombres de archivos: %puede coincidir con cualquier subcadena de cero o más caracteres, [49] mientras que otros caracteres coinciden solo con ellos mismos. Los requisitos previos también se utilizan %para mostrar cómo se relacionan sus nombres con el nombre del objetivo.

El ejemplo anterior de una regla de sufijo se vería como la siguiente regla de patrón:

# De% .html a% .txt % .txt :  %. html	lynx -dump $ <> $ @

Otros elementos [ editar ]

Los comentarios de una sola línea comienzan con el símbolo de almohadilla (#).

Algunas directivas en archivos MAKE pueden incluir otros archivos MAKE.

La continuación de línea se indica con un \carácter de barra invertida al final de una línea.

 objetivo: componente \ componente Tab ↹comando; \ Tab ↹command | \ Tab ↹piped-command

Ejemplos de archivos MAKE [ editar ]

El archivo MAKE:

PAQUETE  = paquete VERSION  =  ` fecha " +% Y.% m% d% "  ` RELEASE_DIR  = .. RELEASE_FILE  =  $ ( PACKAGE ) - $ ( VERSION )# Observe que la variable LOGNAME proviene del entorno en # shells POSIX. # # target: all - Objetivo predeterminado. No hace nada. all : echo  "Hola $ ( LOGNAME ) , nada que hacer por defecto" # a veces: echo "Hola $ {LOGNAME}, nada que hacer por defecto" echo  "Prueba 'hacer ayuda'"# target: help - Muestra objetivos invocables. help :	egrep "^ # target:"  [ Mm ] akefile# target: list - Lista de archivos fuente lista : # No funcionará. Cada comando está en un shell cd src separadols# Correcto, continuación del mismo shell cd src ;  \ls# target: dist - Hacer un lanzamiento. dist :	tar -cf $ ( RELEASE_DIR ) / $ ( RELEASE_FILE )  &&  \	gzip -9 $ ( RELEASE_DIR ) / $ ( RELEASE_FILE ) .tar

A continuación se muestra un archivo MAKE muy simple que, por defecto (la regla "todos" aparece primero) compila un archivo fuente llamado "helloworld.c" usando el compilador C del sistema y también proporciona un destino "limpio" para eliminar los archivos generados si el usuario desea empezar de nuevo. Los $@y $<son dos de las llamadas macros internas (también conocidas como variables automáticas) y representan el nombre de destino y la fuente "implícita", respectivamente. En el siguiente ejemplo, se $^expande a una lista delimitada por espacios de los requisitos previos. Hay una serie de otras macros internas. [46] [50]

CFLAGS  ? = -Gtodos :  hola mundohelloworld :  helloworld . o # Los comandos comienzan con TAB, no espacios $ ( CC )  $ ( LDFLAGS ) -o $ @ $ ^helloworld.o :  helloworld . c $ ( CC )  $ ( CFLAGS ) -c -o $ @ $ <limpio :  FRC $ ( RM ) helloworld helloworld.o# Este pseudo objetivo hace que todos los objetivos que dependen de FRC # sean rehechos incluso en caso de que exista un archivo con el nombre del objetivo. # Esto funciona con cualquier implementación de make bajo el supuesto de que # no hay ningún archivo FRC en el directorio actual. FRC :

Muchos sistemas vienen con macros y reglas de creación predefinidas para especificar tareas comunes, como la compilación basada en el sufijo de archivo. Esto permite a los usuarios omitir las instrucciones reales (a menudo imposibles de transportar) de cómo generar el destino a partir de la (s) fuente (s). En un sistema de este tipo, el archivo MAKE anterior podría modificarse de la siguiente manera:

todos :  hola mundohelloworld :  helloworld . o $ ( CC )  $ ( CFLAGS )  $ ( LDFLAGS ) -o $ @ $ ^limpio :  FRC $ ( RM ) helloworld helloworld.o# Esta es una regla de sufijo explícita. Puede omitirse en sistemas # que manejan reglas simples como esta automáticamente. .co : $ ( CC )  $ ( CFLAGS ) -c $ <FRC : .SUFIJOS : . C


Ese "helloworld.o" depende de "helloworld.c" ahora es manejado automáticamente por Make. En un ejemplo tan simple como el que se ilustra aquí, 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. Make entonces determinará implícitamente cómo crear 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 construcción es usar las llamadas reglas de coincidencia de patrones que se pueden combinar con la generación de dependencias asistida por el compilador. Como ejemplo final que requiere el compilador gcc y GNU Make, aquí hay un archivo MAKE genérico que compila todos los archivos C en una carpeta con 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 ".depend" que luego se incluye en el archivo MAKE. Los programas portátiles deben evitar las construcciones que se utilizan a continuación.

# GNUMakefile genérico# Solo un fragmento para dejar de ejecutar bajo otros comandos make (1) # que no entenderán estas líneas ifneq (,) Este  archivo make  requiere  GNU  Make. terminara siPROGRAM  = foo C_FILES  : =  $ ( comodín * .c ) OBJS  : =  $ ( patsubst% .c,% .o, $ ( C_FILES )) CC  = cc CFLAGS  = -Wall -pedantic LDFLAGS  = LDLIBS  = -lmtodos :  $ ( PROGRAMA )$ (PROGRAMA) : . depende  $ ( OBJS ) $ ( CC )  $ ( CFLAGS )  $ ( OBJS )  $ ( LDFLAGS ) -o $ ( PROGRAMA )  $ ( LDLIBS )dependerá : . depender.depend :  cmd = gcc - MM - MF  depende  $ ( var ) ; gato  depende >>. depender ;.depend :	@ echo "dependencias Generación ..."	@ $ ( foreach var, $ ( C_FILES ) , $ ( cmd ))@rm -f depende-incluir .depend# Estas son las reglas de coincidencia de patrones. Además de las # variables automáticas que se utilizan aquí, la variable $ * que coincide con lo que% representa # puede ser útil en casos especiales. % .o :  %. c $ ( CC )  $ ( CFLAGS ) -c $ <-o $ @% :  %. o $ ( CC )  $ ( CFLAGS ) -o $ @ $ <limpiar :	rm -f .depend $ ( OBJS ).PHONY :  limpio  depende

Ver también [ editar ]

  • Lista de software de automatización de compilación
  • Gráfico de dependencia

Referencias [ editar ]

  1. ↑ a b Thompson, TJ (noviembre de 1980). "Banco de trabajo del diseñador: proporcionar un entorno de producción". Revista técnica de Bell System . 59 (9): 1811–1825. doi : 10.1002 / j.1538-7305.1980.tb03063.x . S2CID  27213583 . En el mantenimiento general de DWB, hemos utilizado el sistema de control de código fuente y la utilidad make proporcionada por el sistema operativo interactivo PWB / UNIX *.
  2. ^ "V7 / usr / src / cmd / make / ident.c" . tuhs.org . 1 de septiembre de 2013. Archivado desde el original el 1 de septiembre de 2013 . Consultado el 18 de marzo de 2018 .
  3. ^ Feldman, SI (abril de 1979). "Hacer --- un programa para mantener programas de computadora". Software: práctica y experiencia . 9 (4): 255–265. CiteSeerX 10.1.1.39.7058 . doi : 10.1002 / spe.4380090402 . 
  4. ^ Matthew Doar (2005). Entornos de desarrollo prácticos . O'Reilly Media . pag. 94. ISBN 978-0-596-00796-6.
  5. ^ "Grupos de Google" . arquivo.pt . Archivado desde el original el 22 de enero de 2011 . Consultado el 18 de marzo de 2018 .CS1 maint: bot: estado de URL original desconocido ( enlace )
  6. ^ "OpenSolaris at Two (Jim Grisanzio)" . 12 de diciembre de 2013. Archivado desde el original el 12 de diciembre de 2013 . Consultado el 18 de marzo de 2018 .
  7. ^ Grisanzio, Jim. La historia de OpenSolaris .
  8. ^ a b c "Desarrollo / Gbuild - The Document Foundation Wiki" . wiki.documentfoundation.org . Consultado el 18 de marzo de 2018 .
  9. ^ a b "Guía de creación de Apache OpenOffice - Apache OpenOffice Wiki" . wiki.openoffice.org . Consultado el 18 de marzo de 2018 .
  10. ^ FreeBSD 2.0.5 Hacer código fuente , 1993
  11. ^ a b https://www.freebsd.org/cgi/man.cgi?query=bmake&sektion=1
  12. ^ https://manpages.debian.org/jessie/freebsd-buildutils/fmake.1
  13. ^ "hacer" . Páginas del manual de NetBSD . Consultado el 9 de julio de 2020 .
  14. ^ "make (1) - Páginas de manual de OpenBSD" . man.openbsd.org . Consultado el 18 de marzo de 2018 .
  15. ^ "hacer" . FreeBSD . Consultado el 9 de julio de 2020 . La inclusión de Makefile, las estructuras condicionales y los bucles for que recuerdan al lenguaje de programación C se proporcionan en make.
  16. ^ Arnold Robbins (2005), Unix en pocas palabras, cuarta edición , O'Reilly
  17. ^ "8. Funciones para transformar texto" , GNU make , Free Software Foundation, 2013
  18. ^ "8.5 La función foreach" , marca GNU , Free Software Foundation, 2013
  19. ^ "Cambios, nuevas funciones y correcciones de la serie de versiones GCC 3.4" . Fundación de Software Libre. 2006.
  20. ^ Javier Martinez Canillas (26 de diciembre de 2012). "Kbuild: el sistema de compilación del kernel de Linux" . Revista de Linux .
  21. ^ Greg Kroah-Hartman (2006), Kernel de Linux en pocas palabras , O'Reilly
  22. ^ "Instrucciones de construcción" .
  23. ^ Rocky Bernstein. "Remake - GNU Make con rastreo comprensible y depurador" .
  24. ^ Glenn Fowler (4 de enero de 2012). "Visión general de nmake" . Investigación de sistemas de información y software, AT&T Labs Research. Archivado desde el original el 2 de septiembre de 2015 . Consultado el 26 de mayo de 2014 .
  25. ^ "Referencia de NMAKE Visual Studio 2015" . Microsoft. 2015.
  26. ^ "Directivas de preprocesamiento de Makefile" . 2014.
  27. ^ "Operadores de preprocesamiento de Makefile" . Microsoft. 2014.
  28. ^ "Rutas de búsqueda en reglas" . Microsoft. 2014.
  29. ^ "HACER" . CodeGear (TM). 2008.
  30. ^ "Jom - Qt Wiki" . Proyecto Qt. 2021.
  31. ^ McIlroy, MD (1987). Un lector de investigación Unix: extractos comentados del Manual del programador, 1971–1986 (PDF) (Informe técnico). Bell Labs. CSTR 139.
  32. ^ Hume, Andrew G .; Flandrena, Bob (2002). "Mantenimiento de archivos en Plan 9 con Mk" . Plan 9 Manual del programador . Laboratorios AT&T Bell. Archivado desde el original el 11 de julio de 2015.
  33. ^ "google / kati: un clon experimental de GNU make" . GitHub . 30 de noviembre de 2020.
  34. ^ "GNU 'hacer ' " . Fundación de Software Libre.
  35. ^ "Makepp" .
  36. ^ "Marca BSD libre" .
  37. ^ Cómo ordenar la salida del archivo de comando ls de Linux Archivado el 13 de septiembre de 2016 en Wayback Machine
  38. ^ una descripción general sobre dsls Archivado el 23 de octubre de 2007 en Wayback Machine , 2007/02/27, phoenix wiki
  39. ↑ Re: Choreography and REST Archivado el 12 de septiembre de 2016 en Wayback Machine , de Christopher B Ferris el 9 de agosto de 2002
  40. ^ Target Junior Makefiles Archivado el 7 de enero de 2010 en Wayback Machine , Andrew W. Fitzgibbon y William A. Hoffman
  41. ^ 3.1 Qué contienen Makefiles , GNU make , Free Software Foundation
  42. ^ "Tipos de requisitos previos (marca GNU)" . GNU.org . Proyecto GNU . Consultado el 15 de diciembre de 2020 .
  43. ^ a b "Capítulo 15. Herramientas: hacer: Automatizar sus recetas", El arte de la programación Unix , Eric S. Raymond 2003
  44. ^ make  - Referencia de comandos y utilidades, la especificación única de UNIX , número 7 de The Open Group
  45. ^ make(1)  -  Manual de comandos generales de FreeBSD
  46. ^ a b "hacer" . www.opengroup.org . Consultado el 18 de marzo de 2018 .
  47. ^ "GNU make manual: reglas de sufijo" . Fundación de Software Libre.
  48. ^ "GNU make manual: reglas de patrones" . Fundación de Software Libre.
  49. ^ Consulte la sección Reglas de coincidencia de patrones en la página de manual de SunPro. Archivado el 29 de mayo de 2014 en Wayback Machine.
  50. ^ Variables automáticas Archivado el 25 de abril de 2016 en Wayback Machine GNU `make '

Enlaces externos [ editar ]

  • GNU Make página de inicio
  • Makefiles prácticos, por ejemplo
  • Escribir y depurar un archivo Makefile
  • Serie de artículos "Ask Mr. Make" sobre GNU Make
  • Gestión de proyectos con GNU make - 3.xª edición
  • ¿Qué tiene de malo hacer?
  • ¿Qué hay de malo en hacer GNU?
  • Recursivo Hacer considerado nocivo
  • Generación avanzada de autodependencia .
  • Usando NMake
  • Make7: una utilidad de creación de código abierto portátil escrita en Seed7
  • Reglas predefinidas de NMAKE de Microsoft .