makepp_functions - Online na nuvem

PROGRAMA:

NOME

makepp_functions - Funções no makepp

DESCRIÇÃO

A: absoluto_filename,
absoluto_nome_do_arquivo_nolink,
abspata,
adicionar prefixo,
adduffix,
e, B: nome de base, C: ligar, D: é,
dir_noslash, E: erro, F: arquivosubst,
filtro,
filtrar,
filter_out_dirs,
achar arquivo,
encontrar_primeiro_para cima,
encontrar_programa,
encontrar string,
encontrar_para cima,
primeiro_disponível,
primeira palavra,
para cada, I: E se,
se for verdade,
infer_linker,
inferir_objetos,
informação, J: Junte, M: faço,
fazer mapa,
maquiagem,
mapa,
"mktemp", N: nãodir, O: apenas_gerado,
only_nondestinos,
only_phony_targets,
only_stale,
apenas_destinos,
ou,
origem, P: patsubst,
pérola,
falso,
pré-construir,
impressão, R: caminho real,
nome_do_arquivo_relativo,
relativo a, S: Concha,
ordenar,
faixa,
substituto,
sufixo, T: temporário, W: Aviso,
curinga,
palavra,
lista de palavras,
palavras, X: xargs

Qualquer expressão no formato "$ (nome)", onde "nome" não é o nome de uma variável, ou
"$(name arg1 arg2 arg3)" é interpretado como uma chamada de função. O nome pode conter letras,
sublinhados ou hifens; para evitar confusão, você pode usar hifens ou sublinhados
de forma intercambiável, uma vez que os hífens internos são convertidos em sublinhados. Avaliando tal
uma expressão simplesmente invoca uma sub-rotina Perl. Se "nome" for precedido por "&", ele executa o
comando embutido ou script com esse nome dentro do processo makepp e retorna o padrão
saída. Isso requer que o perl seja construído para PerlIO. Se o nome não nomear uma função
ele é transformado em uma invocação de chamada.

Tal como acontece com as variáveis, você pode escolher entre "$ (nome ...)" ou "$ {nome ...}". Se você quiser
embute o mesmo parêntese, deve ser emparelhado, o outro não importa: "$ (nome
... () {... "ou" $ {name ... {} (...} ". (No entanto, para map e perl, o primeiro parêntese de fechamento termina
a expressão.) A duplicação permite que os argumentos ocupem várias linhas. As novas linhas são
então tratados como espaços, exceto talvez em "definir". Também existe a sintaxe "$ [name ...]"
ou $ [[nome ...]], que é avaliado durante a leitura do makefile, antes de grocar as regras
e outras construções.

O Makepp possui várias funções embutidas que podem ser úteis. Suporta quase todos os
Funções textuais do GNU make (veja a documentação do GNU make para detalhes), e alguns de seus
ter. Você pode definir sub-rotinas Perl para fazer o que quiser. Veja a declaração "sub"
e a seção sobre como estender o makepp para mais detalhes.

Condicional Funções
e condição1 [, condição2 [, condição3 ...]]
A função e fornece uma operação AND de "curto-circuito". Cada argumento é
expandido, em ordem. Se um argumento se expande para uma string vazia, o processamento para e
o resultado da expansão é a string vazia. Se todos os argumentos se expandirem para um não
string vazia então o resultado da expansão é a expansão do último argumento.

if corda, result-if-string-not-blank [, resultado-se-string-em branco]
se for verdade corda, result-if-string-true [, resultado-se-string-falso]
Uma alternativa para as declarações "ifeq", etc. Se a string não estiver em branco (ou seja, o
condição for verdadeira), o segundo argumento (a cláusula "then") é retornado (após
expansão variável); se a string estiver em branco, o terceiro argumento (a cláusula "else") é
devolvida.

Por exemplo,

CFLAGS: = $ (if $ (filtrar gcc egcc, $ (CC)), -g -Wall, -g)

define CFLAGS como "-g -Wall" se a variável CC for "gcc" ou "egcc" e "-g"
de outra forma. (Isso é o que as regras de construção padrão fazem.)

"iftrue" é semelhante a "if", exceto que a string 0 é tratada como em branco.

or condição1 [, condição2 [, condição3 ...]]
A função ou fornece uma operação OR de "curto-circuito". Cada argumento é expandido,
em ordem. Se um argumento se expande para uma string não vazia, o processamento para e o
resultado da expansão é essa corda. Se, depois que todos os argumentos forem expandidos, todos os
eles são falsos (vazios), então o resultado da expansão é a string vazia.

Envie o e Nome do arquivo Funções
absoluto_filename arquivos
abspata arquivos
Converte nomes de arquivos relativos em absolutos sem . or ... Por exemplo, a
"$ (nome_do_arquivo_ absoluto xyz.c)" pode retornar "/usr/src/our_project/subdir/xyz.c".

absoluto_filename_nolink arquivos
caminho real arquivos
Como absolute_filename, mas garante que os links simbólicos sejam resolvidos.

nome de base nomes de arquivos
O nome de base é o nome completo do arquivo (com o diretório), menos o texto após e
incluindo o último período. Por exemplo, "$ (basename myfile / version-1.0-module.c)" é
"myfile / version-1.0-module"

dir nomes de arquivos
Extrai a parte do diretório de cada arquivo na lista de nomes de arquivo, incluindo o
golpear. Retorna "./" se não houver diretório no nome do arquivo.

dir_noslash nome do arquivo
O mesmo que "$ (dir)", exceto que não retorna a barra final.

arquivosubst padronizar, substituto, palavras
Execute uma substituição de padrão nos nomes dos arquivos. Isso difere do patsubst porque
ele funcionará corretamente quando nomes alternativos para diretórios forem fornecidos (desde que
eles precedem o sinal de porcentagem). Por exemplo,

$ (filesubst ./src/%.c,% .o, $ (wildcard src / *. c))

funcionará com filesubst, mas não com patsubst.

filter_out_dirs nomes de arquivos
Retorna todos os nomes de arquivos que não se referem a diretórios.

achar arquivo nome do arquivo, caminho
Encontra um arquivo no caminho especificado ou na variável de ambiente PATH se nada for
Especificadas. Isso pode ser útil para localizar binários ou incluir arquivos. Por exemplo,

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

Isso localiza o arquivo tcl.h pesquisando todos os diretórios acima. O absoluto
caminho para o arquivo é retornado. Em seguida, "$ (dir_noslash)" extrai esse diretório e
é colocado no caminho de inclusão.

encontrar_programa nome
Retorne o primeiro programa da lista que pode ser encontrado no PATH. Isso é útil
quando há vários programas equivalentes que podem ser usados, e você só quer
escolha um deles. Por exemplo, aqui está a definição padrão de vários
variáveis ​​que o makepp fornece se você não colocar um em seu makefile:

CC = $ (find_program gcc egcc pgcc c89 cc) # e mais, dependendo da máquina
F77 = $(encontrar_programa f77 g77 fort77)
CXX = $ (find_program g ++ c ++ pg ++ cxx CC aCC)

Se nenhum dos programas for encontrado, "$ (find_program)" retorna a string não encontrada, e
registra o que não foi encontrado. Isso geralmente não resultará em um makefile funcional, mas
tenderá a gerar melhores mensagens de erro. Por exemplo, se você fizer algo como
esta:

% .o:% .c
$ (CC) $ (entradas) -o $ (saídas)

e makepp não consegue encontrar um compilador C na lista acima, ele irá substituir não encontrado.
Caso contrário, o shell tentaria executar o arquivo de origem e o erro resultante
mensagem pode ser muito estranha.

encontrar_para cima nome do arquivo
Procura um arquivo com o nome fornecido no diretório., .., ../ ..../../ .., Etc,
até que o arquivo seja encontrado ou o diretório raiz seja alcançado ou o diretório seja localizado
em um sistema de arquivos diferente. (Este último requisito é para evitar problemas com
montadores automáticos ou sistemas de arquivos de rede travados.) Se você tiver um Arquivo RootMakepp, isso também é
uma barreira que impede uma busca mais elevada.

Por exemplo, se você tem um projeto com muitos níveis de subdiretórios, você pode
incluir este fragmento comum em todos os makefiles (por exemplo, usando o "include"
demonstração):

TOP_LEVEL_INCLUDE_DIR: = $ (find_upwards inclui)
# Procura por um diretório que contém o
# inclui subdiretório.

% .o:% .c
$ (CC) $ (CFLAGS) -I $ (TOP_LEVEL_INCLUDE_DIR) -c $ (entrada) -o $ (saída)

Outro problema que "find_upwards" pode ajudar a resolver é localizar o diretório de nível superior
de uma construção. Freqüentemente, é útil definir uma variável como esta:

TOPO: = ../../ ..

se você tiver algumas informações importantes localizadas apenas no diretório de nível superior. Mas
isso é difícil de manter, porque o número de ".." é diferente para diferentes níveis
da árvore de diretórios. Em vez disso, você pode usar "find_upwards" para localizar um arquivo que é
conhecido por estar presente apenas no diretório de nível superior. Suponha, por exemplo, que o
o arquivo "LICENSE" está localizado apenas no diretório de nível superior. Então você pode fazer isso:

SUPERIOR: = $ (dir_noslash $ (find_upwards LICENÇA))

"$ (find_upwards LICENSE)" retorna o caminho completo do arquivo de licença;
"$ (dir_noslash ...)" remove o nome do arquivo, retornando apenas o diretório.

(Observe que a instrução "incluir" pesquisa automaticamente para cima por arquivos, portanto,
não há necessidade de fazer algo assim:

incluir $ (find_upwards top_level_rules.mk)

Em vez disso, você pode apenas fazer

inclua top_level_rules.mk

e funcionará tão bem.)

Se o arquivo não for encontrado, "find_upwards" abortará a construção com uma mensagem de erro.

Se você especificar mais de um arquivo, find_upwards irá procurar pelo primeiro, então
o segundo e assim sucessivamente. Em outras palavras,

$ (find_upwards file1 file2)

é equivalente a

$ (find_upwards file1) $ (find_upwards file2)

Se você quiser procurar por qualquer um dos arquivos, use "find_first_upwards" ao invés.

encontrar_primeiro_acima file1 file2 ...
Esta função se comporta como "find_upwards", exceto que retorna o primeiro arquivo de qualquer
arquivos na lista que encontrar. Especificamente, ele verifica o diretório atual para
qualquer um dos arquivos da lista e retorna o primeiro arquivo existente ou que pode ser construído.
Se nenhum dos arquivos existir ou puder ser construído nesse diretório, ele verifica .., Em seguida
../ .., etc., até atingir o diretório raiz ou um diretório que é
localizado em um sistema de arquivos diferente.

primeiro_disponível file1 file2 ...
Retorna o primeiro arquivo de uma lista que existe ou pode ser construída. Isso pode ser útil para
adaptar seus makefiles para funcionar em várias máquinas ou redes diferentes, onde
arquivos importantes podem estar localizados em locais diferentes. Por exemplo, aqui está uma linha de
um dos meus makefiles:

TCL_LIB = $ (primeiro_disponível \
/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 linha irá verificar a biblioteca Tcl em todos os lugares acima, parando no
o primeiro que encontrar. O comando link inclui $ (TCL_LIB) para que obtenhamos o
biblioteca Tcl apropriada.

infer_linker file1 file2 ...
Dada uma lista de arquivos-objeto, primeiro crie-os, caso ainda não tenham sido. Então encontre
se eles dependem de uma fonte Fortran, C ++ ou C e retornam o correspondente
compilador (que sabe melhor como vincular do que "ld").

inferir_objetos file1 file2 ..., de cinto de segurança
$(infer_objects objeto1.o objeto2.o, *.o)

Se você usar convenções padrão em relação aos nomes dos arquivos de cabeçalho, o makepp é capaz de
adivinhar quais arquivos ".o" ou ".lo" precisam ser vinculados ao seu programa. Eu uso isso para
escolher arquivos de um diretório de biblioteca que contém módulos usados ​​em muitos
programas. Em vez de fazer um arquivo de biblioteca ".a" e fazer com que o vinculador selecione o
módulos relevantes, makepp pode escolher os módulos relevantes para você. Assim, apenas
os módulos relevantes são compilados.

O algoritmo de Makepp para inferir dependências de objetos depende da convenção de que
a implementação de todas as classes ou funções definidas em um arquivo de cabeçalho "xyz.h" são
compilado em um arquivo objeto chamado "xyz.o" (ou "xyz.lo"). Então o algoritmo de makepp para
inferir dependências de objetos começa com um ou alguns objetos que sabemos que devem ser
vinculado ao programa. Verifica quais arquivos foram incluídos com "#include" em
essas fontes e tenta encontrar arquivos de objeto correspondentes para cada um dos
arquivos.

"$ (infer_objects)" precisa ser mencionado na lista de dependências de um programa, como
esta:

meuprog: $ (infer_objects main.o another_object.o, \
** / *. o /other/library/dirs/**/*.o)
$ (CXX) $ (entradas) -o $ (saída) $ (LIBS)

A função "$ (infer_objects)" leva dois argumentos (separados por uma vírgula, como mostrado).
O primeiro é um ou alguns arquivos de objeto que são conhecidos por serem necessários (curingas são
permitido aqui). O segundo é uma lista de objetos possíveis (normalmente você usaria um
curinga aqui) que pode ser vinculado, se necessário. O valor de retorno deste
função é uma lista que contém primeiro todos os objetos no primeiro argumento, e
depois disso, todos os objetos adicionais que estavam contidos no segundo argumento
que são exigidos pelos objetos no primeiro argumento.

Por exemplo, suponha que "main.o" venha de "main.cpp", que inclui "minha_classe.h".
"$ (infer_objects)" procura por arquivos com o nome "my_class.o". Se exatamente um desses
arquivo for encontrado, ele será adicionado à lista. (Se dois arquivos de objeto "my_class.o" forem encontrados
em diretórios diferentes, uma mensagem de aviso é impressa.) "infer_objects" também
examina "my_class.cpp" para ver o que inclui e quais arquivos de objeto adicionais são
implícita.

mktemp
mktemp prefixo
mktemp prefixoXXX
mktemp /
Retorna um nome de arquivo temporário imprevisível, que não existe atualmente. Sem nome
apontar para o mesmo arquivo é retornado duas vezes, mesmo com caminhos relativos diferentes,
dentro de uma execução do makepp (exceto possivelmente com o make recursivo tradicional, ou se o Perl
código em execução dentro de uma ação de regra chama "f_mktemp"). No final do makepp execute todos
os arquivos retornados por esta função são excluídos, se existirem (novamente, exceto para aqueles
retornado por esta função no código Perl executado dentro de uma regra).

Qualquer número de "X" maiúsculos no final do argumento é substituído por esse número
letras e dígitos aleatórios. Quanto mais houver, menos provável que colida
com outros processos, então se você der um prefixo como "/ tmp / abc.", você deve ter o suficiente
"X" s. Se houver mais de um X, o primeiro caractere vem do id do processo. Se
não há nenhum, é como se houvesse dez, o que supostamente é suficiente (8.4e17
possibilidades ou 3.7e15 no Windows). Se não houver nenhum argumento, o prefixo é padronizado para
"tmp."no diretório atual.

Observe que você não deseja dar um nome como destinos de regra e dependências. O
o resultado estaria correto, mas seria recriado toda vez que você executar o makepp.

Além disso, como é sempre diferente, você deve usar isso em uma ação de regra apenas se usar
": build_check ignore_action":

TMPFILE; = $ (mktemp) # 1 chamada; "=" significaria 3 chamadas: 3 arquivos
Contagem A Contagem B:: build_check ignore_action
produzir As-e-Bs> $ (TMPFILE)
& grep -c / A / $ (TMPFILE) -o A-count
& grep -c / B / $ (TMPFILE) -o B-count

Ou você deve exportá-lo e deixar o Shell avaliá-lo:

exportar TMPFILE; = $ (mktemp)
Contagem A Contagem B:
product-As-and-Bs> $$ TMPFILE # makepp não vê o valor var
fgrep -c A $$ TMPFILE> A-count
fgrep -c B $$ TMPFILE> B-count

A última forma repete o valor de retorno anterior, então você pode usá-lo em uma regra de padrão:

% .x:% .y
& grep foo $ (input) -o $ (mktemp)
& sed bar $ (mktemp /) -o $ (saída) # Opera na saída de & grep

nãodir nomes de arquivos
Retorna a parte não pertencente ao diretório do (s) nome (s) de arquivo, ou seja, tudo após o último
barra se houver um, ou o nome do arquivo inteiro caso contrário.

only_generated nomes de arquivos
Retorna apenas os nomes de arquivos na lista que foram gerados pelo makepp e não desde
modificado, de acordo com o arquivo de informações de construção.

Esta função é útil para limpar regras de destino (embora, é claro, "makeppclean" seja o
variante preferida):

$ (falso limpo):
& rm -f $ (only_generated ** / *)

only_nontargets nomes de arquivos
Retorna apenas os nomes de arquivos na lista que não são alvos de nenhuma regra (ou
regras explícitas ou padrão). Você pode especificar um curinga (veja o "$ (curinga)"
para mais detalhes sobre os curingas do makepp). Isso pode ser usado para gerar um
alvo de distribuição, por exemplo:

.PHONY: distribuição

distribuição:
& mkdir nosso_produto - $ (VERSÃO)
& cp $ (filtrar% ~, $ (only_nontargets *)) nosso_produto - $ (VERSÃO)
tar cf - nosso_produto - $ (VERSÃO) | gzip -9c> our_product - $ (VERSION) .tar.gz

Neste caso, o "$ (only_nontargets *)" retorna todos os arquivos no diretório atual
isso não é o alvo de alguma regra. O "$ (filter_out% ~, ...)" remove o editor
cópias de segurança.

Semelhante a "only_targets" (veja acima), "only_nontargets" só conhece alvos que
já foram definidos. Isso só é um problema se você usá-lo para definir variáveis
com a atribuição ":="; se você usá-lo na lista de dependências ou no corpo de um
regra, todas as outras regras já terão sido vistas.

only_stale nomes de arquivos
Retorna apenas os nomes de arquivos na lista que foram gerados pelo makepp e não desde
modificados, de acordo com o arquivo de informações de construção, mas não são mais alvos de nenhuma regra.

Esta função é útil para garantir que não haja dependências de tais arquivos,
sem forçar uma compilação limpa de todos os alvos:

$ (flush falso):
& rm -f $ (only_stale ** / *)

Na verdade, é provavelmente melhor, em vez de escrever um script que chama makepp para gerar
a lista de arquivos obsoletos e, em seguida, fazer com que o script remova todos os arquivos listados que
não estão atualmente sob controle da fonte, apenas no caso de um arquivo gerado se tornar uma fonte
Arquivo. O makepp não tem essa função incorporada porque o makepp é (e provavelmente
deve permanecer) agnóstico sobre o controle de origem.

only_targets nomes de arquivos
Retorna apenas os nomes de arquivo na lista que são realmente alvos de alguma regra
(regras explícitas ou padrão). Você pode especificar curingas (incluindo makepp's
curinga especial, "**") nos nomes dos arquivos. (Veja a função "$ (curinga)" para mais
detalhes. Isso pode ser usado para um alvo limpo, por exemplo:

.PHONY: limpo

limpar \ limpo:
& rm -f $ (only_targets *)

Agora, se você digitar "makepp clean", ele apagará tudo o que sabe como construir. Mas
não crie um alvo limpo, use "makeppclean" ao invés!

Outro lugar onde pode ser útil é evitar a inclusão .o arquivos em seu
Construir. Por exemplo, se você construir uma biblioteca como esta:

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

e então você exclui alguns arquivos de origem, mas se esquece de excluir os correspondentes .o arquivos,
que o .o os arquivos ainda estarão por aí. Isso significa que eles ainda serão incorporados
a biblioteca, apesar do fato de que eles não são mais úteis. Se você modificar o seu
regra assim:

mylib.a: $ (only_targets * .o)
& rm -f $ (saída)
$ (AR) cr $ (saída) $ (entradas)

então esse problema não ocorrerá.

Observe que isso se refere apenas a arquivos que são conhecidos como alvos at que o tempo Você
invocar "apenas alvos". Se "only_targets" aparecer nas dependências ou ações de um
regra, então todos os alvos possíveis serão conhecidos porque dependências e ações não são
avaliada até que a regra seja executada. No entanto, se você avaliar, tente avaliá-lo
anteriormente no makefile com uma variável ": =" como esta:

ALL_TARGETS: = $ (only_targets *)

alvo1: dependência1
ações

alvo2: dependência2
ações

então "only_targets" não saberá sobre as regras subsequentes.

Da mesma forma, "only_targets" não sabe sobre alvos produzidos em makefiles que são
carregado com make recursiva. (Mas você não deve usar make recursiva de qualquer maneira; use
use a instrução "load_makefile" ou o carregamento implícito do makefile.)

nome_do_arquivo_relativo file1 file2 arquivo3 [, golpear]
Retorna o nome desses arquivos em relação ao diretório atual (aquele que
makefile está em). Isso também pode ser usado para limpar "./" desnecessários e outros detritos de
o caminho:

DIR: =.
SUBDIR: = ..
FNAME: = $ (DIR) /../ otherdir / $ (SUBDIR) / arquivos
X: = $ (nome_do_arquivo_relativo $ (FNAME))

If reduzir é verdadeiro (geralmente 1) os nomes de arquivo retornados têm a garantia de conter uma barra
prefixando "./" se necessário, para que você possa usá-lo como um nome executável sem
preocupando-se com o caminho de pesquisa do comando substituindo a localização do diretório.

Se o caminho for pelo diretório raiz, o pai de seu diretório inicial ou
o "$ (ROOT)" do seu sistema de compilação, ou no Windows uma raiz da unidade (dependendo do
ambiente, isso também acontece para / cygdrive / c or /c), um caminho absoluto será
devolvido em seu lugar.

relativo a file1 file2 arquivo3 [, diretório]
Retorna o nome desses arquivos relativos ao diretório especificado. Isto é
normalmente útil quando, por algum motivo, você precisa executar um comando de um
diretório diferente (diretório atual padrão):

fonte_backup.tar:
cd .. && tar cf $ (relative_to $ (output), ..) $ (relative_to., ..)

sufixo nomes ...
Extrai o sufixo de cada nome de arquivo em nomes. Se o nome do arquivo contém um ponto,
o sufixo é tudo que começa com o último período. Caso contrário, o sufixo é o
string vazia. Isso frequentemente significa que o resultado estará vazio quando os nomes não estiverem,
e se os nomes contiverem vários nomes de arquivo, o resultado poderá conter menos nomes de arquivo.

Por exemplo,

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

produz o resultado ".c .c".

temporário palavras
Informe ao makepp que os alvos especificados podem ser removidos pela regra que gera
eles. Semelhante a "falso", exceto que o makepp espera que um arquivo real com esse nome
A vontade pode ser afetada pela regra. Uma regra não é executada se apenas for temporária
os alvos estão desatualizados.

curinga de cinto de segurança
Retorna os nomes classificados de todos os arquivos que correspondem ao padrão fornecido, ou aqueles
arquivos que ainda não existem, mas podem ser construídos com base nas regras que o makepp conhece
sobre o ponto em que avalia a expressão. Neste último ponto é diferente
de caracteres curinga de entrada de regra, que se aplicam até mesmo a arquivos criados por regras encontradas posteriormente.

Makepp suporta todos os curingas usuais do shell ("*", "?" E "[]"). Também tem um
curinga "**" que corresponde a qualquer número de diretórios intermediários. (Esta ideia era
roubado de zsh.) Por exemplo, "** / *. c" corresponde a todos os .c arquivos em toda a fonte
árvore. "objects / ** / *. o" corresponde a todos os .o arquivos contidos em qualquer lugar do
subdiretório objetos ou qualquer um de seus subdiretórios ou qualquer um de seus subdiretórios. O
O caractere curinga "**" não seguirá links virtuais para diretórios em nenhum nível, nem
tentativa de entrar em diretórios que existem, mas não podem ser lidos. Também arquivos e
diretórios que existem mas não podem ser lidos não serão retornados por "$ (curinga)".

Tanga Funções
adicionar prefixo prefixo, palavras
Anexa a sequência de prefixo a cada uma das palavras. Isto é principalmente para GNU make
compatibilidade; usando expansão de estilo rc, isso pode ser feito de uma forma mais legível
como isso:

MÓDULOS: = abcd
X_OLD_STYLE: = $ (addprefix $ (OBJDIR) /, $ (adduffix .o, $ (MODULES)))
X_NEW_STYLE: = $ (OBJDIR) / $ (MODULES) .o # Não é mais fácil de ler?

adduffix sufixo, palavras
Acrescenta a string de sufixo a cada uma das palavras. Isto é principalmente para GNU make
compatibilidade; usando expansão de estilo rc, isso pode ser feito de uma forma mais legível
como isso:

X_OLD_STYLE: = $ (adduffix .o, $ (MODULES))
X_NEW_STYLE: = $ (MÓDULOS) .o

chamada variável[, palavras]...
A função "chamar" é única no sentido de que pode ser usada para considerar variável como um
função parametrizada. Você pode atribuir uma expressão complexa a variável E use
"chamar" para expandir seu conteúdo para diferentes valores parametrizados por palavras mais tarde. Dentro
outros sistemas de marca, uma variável que é usada principalmente para o propósito de ser expandida via
"ligar", é chamado de macro.

Durante a expansão da macro, as variáveis ​​temporárias $1, $2, "..." consulte o
argumentos fornecidos para "chamar" durante sua invocação. A variável $0 será expandido para
o nome da macro (ou seja variável) que a "chamada" está em expansão.

Não há limite, com quantos argumentos uma macro pode ser "chamada" ou com quantos
parâmetros que uma macro pode esperar. Se você passar mais argumentos para "chamar" como a macro
necessidade, todos os argumentos excedentes serão descartados. Se você passar menos argumentos do que um
macro esperada, todos os parâmetros excedentes são recolhidos em uma string vazia.

Primeiro, um exemplo simples:

rest = $ (lista de palavras 2, $ (palavras $ (1)), $ (1))
lista = ABCDE
butfirst: = $ (pausa da chamada, $ (lista))

Aqui, a variável "$ (butfirst)" conterá a lista "BCDE".

E agora um exemplo mais complexo para mostrar o que é possível:

rest = $ (lista de palavras 2, $ (palavras $ (1)), $ {1})
meumapa = $(if $2,$(chamar $1,$(primeira palavra $2)) $(chamar $0,$1,$(chamar descanso,$2)))
downcase = $ {makeperl lc ("$ 1")}

UCWORDS = TODAS ESTAS PALAVRAS SÃO PRÓXIMAS
DCWORDS: = $ (chamar mymap, downcase, $ (UCWORDS))

Agora, "$ (DCWORDS)" contém "todas essas palavras são maiúsculas". A propósito: não faz
diferença, se acessamos os argumentos via $1, "$ {1}" or "$ (1)" dentro de uma macro.

Você pode usar a variável diretamente como se fosse uma função, se não houver
função desse nome. Isso é convertido internamente para "chamar", então esses são
equivalente:

discussão = $ 0 se transformou em $ 1 $ 2.
direct = $ (discussão e argumento)
chamado = $ (chamar discussão, um, argumento)

Pode parecer discutível se "$ [call]" também deve expandir o "$ []" da macro
expressões, ou se uma função deve sempre fazer a mesma coisa, não importa como
é chamado. Este último foi escolhido, porque com a sintaxe normal do make seria
impossível obter "$[1], $[2]..." em uma variável (eles seriam substituídos por nada,
antes mesmo da atribuição ocorrer.) Portanto, se você tiver uma macro para definir um
regra, você deseja que expressões como "$ (saída)" sejam vistas quando a regra for analisada, então
você deve protegê-los de "chamar":

definir mirula
$ 2: $ 1
mycommand $$ (input) -o $$ (output)
fim
$ [myrule myinput, myoutput]

filtro padrões, palavras
Retorna todas as palavras da lista que correspondem aos padrões. Os padrões podem ser simplesmente outros
palavras ou caracteres curinga de nome de arquivo (ou seja, "*", "?" e "[az]" são reconhecidos) ou podem
tem um caractere "%", que significa corresponder a qualquer string naquele ponto (o mesmo que "*").

filtrar padrões, palavras
Retorna todas as palavras da lista que não correspondem aos padrões. Os padrões podem ser simplesmente
outras palavras ou caracteres curinga de nome de arquivo (ou seja, "*", "?" e "[az]" são reconhecidos) ou
eles podem ter um caractere "%", o que significa corresponder a qualquer string nesse ponto (o mesmo que
"*").

Por exemplo:

libproduction.a: $ (filter_out test_ *, $ (wildcard * .o))

vai colocar tudo .o arquivos que existem ou podem ser construídos, exceto aqueles que começam com teste_,
para dentro libprodução.a.

encontrar string achar, in
Devolução find, se for uma substring de in.

primeira palavra palavras
Retorne a primeira palavra.

mapa, palavras, código perl
fazer mapa palavras, código perl
Da mesma forma que o mapa de Perl, se aplica código perl para cada palavra por vez e retorna o
resultados. A primeira variante é o código Perl simples, enquanto a segunda variante passa primeiro
o perlcode por meio da expansão de variável no estilo Make. As palavras são expandidas em ambos
casos.

As palavras estão em $ _ e são retornadas, a menos que você undef $ _. Isso se destina a
modificações não são facilmente tratadas por "patsubst". Apenas a primeira vírgula é um separador,
quaisquer outros são considerados parte do código perl.

# Troque as palavras. Parênteses duplos, para permitir parênteses em perlcode, ou use $ {}:
X = $ ((map $ (VALUES), s /(.+)-(.+)/$ 2- $ 1 /))
# Você pode usar expressões make, mas deve usar $$ para Perl $:
Y = $ (makemap $ (VALUES), tr / $ (OLDCHARS) / $ (NEWCHARS) / ou $$ _ = 'falhou')
# Você pode eliminar candidatos:
Y = $ (map $ (VALUES), undef $ _ if / no_good /)

juntar palavras1, palavras2
Faça uma junção de pares das primeiras palavras e das segundas palavras.

patsubsta padronizar, substituto, palavras
Executa uma substituição em cada palavra da lista de palavras. Um caractere "%" corresponde a qualquer
corda. Isso é melhor ilustrado por um exemplo:

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

pega cada arquivo em C_SOURCES e retorna o nome de um arquivo de objeto em object_dir.
Às vezes é mais conciso usar uma referência de substituição, por exemplo, o acima poderia
foi escrito como

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

tipo word1 word2 word3 ...
Classifica as palavras em ordem lexical e remove duplicatas.

tira corda
Remove os espaços em branco à esquerda e à direita da string e substitui cada espaço interno
sequência de um ou mais caracteres de espaço em branco com um único espaço. Assim, "$ (strip ab
c) "resulta em" abc ".

substantivo de, para, texto
Executa uma substituição textual no texto do texto: cada ocorrência de de é substituída
por para. O resultado é substituído pela chamada de função. Por exemplo,

$ (subst ee, EE, pés na rua)

substitui a string "fEEt on the strEEt".

palavra n, texto
Retorna o na palavra de texto. Os valores legítimos de n comece de 1 no início
ou para trás de -1 no final. Se n é maior do que o número de palavras em texto,
o valor está vazio.

lista de palavras lista de índices, palavras
lista de palavras primeiro índice, último índice, palavras
No primeiro formulário você fornece uma lista de índices (contando de 1 no início ou
para trás de -1 no final) para selecionar as palavras que você deseja. Na segunda forma você
especifique o intervalo de palavras que deseja retornar.

palavras texto
Retorna o número de palavras em texto.

Gerais Funções
foreach var, lista, texto
Os primeiros dois argumentos, var e Lista, são expandidos antes que qualquer outra coisa seja feita; Nota
que o último argumento, texto, não seja expandido ao mesmo tempo. Então, para cada palavra de
o valor expandido de lista, a variável nomeada pelo valor expandido de var é definida como
essa palavra, e o texto é expandido. Presumivelmente, o texto contém referências a essa variável,
portanto, sua expansão será diferente a cada vez.

Este exemplo simples define a variável arquivos à lista de todos os arquivos no
diretórios na lista dirs:

dirs := abcd
arquivos := $(foreach dir,$(dirs),$(curinga $(dir)/*))

Aqui, o texto é "$ (wildcard $ (dir) / *)". A primeira repetição encontra o valor "a" para dir,
portanto, produz o mesmo resultado que "$ (wildcard a / *)"; a segunda repetição produz
o resultado de "$ (wildcard b / *)"; e o terceiro, o de "$ (wildcard c / *)".

Este exemplo tem o mesmo resultado (exceto para definir "dirs") que o exemplo a seguir:

arquivos: = $ (curinga a / * b / * c / * d / *)

Quando o texto é complicado, você pode melhorar a legibilidade dando-lhe um nome, com um
variável adicional:

find_files = $ (wildcard $ (dir) / *)
dirs := abcd
arquivos: = $ (foreach dir, $ (dirs), $ (find_files))

Aqui usamos a variável find_files desta forma. Usamos "=" simples para definir um
variável de expansão recursiva, de modo que seu valor contenha uma chamada de função real para
ser reexpandido sob o controle da foreach; uma variável simplesmente expandida não faria,
já que o curinga seria chamado apenas uma vez no momento de definir find_files.

Nota: Não confunda isso com a variável especial "$(foreach)".

info texto
aviso texto
erro texto
Texto de saída que retorna o nada. O primeiro vai para STDOUT, o segundo para STDERR,
o terceiro aborta adicionalmente o processamento.

pré-construir tem como alvo
fazer tem como alvo
Retorna seu argumento literalmente, mas primeiro cria todos os arquivos listados. Isso é útil
quando um determinado arquivo é necessário ao avaliar uma expressão make. Isso normalmente acontece
quando você tem uma construção onde o conjunto de arquivos envolvidos é calculado por algum shell
comandos. Por exemplo,

file_list:
# comandos shell para calcular uma lista de arquivos para colocar no programa

meu_programa: $ (& cat $ (pré-compilar lista_de_arquivos))

Se você precisar da lista em mais de uma regra, seria mais eficiente usar um
expandir no máximo uma vez variável:

file_list; = $ (& cat $ (pré-construir file_list))

my_program1: ao $ (file_list)

my_program2: bo $ (file_list)

Se, em vez disso, você especificasse apenas "$ (& cat file_list)", o makepp não forçaria
file_list para estar atualizado antes de executar o comando shell. Usando "$ (prebuild)"
é a melhor maneira de resolver esse problema. Você pode ficar tentado a tentar outras coisas, como
esta:

my_program: file_list $ (& cat file_list)

mas isso não vai funcionar porque "$ (& cat file_list)" é avaliado antes que o makepp tente
construir "file_list".

only_phony_targets nomes
Retorna apenas os nomes na lista que são alvos falsos de alguma regra (seja
regras explícitas ou padrão). Você pode especificar curingas (incluindo o especial do makepp
curinga, "**") nos nomes dos arquivos. (Veja a função "$ (curinga)" para mais detalhes.
Isso pode ser usado para agrupar alvos, por exemplo:

$ (testes falsos): $ (only_phony_targets * / ** / tests)

origem variável
Dado o nome de uma variável, informa de onde vem seu valor.

perl código perl
makeperl código perl
Avalia o perlcode em um bloco e retorna o resultado. A primeira variante é Perl simples
código, enquanto a segunda variante passa primeiro o perlcode por meio da variável de estilo Make
expansão.

Observe que, como com todas as funções, o delimitador de função usado pode não aparecer dentro
o perlcode fora de strings entre aspas simples ou duplas. Mas você pode dobrar como em
o último exemplo:

VA = 1
VAR1 = $ {perl ($ VAR + 1) * 3}
VAR2 = $ (perl fazer {$ VAR * = 3; retornar $ VAR + 1} se $ VAR)
VAR3 = $ (makeperl $ (VAR1) * 3 + $$ VAR) # um Make var e um Perl var
VAR = $ ((perl if (...) {...}))

falso palavras
Indica que a lista de palavras são realmente alvos falsos e retorna a lista de
alvos. Deve ser usado assim:

$ (todos falsos): my_program

$ (falso limpo):
& rm -f * .o meu_programa

Você também pode declarar um ou mais alvos como falsos com uma linha como esta em qualquer lugar em
seu makefile:

.PHONY: tudo limpo

impressão texto
Produz o texto e o retorna. Isso é útil principalmente para depuração, quando você não
entenda porque a substituição de variáveis ​​tem o resultado que tem. Por exemplo,

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

irá imprimir o resultado da chamada "patsubst".

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

irá imprimir o último argumento da chamada "patsubst".

concha comando shell
Retorna a saída do comando shell fornecido, com novas linhas substituídas por espaços.

Observe que, como com todas as funções, o delimitador de função usado pode não aparecer dentro
o comando shell fora de strings entre aspas simples ou duplas. Mas você pode dobrar
como no segundo exemplo:

data = $ (data shell) # melhor: $ (perl escalar localtime)
VAR = $ {{shell f () {echo hello; }; f}}

xargs comando, argumentos [, sufixo [, comprimento]]
Retorna uma lista de comandos separados por nova linha em que cada um começa com o especificado
comando e terminar com tantos elementos da lista quanto possível, sem passar
comprimento (padrão 1000) caracteres.

O objetivo disso é evitar ultrapassar o limite de comprimento do comando em seu sistema.
Por exemplo, se houver muitos arquivos gerados, você provavelmente deseja que seu
alvo limpo (que você não deveria ter, porque "makeppclean" é mais eficiente) para
parece algo assim:

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

Isso também tem o efeito colateral de que nenhum comando é gerado se a lista
acontece estar vazio. Mas, neste caso, seria melhor usar o builtin & rm,
porque os argumentos para os comandos embutidos são limitados apenas pela memória do Perl:

$ (falso limpo):
& rm -f $ (only_targets ** / *)

Se um terceiro argumento for especificado, ele será usado para corrigir cada comando. Isto é
útil para especificar redirecionadores, por exemplo (embora aqui novamente o & echo ajude):

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

Parte desta documentação é baseada na documentação do GNU make.

Observe que se uma função for chamada durante a inicialização do makefile, por exemplo, o
a expansão das variáveis ​​de exportação, mensagens de erro ou advertência reportará a linha número 0.

Use makepp_functions online usando serviços onworks.net