En el desarrollo de software , Make es una herramienta de software de interfaz de línea de comandos que realiza acciones ordenadas por dependencias configuradas , tal como se define en un archivo de configuración llamado makefile . Se utiliza comúnmente para la automatización de la compilación para generar código ejecutable (como un programa o una biblioteca ) a partir del código fuente . Pero, sin limitarse a la compilación, Make puede realizar cualquier operación disponible a través del shell del sistema operativo .
Make se usa ampliamente, especialmente en sistemas operativos Unix y similares a Unix , aunque hay muchas tecnologías y herramientas competitivas disponibles, incluidas: herramientas similares que realizan acciones basadas en dependencias, algunos compiladores y de forma interactiva a través de un entorno de desarrollo integrado .
Además de hacer referencia a la herramienta Unix original, Make también es una tecnología ya que se han implementado múltiples herramientas con aproximadamente la misma funcionalidad, incluida una sintaxis y semántica de makefile similares .
Stuart Feldman creó Make mientras trabajaba en Bell Labs . Una primera versión se completó en abril de 1976. [1] [2] [3] Feldman recibió el premio ACM Software System Award 2003 por la creación de Make. [4]
Feldman describe que la inspiración para escribir Make surgió de la frustración de un compañero de trabajo con las herramientas disponibles en ese momento:
Make se originó con una visita de Steve Johnson (autor de yacc, etc.), que irrumpió en mi oficina, maldiciendo a los hados 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 tarde 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 en uso era parte de la cultura. Los Makefiles eran archivos de texto, no binarios codificados mágicamente, porque ese era el espíritu de Unix : cosas imprimibles, depurables y comprensibles.— Stuart Feldman, El arte de la programación Unix , Eric S. Raymond 2003
Antes de Make, la creación de código en Unix consistía principalmente en scripts de shell escritos para el código base de cada programa. El orden de dependencias y la comprobación de desactualización de Make hacen que el proceso de creación de código sea más sólido y eficiente. El archivo makefile permitió una mejor organización de la lógica de creación de código y, a menudo, menos archivos de creación de código.
Make se utiliza ampliamente en parte debido a su temprana inclusión en Unix , comenzando con PWB/UNIX 1.0, que incluía una variedad de herramientas de desarrollo de software. [3]
Make se ha implementado en numerosas ocasiones, generalmente utilizando el mismo formato de archivo makefile y brindando las mismas funciones, pero algunas de ellas aportando mejoras con respecto al original. Ejemplos:
POSIX incluye la estandarización de las características básicas y el funcionamiento de la utilidad Make, y se implementa con distintos grados de compatibilidad con las versiones de Make basadas en Unix. En general, se pueden utilizar makefiles simples entre varias versiones de Make con un éxito razonable. GNU Make, Makepp y algunas versiones de BSD Make buscan primero de forma predeterminada los archivos denominados "GNUmakefile", [35] "Makeppfile" [36] y "BSDmakefile" [37] respectivamente, lo que permite colocar los makefiles que utilizan un comportamiento definido por la implementación en ubicaciones separadas.
En general, en función de un archivo make, Make actualiza los archivos de destino a partir de los archivos de origen si algún archivo de origen tiene una marca de tiempo más reciente que el archivo de destino o si el archivo de destino no existe. Por ejemplo, esto podría incluir la compilación de archivos C ( *.c) en archivos de objeto y, a continuación, la vinculación de los archivos de objeto en un programa ejecutable. O esto podría incluir la compilación de archivos TypeScript ( *.ts) en JavaScript para su uso en un navegador. Otros ejemplos incluyen: convertir un archivo de imagen de origen a otro formato, copiar un archivo a un sistema de gestión de contenido y enviar un correo electrónico sobre el estado de la compilación.
Un archivo makefile define objetivos, donde cada uno es un archivo para generar o un concepto definido por el usuario, llamado objetivo falso .
Realizar actualizaciones de los objetivos pasados como argumentos:
make [ -f makefile ] [ opciones ] [ objetivos ] Si no se especifica ningún objetivo, Make actualiza el primer objetivo en el archivo make, que suele ser un objetivo falso para realizar la acción más utilizada.
Make omite las acciones de compilación si la marca de tiempo del archivo de destino es posterior a la de los archivos de origen. [38] Al hacerlo, se optimiza el proceso de compilación al omitir acciones cuando el archivo de destino está actualizado, pero a veces las actualizaciones se omiten por error debido a problemas con la marca de tiempo del archivo, incluida la restauración de una versión anterior de un archivo de origen, o cuando un sistema de archivos de red es una fuente de archivos y su reloj o zona horaria no está sincronizada con la máquina que ejecuta Make. Además, si la marca de tiempo de un archivo de origen es futura, make activa repetidamente acciones innecesarias, lo que provoca un tiempo de compilación más largo.
Cuando se inicia Make, utiliza el archivo makefile especificado en la línea de comandos o, si no se especifica, utiliza el que se encuentra mediante reglas de búsqueda específicas. Generalmente, Make utiliza de manera predeterminada el archivo en el directorio de trabajo llamado Makefile . GNU Make busca el primer archivo que coincida: GNUmakefile , makefile o Makefile .
Convierte los procesos en las opciones de la línea de comandos en función del archivo make cargado.
El lenguaje makefile es una programación parcialmente declarativa donde se describen las condiciones finales pero no el orden en el que se deben realizar las acciones. [40] [41] [42] [43] Este tipo de programación puede resultar confusa para los programadores acostumbrados a la programación imperativa .
Los Makefiles pueden contener las siguientes construcciones: [44]
#Cada regla comienza con una línea de dependencia que consiste en el nombre del objetivo de la regla seguido de dos puntos (:) y, opcionalmente, una lista de objetivos de los que depende el objetivo de la regla, sus prerrequisitos. [45]
objetivo [objetivo ...]: [componente ...] Tab ↹[comando 1] . . .Tab ↹[comando n]
Generalmente una regla tiene un único objetivo, en lugar de varios.
Una línea de dependencia puede ir seguida de una receta; una serie de líneas de comando con sangría TAB que definen cómo generar el destino a partir de los componentes (es decir, los archivos de origen). Si algún prerrequisito tiene una marca de tiempo más reciente que el archivo de destino o el destino no existe como archivo, se ejecuta la receta.
El primer comando puede aparecer en la misma línea después de los requisitos previos, separados por punto y coma.
objetivos : requisitos previos ; comando Por ejemplo,
hola : ; @ echo " hola "Cada línea de comando debe comenzar con un carácter de tabulación. Aunque un espacio también es un espacio en blanco , Make requiere tabulación. Dado que esto a menudo conduce a confusión y errores, este aspecto de la sintaxis del makefile está sujeto a críticas; Eric S. Raymond lo describe como "uno de los peores errores de diseño en la historia de Unix" [46] y The Unix-Haters Handbook dijo que "usar tabulaciones como parte de la sintaxis es como una de esas trampas de palo pungee en Los Boinas Verdes ". Feldman explica que la elección se debió a una solución temporal para 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 completamente nuevo. No había probado ninguno de los dos, así que pensé que esta sería una buena excusa para aprender. Después de enredarme con mi primer intento con Lex, simplemente hice algo simple con el patrón newline-tab. Funcionó, se mantuvo. 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 [46]
GNU Make. desde la versión 3.82, permite la elección de cualquier símbolo (un carácter) como prefijo de la receta utilizando la variable especial .RECIPEPREFIX, por ejemplo:
.RECIPEPREFIX := : all : :@echo "el símbolo de prefijo de receta está establecido en '$(.RECIPEPREFIX)'" Cada comando se ejecuta en un shell independiente . Dado que los sistemas operativos utilizan shells diferentes, esto puede dar lugar a archivos make no portables. Por ejemplo, GNU Make (todos los Makes POSIX) ejecuta comandos con /bin/sh de forma predeterminada, mientras que normalmente se utilizan comandos Unix como cp . Por el contrario, nmake de Microsoft ejecuta comandos con cmd.exe, mientras que los comandos por lotes como copy están disponibles, pero no necesariamente cp.
Dado que una receta es opcional, la línea de dependencia puede constar únicamente de componentes que hacen referencia a otros objetivos, por ejemplo:
realclean : limpio distclean La siguiente regla de ejemplo se evalúa cuando se realiza una actualización al archivo de destino.txt, es decir, a través de make file.txt. Si file.html es más reciente que file.txt o file.txt no existe, entonces se ejecuta el comando para generar file.txt a partir de file.html.
archivo.txt : archivo . html lynx -dump archivo.html > archivo.txt Un comando puede tener uno o más de los siguientes prefijos (después de la tabulación):
También se pueden ignorar los errores y silenciar el eco mediante los objetivos especiales .IGNOREy .SILENT. [47]
NMAKE de Microsoft tiene reglas predefinidas que se pueden omitir de estos archivos make, por ejemplo .c.obj $(CC)$(CFLAGS)
Un archivo makefile puede definir y utilizar macros. Las macros suelen denominarse variables cuando contienen definiciones de cadenas simples, como . Las macros en archivos makefile pueden anularse en los argumentos de la línea de comandos que se pasan a la utilidad Make. Las variables de entorno también están disponibles como macros.CC=clang
Por ejemplo, la macro CCse usa frecuentemente en archivos make para hacer referencia a la ubicación de un compilador de C. Si se usa de manera consistente en todo el archivo make, entonces el compilador usado se puede cambiar modificando el valor de la macro en lugar de cambiar cada comando de regla que invoca al compilador.
Las macros se nombran comúnmente en mayúsculas :
MACRO = definición Un valor macro puede estar compuesto por otros valores macro. El valor de un macro se expande con cada uso ( de forma diferida ).
Una macro se utiliza expandiéndose mediante $ NAME o $( NAME ). La última opción es más segura, ya que omitir los paréntesis hace que Make interprete la siguiente letra después de $como el nombre completo de la variable. Una forma equivalente utiliza llaves en lugar de paréntesis, es decir ${}, que es el estilo utilizado en BSD .
NUEVA_MACRO = $( MACRO ) - $( MACRO2 ) Las macros pueden estar compuestas de comandos de shell utilizando el operador de sustitución de comandos , denotado por comillas invertidas ( `).
AAAAMMDD = ` fecha ` La sintaxis de la línea de comandos para anular una macro es:
hacer MACRO = "valor" [ MACRO = "valor" ... ] OBJETIVO [ OBJETIVO ... ] Los Makefiles pueden acceder a macros internas predefinidas , siendo ?y @comunes.
objetivo : componente 1 componente 2 # echo componentes MÁS JOVEN que el OBJETIVO echo $? # echo nombre OBJETIVO echo $@ Una sintaxis común al definir macros, que funciona en BSD y GNU Make, es utilizar += , ?= y != en lugar del signo igual ( = ). [48]
Las reglas de sufijo tienen "objetivos" con nombres en el formato .FROM.TOy se utilizan para iniciar acciones basadas en la extensión del archivo. En las líneas de comando de las reglas de sufijo, POSIX especifica [49] que la macro interna $<hace referencia al primer prerrequisito y $@hace referencia al objetivo. 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.txt lynx -dump archivo.html > archivo.txtLas reglas de sufijo no pueden tener requisitos previos propios. [50] Si los tienen, se tratan como archivos normales con nombres inusuales, no como reglas de sufijo. GNU Make admite reglas de sufijo para compatibilidad con archivos make antiguos, pero por lo demás fomenta el uso de reglas de patrón . [51]
Una regla de patrón se parece a una regla normal, excepto que su objetivo 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, [52] 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 así:
# De %.html a %.txt %.txt : % .html lynx -dump $< > $@ Los comentarios de una sola línea comienzan con el símbolo almohadilla (#).
Una directiva especifica un comportamiento especial, como incluir otro archivo Make.
La continuación de una línea se indica con un \carácter de barra invertida al final de una línea.
objetivo: componente \ componente Tab ↹comando ; \ comando | \ comando canalizadoTab ↹Tab ↹
Los siguientes comandos están en el contexto del makefile que sigue.
make # actualiza el primer objetivo, 'all'
make help # actualiza el objetivo 'help' para enumerar los objetivos
make dist # actualiza el objetivo 'dist' para compilarlo para la distribución PAQUETE = paquete VERSIÓN = ` fecha "+%Y.%m%d%" ` DIR_DE_LANZAMIENTO = .. ARCHIVO_DE_LANZAMIENTO = $( PAQUETE ) - $( VERSIÓN ) # Objetivo predeterminado # nota: la variable LOGNAME proviene del entorno all : echo "Hola $( LOGNAME ) , no hay nada que hacer por defecto" echo "Prueba 'make help'" # Mostrar objetivos buscando en este archivo ayuda : egrep "^# target:" [ Mm ] akefile # Crear una distribución de lanzamiento : tar -cf $( DIR_DE_LANZAMIENTO ) / $( ARCHIVO_DE_LANZAMIENTO ) && \ gzip -9 $( DIR_DE_LANZAMIENTO ) / $( ARCHIVO_DE_LANZAMIENTO ) .tar A continuación se muestra un makefile simple que, de manera predeterminada (la regla "all" se enumera primero), compila un archivo fuente llamado "helloworld.c" utilizando el compilador C del sistema y también proporciona un destino "limpio" para eliminar los archivos generados si el usuario desea comenzar de nuevo. $@y $<son dos de las llamadas macros internas (también conocidas como variables automáticas) y representan el nombre del destino y la fuente "implícita", respectivamente. En el ejemplo siguiente, $^se expande a una lista delimitada por espacios de los requisitos previos. Hay una serie de otras macros internas. [49] [53]
Indicadores CF ?= -g todos : holamundo holamundo : holamundo . o $( CC ) $( LDFLAGS ) -o $@ $^ holamundo.o : holamundo . c $( CC ) $( CFLAGS ) -c -o $@ $< limpio : $( RM ) holamundo holamundo.o Muchos sistemas vienen con reglas y macros predefinidas de Make para especificar tareas comunes, como la compilación basada en el sufijo del archivo. Esto permite a los usuarios omitir las instrucciones reales (a menudo no portables) sobre cómo generar el destino a partir de las fuentes. En un sistema de este tipo, el archivo Make anterior se podría modificar de la siguiente manera:
todos : holamundo holamundo : holamundo . o $( CC ) $( CFLAGS ) $( LDFLAGS ) -o $@ $^ limpio : $( RM ) holamundo holamundo.o # regla de sufijo .co : $( CC ) $( CFLAGS ) -c $< .SUFIJOS : . c
Ahora Make se encarga automáticamente de que "helloworld.o" dependa de "helloworld.c". En un ejemplo tan simple como el que se ilustra aquí, esto apenas importa, pero el verdadero poder de las reglas de sufijo se hace evidente cuando el número 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 de objeto como requisitos previos. Make determinará entonces implícitamente cómo crear todos los archivos de objeto y buscará cambios en todos los archivos fuente.
Las reglas de sufijo simples funcionan bien siempre que los archivos fuente no dependan entre sí ni de otros archivos, como los archivos de encabezado. Otra forma de simplificar el proceso de compilación es utilizar las llamadas reglas de coincidencia de patrones que se pueden combinar con la generación de dependencias asistida por compilador. Como último ejemplo que requiere el compilador gcc y GNU Make, aquí hay un makefile genérico que compila todos los archivos C en una carpeta en los archivos de objeto correspondientes y luego los vincula al ejecutable final. Antes de que se realice la compilación, las dependencias se recopilan en un formato compatible con el makefile en un archivo oculto ".depend" que luego se incluye en el makefile. Los programas portables deben evitar las construcciones que se utilizan a continuación.
# Archivo genérico GNUMake# fragmento que fallará si no es GNU ifneq (,) Este makefile requiere GNU Make. endif PROGRAMA = foo C_ARCHIVOS := $( comodín *.c ) OBJS := $( patsubst %.c, %.o, $( C_ARCHIVOS )) CC = cc CFLAGS = -Wall -pedantic LDFLAGS = LDLIBS = -lm todos : $( PROGRAMA ) $(PROGRAMA) : . depende $( OBJS ) $( CC ) $( CFLAGS ) $( OBJS ) $( LDFLAGS ) -o $( PROGRAMA ) $( LDLIBS ) depender : . depender.depend : cmd = gcc - MM - MF depend $( var ) ; cat depend >> . depend ; .depend : @echo "Generando dependencias..." @ $( foreach var, $( C_FILES ) , $( cmd )) @rm -f depend -incluir .depend# Estas son las reglas de coincidencia de patrones. Además de las variables automáticas que se usan 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 $@ $< limpio : rm -f .depend $( OBJS ) .PHONY : depende de la limpieza Makefile consta de dependencias y una dependencia olvidada o adicional puede no ser inmediatamente obvia para el usuario y puede resultar en errores sutiles en el software generado que son difíciles de detectar. Se pueden utilizar varios enfoques para evitar este problema y mantener las dependencias en el código fuente y los makefiles sincronizados. Un enfoque es usar un compilador para realizar un seguimiento de los cambios en las dependencias; por ejemplo, GCC puede analizar estáticamente el código fuente y producir reglas para el archivo dado automáticamente usando -MMswitch. El otro enfoque serían los makefiles o herramientas de terceros que generarían makefiles con dependencias (por ejemplo, la cadena de herramientas Automake del Proyecto GNU puede hacerlo automáticamente).
Otro enfoque es utilizar herramientas de metacompilación como CMake , Meson , etc.
En el mantenimiento general de DWB, hemos utilizado el sistema de control de código fuente y la utilidad de creación proporcionada por el sistema operativo interactivo PWB/UNIX*.
.svg/1280px-Free_and_open-source_software_logo_(2009).svg.png){kind=logo}
{{cite web}}: CS1 maint: bot: estado de URL original desconocido ( enlace )Make incluye la inclusión de archivos Make, estructuras condicionales y bucles for que recuerdan al lenguaje de programación C.
