makepp_extending - Online na nuvem

PROGRAMA:

NOME

makepp_extending - Como estender o makepp usando Perl

DESCRIÇÃO

Makepp internamente é flexível o suficiente para que, escrevendo um pouco de código Perl, você possa
adicione funções ou execute uma série de outras operações.

Geral notas on escrita Perl código para TRABALHO com makepp
Cada makefile vive em seu próprio pacote. Assim, as definições em um makefile não afetam
definições em outro makefile. Um conjunto comum de funções, incluindo todos os padrões
as funções de manipulação textual são importadas para o pacote quando ele é criado.

Variáveis ​​Makefile são armazenadas como escalares Perl nesse pacote. (Há exceções para
isto: variáveis ​​automáticas e o valor padrão de variáveis ​​como CC são na verdade
implementado como funções sem argumentos. Alvo vars específicos, vars de linha de comando e
ambiente vars não são vistos desta forma.) Assim, qualquer código Perl que você escrever tem acesso a todos
variáveis ​​makefile. Variáveis ​​globais são armazenadas no pacote "Mpp :: global". Ver
Variáveis ​​Makefile para os detalhes.

Cada uma das declarações (ifperl / ifmakeperl, perl / makeperl, sub / makesub), o
funções (perl / makeperl, map / makemap) e a ação da regra (perl / makeperl) para
escrever código Perl diretamente no makefile vem em dois sabores. O primeiro é absolutamente
Perl normal, o que significa que você deve usar o prefixo "f_" conforme explicado na próxima seção, se
você deseja chamar as funções makepp. A segunda variante primeiro passa a declaração por meio de
Expansão de variável no estilo Make, significando que você tem que dobrar os "$" s que deseja que o Perl veja.

O tratamento final é especial porque os dados enormes do makepp (dependendo do seu sistema de compilação)
estruturas levariam vários segundos para coletar o lixo com uma saída normal. Então nós fazemos um
saída de força bruta. No processo principal, você ainda pode ter blocos "END", mas se tiver algum
identificadores de arquivo globais eles não podem ser liberados. Mas você deve usar o léxico moderno
filehandles, que são fechados corretamente quando saem do escopo.

No código Perl executado diretamente como uma ação de regra ou por meio de um comando que você define, é o
oposto. Os blocos "END" não serão executados, mas os manipuladores de arquivos globais serão liberados para você. o
"DESTRUIR" de objetos globais nunca será executado.

Adicionando novo textual funções
Você pode adicionar uma nova função ao repertório do makepp simplesmente definindo uma sub-rotina Perl de
o mesmo nome, mas com o prefixo "f_". Por exemplo:

sub f_minhafunc {
meu $ argument = & arg; # Nomeie o argumento.
meu (undef, $ mkfile, $ mkfile_line) = @_; # Nomeie os argumentos.

... faça algo aqui

return $ return_value;
}

XYZ: = $ (myfunc my func argumentos)

Se sua função não aceita argumentos, não há nada a fazer. Se sua função leva um
, como no exemplo acima, use o acessador simples & arg para obtê-lo. Se você
esperar mais argumentos, você precisa do acessador mais complexo "args" descrito abaixo.

Esses acessadores processam os mesmos três parâmetros que devem ser passados ​​para qualquer "f_"
função, ou seja, os argumentos da função, o objeto makefile e um descritor de linha para
mensagens. Portanto, você pode usar a forma eficiente e arg no primeiro caso.

O acessador & arg cuida do seguinte para você: Se os argumentos já eram
expandido (por exemplo, para encontrar o nome da função em "$ (my $ (function) arg)", o arg é
passou como uma string e apenas retornou. Se o argumento ainda precisa de expansão, este é o
caso usual, é ao invés uma referência a uma string. O acessador & arg o expande para você,
para o qual ele precisa do objeto makefile como seu segundo parâmetro.

Se você espera mais argumentos, possivelmente em número variável, o trabalho é executado por "args".
Este acessador usa os mesmos 3 parâmetros de arg, além de parâmetros adicionais:

max: número de argumentos (padrão 2): dê ~ 0 (maxint) para infinito
min: número de argumentos (padrão 0 se max for ~ 0, senão igual ao max)
only_comma: não ocupa espaço entre vírgulas, normal para nomes que não são de nome de arquivo

No máximo max, mas pelo menos min vírgulas presentes antes da expansão são usadas para dividir o
argumentos. Alguns exemplos das funções embutidas do makepp:

my ($ prefix, $ text) = args $ _ [0], $ _ [1], $ _ [2], 2, 2, 1; # addprefix
para meu $ cond (args $ _ [0], undef, $ _ [2], ~ 0) ... # e, ou
my @ args = args $ _ [0], $ _ [1], $ _ [2], ~ 0, 1, 1; # ligar
meu ($ filtros, $ palavras) = ​​args $ _ [0], $ _ [1], $ _ [2]; # filtro

A função deve retornar uma string escalar (não uma matriz) que é então inserida no
texto nesse ponto.

Se a sua função encontrar um erro, ela deve morrer usando a instrução usual do Perl die.
Isso será interceptado por makepp e uma mensagem de erro exibindo o nome do arquivo e a linha
o número da expressão que está causando o erro será impresso.

Essencialmente, não há limites para o que a função pode fazer; você pode acessar o arquivo, execute
comandos de shell, etc.

No momento, as expressões que aparecem nas dependências e nas ações da regra são expandidas
uma vez, enquanto as expressões que aparecem nos destinos são expandidas duas vezes, portanto, tome cuidado se o seu
função tem efeitos colaterais e está presente em uma expressão para um alvo.

Observe que o ambiente (em particular, o cwd) no qual a função avalia
não necessariamente correspondem ao ambiente no qual as regras do Makefile no qual o
função foi avaliada são executados. Se isso for um problema para você, então sua função
provavelmente deve ser algo assim:

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

... Etc.
}

Colocar funções para dentro a Perl módulo
Se você colocar funções em um arquivo de inclusão, você terá uma cópia por Makeppfile que
usa. Para evitar isso, você pode escrevê-los como um módulo Perl normal com um "Exportador"
interface e usá-la. Isso carregará mais rápido e economizará memória:

perl {use meu módulo}
perl {
use my :: module; # put: em uma nova linha para que isso não seja analisado como regra
}

Se você precisar de alguma das funções normalmente disponíveis em um Makefile (como o "f_"
funções, "arg" ou "args"), você deve colocar esta linha em seu módulo:

use Mpp :: Subs;

A desvantagem é que o módulo estaria em um pacote diferente de uma função diretamente
aparecendo em um makefile. Então você precisa passar tudo como parâmetros, ou construir
nomes com a função "chamador" do Perl.

chamada externo Perl Scripts
Se você chamar um script Perl externo via "sistema", ou como uma ação de regra, o makepp irá bifurcar um
novo processo (a menos que seja a última ação da regra) e disparar um novo interpretador de perl.
Não há nada de errado com isso, exceto que há uma maneira mais eficiente:

&comando argumentos ...
Isso pode ser uma ação de regra. Vai chamar uma função comando com um prefixo "c_", e
passe o restante (estilo makepp opcionalmente citado - não exatamente o mesmo que
Shell). Se tal função não puder ser encontrada, isso passa todas as strings para
"corre".

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

$ (callcmd falsa):
& mycmd 'arg com espaço' arg2 "arg3" # chama c_mycmd

%.em
& myscript -o $ (output) $ (input) # chama um myscript externo

Você pode escrever seus comandos dentro da estrutura dos builtins, permitindo que você use
as mesmas opções padrão que eles têm e o manuseio de E / S que eles oferecem.

O operador de bloco "Mpp :: Cmds :: frame" é seguido por uma lista de opções de uma única letra de
os embutidos (no máximo "qw (fi I ​​o O rs)"). Mesmo se você especificar sua própria opção
substituindo um deles, você ainda dá a única letra da opção padrão.

Cada opção é especificada como "[qw (n nome), \ $ ref, argumento, sub]". Os dois primeiros
os elementos são nomes curtos e longos, seguidos pela referência da variável e, opcionalmente, por
um booleano para aceitar um argumento. Sem um arg, a variável é
incrementado cada vez que a opção é fornecida, caso contrário, o valor da opção é armazenado nela.

sub c_my_ocmd {# Caso de saída típico
local @ARGV = @_;
Mpp :: Cmds :: frame {

... imprima algo aqui com @ARGV, com opções já removidas automaticamente

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

sub c_my_icmd {# Caso de entrada típico com 2 opções
local @ARGV = @_;
meu ($ curto, $ longo);
Mpp :: Cmds :: frame {

... faça algo aqui com <>

} qw (i I rs), # s especifica apenas --separator, não -s
[qw (s short), \ $ short], # Sem opção arg -> $ short == 1
[qw (l long), \ $ long, 1, sub {warn "obteve arg $ long"}];
}

Aqui vem um comando simples que aumenta apenas o primeiro caractere de cada entrada
registro (equivalente a "& sed '$$ _ =" \ u \ L $$ _ "'"):

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

Dentro do bloco tratado por quadro, você pode ter blocos aninhados para realizar
operações, como abrir outros arquivos.

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

Isso irá gerar uma mensagem com "--verbose" (que todo comando aceita) se o
comando é executado com sucesso. Mas se o bloco for avaliado como falso, ele morre com
mensagem negada.

corrida escrita argumentos ...
Esta é uma função Perl normal que você pode usar em qualquer contexto Perl dentro do seu makefile.
É semelhante à forma de sistema com vários argumentos, mas executa o script Perl dentro
o processo atual. Para instruções makepp, a função perl ou suas próprias funções
esse é o processo que está executando o makepp. Mas para uma regra que é o subprocesso realizando
isto. O script é analisado quantas vezes for chamado, mas você pode colocar o real
trabalhar em uma biblioteca, como o pod2html faz. Esta lib pode então ser usada no nível superior, então
que já está presente:

perl {use mylib} # é bifurcado para todas as regras que não precisam ser refeitas

%.em
makeperl {execute qw'myscript -o $ (output) $ (input) '}

Se o script chamar "exit", fecha os descritores de arquivo padrão ou depende do sistema
para limpar depois (abrir arquivos, memória ...), isso pode ser um problema com "executar". Se
você chama "run" dentro de instruções ou da função perl, makepp pode ser perturbado ou o
a limpeza só acontece no final do makepp.

Se você tiver um dos problemas mencionados acima, execute o script externamente, ou seja, a partir de
a linha de comando em vez disso. Dentro de uma regra, a limpeza é menos problemática, especialmente não
como a última ação de uma regra, uma vez que o subprocesso de regra sairá depois de qualquer maneira,
exceto no Windows.

Escrevendo os próprio assinatura métodos
Às vezes, você deseja que o makepp calcule um método de assinatura usando uma técnica diferente. Para
Por exemplo, suponha que você tenha um binário que depende de uma biblioteca compartilhada. Normalmente, se você
alterar a biblioteca compartilhada, você não precisa vincular novamente os executáveis ​​que dependem dela porque
a vinculação é feita em tempo de execução. (No entanto, é possível que revincular o executável
pode ser necessário, e é por isso que não tornei isso o padrão.) O que você deseja makepp
a fazer é ter a mesma assinatura para a biblioteca compartilhada, mesmo que ela mude.

Isso pode ser feito de várias maneiras. A maneira mais fácil é criar seu próprio novo
método de assinatura (vamos chamá-lo de "objeto_compartilhado"). Você usaria este método de assinatura
apenas em regras que vinculam binários, como este:

meuprograma: * .o lib1 / lib1.so lib2 / lib2.so
: assinatura shared_object
$ (CC) $ (entradas) -o $ (saída)

Agora temos que criar o método de assinatura.

Todos os métodos de assinatura devem ser suas próprias classes, e a classe deve conter alguns
itens (consulte Mpp / Signature.pm na distribuição para obter detalhes). O nome da classe deve ser
prefixado com "Mpp :: Signature ::", então, neste caso, nossa classe deve ser chamada
"Mpp :: Assinatura :: objeto_compartilhado". Temos que criar um arquivo chamado objeto_compartilhado.pm e colocar
em um Mpp :: Assinatura diretório em algum lugar no caminho de inclusão Perl; o lugar mais fácil
pode estar no MPP / Assinatura diretório na instalação do makepp (por exemplo,
/ usr / local / share / makepp / Mpp / Assinatura ou onde quer que você o tenha instalado).

Para obter detalhes precisos sobre o que precisa ser feito nesta aula, você deve olhar cuidadosamente
o arquivo Mpp / Signature.pm e provavelmente também Mpp / Signature / exact_match.pm no makepp
distribuição. Mas, em nosso caso, tudo o que queremos fazer é fazer uma pequena alteração em um
mecanismo de assinatura existente; se o arquivo for uma biblioteca compartilhada, queremos ter uma constante
assinatura, enquanto se o arquivo for qualquer outra coisa, queremos contar com o normal do makepp
mecanismo de assinatura. A melhor maneira de fazer isso é herdar de
"Mpp :: Signature :: c_compilation_md5", que é o método de assinatura normalmente escolhido
quando makepp reconhece um comando de link.

Então, o arquivo Mpp / Signature / shared_object.pm pode conter o seguinte:

use estrito;
package Mpp :: Signature :: shared_object;
use Mpp :: Signature :: c_compilation_md5;
nosso @ISA = qw (Mpp :: Signature :: c_compilation_md5); # Indica herança.
nosso $ shared_object = bless \ @ISA; # Uma mágica que ajuda o makepp a encontrar
# as sub-rotinas para este método. Tudo
# métodos de assinatura devem ter um destes.
# O valor não é usado, apenas qualquer objeto.
# Agora, aqui está o método que é chamado quando precisamos da assinatura de
# qualquer destino ou dependência para o qual este método de assinatura esteja ativo:
sub-assinatura {
my ($ self, # Este será o mesmo que $ shared_object.
$ finfo) = @_; # Uma estrutura especial que contém tudo
# makepp sabe sobre este arquivo. Ver
# Mpp / File.pm para obter detalhes.

if ($ finfo -> {NAME} = ~ /\.s[oa]$/) {# O nome do arquivo termina em .so ou .sa?
return $ finfo-> file_exists? 'existe' : '';
# Sempre retorna a mesma assinatura se o arquivo
# existe. Neste caso, a assinatura é o
# string "existe".
}

Mpp :: Signature :: c_compilation_md5 :: signature;
# Se o arquivo não terminar em .so ou .sa,
# delegate ao método de assinatura usual do makepp.
}

Este arquivo é fornecido como um exemplo na distribuição do makepp, com alguns
comentários.

A propósito, por que não tornamos isso o padrão? Bem, há momentos em que mudar um
a biblioteca compartilhada exigirá uma nova vinculação do seu programa. Se você mudar o
símbolos que uma biblioteca compartilhada define ou os símbolos que depende de outras bibliotecas
pois, às vezes pode ser necessário revincular.

Suponha, por exemplo, que a biblioteca compartilhada invoque algumas sub-rotinas que seu programa
fornece. Por exemplo, suponha que você altere a biblioteca compartilhada para que agora chame um externo
sub-rotina "xyz ()". A menos que você use a opção "-E" ou "--export-dynamic" para o vinculador
(para GNU binutils; outros linkers têm nomes de opções diferentes), o símbolo "xyz ()" não pode
estar acessível para o vinculador de tempo de execução, mesmo se ele existir em seu programa.

Pior ainda, suponha que você definiu "xyz ()" em outra biblioteca (chame-a libxyz), como isso:

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

Uma vez que "libxyz" é um .a arquivo e não um .assim arquivo, então "xyz ()" não pode ser puxado
corretamente de libxyz.a a menos que você revincule seu binário.

Os métodos Mpp :: Signature também controlam não apenas a string que é usada para determinar se um
arquivo foi alterado, mas o algoritmo que é usado para comparar as strings. Por exemplo, o
método de assinatura "target_newer" na distribuição do makepp apenas requer que o
alvos sejam mais novos do que as dependências, enquanto o método de assinatura "exact_match" (e
tudo o que depende dele, como "md5" e "c_compilation_md5") requer que o
arquivo tem a mesma assinatura da última compilação.

Aqui estão alguns outros tipos de métodos de assinatura que podem ser úteis, para ajudá-lo a perceber
as possibilidades. Se de propósito geral o suficiente, alguns deles podem, eventualmente, ser
incorporado ao makepp:

· Um método de assinatura para bibliotecas compartilhadas que retorna uma soma de verificação de todos os
símbolos e também todos os símbolos de que necessita de outras bibliotecas. Isso resolve o
problema com o exemplo acima, e garante um link correto em todas as circunstâncias.
Foi feita uma tentativa experimental de fazer isto na distribuição do makepp (veja
Mpp / Signature / shared_object.pm), mas só funcionará com GNU binutils e ELF
bibliotecas no momento.

· Um método de assinatura que ignora um carimbo de data gravado em um arquivo. Por exemplo, se você
gerar um .c arquivo automaticamente usando algum programa que insiste em colocar uma string
assim:

static char * date_stamp = "Gerado automaticamente em 01 de abril de 2004 por ninguém";

você pode escrever um método de assinatura que ignore especificamente as alterações nos carimbos de data.
Portanto, se o carimbo de data for a única coisa que mudou, o makepp não será reconstruído.

· Um método de assinatura que calcula as assinaturas da maneira normal, mas ignora o
dependência de arquitetura ao decidir se reconstruir. Isso pode ser útil para
arquivos verdadeiramente independentes de arquitetura; atualmente, se você construir em uma arquitetura,
makepp irá insistir em reconstruir até mesmo arquivos independentes de arquitetura quando você mudar
para uma arquitetura diferente.

· Um método de assinatura que sabe como ignorar comentários em arquivos latex, como o
O método "c_compilation_md5" sabe como ignorar comentários em arquivos C.

· Um método de assinatura para extração automática de documentação que faz somas de verificação apenas para o
comentários de que um extrator de documentação precisa e ignora outras alterações na fonte
arquivo.

Inacabado
Este documento ainda não foi concluído. Deve cobrir como escrever seus próprios scanners para
incluir arquivos e coisas assim.

Use makepp_extending online usando serviços onworks.net