makepp_variables: en línea en la nube

PROGRAMA:

NOMBRE

makepp_variables - Cómo usar variables en makepp

DESCRIPCIÓN

?: PS
$ +,
PS
$ <,
PS
PS
$ ^,
=,
! =,
& =,
+ =,
: =,
; =,
? =, A: ARKANSAS,
ARFBANDERAS,
COMO, C: CC,
banderas,
"dependencias_cambiadas",
entradas_cambiadas,
CURDIR,
CXX,
BANDERAS CXX, D: "dependencias",
"dependencia", F: F77,
FC,
"para cada", I: entrada,
insumos, L: LD,
lex,
LIBTOOL, M: HACER,
HACER OBJETIVOS,
HACER BANDERAS,
HACERINFORMACIÓN,
MAKEPP_DEBUG,
HACER BANDERAS,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signatura_C_plana,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "producción",
"salidas", P: perla,
PCD, R: resonancia magnética,
RAÍZ, S: CASCARÓN,
"sorted_dependencies",
entradas_ordenadas,
"madre", T: objetivo,
objetivos, V: VPATH, Y: YACC

Los Makefiles suelen utilizar variables en muchos lugares. Una razón importante para usar
variables es para garantizar que la información esté contenida en un solo lugar en el archivo MAKE, por lo que
que si cambia, no hay peligro de que las dos copias de la información salgan de
sincronizar

Los nombres de las variables distinguen entre mayúsculas y minúsculas. En teoría, los nombres de las variables pueden estar formados por muchos
personajes, pero makepp probablemente no podrá asimilarlo si haces otra cosa que no sea
caracteres alfanuméricos, "_" y "-".

Cada archivo MAKE tiene su propio conjunto de variables, y establecer una variable en un archivo MAKE
no tienen ningún efecto sobre su valor en ningún otro archivo MAKE. Si desea tener variables establecidas en
muchos archivos MAKE, la mejor manera de hacerlo es hacer que cada uno de ellos incluya una definición común
archivo (consulte la declaración de inclusión) o utilice variables "globales".

Variable Asignación
Una variable puede asumir un valor de varias formas diferentes:

· Se puede establecer una variable dentro de un archivo MAKE. Hay varias formas de hacerlo
esta; vea abajo.

· El valor de una variable se puede especificar en la línea de comando, así:

makepp CFLAGS = -O2 mi_programa

Si se carga más de un archivo MAKE, la variable CFLAGS se propaga a todos los
makefiles. Las variables establecidas en la línea de comando anulan automáticamente cualquier configuración de
la variable en cualquiera de los archivos MAKE.

Si alguna vez es necesario, el archivo MAKE debe, a su vez, anular explícitamente la configuración de la línea de comandos.
La intención no es ignorar lo que solicita el usuario, sino una forma de modificarlo.
El modificador "override" puede preceder a cualquier instrucción de asignación. Pero en el caso de
declaraciones de palabras clave, el orden es importante, por lo que la variante de anulación es
siempre se muestra a continuación. El modificador "anular" se aplica solo a las asignaciones en las que
está presente y no influye en las asignaciones posteriores a la variable.

· Si se establece una variable en el entorno, se puede hacer referencia a ella como una variable makepp.
Por lo general, las asignaciones a las variables dentro de un archivo MAKE anulan la configuración de la
entorno, pero puede cambiar esto utilizando "-e" o "--environment-overrides"
opción de línea de comando.

A las variables se les asigna una de varias expresiones de asignación, como esta

X = 1
MÓDULOS: = abcd
CC? = Gcc
CFLAGS + = -Pared
definir VAR
var línea 1
var línea 2
fin de definición
RUTA de exportación: = $ (PWD): $ (RUTA)
MYPROJECT.INFO global = información que se verá en todos los archivos MAKE

Los espacios en blanco iniciales y finales alrededor de los valores siempre se eliminan.

Los diferentes operadores de asignación tienen significados algo diferentes.

sencillos asignación operadores

=
VARIABLE = cadena de texto
anular VARIABLE = cadena de texto

Esta es la declaración de asignación habitual que admiten todas las implementaciones. los
expresión en el lado derecho no se evalúa hasta que el valor de "$ (VARIABLE)" es
realmente usado en alguna parte. Por lo tanto, si hace lo siguiente:

X = 1
Y = $ (X)
X = 2

Luego, "$ (Y)" más adelante en el archivo MAKE se evaluará como "2".

En general, normalmente desea utilizar ": =" (ver más abajo) en lugar de "=" porque
proporciona una evaluación de variables más predecible. Sin embargo, hay ocasiones en las que necesita
aplazar la evaluación de la variable. Además, si está escribiendo un archivo MAKE, debe ser
compatible con versiones anteriores de otra marca que no sea GNU, entonces no tiene
elección: solo puede utilizar "=".

:=
VARIABLE: = expr
anular VARIABLE: = expr

Esto es lo mismo que "VARIABLE = expr" excepto que se evalúa el lado derecho
de una vez por todas en el momento de la asignación. Así que si

X: = 1
Y: = $ (X)
X: = 2

luego "$ (Y)" más adelante en el archivo MAKE se evaluará como "1" ya que eso es lo que era "$ (X)"
cuando se definió "$ (Y)".

;=
VARIABLE; = expr
anular VARIABLE; = expr

Esto es lo mismo que "VARIABLE: = expr" excepto que se evalúa el lado derecho
solo en el momento del primer uso y luego recordado. Esto es útil para costosos
comandos, que siempre devuelven el mismo valor, pero que no desea realizar cuando
la construcción de objetivos no relacionados:

VAR1; = $ (cálculos costosos de Perl)
VAR2; = $ (comando externo de shell)

Tenga en cuenta que los archivos MAKE antiguos usualmente usarán ": =" aquí, al menos para hacer esto solo una vez.
Pero con este operador, incluso puede no hacerlo, si no lo hace actualmente.
Necesito el valor. Para valores que son idénticos en varios directorios, puede
optimice esto aún más con "global", que se analiza a continuación.

Sin embargo, esto no pretende ser una forma inteligente de forzar el orden de evaluación. Si un
variable definida de esta manera incluye el valor de otra variable, y esa otra
tiene un valor específico del objetivo, y la primera expansión es para ese objetivo, luego el
El valor específico del objetivo se mantendrá también en todos los demás contextos. Esto es un error y
con suerte se solucionará en el futuro.

+=
VARIABLE + = expr
anular VARIABLE + = expr

Agrega la cadena al contenido anterior de la variable, separados por un espacio. Si
la variable se asignó previamente con ": =", luego se evalúa el lado derecho
antes de agregar.

&=
VARIABLE & = expr
anular VARIABLE & = expr

Antepone la cadena al contenido anterior de la variable, separados por un espacio.
Si la variable se asignó previamente con ": =", entonces el lado derecho es
evaluado antes de adjuntar.

Por ejemplo, una forma de garantizar que "CFLAGS", cualquier otra cosa que el usuario pueda introducir,
siempre comienza con "-Wall" son estas dos líneas:

CFLAGS = -O2 # Posiblemente anulado en la línea de comando
anular CFLAGS & = -Wall # Antepuesto incondicionalmente

En los archivos MAKE antiguos, normalmente tenía que hacer algo como esto, que tenía el lado
efecto de forzar el tipo a ": =" para evitar la recursividad sin fin:

VARIABLE: = expr $ (VARIABLE)

?=
VARIABLE? = Expr
anular VARIABLE? = expr # Inútil, pero legal

Establece el valor de la variable, pero solo si la variable no se especificó anteriormente en
el archivo MAKE, en la línea de comandos o en el entorno. La asignación anterior es
exactamente equivalente a

variable ifndef
VARIABLE = expr
terminara si

!=
VARIABLE! = Comando de shell
anular VARIABLE! = comando de shell

Ejecuta el comando de shell y establece la variable para que contenga la salida estándar del comando.
Esto es exactamente equivalente a

VARIABLE: = $ (comando de shell)

Multilínea las variables

La declaración "define" es el equivalente multilínea de las declaraciones simples anteriores. los
operador después de la variable es opcional. Si falta, es equivalente a "definir VARIABLE
= ". Los operadores" & = "y" + = "son ligeramente diferentes aquí, ya que pegan esto a
el valor anterior con una nueva línea, en lugar de un espacio. No debe haber nada excepto un
comentario después de la declaración, es decir, el valor comienza en la siguiente línea.

definir VARIABLE: =
primera línea del valor de la variable
segunda línea del valor de la variable
tercera línea del valor de la variable
endef

anular definir VARIABLE
...
fin de definición

Las palabras clave antes de "definir" pueden ser combinaciones de "exportar" o "global" y
"anular".

Si necesita que el valor de una variable contenga líneas nuevas, debe usar la instrucción "definir" como
mostrado (o puede asignar el valor directamente en Perl). ("endef" fue elegido para
compatibilidad con la marca GNU. También puede utilizar "enddef".) Esto es principalmente útil para
"secuencias de comandos predefinidas", por ejemplo, algo como esto:

definir COMPILE_C_PROGRAM
@ & echo "Compilando $ (entrada)"
@ $ (CC) $ (CFLAGS) $ (CPPFLAGS) $ (INCLUYE) -c $ (entrada) -o $ (salida)
endef

Entonces puede usar esta variable de varias líneas en varias reglas, como esta:

% .o:% .c
$ (COMPILAR_C_PROGRAMA)

$ (ARCO) /%. O: $ (ARCO) /%. C
$ (COMPILAR_C_PROGRAMA)

Tenga en cuenta que a menudo puede lograr el mismo efecto utilizando un punto y coma en lugar de una nueva línea,
porque el shell también lo interpreta como un delimitador de comando. Por ejemplo,

COMPILE_C_PROGRAM = @echo "Compilando $ (entrada)"; \
$ (CC) $ (CFLAGS) $ (CPPFLAGS) $ (INCLUYE) -c $ (entrada) -o $ (salida)

tendrá el mismo efecto, excepto que el punto y coma obliga a Perl a pasarlo al caparazón,
en lugar de ejecutar el comando de forma directa y más eficiente. También tienes que poner cada
incorporado en una línea propia, lo que significa que debe cambiar al eco externo en el
caso de punto y coma.

Hay una especialidad cuando se expande dentro de "definir", es decir, "definir X: =" o en un
variable que ya era ": =", "definir X & =" y "definir X + =". En este caso el
"$ (comando de shell ...)" o incorporado "$ (& command ...)" no consiguen que las nuevas líneas se transformen en
espacios

Exportación las variables a subprocesos

exportar VAR ...
exportar VAR = valor
anular exportación VAR + = valor

La primera forma marca las variables dadas para exportar a subprocesos, con cualquier valor
la variable entonces tiene. La segunda forma, que se aplica solo a una variable, además
asigna un valor de inmediato. Se permiten todas las variantes de asignación.

Compartir las variables a través de hacer archivos

VAR global ...
VAR global = valor
anular VAR global & = valor

La primera forma marca las variables dadas como globales para todos los archivos MAKE. Si alguno de ellos
ya tenía un valor, ese valor se mueve de la variable local makefile a la global
uno. Sin embargo, si, en el momento en que se ve esta declaración, cualquier otro archivo MAKE ya tenía un
valor para cualquiera de ellos, entonces esos archivos MAKE no verán el global.

La segunda forma, que se aplica solo a una variable, además asigna un valor a la derecha
lejos. Se permiten todas las variantes de asignación. Tenga en cuenta que ": =" se expandirá de inmediato.
a los valores en el archivo MAKE local. Por el contrario, las variables "=" se expandirán al
valores en el punto de uso.

Las variables globales pueden ser complicadas de manejar, porque makepp puede cargar archivos MAKE en cualquier
orden, ya que surge la necesidad de construir algún objetivo para el que no se cargan reglas o archivos MAKE.
Por este motivo se recomienda disponer de un Archivo RootMakepp y cargar explícitamente todos
otros que modifican o usan la variable con "load-makefile".

GLIBLIBS global; = $ (shell pkg-config --libs glib-2.0)

También tenga en cuenta que su proyecto puede que algún día se construya junto con otros proyectos. Para esto
razón por la que se recomienda que siempre el nombre del proyecto forme parte de cualquier nombre de variable global.

Específico de destino asignaciones

objetivo: VARIABLE = cadena
objetivo: VARIABLE: = cadena
objetivo: anular VARIABLE + = cadena

Establece un valor específico de destino de la variable. Está en vigor un valor específico del objetivo , solamente
en una acción que produce el objetivo dado. Esto se usa principalmente para cosas como
modo:

CFLAGS: = -O2

mi_prog: archivo1.o archivo2.o archivo_especial.o

archivo_especial.o: CFLAGS: = -g

% .o:% .c
$ (CC) $ (CFLAGS) -c $ (entrada) -o $ (salida)

Lo que sucede aquí es que todos los archivos ".c" se compilarán con optimización ("-O2") excepto
"special_file.c", que se compila en modo de depuración ("-g"). Esta es una forma conveniente de
especifique diferentes opciones de compilación para solo unos pocos archivos.

Las asignaciones de variables específicas de destino como esta se aplican solo a las acciones de la regla; ellos
no están en vigor al evaluar los objetivos o las dependencias de una regla. Si una regla
tiene más de un objetivo, las asignaciones de variables específicas del objetivo se toman solo del
la primera objetivo. También tenga en cuenta que las variables específicas de destino de makepp son ligeramente diferentes
de las marcas GNU en que solo se aplican a la regla para el archivo mencionado, y no a
cualquiera de sus predecesores.

La expansión de comodines se realiza en el destino, por lo que puede hacer algo como esto:

prueba _ *. o: CFLAGS + = -DTEST

Para compatibilidad con la marca GNU, se puede usar "%" en lugar de "*".

Variable Sustitución
Las reglas de sustitución de variables de Makepp son similares a las de otras marcas, pero algo
mas poderoso. Como en todas las marcas, "$ (CC)" o "$ {CC}" representan el valor de la
variable CC. Si necesita un signo de dólar literal, coloque un signo de dólar doble ($$), como
modo:

objetivo: dep1 dep2 dep3 dep4
& rm -f $ (salida)
para archivo en $ (entradas); hacer cat $$ file >> $ (salida); hecho

Además, makepp tiene una sintaxis "$ [VARIABLE]", que hace lo mismo que la otra
dos, pero antes makepp asimila cualquier otra cosa. Esto permite usarlo para reglas completas.
y / o condicionales:

definir regla_soporte =
ifdef ALGUNAS_VAR
soporte:
& echo esto es una regla -o $ (salida)
terminara si
fin de definición

$ [bracket_rule]

estilo rc sustitución

De forma predeterminada, makepp utiliza la sustitución de estilo rc (llamada así porque fue pionera en
rc shell). Esto se ilustra mejor con un ejemplo:

MÓDULOS = abcd

mylib.a: module_dir / $ (MODULES) .o $ (OTHER_OBJECTS)
$ (CXX) $ (dependencias) -o $ (objetivo)

El prefijo "module_dir /" se antepone a cada palabra en MODULES, y el sufijo ".o" es
adjunto a cada palabra.

También puede utilizar la sustitución de estilo rc sin siquiera poner la lista de palabras en un
variable; la sintaxis es "$ (palabra1 palabra2)". Tenga en cuenta el espacio entre el paréntesis y el
primera palabra. Entonces, el ejemplo anterior podría haberse escrito como:

mylib.a: module_dir / $ (abcd) .o $ (OTHER_OBJECTS)
$ (CXX) $ (dependencias) -o $ (objetivo)

Una variable dará una sustitución de estilo rc solo cuando haya más de una palabra en ella.
Con una palabra es como hacer tradicional. Por desgracia, cuando la variable está vacía, hay un
conflicto. Las marcas tradicionales simplemente lo expanden a la cuerda vacía. Pero cuando piensas en
como una lista, querrás que "-I $ (DIRLIST)" desaparezca, no para dar un "-I" solitario. los
La solución es envolverlo en una lista que comience con un espacio: "-I $ ($ (DIRLIST))" le da
exactamente tantas opciones como palabras haya en la lista.

Si pones varias variables en la misma palabra que se expanden a arreglos de palabras, rc-style
la sustitución en realidad toma el producto cartesiano, por lo que puede hacer algo como esto si
usted quiere:

DIRS = s1 s2
MÓDULOS = abc
SUFIJOS = .o .c
ARCHIVOS: = $ (DIRS) / $ (MÓDULOS) $ (SUFIJOS)

y ARCHIVOS contendrán la cadena

s1 / ao s1 / ac s1 / bo s1 / bc s1 / co s1 / cc s2 / ao s2 / ac s2 / bo s2 / bc s2 / co s2 / cc

Además de los espacios en blanco, la sustitución de estilo rc se detiene en cualquier cita, en cualquier círculo, rizado o cuadrado
paréntesis y cualquiera de ",:; = # @". Tenga en cuenta que esto puede resultar sorprendente y, de nuevo, es necesario
una lista explícita. Supongamos que desea buscar encabezados mediante comodines en todos los directorios.
comenzando con una letra mayúscula:

MALO: = [AZ] * / ** / *. $ (Hpp h) # [AZ] * / ** / *. Hpp * / ** / *. H
BUENO: = $ ([AZ] * / ** / *.) $ (Hpp h) # [AZ] * / ** / *. Hpp [AZ] * / ** / *. H

Si la sustitución de estilo rc se interpone en el camino, o si necesita tener una entrada inicial o final
espacios en blanco en sus variables make, luego puede desactivar la sustitución de estilo rc configurando
la variable "makepp_simple_concatenation = 1". Puede desactivarlo globalmente en el comando
línea o como una variable de entorno. O en base a cada archivo make estableciendo la variable en
su archivo MAKE. Debe hacer esto cerca de la parte superior del archivo MAKE, o de lo contrario puede encontrarse con
situaciones divertidas en las que se utiliza la sustitución al estilo rc para algunas evaluaciones y no para otras.
(Todas las expresiones evaluadas antes de la asignación usarán sustituciones de estilo rc, y todas
las expresiones evaluadas después no lo harán. Desde el momento de la evaluación de expresiones en
makefiles es complicado y no siempre obvio por el orden de las declaraciones en el
makefile, es mejor configurar "makepp_simple_concatenation" lo antes posible).
incluso configúrelo solo para un objetivo:

objetivo: makepp_simple_concatenation = 1
objetivo:
& echo before_first $ (LIST) after_last -o $ (salida)

Debido a que "$ [VARIABLE]" se evalúa antes que "$ (VARIABLE)", la combinación de los dos en rc-
La sustitución no dará el resultado que puede esperar, a menos que lo envuelva en un
lista:

A = ab
norte = 1 2
MALO: = $ (A) $ [N]
BUENO: = $ (A) $ ($ [N])

Las últimas líneas se leen como

MALO: = $ (A) 1 2 # a1 b1 2
BUENO: = $ (A) $ (1 2) # a1 a2 b1 b2

Sustitución Referencias

Una referencia de sustitución tiene la forma "$ (VAR: A = B)", donde A es un patrón que debe coincidir y B es
un patrón para reemplazarlo. Las referencias de sustitución son una abreviatura de
función "patsubst". Por ejemplo:

archivos_origen = ac bc cc dc
archivos_objeto = $ (archivos_origen:%. c =%. o)

establecerá "$ (object_files)" en "ao bo co do". El "%" es un carácter especial que coincide
cualquier cadena arbitraria. Si tanto A como B comienzan con "%", un caso común al reemplazar
sufijos, se pueden omitir:

archivos_objeto = $ (archivos_origen: .c = .o)
object_files = $ (source_files: c = o) # lo mismo, porque. no es especial

Espacio en blanco in las variables

Si necesita controlar el espacio en blanco en una variable, debe (actualmente) deshabilitar el estilo rc
sustitución (estableciendo "makepp_simple_concatenation = 1") y luego use una sintaxis como esta:

nulo =
T = -o $ (nulo)

o, con una evaluación vacía:

T = -o $ ()

Al hacer esto, la variable "T" contiene "-o" seguido de un espacio.

No se recomienda este tipo de técnica para manejar espacios en blanco. Si necesitas variables
en su archivo MAKE para contener espacios, debe pensar seriamente en lo que está haciendo.
Si necesita manejar espacios, generalmente es mucho mejor poner código Perl en su
makefile para cuidarlo (usando las declaraciones "perl_begin" o "sub"), o para manejarlo
en declaraciones de shell en las acciones de las reglas.

Estos casos suelen surgir cuando las personas intentan utilizar las mismas reglas para diferentes
arquitecturas que no utilizan la sintaxis de comandos típica de Unix. Por ejemplo, a veces uno ve
cosas como esta en archivos MAKE:

ifeq ($ (ARCH), weirdarch)
O: = / SALIDA =
más
nulo: =
O: = -o $ (nulo)
terminara si

% .o:% .c
$ (COMPILADOR) $ (entrada) $ (O) $ (salida)

Puede hacer esto con makepp si realmente lo desea, pero probablemente encontrará que su
Los makefiles son sustancialmente más legibles si tiene una variable menos complicada
sustitución, por ejemplo,

ifeq ($ (ARCH), weirdarch)
% .o:% .c
$ (WEIRD_COMPILER) $ (entrada) / SALIDA = $ (salida)
más
% .o:% .c
$ (CC) -c $ (entrada) -o $ (salida)
terminara si

Nunca se permiten espacios en blanco en los nombres de las variables, solo en sus valores. Esto es diferente
de algunos hacen implementaciones.

Automático Variables
Las variables automáticas son variables que asumen diferentes valores según la regla
se evalúan en. Makepp admite la mayoría de las variables automáticas que otras
versiones de hacer uso. Además, tiene nombres menos crípticos y más largos para la mayoría de ellos.
que puedes usar en su lugar. (Para los archivos MAKE heredados que redefinen estos nombres, el
La definición en el archivo MAKE anula el significado predeterminado. Por ejemplo, si dices
"target = abc" en su archivo MAKE, luego "$ (target)" siempre se expandirá a "abc", y no
ya sea equivalente a $ @.)

La siguiente es una lista completa de todas las variables automáticas que admite makepp:

salida
dirigidos
$ @ El objetivo de la regla actual. En realidad, dado que makepp admite múltiples objetivos para
cualquier regla, esta es la la primera objetivo. Por ejemplo, en la siguiente regla

y.tab.c y.tab.h: analizador.y
$ (YACC) -o $ (salida) $ (YFLAGS) $ (entrada)

"$ (salida)" contendrá el valor y.tab.c. Dado que estas variables mágicas son de hecho
funciones, también puede pasar un índice como argumento. Esto cuenta desde 1 o hacia atrás
de 1. Entonces, "$ (salida 2)" o "$ (salida -1)" contendrán el valor y.tab.h.

Si bien las tres formas de esta variable tienen el mismo valor, hay una diferencia en
interpretación para reglas de objetivos múltiples. Si usa el nombre críptico antiguo $ @,
makepp interpretará eso como un conjunto de reglas de estilo antiguo, en lugar de una regla moderna que
produce todos esos objetivos de una sola vez:

ab: # realmente: una regla para a y b
toque $ @

cd: # error: mpp se queja de que esto no construyó d
toque $ (salida)

salidas
tiene como objetivo
Todos los objetivos de la regla actual. Igual que "$ (target)" a menos que haya más de uno
objetivo. En el ejemplo anterior, "$ (salidas)" será y.tab.c y.tab.h. Puedes pasar un
lista de índice, por lo que "$ (salidas 2 1)" será y.tab.h y.tab.c.

dependencia
Las opciones de entrada
$ <La primera dependencia explícita de la regla. Por ejemplo, en esta regla

% .o:% .c
$ (CC) $ (CFLAGS) -c $ (entrada) -o $ (salida)

"$ (entrada)" será el nombre del .c archivo, independientemente de lo .h archivos makepp
descubre. Si especifica más de una dependencia, puede obtenerlas pasando un
índice: "$ (input $ (INDEX))" es la dependencia INDEXth.

dependencias
entradas
$ ^ Todas las dependencias explícitas del objetivo, sin incluir .h archivos descubiertos por
makepp_scanning para incluye.

Por ejemplo, en la regla

myprog.o: * .o
$ (CC) $ (CFLAGS) $ (entradas) -o $ (salida)

"$ (entradas)" serán todos los archivos .o del directorio. Puedes elegir solo los que quieras
desea pasando una lista de índice. Si especifica explícitamente diferentes tipos de archivos,
puede elegirlos como en "$ (entradas 2 3 4)" (pero con un comodín esto no es demasiado
prometedor).

Dependencias ordenadas
entradas_ordenadas
$ + Todas las dependencias del objetivo, en orden ordenado, con los duplicados eliminados.
Equivalente a "$ (sort $ (entradas))".

dependencias_cambiadas
entradas_cambiadas
PS Las dependencias del destino que han cambiado. Esto incluye solo explícito
dependencias (es decir, las que enumera en el archivo MAKE), no descubiertas implícitamente
dependencias del escaneo (como archivos .h).

Esto se usa comúnmente en comandos como este:

libmine.a: $ (MÓDULOS): build_check ignore_action
$ (AR) ru $ @ $?

es decir, ar se le dice que reemplace solo aquellos módulos que hayan cambiado. (Nota la
Regla de verificación de compilación "ignore_action". Si no especifica esto, makepp forzará la
acción que se ejecutará siempre que cambie. Si no ha cambiado ninguna dependencia, el
La cadena de acción será "ar ru libmine.a", que probablemente sea diferente de lo que era.
la última vez que lo ejecutó, por lo que, sin "ignore_action", makepp lo ejecutará. En esto
caso, es inofensivo, pero con otros comandos, podría ser un problema. Ver
makepp_build_check para obtener detalles sobre "ignore_action".)

Crear archivos como este no es una buena idea porque hará que sus compilaciones sean menos
de confianza. El problema con esto es que si crea el archivo, elimine uno de
los módulos de la lista de MÓDULOS, los módulos todavía estarán en el archivo y
hacer pp

tallo
$ * La raíz en una regla de patrón (es decir, cualquier coincidencia del '%'). Alternativamente, si esto
no es una regla de patrón, devuelve el nombre del archivo sin la extensión (es decir, es
equivalente a "$ (nombre base $ (entrada))".

Esto es principalmente por compatibilidad con versiones anteriores. Por ejemplo, en versiones antiguas de make the
única forma de decirle cómo compilar cualquier .c archivo en el correspondiente .o el archivo era como
modo:

.co:
$ (CC) $ (CFLAGS) -c $ *. C -o $ *. O

Esta es una forma pésima de escribir la regla. Es mucho más claro usar el estilo GNU-make
reglas de patrón, como esta:

% .o:% .c
$ (CC) $ (CFLAGS) -c $ (entrada) -o $ (salida)

foreach
El nombre de archivo actual de la cláusula "foreach". las cláusulas "foreach" rara vez se utilizan,
pero son el tipo de regla de patrón de propósito más general que admite makepp. Para
ejemplo,

#
# Construya archivos .c con algún tipo de preprocesador especial:
#
% .c:% .k
$ (preprocesador) $ (entrada)> $ (salida)

#
# Compile archivos .c en archivos .o:
#
% .o:% .c
$ (CC) $ (CFLAGS) -c $ (entrada) -o $ (salida)

#
# Indicadores de compilación alternativos especiales para archivos .c derivados
# de archivos .k:
#
$ (foreach:%. k =%. o): $ (foreach:%. k =%. c): foreach * .k
$ (CC) $ (SPECIAL_K_FLAGS) -c $ (entrada) -o $ (salida)

Consulte la documentación sobre la cláusula foreach en las reglas para obtener más detalles y ejemplos.

$ / Esto es esencialmente una constante, ya sea "/", o en Windows nativo "\". Lo necesitas, si
desea iniciar un programa de forma portátil, por ejemplo, uno que creó en el directorio actual:

mi salida:
. $ / myprog> $ (salida)

Para los nombres de archivo pasados ​​como argumentos, no es tan necesario ya que Windows puede manejar Unix
sintaxis allí.

Optión Variables
Puede configurarlos de todas las formas explicadas anteriormente (excepto si se indica lo contrario) para modificar
el comportamiento de makepp. De forma predeterminada, todos están indefinidos.

MAKEPP_DEBUG
Si exporta esto con un valor verdadero antes de llamar a makepp, obtendrá más depuración
info. Esta es la "RULE_SOURCE" de los archivos creados mientras está en vigor en
makeppinfo, mppi y detalles sobre la expansión de variables y la coincidencia de reglas en
makepplog, mppl. Esto también le mostrará si makepp se queda sin memoria o se cuelga,
porque está expandiendo sin cesar las mismas variables:

A = $ A # evaluación diferida, necesita: =
B = $ C
C = $ B

MAKEPP_LN_CP
Vea la nota debajo de & ln.

makepp_percent_subdirs
Establezca esto en un valor verdadero (como 1) para que "%" en los objetivos o las dependencias coincidan
en más de un directorio.

makepp_require_phony
Establezca esto en un valor verdadero (como 1) para evitar la falsedad implícita (es decir, si una regla
tiene éxito sin producir su objetivo). Esta variable debe ser verdadera por defecto, para
evitar cadenas de dependencia rotas, pero eso rompería la compatibilidad con versiones anteriores
archivos MAKE descuidados.

makepp_signature_C_plano
Esta es una opción para la firma C. Establezca esto en un valor real (como 1) para tratar su
fuentes como planas, es decir, todas las líneas nuevas (excepto alrededor de las declaraciones del preprocesador)
tratados como espacios en blanco y las directivas "#line" se ignoran.

makepp_simple_concatenación
Establezca esto en un valor verdadero (como 1) para evitar una "sustitución de estilo rc".

PERL
Puede establecer esto en el perl exacto que está utilizando para ejecutar los scripts en el makepp
suite y expórtelo. Esto puede ayudar a ejecutar subguiones con el mismo perl. Este es
sobre todo útil para el conjunto de pruebas, la instalación y para compilaciones recursivas.

VPATH
Establecer esta variable en algún valor implícitamente llama "vpath% value".

predefinida Variables
Makepp predefine algunas variables, que puede anular:

AR Por defecto: "Arkansas".

ARFBANDERAS
Por defecto: "rv".

AS Por defecto: "como".

CC Por defecto: El primero que se encuentra entre "gcc", "egcc", "pgcc", "c89" o "cc", o en Windows
además, "cl" o "bcc32".

FLANDERAS
Por defecto: Si "$ (CC)" es un compilador GNU "-g -Wall", si es uno de los dos Windows
compiladores nada, más "-g".

CURDIR
El directorio en el que reside el Makefile actual.

CXX Por defecto: El primero que se encuentra entre "g ++", "c ++", "pg ++", "cxx", "C" "C" o "aCC", o en
Windows, además, "cl" o "bcc32".

CXXBANDERAS
Por defecto: Si "$ (CXX)" es un compilador GNU "-g -Wall", si es uno de los dos Windows
compiladores nada, más "-g".

F77 Por defecto: El primero encontrado entre "f77", "g77" o "fort77".

FC Por defecto: "$ (F77)".

LD Por defecto: "ld".

LEX Por defecto: El primero que se encuentra entre "lex" o "flex".

LIBTOOL
Por defecto: "libtool".

HAZ
Esta variable tiene dos valores diferentes, dependiendo de la presencia o no de
"--hacer-recursivo-tradicional". Makepp reconoce cuándo se usa esta variable y
desactiva algunas funciones, incluso antes de que se produzca la recursividad. Esto puede ser
indeseable mientras lo está eliminando gradualmente, así que primero convierta las llamadas en un
makepp específico "$ ((MAKE))", que no desactivará las funciones. No deberías configurarlo
porque eso rompe nuestro trabajo de recursividad inteligente.

HACER OBJETIVOS
Makepp establece esta variable, pero no la utiliza. Puede consultarlo para hacer algo solo si
se solicitó un determinado objetivo.

Por defecto: Cualquier objetivo explícito proporcionado por el usuario (o una invocación recursiva).
Vacío cuando se construye implícitamente un objetivo predeterminado.

ifneq $ (filtro de destino especial, $ (MAKECMDGOALS))
# special-target es uno de los objetivos explícitos actuales
else ifeq $ (MAKECMDGOALS)
# sin objetivos explícitos
terminara si

MAKEFLAGS (exportado)
Las opciones estándar con las que se llamó a makepp. Los que tienen una sola letra
se combinan al principio sin un "-" inicial (Dios sabe por qué gmake eligió
para soltar el "-").

HACERINFORMACIÓN
Por defecto: "makeinfo".

MAKEPPFLAGS (exportado)
Se establece en el mismo valor que MAKEFLAGS, pero solo si esta variable está presente en
entorno de makepp.

_MAKEPPFLAGS (exportado)
Las opciones específicas de makepp necesarias para la compatibilidad con POSIX / gmake, con las que makepp
fue llamado. Estos están en una variable separada, por lo que un archivo MAKE heredado no se puede romper
compatibilidad desarmando MAKEFLAGS. Esto solo se establece con
"--hacer-recursivo-tradicional".

MAKEPP_VERSION
La versión de makepp con la que está ejecutando. Si es una versión beta, tendrá una
guión seguido de AAMMDD más algunos datos internos más. Puedes usar esto para "ifdef"
para ocultar construcciones específicas de makepp de otras marcas.

Por defecto: El mismo valor mostrado por "makepp --version"

PWD Un alias para "CURDIR".

RM Por defecto: "rm -f". Esto está destinado a los archivos Makefiles heredados. Para los nuevos preferiblemente use
el comando incorporado & rm directamente. Si quieres escribir una regla falsa falsa, mira
el comando "makeppclean -r" en su lugar.

RAÍZ
La ruta relativa a la raíz de su sistema de compilación, es decir, el directorio más arriba en
que tiene un "RootMakeppfile (.mk)". Si no tiene uno, esta variable es
vacío.

SHELL
Esta variable solo se respeta si la "exporta". En ese caso es el Shell
que se utiliza para ejecutar acciones no integradas con algún carácter especial en él (sin formato
los que se ejecutan directamente). En Windows Strawberry o ActiveState Perl, si tiene
un Shell similar a Unix, en su lugar, debe establecer su variable SHELL en un valor que termine en "sh"
o "sh.exe" antes llamando a makepp.

Por defecto: El primero que se encuentra entre "/ usr / xpg4 / bin / sh" (por ejemplo, Solaris) o "/ sbin / xpg4 / sh"
(por ejemplo, Reliant Unix) o "/ Bin / sh".

YACC
Por defecto: El primero encontrado entre "bison -y" o "yacc".

Variables y Perl
Los valores de las variables se almacenan como escalares de Perl ordinarios, por lo que puede acceder a ellos directamente desde
Código Perl si necesita realizar manipulaciones complicadas con ellos; ver makepp_extending
para obtener más detalles.

El acceso a las variables globales desde Perl se logra prefijándolas con "Mpp :: global"
paquete. De hecho, cualquier variable que aún no esté presente en el archivo MAKE actual y que
asignar a en este paquete será a partir de entonces global, como si acabara de emitir el
declaración "global" para ello.

Sin embargo, este acceso directo es propenso a errores. El usuario puede haber anulado estas variables.
en la línea de comandos oa través del entorno. Algún otro archivo MAKE cargado antes de este
uno puede haber hecho que la variable sea global o específica del objetivo. En estos casos no
encontrar el valor de la variable, o al asignarlo, podría quitarle su propiedad
(equivalente a un modificador "anular", excepto para los detalles específicos del objetivo).

Con el acceso directo también se omite la expansión de estas variables, si son del tipo
"=" o "; =". Las variables especiales como "$ (CC)" comienzan como funciones, hasta que son
asignado a. Entonces, en muchos casos, no verá su valor.

Por estas razones, es mejor dejar que makepp determine el valor correcto. Puedes usar el
variante "makeperl", en la que la variable se ha evaluado antes de que el código Perl obtenga
interpretado:

makeperl {$$ current_value = '$ (MAKEFILE_VAR)'}

Si necesita una variable en los bloques de perl de makefile, esto se logra a través de la variable de Perl
$ makefile de la siguiente manera:

perl {$ valor_actual = $ makefile-> expand_variable ('MAKE_VAR')}

Las funciones siempre obtienen el objeto makefile pasado como segundo argumento $ _ [1]:

sub f_f {$ valor_actual = $ _ [1] -> expand_variable ('MAKE_VAR')}

Se supone que los comandos deben llamarse dentro de una acción de regla, donde el objeto Makefile es
accesible a través de "$ Mpp :: Subs :: rule -> {MAKEFILE}":

sub c_cmd {$ valor_actual = $ Mpp :: Subs :: regla -> {MAKEFILE} -> expand_variable ('MAKE_VAR')}

Use makepp_variables en línea usando los servicios de onworks.net