Hacer (software)

En el desarrollo de software , Make es una herramienta de interfaz de línea de comandos que ejecuta acciones ordenadas según las dependencias configuradas , tal como se define en un archivo de configuración llamado makefile . Se usa comúnmente para automatizar la compilación y generar código ejecutable (como un programa o una biblioteca ) a partir del código fuente . Make no se limita a la compilación y puede realizar cualquier operación disponible a través del intérprete de comandos del sistema operativo .

Make es ampliamente utilizado, especialmente en sistemas operativos Unix y similares a Unix , aunque existen muchas tecnologías y herramientas competidoras, 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 original de Unix , Make también es una tecnología, ya que se han implementado múltiples herramientas con prácticamente la misma funcionalidad , incluyendo una sintaxis y semántica de makefile similares .

Stuart Feldman creó Make mientras trabajaba en Bell Labs . Una versión inicial se completó en abril de 1976. ^{[ 1 ] [ 2 ] [ 3 ]} Feldman recibió el premio ACM Software System Award de 2003 por ser el autor de Make. ^{[ 4 ]}

Feldman describe la inspiración para escribir Make como resultado de la frustración de un compañero de trabajo con las herramientas disponibles en ese momento:

Make surgió a raíz de la visita de Steve Johnson (autor de yacc, etc.), quien irrumpió en mi oficina maldiciendo al destino por haberle hecho perder una mañana depurando un programa que funcionaba correctamente (el error ya se había corregido, el archivo no se había compilado y, cc *.opor lo tanto, no se vio afectado). Como yo había pasado parte de la noche anterior lidiando con el mismo problema en un proyecto en el que estaba trabajando, surgió la idea de una herramienta para solucionarlo. Empezó con una elaborada idea de un analizador de dependencias, que se simplificó considerablemente y se convirtió en Make ese mismo fin de semana. El uso de herramientas aún en desarrollo era parte de la cultura. Los Makefiles eran archivos de texto, no binarios codificados mágicamente, porque esa era la filosofía de Unix : cosas imprimibles, depurables y comprensibles.

Antes de Make, la compilación en Unix consistía principalmente en scripts de shell escritos para el código fuente de cada programa. El ordenamiento de dependencias y la comprobación de versiones obsoletas de Make hacen que el proceso de compilación sea más robusto y eficiente. El archivo makefile permitió una mejor organización de la lógica de compilación y, a menudo, un menor número de archivos de compilación.

Make es ampliamente utilizado en parte debido a su temprana inclusión en Unix , comenzando con PWB/UNIX 1.0, que presentaba una variedad de herramientas de desarrollo de software. ^{[ 3 ]}

Make se ha implementado numerosas veces, generalmente utilizando el mismo formato de archivo makefile y proporcionando las mismas características, pero algunas incorporan mejoras respecto al original. Ejemplos:

• Sun DevPro Make apareció en 1986 con SunOS-3.2. Con SunOS-3.2, se distribuyó como un programa opcional; con SunOS-4.0, SunPro Make se convirtió en el programa Make predeterminado. ^{[ 5 ]} En diciembre de 2006, Sun DevPro Make se convirtió en código abierto como parte de los esfuerzos para liberar el código fuente de Solaris . ^{[ 6 ] [ 7 ]}
• dmake o Distributed Make venía con Sun Solaris Studio como su Make predeterminado, pero no el predeterminado en el sistema operativo Solaris (SunOS). Originalmente era necesario para compilar OpenOffice, pero en 2009 ^{[ 8 ]} el sistema de compilación se reescribió 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 distintos grados de modificación en FreeBSD , ^{[ 11 ]} NetBSD ^{[ 13 ]} y OpenBSD . ^{[ 14 ]} De manera distintiva, tiene condicionales y bucles iterativos que se aplican en la etapa de análisis y pueden usarse para construir condicional y programáticamente el makefile, ^{[ 15 ]} incluyendo la generación de objetivos en tiempo de ejecución.
• GNU Make (abreviado gmake ) es la implementación estándar de Make para Linux y macOS. ^{[ 16 ]} Proporciona varias extensiones sobre el Make original, como condicionales. También proporciona muchas funciones integradas que se pueden usar para eliminar la necesidad de usar scripts de shell en las reglas del makefile, así como para manipular las variables establecidas y utilizadas en el makefile. ^{[ 17 ]} Por ejemplo, la función foreach se puede usar para iterar sobre una lista de valores, como los nombres de los archivos en un directorio dado. ^{[ 18 ]} GNU Make es necesario para compilar muchos sistemas de software, incluyendo GNU Compiler Collection (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 una mejor información de ubicación y ubicación de errores, seguimiento de ejecución, perfilado de ejecución y contiene un depurador.
• nmake de Glenn Fowler ^{[ 24 ]} (sin relación con la variante de Microsoft del mismo nombre) es incompatible con la variante UNIX, pero proporciona características que, según algunos, reducen el tamaño de los makefiles en un factor de 10.
• Microsoft nmake normalmente se instala con Visual Studio . ^{[ 25 ]} Admite directivas de preprocesador como inclusiones y expresiones condicionales que utilizan variables definidas en la línea de comandos o dentro de los makefiles. ^{[ 26 ] [ 27 ]} Las reglas de inferencia difieren de Make; por ejemplo, pueden incluir rutas de búsqueda. ^{[ 28 ]}
• Embarcadero make tiene una opción de línea de comandos que "Hace que MAKE imite a NMAKE de Microsoft". ^{[ 29 ]}
• La herramienta Jom del proyecto Qt es un clon de nmake. ^{[ 30 ]}
• Mk reemplazó a Make en 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 compilación estándar en Plan 9 , el sucesor previsto de Unix por Bell Labs. ^{[ 32 ]}
• Kati es el reemplazo de GNU Make por parte de Google, utilizado desde 2020 en las compilaciones del sistema operativo Android . Traduce el archivo makefile a ninja para compilaciones incrementales más rápidas (similar a la metaherramienta cmake). ^{[ 33 ]}
• Snakemake es una implementación basada en Python para compilar y ejecutar flujos de trabajo bioinformáticos . ^{[ 34 ]}

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, los makefiles simples se pueden usar entre varias versiones de Make con un éxito razonable. GNU Make, Makepp y algunas versiones de BSD Make buscan por defecto primero los archivos llamados "GNUmakefile", ^{[ 35 ]} "Makeppfile" ^{[ 36 ]} y "BSDmakefile" ^{[ 37 ]} respectivamente, lo que permite colocar makefiles que usan un comportamiento definido por la implementación en ubicaciones separadas.

En general, basándose en un archivo makefile, Make actualiza los archivos de destino a partir de los archivos fuente si alguno de ellos tiene una marca de tiempo más reciente que el archivo de destino o si este último no existe. Por ejemplo, esto podría incluir compilar archivos C*.c en archivos objeto y luego enlazarlos para crear un programa ejecutable. También podría incluir compilar archivos TypeScript*.ts a JavaScript para su uso en un navegador. Otros ejemplos incluyen: convertir un archivo de imagen fuente 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, cada uno de los cuales es un archivo a generar o un concepto definido por el usuario, denominado objetivo ficticio .

Realizar actualizaciones en los objetivos pasados ​​como argumentos:

make [ -f makefile ] [ opciones ] [ objetivos ]

Si no se especifica ningún objetivo, Make actualiza el primer objetivo del archivo makefile, que suele ser un objetivo ficticio para realizar la acción más utilizada.

Make omite acciones de compilación si la marca de tiempo del archivo de destino es posterior a la de los archivos fuente. ^{[ 38 ]} Esto optimiza el proceso de compilación al omitir acciones cuando el archivo de destino está actualizado, pero a veces las actualizaciones se omiten erróneamente debido a problemas con la marca de tiempo del archivo, como la restauración de una versión anterior de un archivo fuente, o cuando un sistema de archivos de red es la fuente de archivos y su reloj o zona horaria no está sincronizado con la máquina que ejecuta Make. Además, si la marca de tiempo de un archivo fuente es futura, Make activa repetidamente acciones innecesarias, lo que provoca un tiempo de compilación más prolongado.

Cuando Make se inicia, utiliza el archivo makefile especificado en la línea de comandos o, si no se especifica, utiliza el que encuentra mediante reglas de búsqueda específicas. Generalmente, Make utiliza por defecto el archivo en el directorio de trabajo llamado Makefile . GNU Make busca el primer archivo que coincida con: GNUmakefile , makefile o Makefile .

Realizar procesos según las opciones de la línea de comandos en función del archivo makefile cargado.

El lenguaje makefile es programación parcialmente declarativa donde se describen las condiciones finales, pero no el orden en que se deben realizar las acciones. ^{[ 40 ] [ 41 ] [ 42 ] [ 43 ]}

Los archivos Makefile pueden contener las siguientes construcciones: ^{[ 44 ]}

• Regla explícita : define cuándo y cómo actualizar un objetivo, enumerando los requisitos previos (objetivos dependientes) y los comandos que definen la acción de actualización, denominada receta.
• Regla implícita : define cuándo y cómo recrear una clase de archivos en función de sus nombres, incluyendo cómo un objetivo depende de un archivo con un nombre similar al del objetivo y una receta de actualización.
• Definición de variable : asocia un valor de texto con un nombre que puede sustituirse en texto posterior.
• Directiva : instrucción para realizar alguna acción especial, como incluir otro archivo makefile.
• Comentario : línea que comienza con#

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

objetivos : prerrequisitos ; comando

hola : ; @ echo " hola " 

.RECIPEPREFIX := : all : :@echo "El símbolo de prefijo de receta está establecido en '$(.RECIPEPREFIX)'"

realclean : limpiar destclean

archivo.txt : archivo.html lynx -dump archivo.html > archivo.txt ​​

MACRO = definición 

NUEVA_MACRO = $( MACRO ) - $( MACRO2 )

AAAAMMDD != fecha 

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

objetivo : componente 1 componente 2  # echo componentes MÁS JÚNIROS que OBJETIVO echo $?  # echo nombre de OBJETIVO echo $@

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

$ make -n file.txt lynx -dump file.html > file.txt

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

 objetivo: componente \ componente Tab ↹dominio ; \ otro-comando | \ comando canalizado

Los siguientes comandos se encuentran en el contexto del archivo makefile que se muestra a continuación.

make # actualiza el primer objetivo, 'all' make help # actualiza el objetivo 'help' para listar objetivos make dist # actualiza el objetivo 'dist' para compilar para distribución

PAQUETE = paquete VERSIÓN = ` fecha "+%Y.%m%d%" ` DIRECTORIO_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 help : egrep "^# target:" [ Mm ] akefile# Crea una distribución de lanzamiento : tar -cf $( RELEASE_DIR ) / $( RELEASE_FILE ) && \ gzip -9 $( RELEASE_DIR ) / $( RELEASE_FILE ) .tar 

A continuación se muestra un archivo makefile simple que, por defecto (la regla "all" aparece primero), compila un archivo fuente llamado "helloworld.c" utilizando el compilador C del sistema y también proporciona un objetivo "clean" 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 objetivo y la fuente "implícita", respectivamente. En el ejemplo siguiente, $^se expande a una lista de prerrequisitos delimitada por espacios. Hay varias otras macros internas. ^{[ 50 ] [ 54 ]}

CFLAGS ?= -g LDLIBS += -lmtodo : Salida.txt​​Out.txt : helloworld ./$< > $@helloworld : helloworld . o $( CC ) $( LDFLAGS ) -o $@ $^ $( LDLIBS )holamundo.o : holamundo . c $( CC ) $( CFLAGS ) -c -o $@ $<limpiar : $( RM ) Out.txt helloworld helloworld.o 

Muchos sistemas incluyen reglas y macros de Make predefinidas 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 del código fuente. En un sistema de este tipo, el archivo makefile anterior podría modificarse de la siguiente manera:

todos : hola mundohelloworld : helloworld . o $( CC ) $( CFLAGS ) $( LDFLAGS ) -o $@ $^limpio : $( RM ) helloworld helloworld.o# regla de sufijo .co : $( CC ) $( CFLAGS ) -c $<.SUFIJOS : . c

La dependencia de "helloworld.o" con "helloworld.c" ahora se gestiona automáticamente con Make. En un ejemplo tan sencillo como el que se muestra aquí, esto apenas importa, pero el verdadero potencial de las reglas de sufijo se hace evidente cuando aumenta el número de archivos fuente en un proyecto de software. Basta con escribir una regla para el paso de enlace y declarar los archivos objeto como prerrequisitos. Make determinará entonces implícitamente cómo compilar todos los archivos 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 cabecera. Otra forma de simplificar el proceso de compilació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 makefile genérico que compila todos los archivos C de una carpeta a los archivos objeto correspondientes y luego los enlaza al ejecutable final. Antes de la compilación, las dependencias se recopilan en un formato compatible con makefile en un archivo oculto ".depend", que luego se incluye en el makefile. Los programas portátiles deben evitar las construcciones que se utilizan a continuación.

# Archivo GNUMakefile genérico# Fragmento que fallará si no se cumple la condición de GNU ifneq (,) Este archivo makefile requiere GNU Make. endifPROGRAMA = foo C_FILES := $( comodín *.c ) OBJS := $( patsubst %.c, %.o, $( C_FILES )) CC = cc CFLAGS = -Wall -pedantic LDFLAGS = LDLIBS = -lmtodos : $( PROGRAMA )$(PROGRAM) : . depende $( OBJS ) $( CC ) $( CFLAGS ) $( OBJS ) $( LDFLAGS ) -o $( PROGRAM ) $( 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 # utilizadas 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 ).FALSO : limpio depende

Los archivos Makefile incluyen dependencias, y una dependencia olvidada o adicional puede no ser evidente para el usuario y provocar errores sutiles en el software generado, difíciles de detectar. Existen diversos enfoques para evitar este problema y mantener sincronizadas las dependencias entre el código fuente y los archivos Makefile. Un enfoque consiste en utilizar el compilador para controlar los cambios en las dependencias. GCC puede analizar estáticamente el código fuente y generar reglas para el archivo especificado automáticamente mediante un -MMinterruptor. Otro enfoque sería utilizar archivos Makefile o herramientas de terceros que generen archivos Makefile con dependencias (por ejemplo, la cadena de herramientas Automake del Proyecto GNU puede hacerlo automáticamente).

Otro enfoque consiste en utilizar herramientas de meta-compilación como CMake , Meson , etc.

• Grafo de dependencias : grafo dirigido que representa dependencias. 
• Lista de software de automatización de compilación

• Página principal de GNU Make
• Make : un programa para el mantenimiento de programas informáticos. Artículo de Stuart Feldman de 1978 que describe make.