makepp_functions - Online en la nube

PROGRAMA:

NOMBRE

makepp_functions - Funciones en makepp

DESCRIPCIÓN

A: nombre_archivo_absoluto,
absoluto_nombre_archivo_nolink,
abspata,
añadir prefijo,
adduffix,
y, B: nombre de base C: llamada, D: es,
dir_noslash, E: error, F: archivosubst,
filtrar,
filtrar,
filter_out_dirs,
encontrar archivo,
encontrar_primero_hacia arriba,
encontrar_programa,
encontrar,
encontrar_hacia arriba,
primero disponible,
primera palabra,
para cada, I: Si,
si es verdad,
infer_linker,
inferir_objetos,
información, J: entrar, M: fabricar,
hacer mapa,
maquillaje,
mapa,
"mktemp", N: nodir, O: solo_generado,
solo_no objetivos,
solo_destinos_fónicos,
solo_anticuado,
solo_objetivos,
o,
origen, P: patsubst,
perlas,
falso,
preconstrucción
impresión, R: camino real
nombre_archivo_relativo,
relativo a, S: cáscara,
ordenar,
tira,
sustancia,
sufijo, T: temporal, W: advertencia,
comodín,
palabra,
lista de palabras,
palabras, X: xargs

Cualquier expresión del formato "$ (nombre)", donde "nombre" no es el nombre de una variable, o
"$ (nombre arg1 arg2 arg3)" se interpreta como una llamada de función. El nombre puede contener letras,
guiones bajos o guiones; para evitar confusiones, puede utilizar guiones o guiones bajos
indistintamente, ya que los guiones internos se convierten en guiones bajos. Evaluando tales
una expresión simplemente invoca una subrutina de Perl. Si "nombre" va precedido por "&", ejecuta el
comando incorporado o script de ese nombre dentro del proceso makepp, y devuelve el estándar
producción. Esto requiere que perl esté construido para PerlIO. Si el nombre no nombra una función
se transforma en una invocación de llamada.

Al igual que con las variables, tiene la opción de "$ (nombre ...)" o "$ {nombre ...}". Si quieres
incrustar el mismo paréntesis, debe estar emparejado, el otro no importa: "$ (nombre
... () {... "o" $ {name ... {} (...} ". (Sin embargo, para map y perl, el primer par de cierre termina
la expresión.) La duplicación permite que los argumentos abarquen varias líneas. Las nuevas líneas son
luego se tratan como espacios, excepto quizás en "definir". También existe la sintaxis "$ [nombre ...]"
o $ [[nombre ...]], que se evalúa mientras se lee el archivo MAKE, antes de las reglas de grokking
y otras construcciones.

Makepp tiene una serie de funciones integradas que pueden resultar útiles. Es compatible con casi todos
Funciones textuales de GNU make (consulte la documentación de GNU make para obtener más detalles), y algunas de sus
propio. Puede definir subrutinas de Perl para hacer lo que quiera. Ver la declaración "sub"
y la sección sobre cómo extender makepp para más detalles.

Condicional Clave
y condición1 [, condición2 [, condición3 ...]]
La función y proporciona una operación Y de "cortocircuito". Cada argumento es
ampliado, en orden. Si un argumento se expande a una cadena vacía, el procesamiento se detiene y
el resultado de la expansión es la cadena vacía. Si todos los argumentos se expanden a una
cadena vacía, el resultado de la expansión es la expansión del último argumento.

if cuerda, resultado-si-cadena-no-en-blanco [, resultado-si-cadena-en blanco]
si es verdad cuerda, resultado-si-cadena-verdadero [, resultado-si-cadena-falso]
Una alternativa a las declaraciones "ifeq", etc. Si la cadena no está en blanco (es decir, el
condición es verdadera), el segundo argumento (la cláusula "entonces") se devuelve (después
expansión variable); si la cadena está en blanco, el tercer argumento (la cláusula "else") es
devuelto.

Por ejemplo,

CFLAGS: = $ (si $ (filtro gcc egcc, $ (CC)), -g -Wall, -g)

define CFLAGS como "-g -Wall" si la variable CC es "gcc" o "egcc" y "-g"
de lo contrario. (Esto es lo que hacen las reglas de compilación predeterminadas).

"iftrue" es similar a "if", excepto que la cadena 0 se trata como en blanco.

or condición1 [, condición2 [, condición3 ...]]
La función o proporciona una operación OR de "cortocircuito". Cada argumento se expande,
en orden. Si un argumento se expande a una cadena no vacía, el procesamiento se detiene y el
resultado de la expansión es esa cadena. Si, después de expandir todos los argumentos, todos los
son falsas (vacías), entonces el resultado de la expansión es la cadena vacía.

Archive y Nombre del archivo Clave
nombre_archivo_absoluto archivos
Abspata archivos
Convierte nombres de archivos relativos en absolutos sin . or ... Por ejemplo,
"$ (nombre_archivo_ absoluto xyz.c)" podría devolver "/usr/src/our_project/subdir/xyz.c".

absoluto_nombre_archivo_nolink archivos
Realpath archivos
Como nombre_archivo_ absoluto, pero garantiza que los enlaces simbólicos se resuelvan.

nombre base nombres de archivo
El nombre base es el nombre completo del archivo (con el directorio), menos el texto después y
incluido el último período. Por ejemplo, "$ (nombre base miarchivo / versión-1.0-module.c)" es
"myfile / version-1.0-module"

dir nombres de archivo
Extrae la parte del directorio de cada archivo en la lista de nombres de archivo, incluido el final
barra oblicua. Devuelve "./" si no hay un directorio en el nombre del archivo.

dir_noslash nombre de archivo
Igual que "$ (dir)" excepto que no devuelve la barra al final.

archivosubst modelo, sustituir, palabras
Realice una sustitución de patrones en los nombres de archivo. Esto se diferencia de patsubst en que
funcionará correctamente cuando se proporcionen nombres alternativos para directorios (siempre que
preceden al signo de porcentaje). Por ejemplo,

$ (filesubst ./src/%.c,% .o, $ (comodín src / *. c))

funcionará con filesubst pero no con patsubst.

filter_out_dirs nombres de archivo
Devuelve todos los nombres de archivo que no se refieren a directorios.

encontrar archivo nombre del archivo, camino
Encuentra un archivo en la ruta especificada, o en la variable de entorno PATH si no hay nada
especificado. Esto puede resultar útil para buscar binarios o incluir archivos. Por ejemplo,

TCL_INCLUDE: = -I $ (dir_noslash $ (buscar archivo tcl.h, \
/usr/local/stow/tcl-8.4.5-no-thread/include \
/usr/include/tcl8.4 / usr / include / tcl \
/net/na1/tcl8.4a3/include /net/na1/tcl8.4a3/include))

Esto ubica el archivo tcl.h buscando en todos los directorios anteriores. El absoluto
Se devuelve la ruta al archivo. Luego, "$ (dir_noslash)" extrae ese directorio, y
se coloca en la ruta de inclusión.

encontrar_programa nombre
Devuelve el primer programa de la lista que se puede encontrar en la RUTA. Esto es útil
cuando hay varios programas equivalentes que se pueden usar y solo desea
elige uno de ellos. Por ejemplo, aquí está la definición predeterminada de varios
variables que proporciona makepp si no pones una en tu archivo MAKE:

CC = $ (find_program gcc egcc pgcc c89 cc) # y más, dependiendo de la máquina
F77 = $ (buscar_programa f77 g77 fort77)
CXX = $ (buscar_programa g ++ c ++ pg ++ cxx CC aCC)

Si no se encuentra ninguno de los programas, "$ (find_program)" devuelve la cadena no encontrada y
registra lo que no se encontró. Por lo general, esto no dará como resultado un archivo MAKE funcional, pero
tenderá a generar mejores mensajes de error. Por ejemplo, si haces algo como
modo:

% .o:% .c
$ (CC) $ (entradas) -o $ (salidas)

y makepp no ​​puede encontrar un compilador de C en la lista anterior, lo sustituirá por no encontrado.
De lo contrario, el shell intentaría ejecutar el archivo fuente y el error resultante
El mensaje puede ser realmente extraño.

encontrar_hacia arriba nombre de archivo
Busca un archivo con el nombre dado en el directorio., .., ../ ..../../ .., Etc,
hasta que se encuentre el archivo o se alcance el directorio raíz o se ubique el directorio
en un sistema de archivos diferente. (Este último requisito es prevenir problemas con
montadores automáticos o sistemas de archivos de red colgados). Archivo RootMakepp, eso también es
una barrera que impide buscar más alto.

Por ejemplo, si tiene un proyecto con muchos niveles de subdirectorios, podría
incluir este fragmento común en todos los archivos MAKE (por ejemplo, usando el "incluir"
declaración):

TOP_LEVEL_INCLUDE_DIR: = $ (find_upwards incluye)
# Busca un directorio que contenga el
# incluye subdirectorio.

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

Otro problema que "find_upwards" puede ayudar a resolver es ubicar el directorio de nivel superior
de una construcción. A menudo es útil definir una variable como esta:

ARRIBA: = ../../ ..

si tiene información importante ubicada solo en el directorio de nivel superior. Pero
esto es difícil de mantener, porque la cantidad de ".." es diferente para diferentes niveles
del árbol de directorios. En su lugar, puede utilizar "find_upwards" para localizar un archivo que es
conocido por estar presente solo en el directorio de nivel superior. Supongamos, por ejemplo, que el
El archivo "LICENCIA" se encuentra solo en el directorio de nivel superior. Entonces podrías hacer esto:

ARRIBA: = $ (dir_noslash $ (buscar LICENCIA))

"$ (find_upwards LICENSE)" devuelve la ruta completa del archivo de licencia;
"$ (dir_noslash ...)" elimina el nombre del archivo, devolviendo solo el directorio.

(Tenga en cuenta que la instrucción "incluir" busca archivos automáticamente hacia arriba, por lo que
no es necesario hacer algo como esto:

incluir $ (find_upwards top_level_rules.mk)

En cambio, puedes simplemente hacer

incluir top_level_rules.mk

y funcionará igual de bien).

Si no se encuentra el archivo, "find_upwards" abortará la compilación con un mensaje de error.

Si especifica más de un archivo, find_upwards buscará el primero y luego
el segundo, y así sucesivamente. En otras palabras,

$ (find_upwards file1 file2)

es equivalente a

$ (find_upwards file1) $ (find_upwards file2)

Si desea buscar alguno de los archivos, utilice "find_first_upwards" en su lugar.

encontrar_primero_hacia arriba file1 file2 ...
Esta función se comporta como "find_upwards" excepto que devuelve el primer archivo de cualquier
archivos en la lista que encuentra. Específicamente, comprueba el directorio actual para
cualquiera de los archivos de la lista y devuelve el primer archivo que existe o que se puede construir.
Si ninguno de los archivos existe o se puede construir en ese directorio, verifica .., entonces
../ .., etc., hasta que llegue al directorio raíz o al directorio
ubicado en un sistema de archivos diferente.

primero disponible file1 file2 ...
Devuelve el primer archivo de una lista que existe o que se puede crear. Esto puede ser útil para
adaptar sus archivos MAKE para que funcionen en varias máquinas o redes diferentes, donde
Los archivos importantes pueden estar ubicados en diferentes lugares. Por ejemplo, aquí hay una línea de
uno de mis archivos MAKE:

TCL_LIB = $ (primer_disponible \
/usr/local/stow/tcl-8.4.5-nothread/lib/libtcl8.4.so \
/usr/lib/libtcl8.4.so /usr/lib/libtcl.so \
/net/na1/tcl8.4a3/lib/libtcl8.4.a \
/net/na1/tcl8.4a3/lib/libtcl8.4.sl)

Esta línea buscará la biblioteca Tcl en todos los lugares anteriores, deteniéndose en el
el primero que encuentra. El comando de enlace luego incluye $ (TCL_LIB) por lo que obtenemos el
biblioteca Tcl apropiada.

infer_linker file1 file2 ...
Dada una lista de archivos de objeto, primero constrúyalos si aún no lo han hecho. Entonces busca
si dependen de una fuente Fortran, C ++ o C y devuelven el correspondiente
compilador (que sabe mejor cómo vincular que "ld").

inferir_objetos file1 file2 ... patrón
$ (infer_objects object1.o object2.o, * .o)

Si usa convenciones estándar con respecto a los nombres de archivos de encabezado, makepp es capaz de
adivinar qué archivos ".o" o ".lo" deben vincularse con su programa. Yo uso esto para
seleccionar archivos de un directorio de biblioteca que contiene módulos utilizados en diferentes
programas. En lugar de crear un archivo de biblioteca ".a" y hacer que el vinculador elija el
módulos relevantes, makepp puede seleccionar los módulos relevantes para usted. De esta manera, solo
los módulos relevantes se compilan.

El algoritmo de Makepp para inferir dependencias de objetos depende de la convención de que
la implementación de todas las clases o funciones definidas en un archivo de encabezado "xyz.h" son
compilado en un archivo objeto llamado "xyz.o" (o "xyz.lo"). Así que el algoritmo de makepp para
inferir dependencias de objetos comienza con uno o unos pocos objetos que sabemos que deben ser
vinculado al programa. Examina qué archivos se incluyeron con "#include" en
esas fuentes, e intenta encontrar los archivos de objeto correspondientes para cada uno de los
archivos.

"$ (infer_objects)" debe mencionarse en la lista de dependencias de un programa, como
modo:

myprog: $ (infer_objects main.o otro_objeto.o, \
** / *. o /otra/library/dirs/**/*.o)
$ (CXX) $ (entradas) -o $ (salida) $ (LIBS)

La función "$ (infer_objects)" toma dos argumentos (separados por una coma, como se muestra).
El primero es uno o unos pocos archivos de objeto que se sabe que son necesarios (los comodines son
permitido aquí). El segundo es una lista de posibles objetos (normalmente usaría un
comodín aquí) que podría vincularse si es necesario. El valor de retorno de este
La función es una lista que contiene primero todos los objetos en el primer argumento, y
luego, después de esos, todos los objetos adicionales que estaban contenidos en el segundo argumento
que son requeridos por los objetos en el primer argumento.

Por ejemplo, suponga que "main.o" proviene de "main.cpp", que incluye "my_class.h".
"$ (infer_objects)" busca archivos con el nombre "my_class.o". Si exactamente uno de esos
se encuentra el archivo, se agrega a la lista. (Si se encuentran dos archivos de objeto "my_class.o"
en diferentes directorios, se imprime un mensaje de advertencia.) "infer_objects" también
examina "my_class.cpp" para ver qué incluye y qué archivos de objeto adicionales son
implícito.

mktemp
mktemp prefijo
mktemp prefijoXXX
mktemp /
Devuelve un nombre de archivo temporal impredecible, que no existe actualmente. Sin nombre
apuntando al mismo archivo se devuelve dos veces, incluso con diferentes rutas relativas,
dentro de una ejecución makepp (excepto posiblemente con la marca recursiva tradicional, o si Perl
código que se ejecuta dentro de una acción de regla llamada "f_mktemp"). Al final del makepp, ejecuta todo
Los archivos devueltos por esta función se eliminan, si existen (de nuevo, excepto aquellos
devuelto por esta función en código Perl que se ejecuta dentro de una regla).

Cualquier número de "X" mayúsculas al final del argumento se reemplaza por esa cantidad
letras y dígitos aleatorios. Cuanto más haya, menos probable es que esto choque
con otros procesos, así que si le da un prefijo como "/ tmp / abc.", deberías tener suficiente
"X" s. Si hay más de una X, el primer carácter proviene de la identificación del proceso. Si
no hay ninguno, es como si hubiera diez, lo que supuestamente es suficiente (8.4e17
posibilidades o 3.7e15 en Windows). Si no hay ningún argumento, el prefijo predeterminado es
"tmp."en el directorio actual.

Tenga en cuenta que no desea dar un nombre como los destinos y las dependencias de las reglas. los
El resultado sería correcto, pero se volvería a crear cada vez que ejecute makepp.

Además, como siempre es diferente, debe usar esto en una acción de regla solo si usa
": build_check ignore_action":

TMPFILE; = $ (mktemp) # 1 llamada; "=" significaría 3 llamadas: 3 archivos
A-count B-count:: build_check ignore_action
producir-como-y-Bs> $ (TMPFILE)
& grep -c / A / $ (TMPFILE) -o A-count
& grep -c / B / $ (TMPFILE) -o B-count

O debería exportarlo y dejar que Shell lo evalúe:

exportar TMPFILE; = $ (mktemp)
Conteo A Conteo B:
produce-As-and-Bs> $$ TMPFILE # makepp no ​​ve el valor var
fgrep -c A $$ TMPFILE> A-count
fgrep -c B $$ TMPFILE> B-count

El último formulario repite el valor de retorno anterior, por lo que puede usarlo en una regla de patrón:

% .x:% .y
& grep foo $ (entrada) -o $ (mktemp)
& sed bar $ (mktemp /) -o $ (salida) # Operar en la salida de & grep

nodir nombres de archivo
Devuelve la parte que no pertenece al directorio de los nombres de archivo, es decir, todo lo que sigue al último
barra diagonal si hay uno, o el nombre completo del archivo en caso contrario.

solo_generado nombres de archivo
Devuelve solo aquellos nombres de archivo en la lista que fueron generados por makepp y no desde
modificado, de acuerdo con el archivo de información de compilación.

Esta función es útil en reglas de destino limpio (aunque, por supuesto, "makeppclean" es el
variante preferida):

$ (falso limpio):
& rm -f $ (solo_generado ** / *)

only_nontargets nombres de archivo
Devuelve solo aquellos nombres de archivo en la lista que no son objetivos de ninguna regla (ya sea
reglas explícitas o de patrones). Puede especificar un comodín (consulte el "$ (comodín)"
función para obtener más detalles sobre los comodines de makepp). Esto se puede utilizar para generar un
destino de distribución, por ejemplo:

.PHONY: distribución

distribución:
& mkdir our_product - $ (VERSION)
& cp $ (filter-out% ~, $ (only_nontargets *)) our_product - $ (VERSION)
tar cf - our_product - $ (VERSION) | gzip -9c> our_product - $ (VERSION) .tar.gz

En este caso, "$ (only_nontargets *)" devuelve todos los archivos del directorio actual
eso no es un objetivo de alguna regla. El "$ (filter_out% ~, ...)" elimina el editor
copias de seguridad

Similar a "only_targets" (ver arriba), "only_nontargets" solo conoce los objetivos que
ya se han definido. Esto solo es un problema si lo usa para definir variables
con la asignación ": ="; si lo usa en la lista de dependencias o en el cuerpo de un
regla, todas las demás reglas ya se habrán visto.

solo_antiguo nombres de archivo
Devuelve solo aquellos nombres de archivo en la lista que fueron generados por makepp y no desde
modificado, de acuerdo con el archivo de información de compilación, pero ya no son objetivos de ninguna regla.

Esta función es útil para garantizar que no haya dependencias en dichos archivos,
sin forzar una construcción limpia de todos los objetivos:

$ (descarga falsa):
& rm -f $ (only_stale ** / *)

En realidad, probablemente sea mejor escribir un script que llame a makepp para generar
la lista de archivos obsoletos, y luego haga que ese script elimine todos los archivos enumerados que
no están actualmente bajo el control de la fuente, en caso de que un archivo generado se convierta en una fuente
expediente. Makepp no ​​tiene una función de este tipo incorporada porque makepp es (y probablemente
debería permanecer) agnóstico sobre el control de fuente.

solo_objetivos nombres de archivo
Devuelve solo aquellos nombres de archivo en la lista que son realmente objetivos de alguna regla
(reglas explícitas o de patrones). Puede especificar comodines (incluidos los de makepp
comodín especial, "**") en los nombres de archivo. (Consulte la función "$ (comodín)" para obtener más
detalles. Esto se puede utilizar para un objetivo limpio, por ejemplo:

.PHONY: limpio

limpiar:
& rm -f $ (solo_destinos *)

Ahora, si escribe "makepp clean", eliminará todo lo que sabe cómo compilar. Pero
¡No cree un objetivo limpio, use "makeppclean" en su lugar!

Otro lugar en el que puede resultar útil es evitar incluir obsoletos .o archivos en tu
construir. Por ejemplo, si crea una biblioteca como esta:

mylib.a: * .o
& rm -f $ (salida)
$ (AR) cr $ (salida) $ (entradas)

y luego borras algunos archivos fuente pero olvidas borrar el correspondiente .o archivos,
las .o los archivos todavía estarán disponibles. Esto significa que todavía se incorporarán a
la biblioteca a pesar de que ya no son útiles. Si modifica su
regla como esta:

mylib.a: $ (solo_destinos * .o)
& rm -f $ (salida)
$ (AR) cr $ (salida) $ (entradas)

entonces este problema no ocurrirá.

Tenga en cuenta que esto se refiere solo a archivos que se sabe que son objetivos at las equipo Usted
invocar "solo-objetivos". Si aparece "only_targets" en las dependencias o acciones de un
regla, entonces todos los posibles objetivos serán conocidos porque las dependencias y acciones no son
evaluado hasta que se ejecute la regla. Sin embargo, si evalúas intenta evaluarlo
anteriormente en el archivo MAKE con una variable ": =" como esta:

ALL_TARGETS: = $ (only_targets *)

target1: dependencia1
acciones

target2: dependencia2
acciones

entonces "only_targets" no conocerá las reglas posteriores.

De manera similar, "only_targets" no conoce los destinos producidos en archivos MAKE que son
cargado con marca recursiva. (Pero no deberías usar make recursivo de todos modos; usa
utilice la instrucción "load_makefile" o la carga implícita de un archivo MAKE en su lugar).

nombre_archivo_relativo file1 file2 file3 [, barra oblicua]
Devuelve el nombre de esos archivos en relación con el directorio actual (el que
makefile está en). Esto también se puede utilizar para limpiar "./" innecesarios y otra basura de
el camino:

DIR: =.
SUBDIR: = ..
FNAME: = $ (DIR) /../ otherdir / $ (SUBDIR) / files
X: = $ (nombre_archivo_relativo $ (FNAME))

If tala es verdadero (generalmente 1) los nombres de archivo devueltos están garantizados para contener una barra
anteponiendo "./" si es necesario, para que pueda usarlo como un nombre ejecutable sin
preocuparse de que la ruta de búsqueda del comando anule la ubicación del directorio.

Si la ruta pasa por el directorio raíz, el padre de su directorio de inicio o
el "$ (ROOT)" de su sistema de compilación, o en Windows la raíz de una unidad (dependiendo de la
medio ambiente, esto también sucede para / cygdrive / c or /c), una ruta absoluta será
regresó en su lugar.

relativo a file1 file2 file3 [, directorio]
Devuelve el nombre de esos archivos en relación con el directorio especificado. Este es
Suele ser útil cuando, por cualquier motivo, tiene que ejecutar un comando desde un
directorio diferente (directorio actual predeterminado):

fuente_copia de seguridad.tar:
cd .. && tar cf $ (relativo_a $ (salida), ..) $ (relativo_a., ..)

sufijo nombres ...
Extrae el sufijo de cada nombre de archivo en los nombres. Si el nombre del archivo contiene un punto,
el sufijo es todo lo que comienza con el último punto. De lo contrario, el sufijo es el
cuerda vacía. Esto frecuentemente significa que el resultado estará vacío cuando los nombres no lo estén,
y si los nombres contienen varios nombres de archivo, el resultado puede contener menos nombres de archivo.

Por ejemplo,

$ (sufijo src / foo.c src-1.0 / bar.c hacks)

produce el resultado ".c .c".

temporal palabras
Hágale saber a makepp que los objetivos especificados pueden ser eliminados por la regla que genera
ellos. Similar a "falso", excepto que makepp espera que un archivo real con ese nombre
Will puede verse afectado por la regla. Una regla no se ejecuta si solo es temporal
los objetivos están desactualizados.

comodín patrón
Devuelve los nombres ordenados de todos los archivos que coinciden con el patrón dado que existen, o aquellos
archivos que aún no existen pero que se pueden construir según las reglas que makepp conoce
sobre en el punto en el que evalúa la expresión. En este último punto se diferencia
a partir de comodines de entrada de reglas, que se aplican incluso a archivos creados por reglas que se encuentran más adelante.

Makepp admite todos los comodines de shell habituales ("*", "?" Y "[]"). También tiene un
comodín "**" que coincide con cualquier número de directorios intermedios. (Esta idea fue
robado de zsh.) Por ejemplo, "** / *. c" coincide con todos los .c archivos en toda la fuente
árbol. "objetos / ** / *. o" coincide con todos los .o archivos contenidos en cualquier parte del
subdirectorio objetos o cualquiera de sus subdirectorios o cualquiera de sus subdirectorios. los
El comodín "**" no seguirá enlaces suaves a directorios en ningún nivel, ni tampoco
intente entrar en directorios que existen pero que no se pueden leer. También archivos y
los directorios que existen pero que no se pueden leer no serán devueltos por "$ (comodín)".

Cordón Clave
añadirprefijo prefijo, palabras
Antepone la cadena de prefijo a cada una de las palabras. Esto es principalmente para GNU make
compatibilidad; usando la expansión de estilo rc, esto se puede hacer de una manera más legible
Me gusta esto:

MÓDULOS: = abcd
X_OLD_STYLE: = $ (agregarprefijo $ (OBJDIR) /, $ (agregar sufijo .o, $ (MÓDULOS)))
X_NEW_STYLE: = $ (OBJDIR) / $ (MODULES) .o # ¿No es más fácil de leer?

adduffix sufijo, palabras
Agrega la cadena de sufijo a cada una de las palabras. Esto es principalmente para GNU make
compatibilidad; usando la expansión de estilo rc, esto se puede hacer de una manera más legible
Me gusta esto:

X_OLD_STYLE: = $ (añade sufijo .o, $ (MÓDULOS))
X_NEW_STYLE: = $ (MÓDULOS) .o

llamar al variable[, palabras]...
La función "llamar" es única en el sentido de que se puede utilizar para considerar variable como herramienta de edición del
función parametrizada. Puede asignar una expresión compleja a variable y use
"llamar" para expandir su contenido a diferentes valores parametrizados por palabras mas tarde. En
otros sistemas de marca, una variable que se utiliza principalmente con el propósito de expandirse a través de
"llamar", se llama macro.

Durante la expansión de la macro, las variables temporales $1, $2, "..." referirse a
argumentos dados a "llamar" durante su invocación. La variable $0 se expandirá a
el nombre de la macro (es decir variable) esa "llamada" se está expandiendo actualmente.

No hay límite, con cuántos argumentos se puede "llamar" a una macro o cuántos
parámetros que puede esperar una macro. Si pasa más argumentos a "llamar" como macro
necesidad, todos los argumentos excedentes serán descartados. Si pasa menos argumentos que un
macro esperan, todos los parámetros excedentes colapsan en la cadena vacía.

Primero un ejemplo simple:

resto = $ (lista de palabras 2, $ (palabras $ (1)), $ (1))
lista = ABCDE
pero primero: = $ (llamar al descanso, $ (lista))

Aquí, la variable "$ (pero primero)" contendrá la lista "BCDE".

Y ahora un ejemplo más complejo para mostrar lo que es posible:

resto = $ (lista de palabras 2, $ (palabras $ (1)), $ {1})
mymap = $ (si $ 2, $ (llamar $ 1, $ (primera palabra $ 2)) $ (llamar $ 0, $ 1, $ (llamar resto, $ 2)))
downcase = $ {makeperl lc ("$ 1")}

UCWORDS = TODAS ESTAS PALABRAS SON UPCASE
DCWORDS: = $ (llamar mymap, downcase, $ (UCWORDS))

Ahora "$ (DCWORDS)" contiene "todas estas palabras están en mayúsculas". Por cierto: no hace
diferencia, si accedemos a los argumentos a través de $1, "$ {1}" or "$ (1)" dentro de una macro.

Puede usar directamente la variable como si fuera una función, si no hay
función de ese nombre. Esto se convierte internamente en "llamar", por lo que son
equivalente:

discusión = El $ 0 se convirtió en $ 1 $ 2.
directo = $ (discusión y argumento)
llamado = $ (llamar discusión, an, argumento)

Podría parecer discutible si "$ [call]" también debería expandir "$ []" de la macro
expresiones, o si una función siempre debe hacer lo mismo, sin importar cómo
se llama. Se eligió este último, porque con la sintaxis de make normal sería
imposible obtener "$ [1], $ [2] ..." en una variable (no serían reemplazados por nada,
incluso antes de que tenga lugar la asignación.) Por lo tanto, si tiene una macro para definir un
regla, desea que se vean expresiones como "$ (salida)" cuando se analiza la regla, por lo que
debes protegerlos de la "llamada":

definir myrule
$ 2: $ 1
mycommand $$ (entrada) -o $$ (salida)
endef
$ [myrule myinput, myoutput]

filtrar patrones, palabras
Devuelve todas las palabras de la lista que coinciden con los patrones. Los patrones pueden ser simplemente otros
palabras o comodines de nombre de archivo (es decir, se reconocen "*", "?" y "[az]"), o pueden
tener un carácter "%", lo que significa coincidir con cualquier cadena en ese punto (igual que "*").

filtrar patrones, palabras
Devuelve todas las palabras de la lista que no coinciden con los patrones. Los patrones pueden ser simplemente
otras palabras, o comodines de nombre de archivo (es decir, se reconocen "*", "?" y "[az]"), o
pueden tener un carácter "%", lo que significa que coinciden con cualquier cadena en ese punto (igual que
"*").

Por ejemplo:

libproduction.a: $ (filter_out test_ *, $ (comodín * .o))

pondrá todo .o archivos que existen o pueden construirse, excepto los que comienzan con test_,
dentro producciónlib.a.

encontrar encontrar, in
Ida y vuelta encontrar, si es una subcadena de in.

primera palabra palabras
Devuelve la primera palabra.

mapa palabras, código perl
hacer mapa palabras, código perl
De manera similar al mapa de Perl, se aplica código perl a cada palabra por turno y devuelve el
resultados. La primera variante es un código Perl simple, mientras que la segunda variante pasa primero
el perlcode a través de la expansión de variables de estilo Make. Las palabras se expanden en ambos
casos.

Las palabras están en $ _ y se devuelven a menos que no defina $ _. Esto está destinado a
modificaciones que no son fáciles de manejar por "patsubst". Solo la primera coma es un separador,
cualquier otro se considera parte del código perl.

# Cambiar palabras. Parens dobles, para permitir parens en perlcode, o use $ {}:
X = $ ((mapa $ (VALORES), s /(.+)-(.+)/$ 2- $ 1 /))
# Puede usar expresiones make, pero luego debe usar $$ para Perl $:
Y = $ (makemap $ (VALUES), tr / $ (OLDCHARS) / $ (NEWCHARS) / or $$ _ = 'failed')
# Puede eliminar candidatos:
Y = $ (mapa $ (VALORES), undef $ _ si / no_bueno /)

únete palabras1, palabras2
Combine por parejas las primeras palabras y las segundas palabras.

Patsubst modelo, sustituir, palabras
Realiza una sustitución en cada palabra de la lista de palabras. Un carácter "%" coincide con cualquier
cuerda. Esto se ilustra mejor con un ejemplo:

OBJS = $ (patsubst% .c, object_dir /%. O, $ (C_SOURCES))

toma cada archivo en C_SOURCES y devuelve el nombre de un archivo de objeto en object_dir.
A veces es más conciso utilizar una referencia de sustitución, por ejemplo, lo anterior podría
han sido escritos como

OBJS = $ (C_SOURCES:%. C = object_dir /%. O)

sort word1 word2 word3 ...
Ordena las palabras en orden léxico y elimina los duplicados.

tira cadena
Elimina los espacios en blanco iniciales y finales de la cadena y reemplaza cada uno de los internos.
secuencia de uno o más caracteres de espacio en blanco con un solo espacio. Por tanto, "$ (strip ab
c) "da como resultado" abc ".

subst desde, hasta, texto
Realiza un reemplazo textual en el texto del texto: cada ocurrencia de se reemplaza
por a. El resultado se sustituye por la llamada a la función. Por ejemplo,

$ (subst ee, EE, pies en la calle)

sustituye la cadena "FEEt on the strEEt".

por el temor n, texto
Devuelve el na palabra de texto. Los valores legítimos de n empezar desde 1 al principio
o hacia atrás desde -1 al final. Si n es mayor que la cantidad de palabras en texto, la
el valor está vacío.

lista de palabras lista de índice, palabras
lista de palabras primer índice, últimoíndice, palabras
En el primer formulario, proporciona una lista de índices (contando desde 1 al principio o
hacia atrás desde -1 al final) para seleccionar las palabras que desee. En la segunda forma tu
especifique el rango de palabras que desea devolver.

palabras texto
Devuelve el número de palabras en texto.

Observaciones Clave
foreach var, lista, texto
Los dos primeros argumentos, var y lista, se expanden antes de que se haga cualquier otra cosa; Nota
que el último argumento, el texto, no se expande al mismo tiempo. Luego, para cada palabra de
el valor expandido de la lista, la variable nombrada por el valor expandido de var se establece en
esa palabra y el texto se expande. Presumiblemente, el texto contiene referencias a esa variable,
por lo que su expansión será diferente cada vez.

Este simple ejemplo establece la variable archivos a la lista de todos los archivos en el
directorios en la lista dirs:

dirs: = abcd
archivos: = $ (directorio foreach, $ (directorios), $ (comodín $ (dir) / *))

Aquí el texto es "$ (comodín $ (dir) / *)". La primera repetición encuentra el valor "a" para dir,
por lo que produce el mismo resultado que "$ (comodín a / *)"; la segunda repetición produce
el resultado de "$ (comodín b / *)"; y el tercero, el de "$ (comodín c / *)".

Este ejemplo tiene el mismo resultado (excepto para configurar "dirs") que el siguiente ejemplo:

archivos: = $ (comodín a / * b / * c / * d / *)

Cuando el texto es complicado, puede mejorar la legibilidad dándole un nombre, con un
variable adicional:

find_files = $ (comodín $ (dir) / *)
dirs: = abcd
archivos: = $ (directorio foreach, $ (directorios), $ (buscar_archivos))

Aquí usamos la variable find_files de esta manera. Usamos simple "=" para definir un
variable de expansión recursiva, de modo que su valor contenga una llamada de función real a
volver a expandirse bajo el control de foreach; una variable simplemente expandida no funcionaría,
ya que el comodín se llamaría solo una vez al momento de definir find_files.

Nota: No confunda esto con la variable especial "$ (foreach)".

info texto
advertencia texto
error texto
Texto de salida que devuelve la nada. El primero va a STDOUT, el segundo a STDERR,
el tercero además aborta el procesamiento.

preconstruir tiene como objetivo
para lograr tiene como objetivo
Devuelve su argumento literalmente, pero primero crea todos los archivos enumerados. Esto es útil
cuando se necesita un archivo determinado al evaluar una expresión de creación. Esto suele suceder
cuando tiene una compilación donde el conjunto de archivos involucrados es calculado por algún shell
comandos. Por ejemplo,

file_list:
# comandos de shell para calcular una lista de archivos para poner en el programa

mi_programa: $ (& cat $ (preconstruir lista_de_archivos))

Si necesita la lista en más de una regla, sería más eficiente utilizar una
expandir como máximo una vez variable:

file_list; = $ (& cat $ (preconstruir file_list))

my_program1: ao $ (lista_archivos)

my_program2: bo $ (lista_archivos)

Si, en cambio, especificaste solo "$ (& cat file_list)", makepp no ​​forzaría
file_list para estar actualizado antes de ejecutar el comando de shell. Usando "$ (prebuild)"
es la mejor forma de solucionar este problema. Es posible que tenga la tentación de probar otras cosas, como
modo:

mi_programa: file_list $ (& cat file_list)

pero esto no funcionará porque "$ (& cat file_list)" se evalúa antes de que makepp intente
construir "file_list".

only_phony_targets nombres
Devuelve solo aquellos nombres en la lista que son objetivos falsos de alguna regla (ya sea
reglas explícitas o de patrones). Puede especificar comodines (incluido el especial de makepp
comodín, "**") en los nombres de archivo. (Consulte la función "$ (comodín)" para obtener más detalles.
Esto se puede utilizar para agrupar destinos, por ejemplo:

$ (pruebas falsas): $ (only_phony_targets * / ** / tests)

natural variable
Dado el nombre de una variable, te dice de dónde proviene su valor.

perl código perl
maquillaje código perl
Evalúa perlcode en un bloque y devuelve el resultado. La primera variante es simple Perl
código, mientras que la segunda variante pasa primero el código perl a través de la variable de estilo Make
expansión.

Tenga en cuenta que, como con todas las funciones, el delimitador de función utilizado puede no aparecer dentro
el perlcode fuera de las cadenas entre comillas simples o dobles. Pero puedes doblarlo como en
el último ejemplo:

var = 1
VAR1 = $ {perl ($ VAR + 1) * 3}
VAR2 = $ (perl do {$ VAR * = 3; devuelve $ VAR + 1} si $ VAR)
VAR3 = $ (makeperl $ (VAR1) * 3 + $$ VAR) # uno Make var y uno Perl var
VAR = $ ((perl si (...) {...}))

falso palabras
Indica que la lista de palabras son en realidad objetivos falsos y devuelve la lista de
objetivos. Está destinado a usarse así:

$ (falso todo): mi_programa

$ (falso limpio):
& rm -f * .o mi_programa

También puede declarar uno o más objetivos como falsos con una línea como esta en cualquier lugar
su archivo MAKE:

.PHONY: todo limpio

Imprimir texto
Envía el texto y lo devuelve. Esto es principalmente útil para depurar, cuando no
entender por qué la sustitución de variables tiene el resultado que tiene. Por ejemplo,

XYZ: = $ (imprimir $ (patsubst% .c,% o, $ (SOURCE_FILES)))

imprimirá el resultado de la llamada "patsubst".

XYZ: = $ (patsubst% .c,% o, $ (imprimir $ (FUENTE_FILES)))

imprimirá el último argumento de la llamada "patsubst".

shell comando de shell
Devuelve la salida del comando de shell dado, con nuevas líneas reemplazadas por espacios.

Tenga en cuenta que, como con todas las funciones, el delimitador de función utilizado puede no aparecer dentro
el comando de shell fuera de cadenas entre comillas simples o dobles. Pero puedes doblarlo
como en el segundo ejemplo:

fecha = $ (fecha de shell) # mejor: $ (hora local escalar de perl)
VAR = $ {{shell f () {echo hola; }; F}}

xargs comando, argumentos [, sufijo [, longitud]]
Devuelve una lista de comandos separados por líneas nuevas, cada uno de los cuales comienza con el
comando, y terminar con tantos elementos de la lista como sea posible sin repasar
de largo (predeterminado 1000) caracteres.

El propósito de esto es evitar que se sobrepase el límite de longitud del comando en su sistema.
Por ejemplo, si hay muchos archivos generados, probablemente querrá su
objetivo limpio (que no debería tener, porque "makeppclean" es más eficiente) para
parece algo como esto:

$ (falso limpio):
$ (xargs $ (RM), $ (only_targets ** / *))

Esto también tiene el efecto secundario de que no se genera ningún comando si la lista
pasa a estar vacío. Pero en este caso sería mejor usar el & rm incorporado,
porque los argumentos de los comandos incorporados solo están limitados por la memoria de Perl:

$ (falso limpio):
& rm -f $ (solo_destinos ** / *)

Si se especifica un tercer argumento, entonces se usa para postfijar cada comando. Este es
útil para especificar redirectores, por ejemplo (aunque aquí nuevamente & echo ayudaría):

manifiesto:
& rm -f $ @
& toque $ @
$ (xargs echo, $ (only_nontargets ** / *), >> $ @)

Parte de esta documentación se basa en la documentación de GNU make.

Tenga en cuenta que si se llama a una función durante la inicialización del archivo MAKE, por ejemplo, el
La expansión de las variables de exportación, los mensajes de error o advertencia informarán la línea número 0.

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