Comando make de Linux con ejemplos

Introducción

Linux make command es una utilidad comúnmente utilizada por administradores de sistemas y desarrolladores. El comando ayuda en el proceso de compilación y es una herramienta imprescindible para crear aplicaciones grandes. Esta utilidad elimina la repetición y acelera la compilación, ahorrando tiempo.

Este artículo le mostrará cómo usar Linux make comando con ejemplos.

Requisitos previos

• Acceso a la terminal.
• El make función instalada.
• Un editor de texto.

Nota: Si make no está disponible en el sistema, use sudo apt install make .

¿Cómo funciona el comando make?

El make El comando compila diferentes piezas del programa y crea un ejecutable final. El propósito de make es automatizar la compilación de archivos, haciendo que el proceso sea más simple y menos lento.

El comando funciona con cualquier lenguaje de programación siempre que el compilador se pueda ejecutar con un comando de shell.

La compilación es sencilla cuando se trabaja con unos pocos archivos. Por lo tanto, el proceso incluye invocar al compilador y enumerar los nombres de los archivos.

Por ejemplo, para compilar un programa en C a partir de tres archivos (file1.c , archivo2.c , archivo3.h ):

Invoque el compilador con:

gcc file1.c file2.c file3.h

El gcc comando crea un a.out archivo, que es un ejecutable compilado estándar.

Sin embargo, cambiar uno de los archivos de origen requiere volver a compilar todo, lo que es aún más complicado cuando se trabaja con aplicaciones grandes. El make El comando automatiza el proceso, lo que permite a los usuarios actualizar solo las partes que deben cambiarse sin volver a compilar cada archivo.

El make El comando utiliza un archivo generado por el usuario, Makefile, para compilar partes del programa. Cuando se ejecuta por primera vez, make busca en el Makefile instrucciones, por ejemplo, descripciones de archivos y horas de modificación. Según los datos disponibles, make decide qué archivos deben actualizarse y emite los comandos necesarios.

¿Qué son los archivos MAKE?

Un Makefile es un archivo de texto que contiene un conjunto de reglas que dan instrucciones a make cómo construir una aplicación. Una regla consta de tres partes:el objetivo , dependencias y comando(s) .

La sintaxis básica de Makefile es:

target: dependencies
<TAB> commands

Partes de la sintaxis son:

• Objetivos . Nombres de los archivos que se crearán o actualizarán después de ejecutar make .
• Dependencias . Nombres de los archivos (separados por espacios) a partir de los cuales se construye el objetivo.
• Los comandos . Reglas que describen cómo crear o actualizar el destino cuando cambian las dependencias.

Un Makefile tiene varios conjuntos de reglas. La primera regla es la predeterminada y establece cómo se creará el ejecutable final (el destino) a partir de archivos de objeto (dependencias) aún no creados:

La sintaxis en este caso es:

EXECUTABLE: Object file 1, Object file 2
<TAB> commands

Nota: Los comandos en Makefiles siempre vienen después de TAB llave. De lo contrario, el comando no funciona.

Después de establecer la regla uno, el usuario agrega instrucciones sobre cómo crear archivos de objetos:

El make El comando funciona compilando archivos de origen en archivos de objeto y luego compilando archivos de objeto en el archivo de destino, el ejecutable final. La sintaxis de Makefile con las tres reglas mencionadas anteriormente es:

EXECUTABLE: Object file 1, Object file 2
<TAB> commands

Object file 1: Source file 1, Source file 2
<TAB> commands

Object file 2: Source file 2
<TAB> commands

Sintaxis del comando make de Linux

El make básico la sintaxis se ve así:

make [OPTIONS]

Cuando se ejecuta sin argumentos, make crea el primer objetivo a partir del Makefile.

Opciones de comando Linux make

El make El comando es ampliamente utilizado debido a su efectividad, variedad y capacidad para realizar acciones específicas. Mientras que el comando imprime el resultado cuando se ejecuta sin opciones, agregar argumentos expande make 's usabilidad

Estas son las opciones más utilizadas:

Comando	Descripción
-B , --always-make	Compila incondicionalmente todos los objetivos.
-d , --debug[=FLAGS]	Imprime la información de depuración.
-C dir , --directory=dir	Cambia el directorio antes de ejecutar el Makefile.
-f file , --file=file , --Makefile=FILE	Utiliza un archivo específico como Makefile.
-i , --ignore-errors	Ignora todos los errores en los comandos.
-I dir , --include-dir=dir	Especifica un directorio para buscar el Makefile especificado.
-j [jobs] , --jobs[=jobs]	Especifica el número de trabajos que se ejecutarán simultáneamente.
-k , --keep-going	Continúa ejecutando make durante el mayor tiempo posible después de recibir un error.
-l [load] , --load-average[=load]	Especifica que no se debe iniciar ninguna tarea nueva si hay otras tareas en la cola.
-n , --dry-run , --just-print , --recon	Imprime la salida esperada sin ejecutar make .
-o file , --old-file=file , --assume-old=file	Se asegura de que make no rehace el archivo incluso si es más antiguo que las dependencias.
-p , --print-data-base	Imprime la base de datos producida después de leer el Makefile.
-q , --question	Activa el modo Pregunta, en el que make no ejecuta ningún comando pero devuelve un estado de salida cero si el objetivo ya está compilado.
-r , --no-builtin-rules	Elimina las reglas implícitas integradas.
-s , --silent , --quiet	Restringe la impresión de los comandos a medida que se ejecutan.
-S , --no-keep-going , --stop	Detiene "-k , --keep-going " comando.
-t , --touch	Toca archivos en lugar de ejecutar los comandos.
--trace	Rastrea la disposición de cada objetivo.
-W file , --what-if=file , --new-file=file , --assume-new=file	Ignora el hecho de que el archivo de destino ha sido modificado.
--warn-undefined-variables	Advierte que se hace referencia a una variable desconocida.

Ejemplos de comandos make de Linux

La mejor manera de entender make y Makefiles es ejecutando el comando y diferentes opciones en un programa simple.

Por ejemplo, para crear un ejecutable que imprima el mensaje "Más información sobre Makefiles" , sigue estos pasos:

1. Cree un directorio llamado Prueba .

2. Cree tres archivos fuente main.c , texto.c y texto.h :

• principal.c - es el archivo con la función principal (int main ) que llama a una función desde otro archivo.

• texto.c - es el archivo con el que desea imprimir "¡Aprenda sobre Makefiles!".

• texto.h - es el archivo de encabezado con declaraciones para las funciones. El encabezado se incluye tanto en c archivos con el #include argumento, que tiene el mismo propósito que copiar/pegar el contenido del encabezado.

Las siguientes secciones ilustran algunos casos de uso comunes de make y Makefiles en los tres archivos mencionados anteriormente.

Nota: Los siguientes ejemplos están escritos en lenguaje C.

Crear un programa

Hay dos formas de crear un programa:

• Compilar archivos de forma estándar invocando el compilador gcc. Este método es adecuado para programas más pequeños.
• Uso de make y Makefiles.

Crear un programa con el compilador gcc

Use el compilador gcc solo para programas simples. De lo contrario, use Makefiles cuando trabaje con una gran cantidad de archivos.

Para crear un programa con el compilador:

1. Abra la terminal y navegue hasta el directorio que contiene los archivos.

2. Invoca el gcc compilador y escriba el nombre de ambos c archivos El encabezado no se compila porque ya está incluido en c archivos.

gcc main.c text.c

3. Enumere todos los archivos en el directorio actual con el ls comando:

ls

La terminal muestra que el nuevo ejecutable a.out se crea el archivo. El ejecutable también se ve a través de un explorador de archivos:

Para probar si la compilación fue exitosa, invoque el ejecutable con:

./a.out

La terminal muestra que el ejecutable funciona correctamente.

Cree un programa con Make y Makefiles

Compilar archivos con make y Makefiles es más simple que usar el compilador. Comience por crear un nuevo documento de texto en el mismo directorio y asígnele el nombre Makefile o archivo make .

Abra el archivo y use la sintaxis básica de Makefile como guía:

1. Escriba el nombre del nuevo ejecutable como destino, por ejemplo, my_app.

2. Agregar archivos de objetos main.o y texto.o como las dependencias. El make El comando vuelve a compilar el destino cada vez que cambian los archivos de objetos.

3. Presiona TAB e invoque el gcc compilador para los archivos objeto:

<TAB> gcc main.o text.o

4. Agrega el -o marcar y nombrar el objetivo my_app.

Después de escribir la primera regla, el Makefile se ve así:

my_app: main.o text.o
<TAB> gcc main.o text.o -o my_app

A continuación, instruya al Makefile sobre cómo crear principal.o :

1. Establecer main.o como objetivo.

2. Escribe main.c como la dependencia. principal.c sirve para crear y actualizar main.o .

3. Escriba el siguiente comando para actualizar main.o cada vez main.c cambios:

gcc -c main.c

4. Agregue el -c bandera para indicar al Makefile que no cree un nuevo ejecutable sino que solo lea el código y compile el archivo objeto.

main.o: main.c
<TAB> gcc -c main.c

Para crear text.o , establezca ese archivo como destino y agregue ambos text.c y texto.h como dependencias. Sin embargo, el gcc El comando solo compila el text.c archivo, ya que los encabezados nunca se compilan:

text.o: text.c text.h
<TAB> gcc -c text.c

Guarda el Makefile y escribe make en la terminal.

El make comando creó dos archivos de objeto (main.o y texto.o ) y el ejecutable (my_app ).

Para verificar que make creó nuevos archivos, ejecute ls de nuevo:

La terminal muestra que ejecutar el comando creó my_app . Para ejecutar my_app archivo, escriba:

./my_app

Actualizar el Programa

Cuando se cambia un archivo fuente, make solo actualiza los archivos de objetos dependiendo de ese archivo fuente. Por ejemplo, para cambiar el texto que se muestra al ejecutar my_app de "Más información sobre Makefiles " a "Dónde estoy ?":

1. Abra texto.c en el editor de texto:

2. Cambia el texto a "¿Dónde estoy?" :

3. Guarde el archivo, abra la terminal y ejecute make :

El make el comando detectó cambios en text.c y recopiló solo ese archivo.

Para verificar el cambio, ejecute el ejecutable:

./my_app

Compilar todos los archivos

Para compilar todos los archivos y no solo los archivos modificados, use -B o --always-make opciones

Por ejemplo, para cambiar el texto en text.c volver a "Más información sobre Makefiles" y guarde el archivo, ingrese:

make -B

El resultado muestra que make compiló todos los archivos de la carpeta, incluso los que no se han modificado.

Limpiar archivos de objetos

Cuando un usuario ejecuta make por primera vez, el comando crea archivos de objetos y el ejecutable. Por lo tanto, para ordenar la carpeta de origen y limpiar los archivos de objetos, agregue el clean función al Makefile:

clean:
<TAB> rm *.o my_app

El comando consta de:

• El objetivo limpio sin dependencias - el objetivo siempre se considera obsoleto y siempre se ejecuta.
• El rm comando - elimina objetos especificados.
• El *.o parte - coincide con los archivos con o extensión y limpia los archivos de objetos y my_app .

Para limpiar archivos de objetos, ejecute:

make clean

Después de ejecutar ls de nuevo, la terminal muestra que los archivos de objeto y my_app han sido eliminados.

Ejecute make en modo de depuración

Ejecute make en modo de depuración para imprimir información adicional sobre el proceso de compilación. Ejecute make con el -d opción para mostrar la salida de depuración:

make -d

Usar un archivo diferente como Makefile

Por defecto, make busca un archivo llamado Makefile o makefile en el directorio actual. Para usar otro archivo, ejecute:

make -f [file_name]

Por ejemplo, si un Makefile se llama mi_archivo , ejecutar:

make -f my_file

Usar variables

Las variables en Makefiles representan múltiples nombres de archivo, argumentos, objetivos, dependencias, comandos, directorios de origen u otros elementos. Además, una variable se define por un nombre y representa una cadena de texto denominada valor de la variable.

Para definir una variable, use = . Por ejemplo, sustituya gcc con una variable C.

C=gcc

my_app: main.o text.o
<TAB> $ (C) main.o text.o -o my_app

main.o:main.c
<TAB> $ (C) -c main.c
        
text.o: text.c text.h
<TAB> $ (C) -c text.c

Al ejecutar make en la terminal, el comando lee el C variable como gcc :

Conclusión

Después de leer los ejemplos de este tutorial, sabrá cómo usar el make comando en Linux y cómo funciona.

A continuación, descargue la hoja de trucos de los comandos de Linux para conocer otros comandos importantes de Linux.