makepp_extending: en línea en la nube

PROGRAMA:

NOMBRE

makepp_extending - Cómo extender makepp usando Perl

DESCRIPCIÓN

Makepp internamente es lo suficientemente flexible para que al escribir un poco de código Perl, pueda
agregue funciones o realice una serie de otras operaciones.

General reconoce on la escritura Perl código a TRABAJO hacer pp
Cada archivo MAKE vive en su propio paquete. Por lo tanto, las definiciones en un archivo MAKE no afectan
definiciones en otro archivo MAKE. Un conjunto común de funciones que incluye todos los estándares
Las funciones de manipulación textual se importan al paquete cuando se crea.

Las variables de Makefile se almacenan como escalares de Perl en ese paquete. (Hay excepciones a
esto: las variables automáticas y el valor predeterminado de variables como CC son en realidad
implementadas como funciones sin argumentos. Apunte a vars específicas, vars de línea de comando y
las variables de entorno no se ven de esta manera.) Por lo tanto, cualquier código Perl que escriba tiene acceso a todos
variables de makefile. Las variables globales se almacenan en el paquete "Mpp :: global". Ver
Makefile variables para los detalles.

Cada una de las declaraciones (ifperl / ifmakeperl, perl / makeperl, sub / makesub), el
funciones (perl / makeperl, map / makemap) y la acción de la regla (perl / makeperl) para
escribir código Perl directamente en el archivo MAKE viene en dos versiones. El primero es absolutamente
Perl normal, lo que significa que debe usar el prefijo "f_" como se explica en la siguiente sección, si
desea llamar a las funciones de makepp. La segunda variante primero pasa la declaración a través de
Expansión de variables de estilo Make, lo que significa que tiene que duplicar los "$" que desea que Perl vea.

El manejo final es especial porque los datos de makepp son enormes (dependiendo de su sistema de compilación)
las estructuras tardarían varios segundos en recolectarse la basura con una salida normal. Entonces hacemos un
salida de fuerza bruta. En el proceso principal aún puede tener bloques "END" pero si tiene alguno
identificadores de archivos globales, es posible que no se vacíen. Pero deberías usar el léxico moderno
identificadores de archivos, que se cierran correctamente cuando se salen del alcance.

En el código Perl se ejecuta directamente como una acción de regla o mediante un comando que defina, es el
opuesto. Los bloques "END" no se ejecutarán, pero los identificadores de archivos globales se vacían automáticamente. los
"DESTROY" de objetos globales nunca se ejecutará.

Adición nueva textual funciones
Puede agregar una nueva función al repertorio de makepp simplemente definiendo una subrutina de Perl de
el mismo nombre pero con el prefijo "f_". Por ejemplo:

sub f_myfunc {
mi $ argumento = & arg; # Nombra el argumento.
my (indef, $ mkfile, $ mkfile_line) = @_; # Nombra los argumentos.

... haz algo aquí

return $ return_value;
}

XYZ: = $ (myfunc mis argumentos de func)

Si su función no acepta argumentos, no hay nada que hacer. Si tu función toma una
argumento, como en el ejemplo anterior, use el simple descriptor de acceso & arg para obtenerlo. Si tu
Espere más argumentos, necesita los "argumentos" de acceso más complejos que se describen a continuación.

Estos descriptores de acceso procesan los mismos tres parámetros que deben pasarse a cualquier "f_"
función, es decir, los argumentos de la función, el objeto makefile y un descriptor de línea para
mensajes. Por lo tanto, puede usar la forma eficiente & arg en el primer caso.

El descriptor de acceso & arg se encarga de lo siguiente por usted: Si los argumentos ya estaban
expandido (por ejemplo, para encontrar el nombre de la función en "$ (mi $ (función) arg)" el ​​argumento es
pasó como una cadena y simplemente regresó. Si el argumento aún necesita expansión, este es el
caso habitual, es en cambio una referencia a una cadena. El descriptor de acceso & arg lo expande para usted,
para lo cual necesita el objeto Makefile como segundo parámetro.

Si espera más argumentos, posiblemente en número variable, el trabajo se realiza mediante "args".
Este descriptor de acceso toma los mismos 3 parámetros que arg, más parámetros adicionales:

max: número de argumentos (por defecto 2): da ~ 0 (maxint) para infinito
min: número de argumentos (predeterminado 0 si max es ~ 0, de lo contrario es igual que max)
only_comma: no coma espacio entre las comas, lo habitual para los nombres que no son de archivo

Como máximo, pero al menos como mínimo, las comas presentes antes de la expansión se utilizan para dividir el
argumentos. Algunos ejemplos de las funciones integradas de makepp:

mi ($ prefijo, $ texto) = argumentos $ _ [0], $ _ [1], $ _ [2], 2, 2, 1; # addprefix
para mi $ cond (args $ _ [0], undef, $ _ [2], ~ 0) ... # y, o
my @ args = args $ _ [0], $ _ [1], $ _ [2], ~ 0, 1, 1; # llama
my ($ filtros, $ palabras) = ​​argumentos $ _ [0], $ _ [1], $ _ [2]; # filtro

La función debe devolver una cadena escalar (no una matriz) que luego se inserta en el
texto en ese punto.

Si su función encuentra un error, debería morir usando la declaración habitual de Perl.
Esto será atrapado por makepp y un mensaje de error que muestra el nombre del archivo y la línea
se imprimirá el número de la expresión que causa el error.

Básicamente, no hay límites sobre lo que puede hacer la función; puede acceder al archivo, ejecutar
comandos de shell, etc.

En la actualidad, las expresiones que aparecen en las dependencias y en las acciones de la regla se expanden
una vez, mientras que las expresiones que aparecen en los objetivos se expanden dos veces, así que tenga cuidado si su
La función tiene efectos secundarios y está presente en una expresión para un objetivo.

Tenga en cuenta que el entorno (en particular, el cwd) en el que se evalúa la función
no necesariamente coincide con el entorno en el que las reglas del Makefile en el que el
la función fue evaluada se ejecutan. Si esto es un problema para usted, entonces su función
probablemente debería verse algo como esto:

sub f_foo {
...
chdir $ makefile -> {CWD};

... etc.
}

Poniendo funciones dentro a Perl módulo
Si coloca funciones en un archivo de inclusión, tendrá una copia por Makeppfile que
lo usa. Para evitarlo, puede escribirlos como un módulo Perl normal con un "Exportador".
interfaz y utilícela. Esto se cargará más rápido y ahorrará memoria:

perl {usar mymodule}
perlas {
use my :: module; # put: en una nueva línea para que esto no se analice como regla
}

Si necesita alguna de las funciones normalmente disponibles en un Makefile (como la "f_"
functions, "arg" o "args"), debes poner esta línea en tu módulo:

use Mpp :: Subs;

El inconveniente es que el módulo estaría en un paquete diferente al de una función directamente
que aparece en un archivo MAKE. Por lo tanto, debe pasar todo como parámetros o construir
nombres con la función "llamador" de Perl.

llamar externo Perl guiones
Si llama a un script de Perl externo a través de "sistema", o como una acción de regla, makepp bifurcará un
nuevo proceso (a menos que sea la última acción de la regla) y active un nuevo intérprete de Perl.
No hay nada de malo en eso, excepto que hay una forma más eficiente:

&comando argumentos ...
Esta puede ser una acción de regla. Llamará a una función comando con un prefijo "c_", y
pasarle el resto (opcionalmente citado estilo makepp - no es exactamente lo mismo que
Shell) argumentos. Si no se puede encontrar dicha función, esto pasa todas las cadenas a
"correr".

sub c_mycmd {mis @args = @_; ...}

$ (llamada falsa cmd):
& mycmd 'arg con espacio' arg2 "arg3" # llama a c_mycmd

%.Salir en
& myscript -o $ (salida) $ (entrada) # llama a myscript externo

Puede escribir sus comandos dentro del marco de las funciones incorporadas, lo que le permite usar
las mismas opciones estándar que tienen y el manejo de E / S que brindan.

El operador de bloque "Mpp :: Cmds :: frame" va seguido de una lista de opciones de una sola letra de
las incorporaciones (como máximo "qw (fi I ​​o O rs)"). Incluso si especifica su propia opción
anulando uno de estos, todavía da la única letra de la opción estándar.

Cada opción propia se especifica como "[qw (n nombre), \ $ ref, argumento, sub]". Los primeros dos
Los elementos son el nombre corto y largo, seguidos de la referencia de la variable y, opcionalmente, de
un booleano para saber si se debe tomar un argumento. Sin un argumento, la variable es
incrementa cada vez que se da la opción, de lo contrario, el valor de la opción se almacena en ella.

sub c_my_ocmd {# Caso de salida típico
@ARGV local = @_;
Mpp :: Cmds :: marco {

... imprima algo aquí con @ARGV, con opciones ya eliminadas automáticamente

} 'f', qw (o O);
}

sub c_my_icmd {# Caso de entrada típico con 2 opciones
@ARGV local = @_;
my ($ corto, $ largo);
Mpp :: Cmds :: marco {

... haz algo aquí con <>

} qw (i I rs), # s especifica solo --separator, no -s
[qw (s short), \ $ short], # Sin opción arg -> $ short == 1
[qw (l largo), \ $ largo, 1, sub {advertir "tiene arg $ largo"}];
}

Aquí viene un comando simple que reemplaza solo el primer carácter de cada entrada
registro (equivalente a "& sed '$$ _ =" \ u \ L $$ _ "'"):

sub c_uc {
@ARGV local = @_;
Mpp :: Cmds :: marco {
imprimir "\ u \ L $ _" while <>;
} 'f', qw (i I o O rs);
}

Dentro del bloque manejado por marco, puede tener bloques anidados para realizar tareas críticas
operaciones, como abrir otros archivos.

Mpp :: Cmds :: perform {...} 'mensaje';

Esto generará un mensaje con "--verbose" (que todos los comandos aceptan) si
el comando se ejecuta correctamente. Pero si el bloque se evalúa como falso, muere con
mensaje negado.

corrida guión argumentos ...
Esta es una función de Perl normal que puede usar en cualquier contexto de Perl dentro de su archivo MAKE.
Es similar a la forma de sistema de múltiples argumentos, pero ejecuta el script Perl dentro de
el proceso actual. Para declaraciones makepp, la función perl o sus propias funciones
ese es el proceso que ejecuta makepp. Pero para una regla que es el subproceso que realiza
eso. El script se analiza tantas veces como se llama, pero puede poner el código real
trabajar en una biblioteca, como lo hace pod2html. Esta biblioteca se puede usar en el nivel superior, por lo que
que ya está presente:

perl {use mylib} # se bifurca a todas las reglas que no necesitan analizarlo

%.Salir en
makeperl {ejecutar qw'myscript -o $ (salida) $ (entrada) '}

Si el script llama a "salir", cierra los descriptores de archivos estándar o se basa en el sistema
para limpiar después (archivos abiertos, memoria ...), esto puede ser un problema con "ejecutar". Si
llama "ejecutar" dentro de declaraciones o la función de perl, makepp puede ser perturbado o el
la limpieza solo ocurre al final de makepp.

Si tiene uno de los problemas antes mencionados, ejecute el script externamente, es decir, desde
en su lugar, la línea de comando. Dentro de una regla, la limpieza es un problema menor, especialmente no
como la última acción de una regla, ya que el subproceso de la regla se cerrará después de todos modos,
excepto en Windows.

Escribiendo su proveedor EL DESARROLLADOR firma métodos
A veces desea que makepp calcule un método de firma utilizando una técnica diferente. Para
Por ejemplo, suponga que tiene un binario que depende de una biblioteca compartida. Normalmente, si
cambiar la biblioteca compartida, no tiene que volver a vincular los ejecutables que dependen de ella porque
la vinculación se realiza en tiempo de ejecución. (Sin embargo, es posible que al volver a vincular el ejecutable
podría ser necesario, razón por la cual no hice esto como predeterminado).
hacer es tener la misma firma para la biblioteca compartida incluso si cambia.

Esto puede ser realizado de varias maneras. La forma más sencilla es crear su propio
método de firma (llamémoslo "objeto_compartido"). Usarías este método de firma
solo en reglas que enlazan binarios, como este:

myprogram: * .o lib1 / lib1.so lib2 / lib2.so
: firma objeto_compartido
$ (CC) $ (entradas) -o $ (salida)

Ahora tenemos que crear el método de firma.

Todos los métodos de firma deben ser de su propia clase, y la clase debe contener algunos
artículos (consulte Mpp / Signature.pm en la distribución para obtener más detalles). El nombre de la clase debe ser
con el prefijo "Mpp :: Signature ::", por lo que en este caso nuestra clase debería llamarse
"Mpp :: Firma :: objeto_compartido". Tenemos que crear un archivo llamado objeto_compartido.pm y poner
en un Mpp :: Firma directorio en algún lugar de la ruta de inclusión de Perl; el lugar más fácil
podría estar en el Mpp / Firma directorio en la instalación de makepp (por ejemplo,
/ usr / local / share / makepp / Mpp / Signature o donde lo haya instalado).

Para obtener detalles precisos sobre lo que debe incluirse en esta clase, debe revisar detenidamente
el archivo Mpp / Firma.pm y probablemente también Mpp / Signature / exact_match.pm en el makepp
distribución. Pero en nuestro caso, todo lo que queremos hacer es realizar un cambio muy pequeño en un
mecanismo de firma existente; si el archivo es una biblioteca compartida, queremos tener una constante
firma, mientras que si el archivo es cualquier otra cosa, queremos confiar en el normal de makepp
mecanismo de firma. La mejor forma de hacer esto es heredar de
"Mpp :: Signature :: c_compilation_md5", que es el método de firma que se suele elegir
cuando makepp reconoce un comando de enlace.

Entonces el archivo Mpp / Firma / objeto_compartido.pm puede contener lo siguiente:

uso estricto
paquete Mpp :: Firma :: objeto_compartido;
use Mpp :: Signature :: c_compilation_md5;
nuestro @ISA = qw (Mpp :: Signature :: c_compilation_md5); # Indicar herencia.
nuestro $ objeto_compartido = bendecir \ @ISA; # Un trozo de magia que ayuda a quepp encuentre
# las subrutinas para este método. Todos
# Los métodos de firma deben tener uno de estos.
# El valor no se usa, solo cualquier objeto.
# Ahora aquí está el método que se llama cuando necesitamos la firma de
# cualquier objetivo o dependencia para el que este método de firma esté activo:
sub firma {
my ($ self, # Esto será lo mismo que $ shared_object.
$ finfo) = @_; # Una estructura especial que lo contiene todo
# makepp conoce este archivo. Ver
# Mpp / File.pm para más detalles.

if ($ finfo -> {NAME} = ~ /\.s[oa]$/) {# ¿El nombre del archivo termina en .so o .sa?
return $ finfo-> file_exists? 'existe': '';
# Devuelva siempre la misma firma si el archivo
# existe. En este caso, la firma es la
# cadena "existe".
}

Mpp :: Firma :: c_compilation_md5 :: firma;
# Si el archivo no terminó en .so o .sa,
# delegado al método de firma habitual de makepp.
}

Este archivo se proporciona como ejemplo en la distribución de makepp, con algunos
comentarios.

Por cierto, ¿por qué no lo hacemos por defecto? Bueno, hay ocasiones en las que cambiar un
La biblioteca compartida requerirá una vinculación de su programa. Si alguna vez cambia el
símbolos que define una biblioteca compartida, o los símbolos que depende de otras bibliotecas
porque, a veces, puede ser necesario volver a vincular.

Suponga, por ejemplo, que la biblioteca compartida invoca algunas subrutinas que su programa
proporciona. Por ejemplo, suponga que cambia la biblioteca compartida para que ahora llame a un externo
subrutina "xyz ()". A menos que utilice la opción "-E" o "--export-dynamic" para el vinculador
(para GNU binutils; otros enlazadores tienen diferentes nombres de opciones), el símbolo "xyz ()" puede no
ser accesible para el enlazador en tiempo de ejecución incluso si existe en su programa.

Peor aún, suponga que definió "xyz ()" en otra biblioteca (llámelo libxyz), Me gusta esto:

mi_programa: main.o lib1 / lib1.so xyz / libxyz.a

Dado que "libxyz" es un .a archivo y no un .asi que archivo, entonces "xyz ()" no puede ser extraído
correctamente desde libxyz.a a menos que vuelva a vincular su binario.

Los métodos Mpp :: Signature también controlan no solo la cadena que se utiliza para determinar si un
archivo ha cambiado, pero el algoritmo que se utiliza para comparar las cadenas. Por ejemplo, el
El método de firma "target_newer" en la distribución de makepp simplemente requiere que el
los destinos sean más nuevos que las dependencias, mientras que el método de firma "exact_match" (y
todo lo que depende de él, como "md5" y "c_compilation_md5") requiere que el
El archivo tiene la misma firma que en la última compilación.

Aquí hay algunos otros tipos de métodos de firma que pueden ser útiles para ayudarlo a darse cuenta
las posibilidades. Si el propósito general es suficiente, algunos de estos pueden eventualmente ser
incorporado en makepp:

· Un método de firma para bibliotecas compartidas que devuelve una suma de comprobación de todos los exportados
símbolos, y también todos los símbolos que necesita de otras bibliotecas. Esto resuelve el
problema con el ejemplo anterior, y garantiza un enlace correcto en todas las circunstancias.
Se ha hecho un intento experimental para hacer esto en la distribución makepp (ver
Mpp / Firma / objeto_compartido.pm), pero solo funcionará con GNU binutils y ELF
bibliotecas en este momento.

· Un método de firma que ignora un sello de fecha escrito en un archivo. Por ejemplo, si tu
generar un .c archivo automáticamente usando algún programa que insiste en poner una cadena
de esta manera:

static char * date_stamp = "Generado automáticamente el 01 de abril de 2004 por nadie";

podría escribir un método de firma que ignore específicamente los cambios en las marcas de fecha.
Por lo tanto, si el sello de fecha es lo único que ha cambiado, makepp no ​​se reconstruirá.

· Un método de firma que calcula las firmas de la manera normal, pero ignora las
dependencia de la arquitectura a la hora de decidir si reconstruir. Esto podría ser útil para
archivos verdaderamente independientes de la arquitectura; actualmente, si se basa en una arquitectura,
makepp insistirá en reconstruir incluso archivos independientes de la arquitectura cuando cambie
a una arquitectura diferente.

· Un método de firma que sabe cómo ignorar los comentarios en archivos de látex, ya que
El método "c_compilation_md5" sabe cómo ignorar los comentarios en los archivos C.

· Un método de firma para la extracción automática de documentación que realiza sumas de comprobación solo
comenta que un extractor de documentación necesita e ignora otros cambios en la fuente
archivo.

Inconcluso
Este documento aún no está terminado. Debería cubrir cómo escribir sus propios escáneres para
incluir archivos y cosas por el estilo.

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