Una breve introducción a 'MakeFiles' en desarrollo de software de código abierto con GNU Make

GNU Make es una utilidad de desarrollo que determina las partes de una base de código particular que se recompilarán y pueden emitir comandos para realizar esas operaciones en la base de código. Este particular hacer La utilidad se puede usar con cualquier lenguaje de programación siempre que su compilación se pueda hacer desde el shell emitiendo comandos.

Para usar GNU Make, Necesitamos tener algún conjunto de reglas que define la relación entre diferentes archivos en nuestro programa y comandos para actualizar cada archivo. Estos se escriben en un archivo especial llamado 'makfile'. El 'hacer'El comando usa el'makfile'Base de datos y los últimos tiempos de modificación de los archivos para decidir qué archivos se volverán a compilarse nuevamente.

Contenido de un makil

Generalmente 'muelles'Contiene 5 tipos de cosas, a saber: reglas implícitas, reglas explícitas, Definiciones variables, directivas, y comentario.

1. Un regla explícita Especifica cómo hacer/rehacer uno o más archivos (llamados objetivos, se explicará más adelante) y cuándo hacer lo mismo.
2. Un regla implícita Especifica cómo hacer/rehacer uno o más archivos en función de sus nombres. Describe cómo un nombre de archivo de destino está relacionado con un archivo con un nombre similar al objetivo.
3. A definición variable es una línea que especifica un valor de cadena para que una variable se sustituya más adelante.
4. A directiva es una instrucción para hacer algo especial mientras lee el makfile.
5. A '#'Se utiliza el símbolo representan el comienzo de un comentario adentro muelles. Una línea que comienza con '#'es simplemente ignorado.

Estructura de Makfiles

La información que dice hacer Cómo recompilar un sistema proviene de leer una base de datos llamada makfile. Un simple makfile Consiste en reglas de la siguiente sintaxis:

Target ...: Requisitos previos ... receta .. 

A objetivo se define como el archivo de salida generado por el programa. También puede ser Objetivos falsos, que se explicará a continuación. Ejemplos de archivos de destino incluyen ejecutables, archivos de objetos o Objetivos falsos como limpio, instalar, desinstalar etc.

A requisito previo es un archivo que se usa como entrada para crear los archivos de destino.

A receta es la acción que hacer se realiza para crear el archivo de destino en función de los requisitos previos. Es necesario poner el personaje de la tabla antes de cada receta dentro del muelles A menos que especifiquemos el '.Recipeprefix'variable para definir otro personaje como prefijo a receta.

Una muestra de makfile

Final: Principal.o Fin.o Inter.o Comienza.o GCC -O Final Main.o Fin.o Inter.o Comienza.o Principal.O: principal.C Global.H GCC -C Main.C End.o: fin.c local.H Global.H GCC -C Fin.C Inter.O: Inter.C Global.H GCC -C Inter.c inicio.O: Comienza.C Global.H GCC -C Inicio.C Clean: RM -F Principal.o Fin.o Inter.o Comienza.O

En el ejemplo anterior usamos 4 C archivos de origen y dos archivos de encabezado para crear el ejecutable final. Aquí cada uno '.O'El archivo es tanto un objetivo como un requisito previo dentro del makfile. Ahora eche un vistazo al último nombre objetivo limpio. Es solo una acción en lugar de un archivo objetivo.

Como normalmente no necesitamos esto durante la compilación, no se escribe como un requisito previo en ninguna otra regla. Los objetivos que no se refieren a los archivos, pero se llaman solo acciones Objetivos falsos. No tendrán requisitos previos como otros archivos de destino.

¿Cómo GNU hace que el proceso sea un archivo de make

Por defecto hacer comienza con el primer objetivo en el 'makfile'y se llama como'objetivo predeterminado'. Teniendo en cuenta nuestro ejemplo, tenemos final Como nuestro primer objetivo. Dado que sus requisitos previos incluyen otros archivos de objetos, se deben actualizar antes de crear final. Cada uno de estos requisitos previos se procesa de acuerdo con sus propias reglas.

La recompilación ocurre si se hacen modificaciones a archivos fuente o archivos de encabezado o si el archivo de objeto no existe en absoluto. Después de volver a compilar los archivos de objetos necesarios, hacer Decide si volver a reiniciar final O no. Esto debe hacerse si el archivo final no existe, o si alguno de los archivos de objeto es más nuevo que él.

Así, si cambiamos el archivo enterrar.C, luego en correr hacer Recomchará el archivo de origen para actualizar el archivo de objeto enterrar.O y luego enlace final.

Usar variables dentro de Makefiles

En nuestro ejemplo, tuvimos que enumerar todo el archivos de objetos dos veces en la regla para final Como se muestra abajo.

Final: Principal.o Fin.o Inter.o Comienza.o GCC -O Final Main.o Fin.o Inter.o Comienza.O

Para evitar tales duplicaciones, podemos introducir variables para almacenar la lista de archivos de objetos que se están utilizando dentro del makfile. Mediante el uso de la variable Obj Podemos reescribir la muestra makfile a uno similar que se muestra a continuación.

Obj = principal.o Fin.o Inter.o Comienza.o Final: $ (OBJ) GCC -O final $ (OBJ) Main.O: principal.C Global.H GCC -C Main.C End.o: fin.c local.H Global.H GCC -C Fin.C Inter.O: Inter.C Global.H GCC -C Inter.c inicio.O: Comienza.C Global.H GCC -C Inicio.C Clean: RM -F $ (OBJ)

Reglas para limpiar el directorio de origen

Como vimos en el ejemplo makfile, Podemos definir reglas para limpiar El directorio de origen eliminando los archivos de objetos no deseados después de la compilación. Supongamos que tenemos un archivo objetivo llamado limpio. Como puede hacer diferenciar las dos situaciones anteriores? Aquí viene el concepto de Objetivos falsos.

A objetivo falso es uno que no es realmente el nombre de un archivo, sino que es solo un nombre para que se ejecute una receta cada vez que se realiza una solicitud explícita del makfile. Una razón principal para usar objetivo falso es evitar un conflicto con un archivo del mismo nombre. Otra razón es mejorar el rendimiento.

Para explicar esto, revelaré un giro inesperado. La receta de limpio no se ejecutará de forma predeterminada en ejecución hacer. En su lugar, es necesario invocar lo mismo emitiendo el comando hacer limpia.

.Pelato: limpio limpio: RM -f $ (OBJ)

Ahora intenta crear muelles para su propia base de código. Siéntase libre de comentar aquí con sus dudas.