GNU Make Tutorial

GNU Make es una herramienta esencial para construir y administrar los proyectos, especialmente cuando el proyecto contiene diferentes archivos que se crean con diferentes herramientas. En ese caso, la marca GNU localiza el makfile para ese proyecto a medida que el archivo especifica las dependencias requeridas entre varios archivos en el proyecto dado y los comandos que se requieren para construir el proyecto.

GNU Make está diseñado para manejar grandes proyectos. Determina las secciones de un programa que debe ser recompilado después de una acción determinada y ofrece los comandos para recompilar las secciones. La publicación de hoy proporciona una guía práctica para comprender todo sobre GNU Make.

Comprender un makefile

GNU Make Reads the MakeFile of a Project para determinar qué debe hacer para construir y administrar el proyecto. Un Makefile tiene tres componentes clave: objetivo, requisito previo y receta.

A objetivo representa el archivo que el "hacerEl comando puede generar. El objetivo puede depender de los requisitos previos y también puede ser una acción a realizar. Idealmente, el objetivo destaca el archivo que se construirá una vez que ejecutemos el "hacer" dominio.

A requisito previo representa el archivo que se utilizará como entrada para crear el objetivo. Un objetivo puede depender de múltiples requisitos previos.

A receta es una acción o comando realizado por "hacer"Para recompilar el objetivo cada vez que cambia el requisito previo. La receta puede contener diferentes comandos en las mismas líneas o diferentes. A espacio de pestaña precede a cada nueva línea de recetas, y el editor plantea un error si se pierde al agregar el carácter de pestaña.

El receta actúa como una serie de comandos de shell que comienzan con un personaje de pestaña. Aquí hay un ejemplo de un simple archivo que resalta el objetivo, los requisitos previos y la receta:

El makfile provisto consiste en una regla en la receta. Tenga en cuenta que marca usa la primera regla en MakeFile como la regla predeterminada. Entonces, en tal makile ","hacer"Usa el GCC -O Bienvenido Genial.C Como regla general, para construir y administrar el proyecto. La regla especifica que para que usted haga el archivo para generar el bienvenido archivo, debemos ejecutar el comando que usa el excelente.C como la entrada para crear el bienvenido archivo.

De nuevo, no todas las reglas tienen un requisito previo. Por ejemplo, si tiene un archivo MakEl para eliminar los archivos intermedios que se crean al construir un archivo, dicha regla no tendrá ningún requisito previo. Eche un vistazo al siguiente ejemplo:

En este caso, la regla elimina todos los archivos que contienen un *.o Extensión. Por lo tanto, no se requiere un requisito previo en tal caso, ya que no se requiere recompilación del objetivo.

Trabajando con un makefile

El primer ejemplo es un proyecto C simple con dos archivos C y un archivo de encabezado. Creamos una función que imprime un mensaje de bienvenida e incluye un archivo de encabezado externo en nuestro proyecto.

Aquí está la función principal:

Nuestros archivos de encabezado se parecen a los siguientes:

Ahora, creemos un File que compile los archivos del proyecto para crear un archivo ejecutable en el directorio actual. Idealmente, ejecutamos el siguiente comando para construir el proyecto:

$ GCC -O Greatmake Mainfunc.C func1.C -I.

En la siguiente imagen, podemos notar cómo la compilación construye con éxito el proyecto. Si ejecutamos el archivo ejecutable creado, obtenemos la salida deseada.

¿Cómo podemos representar lo mismo y usar un archivo de make?? Aquí está la cosa: aunque compilar directamente el proyecto en la línea de comando funciona bien, el problema entra cuando cambia las computadoras o pierde el código de compilación. En tal caso, debe recompilar el proyecto. Nuevamente, cada vez que realiza cambios en un archivo, debe recompilar manualmente el proyecto para acomodar los cambios.

Toda esta molestia se puede excluir creando un archivo simple como se muestra en lo siguiente:

El makfile contiene dos objetivos: uno con requisitos previos y un comando y el otro con solo el comando.

Anteriormente, notamos que "hacer"Utiliza el primer comando como el comando predeterminado para construir el proyecto. Por lo tanto, podemos escribir hacer en el directorio del proyecto para ejecutar el comando para crear el proyecto. El comando Make genera el objetivo que es Greatmake Como el archivo ejecutable. Eche un vistazo a lo siguiente:

Ahora, podemos ejecutar cómodamente el archivo ejecutable para ver la salida del proyecto creado.

ps ./archivo de salida

Supongamos que usamos "hacer"Para ejecutar otro comando en lugar del predeterminado. Especifique el objetivo que desea ejecutar con el comando Make.

$ Make Target

Usemos el mismo MakFile y usemos el Hola Target:

Observe cómo logramos obtener "hacer"Para ejecutar el comando, ya que no se especifican requisitos previos con el objetivo.

Si realizamos algunos cambios en uno de los archivos del proyecto, ejecutando el "hacerEl comando acomoda los cambios sin necesidad de recompilar el proyecto manualmente.

Aún así, si ejecutas el "hacer"Comando sin nuevos cambios",hacer"Le notifica que el archivo ejecutable está actualizado.

Supongamos que no está seguro de los cambios que realizó o qué hace el comando hacer cuando se ejecuta. Puedes hacer una carrera seca agregando la bandera -n.

El primer ejemplo en la siguiente ilustración, la marca -norte, muestra el comando que se ejecuta con el comando predeterminado. En el siguiente caso, el Make -N muestra los cambios que se agregan al objetivo de Hello.

Si se siente cómodo con los cambios, puede ejecutar el comando Make para el objetivo dado para acomodar los cambios como en el siguiente ejemplo:

Cómo usar las variables MakeFile

Hasta ahora, entendimos cómo "hacer"Funciona con un makile. Sin embargo, nuestro enfoque hasta ahora no es el mejor para manejar grandes proyectos, especialmente cuando algunos valores deben cambiar con el tiempo. Un mejor enfoque implica el uso de variables de tal manera que si desea cambiar el compilador para el programa, puede editar la variable en lugar de cambiar manualmente el código MakeFile para el compilador.

Además, las variables ayudan a lograr un código de maquillaje limpio que cualquiera pueda leer y comprender.

Tengamos un ejemplo de uso de las variables para crear archivos.

En el makfile, definimos una variable nombrada archivos que contiene dos valores para los archivos que creamos cuando construimos el proyecto:

En este ejemplo, consulemos nuestro ejemplo anterior de compilar el programa C. Pero, en este caso, agregemos algunas variables que podemos cambiar a lo largo del programa.

Primero, especificamos la ruta que el compilador debe usar para ubicar los archivos de encabezado como el directorio actual (.). Un mejor enfoque es especificar la ruta como una variable. Puede especificar la variable que el compilador usará utilizando el Clags constantes especiales que se utilizan para comunicarse con el compilador.

CFLAGS = -I.

Utilizar el $ (CFLAGS) marcador de posición variable en lugar de la ruta.

Aún así, podemos establecer el compilador de tipo para usar como una variable, de modo que alguien que use un compilador diferente podría cambiar la variable para especificar un compilador para usar para su caso.

CC = GCC

Utilizar el $ (CC) marcador de posición variable en lugar del compilador. Aquí está el final de Makefile con las variables adicionales:

Cuando ejecutamos el comando Make, obtenemos la misma salida que anteriormente, solo que nuestro código MakeFile ahora es más limpio y eliminamos cualquier redundancia.

Al crear el makefile, puede crear una macro Obj para representar los requisitos previos que se requieren para crear un objetivo. De esa manera, puede editar rápidamente los archivos de objeto desde la macro sin manipular el otro makfile. Por ejemplo, podemos tener un Macro OBJ para nuestro objetivo como se muestra en lo siguiente:

Tenga en cuenta que reemplazamos los requisitos previos con la variable de objeto.

Manejo de dependencias

El "incluir"Los archivos dependen del".C"Archivos en el proyecto. Cuando trabajas con un proyecto grande y editas el "incluir" archivo, "Hacer" no recompilará el ".C"Archivos. Este error significa que su proyecto no se volverá a compilar correctamente a menos que hagamos que MakeFile note las dependencias existentes entre el ".C" y ".H"Archivos.

En ese caso, necesitamos usar la constante especial Deps para crear una macro para manejar estas dependencias. Podemos representar el DEPS como regla, como se muestra en lo siguiente:

La regla anterior primero crea un Deps macro cuyo valor es el archivo de encabezado en los archivos del proyecto. A continuación, instruye "hacer"Eso antes de que genera el".O"Archivo, primero debe compilar el".C"Archivo utilizando el compilador especificado. A continuación, el indicador -c indica el compilador para generar un archivo de objeto mientras el -o $@ instrucciones "hacer"Para poner la salida compilada a la izquierda del colon.

Con esta regla, manejamos todas las dependencias de tal manera que cada vez que cambiemos cualquier archivo ","hacer"Acomoda al recompensa el proyecto.

Agregar otros makfiles

Cuando se trabaja con un archivo, es posible incluir los otros makfiles. De esa manera, el archivo actual puede leer desde los mapeos incluidos para admitir la compilación.

Para incluir otros makfiles, agregue el incluir Palabra clave que instruye "hacer"Para detener la lectura del archivo actual y leer el otro makefiles incluidos.

incluir nombres de archivo

También puede incluir otros tipos de archivos con la palabra clave incluir, siempre que agregue el espacio entre los nombres de los archivos.

Dividiendo largas colas en makefiles

A pesar de "hacer"No tiene límite en cuánto tiempo puede durar una declaración, las oraciones largas se vuelven rápidamente ilegibles y son un estilo de formato malo. GNU "hacer"Acomoda la división de oraciones largas agregando el carácter de barra insegura.

Obj = mainfunc.C \
Func1.C

En este ejemplo, "hacer"Lee la línea anterior como Obj = mainfunc.C func1.C e ignora el bartosa.

En la imagen proporcionada, dividimos la línea de receta con una barra insegura.

Supongamos que desea representar una palabra sin agregar un espacio en blanco. Reemplace la barra de barras con un signo de dólar, una barra insegura y una nueva línea.

Aquí hay un ejemplo:

Cuando "hacer"Lee el makfile, primero ignora la barra insegura para una nueva línea. A continuación, lee el signo del dólar como un espacio que representa una variable con un personaje.

Por lo tanto, eventualmente trata sus líneas divididas como una palabra sin espacio en blanco. Cuando usamos "hacer"Para leer el makfile, no recibimos ningún error ya que"hacer"Trata las líneas divididas en la variable como una palabra.

Limpiar un directorio

Una vez que compile un programa usando "hacer", Es posible que deba limpiar archivos innecesarios que se generan como salida. Aunque es posible crear un objetivo limpio, ese no es el enfoque recomendado, como se muestra en lo siguiente:

La imagen anterior instruye "hacer" para eliminar todos los archivos de texto y ".O"Archivos de extensión que se crean en el directorio actual.

Para manejar las situaciones imprevistas, es mejor crear una regla más precisa y asegurarse de no agregarla como la regla predeterminada (primero) en el archivo MakE.

Al ejecutar la regla limpia, use el "hacer limpia" dominio.

Conclusión

GNU "Make" es una herramienta útil para construir y administrar proyectos pequeños y grandes. Saber cómo usarlo es una ventaja adicional, ya que le ayuda a leer sus makefiles y compilar sus proyectos perfectamente. Aprendimos a usar la GNU "hacer"En profundidad y cómo trabajar con un archivo de MakE, incluida la comprensión de cómo Make Read The MakeFile. Con suerte, esta guía ha sentado una base para mejorar su GNU, las habilidades para manejar sus proyectos.