El papel del makefile
Makefile se utiliza para automáticamente compilación y enlace, un proyecto hay una gran cantidad de archivos, cada archivo cambios conducirán a re-enlace del proyecto, pero no todos los archivos tienen que recompilar, información del archivo Makefile se registra, cuando la marca se decidirá en el momento de la conexión, que necesitan volver a compilar los archivos. La misión de makefile es: dejar que el compilador sabe compilar una necesidad de archivos que depender de qué otros archivos . Cuando los archivos dependientes han cambiado, el compilador encontrará automáticamente el archivo generado final está obsoleta, y debe volver a compilar el módulo correspondiente. makefile llevar los beneficios de que - "la compilación de automatización" Una vez escrita, sólo se necesita un comando make, todo el proyecto es totalmente automática compilador, lo que mejora en gran medida la eficiencia del desarrollo de software. Por defecto, el comando make en el directorio actual con el fin de encontrar un archivo llamado "GNUmakefile", "makefile" "Makefile" archivo, busque la explicación de este documento. Por supuesto también se puede utilizar make -f DIR / makefile para especificar el archivo MAKE
Dos sintaxis makefile esbozado
2.1 normas makefile
objetivo: ... ... dependencias
de comandos
archivo de objeto de destino, que puede ser de archivos de objeto, el archivo se puede ejecutar, también puede ser una etiqueta
dependencias que es para generar el archivo de destino requerido o de destino.
comando make es un comando a ejecutar. (Arbitraria de comandos de Shell, puede haber varias filas)
Se trata de una interdependencia entre archivos, es decir, un objetivo o más de los archivos de destino depende de las dependencias de archivos en sus reglas de generación definidos en el comando. dependencias Si hay más de una vez para presentar nuevas palabras que el archivo de destino, se ejecutará el comando comando definido. Esta es la regla del Makefile. Makefile está en el contenido básico. Comando en el Makefile, debe iniciar con la tecla [Tab].
2.2 Definición de variables
Makefile define variables son generalmente dos: = y: = . = Símbolo definido variables llamadas de retardo variable, sólo cuando en uso sólo está abierto a la expansión ;: = símbolo define las variables como variables inmediatamente, una vez que se extiende la definición. = No definido variables utilizando nuevo valor adicional, usando: = variables definidas pueden utilizarse para añadir un nuevo valor + =
2.3 archivo indica
Use palabras clave incluyen en el Makefile Makefile puede contener otros entraron, #include al igual que el lenguaje C, el archivo se incluye en el modelo original, ya que está en el archivo actual que contiene la ubicación . incluir la sintaxis es: incluir <nombre de archivo> el nombre de archivo puede ser el modo de funcionamiento actual del sistema de archivos de Shell (que puede contener ruta seguridad y comodines)
2.4 pseudotarget
pseudodiana no es un archivo, sólo una etiqueta , porque la pseudodiana no es un archivo, así que no puede generar dependencias y decidir si se va a ejecutar. Nosotros sólo indican este objetivo se puede permitir que surta efecto por explícitamente . Por supuesto, la pseudodiana no puede ser nombrado y el nombre de archivo del mismo nombre, de lo contrario será pseudodiana sentido del. Por supuesto, con el fin de evitar esta situación y archivo del mismo nombre, se puede utilizar una marca especial .PHONY explícitamente indican un objetivo de pseudo-objetivo es hacer las instrucciones, si este documento o no, el objetivo es pseudo-objetivo.
2,5 automatización Variable
$ < Nombre del primer archivo de un dependiente
$? Todos los archivos dependientes, separadas por espacios, fecha de modificación, estas dependencias se pueden crear más tarde de la fecha prevista
$ @ Nombre completo del objetivo
$ ^ Todos los archivos dependientes, separados por espacios, que no contiene archivos duplicados dependientes
Ejemplos de tres makefile común
debe proyectar:
La parte superior Makefile superior Makefile.build subdirectorio Makefile
proceso de compilación:
De forma recursiva a partir de la parte superior en los subdirectorios, al entrar en la parte inferior de una lista, comenzando con GCC, a continuación, todas las capas empaquetadas en un archivo .o acumulación IN.O, volver a entrar en el directorio principal de forma recursiva subdirectorios, cuando haya terminado la compilación de todos los subdirectorios, comenzaron a compilar el archivo .c superior, y, finalmente, la parte superior de los archivos .o y subdirectorios para cada enlace acumulación IN.O de nivel superior en nuestro archivo de destino
El análisis Makefile superior (con el proyecto y el cambio):
# ---------------------------------------------- herramientas de compilación especificados cadena ------------------------------------------------- -
CROSS_COMPILE = # especies compilador especificada
AS = $ (CROSS_COMPILE) como #
LD LD herramienta de enlace # (CROSS_COMPILE) = $
CC = gcc herramienta de compilación número (CROSS_COMPILE) $
CPP = $ (CC) -S #
AR = $ (CROSS_COMPILE) ar # Packaging Tool
NM = $ (CROSS_COMPILE) nm #
TIRA = $ (CROSS_COMPILE) tira # herramientas de optimización
Objcopy = $ (CROSS_COMPILE) objcopy #
Objdump = $ (CROSS_COMPILE) objdump #
Exportar como LD CC CPP AR NM # variables definidas exportación, para facilitar el uso de otros makefile
exportación TIRA objcopy objdump variables # definen la exportación, para facilitar el uso de otra makefile
CFLAGS: = -g -Wall -O2 # compilador argumentos
CFLAGS + = -I $ (pwd cáscara ) / # incluye archivos de cabecera especifica el compilador (modificado manualmente de acuerdo con el artículo real)
LDFLAGS: = -lm -lfreetype -lvga # compilador de la biblioteca de enlace especificado (modificado manualmente de acuerdo con el proyecto real)
export CFLAGS LDFLAGS variables # definen la exportación, para facilitar el uso de otra makefile
TOPDIR: = $ (pwd cáscara) # Obtener el directorio de nivel superior del programa actual
De alto nivel de salida TOPDIR exportación de directorio #
OBJETIVO: = nombre del programa después de show_file # compilador (modificado manualmente de acuerdo con el proyecto real)
# ------------------------- superior .o archivos que se genere, así como carpeta de nivel superior (modificado manualmente de acuerdo con el proyecto real) ------ ------------
obj-y + = main.o
obj-y += display/
obj-y += draw/
obj-y += encoding/
obj-y += fonts/
El primer nivel de la parte superior # -------------------------------------------- regla (regla por defecto) -----------------------------------------
todos :
make -C $ ./ -f (TOPDIR) /Makefile.build # en el directorio actual, compilado usando la parte superior makefile.build
$ (CC) $ (LDFLAGS) -o $ (TARGET) incorporado IN.O # incorporado IN.O el enlace del archivo compilado generar nuestro archivo de destino
# ------------------------------------------------ superior la regla de purga ----------------------------------------------- --------
limpiar:
rm -f $ (shell hallazgo -name "* .o") # eliminar todos los archivos .o
rm -f $ (shell hallazgo -name "* .d") # eliminar todos los archivos .d
rm -f $ (TARGET) # borrar el archivo de destino
.PHONY: todo limpio
Top Makefile.build resuelto (sin cambios):
PHONY: = # __build definir una variable de PHONY
__build: # Descripción __build el comienzo de la pseudo-objetivo, por lo que es el primer gol Makefile.build
obj-Y: = # variable de destino que define el directorio actual, el valor inicial está vacía
subdir-Y: = # se define subdirectorio variable del directorio actual, el valor inicial está vacía
incluye Makefile Makefile # vendrá en el directorio actual contiene la inicialización obj-y
#obj-y:=a.o b.o c/ d/
__subdir-Y: = $ (patsubst% /,%, $ (filtro% /, $ (obj-y))) # seleccionados actualmente directorio en la variable de destino subdirectorio, y quitar /
# $ (Filter% /, $ (obj-y)) c / d /
#__ subdirectorio-Y: cd
subdir-y + = $ (__ subdirectorio-y) # El subdirectorio-y definido como inicio de la asignación __subdir-y
# Subdirectorio-Y: cd
subdir_objs: = $ (foreach f, $ (subdirectorio-y), $ (f) /built-in.o) # Para cada valor dentro subdirectorio-y (directorio), un aumento correspondiente en el directorio / incorporado. o el valor de la variable
#subdir_objs: c / incorporado in.od / incorporado IN.O
cur_objs: = $ (filtro de salida% /, $ (obj-y)) # .o archivo obtenido en el obj-y
#cur_objs: la bo
dep_files: = $ (. f foreach, $ (cur_objs), $ (f) .d) # Para todos los archivos .o, definir su nombre de archivo dependiente
#dep_files: .ad .Bd
dep_files: = $ ($ comodín (dep_files))
ifneq ($ (dep_files), #) de acuerdo a confiar en el nombre del archivo, para determinar si existen existen dependencias contiene vienen
incluyen $ (dep_files)
terminara si
PHONY + = $ (subdir-y) # El $ se añadió también (subdir-y) variable a la Phony
-------------------------------------------- Makefile. Construir primera normas ------------------------------------------------ --------------
__build: $ (subdirectorio-y) incorporado IN.O primera regla #
$ (Subdir-y): # La primera regla de una regla de dependencia
make -C $ @ $ -f valores (TOPDIR) /Makefile.build # entraron almacenan secuencialmente dentro de la variable subdirectorio, Makefile.build utiliza para compilar
La segunda regla $ dependientes (cur_objs) $ (subdir_objs) # primera regla: incorporado IN.O
$ (LD) -r -o $ @ $ ^ # comando de esta regla: .oy $ (subdir_obj) bajo el directorio empaquetado en un archivo integrado IN.O
dep_file = . $ @. d #
% .O: segundas reglas dependientes regla% .c # dependencia de la primera regla
$ (CC) $ (CFLAGS) -wp, -MD, $ (dep_file) -c -o $ @ $ <# se utiliza para compilar todos los archivos .c en .o archivos en el directorio
.PHONY: $ (PHONY) # declaró como falso objeto PHONY voluntad
Subdirectorio Makefile (con el proyecto y el cambio):
Subdirectorio Makefile es incluir todos los subdirectorios del nombre de archivo de destino y nombre de la carpeta en el directorio.
Por ejemplo, todos los subdirectorios se pueden escribir como:
objs-y := a.o
objs-y += b.o
objs-y += c/
objs-y + = d /
Cuatro ejemplos de proyectos
