makepp_variables - Online na nuvem

PROGRAMA:

NOME

makepp_variables - Como usar variáveis ​​no makepp

DESCRIÇÃO

?: $ *,
$ +,
$ /,
$ <,
$ ?,
$ @,
$ ^,
=,
! =,
& =,
+ =,
: =,
; =,
? =, A: AR,
ARFLAG,
COMO, C: DC,
FLAGAS,
"changes_dependencies",
changes_inputs,
CURDIR,
CXX,
CXXBANDEIRAS, D: "dependências",
"dependência", F: F77,
F.C.,
"para cada", I: entrada,
insumos, L: LD,
LEX,
LIBTOOL, M: FAÇO,
MAKECMDGOALS,
MAKEFLAGS,
MAKEINFO,
MAKEPP_DEBUG,
MAKEPPFLAGS,
_MAKEPPFLAGS,
MAKEPP_LN_CP,
"makepp_percent_subdirs",
"makepp_require_phony",
makepp_signature_C_flat,
"makepp_simple_concatenation",
MAKEPP_VERSION, O: "saída",
"saídas", P: PERL,
PCD, R: ressonância magnética,
RAIZ, S: CONCHA,
"ordenadas_dependências",
ordenadas_entradas,
"tronco", T: alvo,
metas, V: VPATH, Y: YACC

Makefiles normalmente usam variáveis ​​em muitos lugares. Uma razão importante para usar
variáveis ​​é para garantir que a informação esteja contida em apenas um lugar no makefile, então
que se mudar, não há perigo de as duas cópias das informações saírem do
sincronizar.

Os nomes das variáveis ​​diferenciam maiúsculas de minúsculas. Em teoria, os nomes das variáveis ​​podem ser compostos por muitos
personagens, mas o makepp provavelmente não será capaz de grocá-lo se você fizer algo diferente
caracteres alfanuméricos, "_" e "-".

Cada makefile tem seu próprio conjunto de variáveis, e definir uma variável em um makefile irá
não tem efeito sobre seu valor em qualquer outro makefile. Se você quiser ter variáveis ​​definidas em
muitos makefiles, a melhor maneira de fazer isso é fazer com que cada um deles inclua definições comuns
(consulte a instrução de inclusão) ou use variáveis ​​"globais".

Variável Atribuição
Uma variável pode assumir um valor de várias maneiras diferentes:

· Uma variável pode ser definida dentro de um makefile. Existem várias maneiras diferentes de fazer
isto; Veja abaixo.

· O valor de uma variável pode ser especificado na linha de comando, assim:

makepp CFLAGS = -O2 my_program

Se mais de um makefile for carregado, a variável CFLAGS é propagada para todos os
makefiles. Variáveis ​​definidas na linha de comando substituem automaticamente qualquer configuração de
a variável em qualquer um dos makefiles.

Se necessário, o makefile deve, por sua vez, substituir explicitamente as configurações da linha de comando.
A intenção não é ignorar o que o usuário solicita, mas sim uma forma de modificá-lo.
O modificador "override" pode preceder qualquer instrução de atribuição. Mas no caso de
declarações de palavras-chave, a ordem é importante, e é por isso que a variante de substituição é
sempre mostrado abaixo. O modificador "override" se aplica apenas a quaisquer atribuições onde
está presente e não influencia atribuições posteriores à variável.

· Se uma variável é definida no ambiente, ela pode ser referenciada como uma variável makepp.
Normalmente atribuições a variáveis ​​dentro de configurações de substituição de makefile do
ambiente, mas você pode mudar isso usando "-e" ou "- substituições de ambiente"
opção de linha de comando.

As variáveis ​​são atribuídas com uma das várias expressões de atribuição, como esta

X = 1
MÓDULOS: = abcd
CC? = Gcc
CFLAGS + = -Wall
definir VAR
var linha 1
var linha 2
enddef
exportar PATH: = $ (PWD): $ (PATH)
global MYPROJECT.INFO = informação a ser vista em todos os makefiles

Os espaços em branco à esquerda e à direita em torno dos valores são sempre eliminados.

Os diferentes operadores de atribuição têm significados um pouco diferentes.

simples atribuição operadores

=
VARIABLE = string de texto
substituir VARIABLE = string de texto

Esta é a instrução de atribuição usual que todas as implementações do make suportam. o
a expressão do lado direito não é avaliada até que o valor de "$ (VARIABLE)" seja
realmente usado em algum lugar. Portanto, se você fizer o seguinte:

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

Então, "$ (Y)" posteriormente no makefile será avaliado como "2".

Em geral, você geralmente deseja usar ": =" (veja abaixo) em vez de "=" porque
fornece avaliação de variável mais previsível. No entanto, há momentos em que você precisa
para adiar a avaliação da variável. Além disso, se você está escrevendo um makefile que deve ser
compatível com versões anteriores com alguma versão do make diferente do GNU make, então você não tem
escolha: você só pode usar "=".

:=
VARIÁVEL: = expr
substituir VARIÁVEL: = expr

É o mesmo que "VARIABLE = expr" exceto que o lado direito é avaliado
de uma vez por todas no momento da atribuição. Assim se

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

então "$ (Y)" mais tarde no makefile será avaliado como "1" já que isso é o que "$ (X)" era
quando "$ (Y)" foi definido.

;=
VARIÁVEL; = expr
substituir VARIABLE; = expr

É o mesmo que "VARIÁVEL: = expr" exceto que o lado direito é avaliado
apenas no momento do primeiro uso e depois lembrado. Isso é útil para caras
comandos, que sempre retornam o mesmo valor, mas que você não deseja executar quando
construir alvos não relacionados:

VAR1; = $ (cálculos caros perl)
VAR2; = $ (comando externo shell)

Observe que os makefiles antigos geralmente usam ": =" aqui, para fazer isso pelo menos uma vez.
Mas com este operador você pode ainda não fazer isso, se você atualmente não
precisa do valor. Para valores idênticos em vários diretórios, você pode
otimize isso ainda mais com "global", discutido abaixo.

No entanto, essa não é uma forma inteligente de forçar a ordem de avaliação. Se um
variável definida assim inclui o valor de outra variável, e aquela outra
tem um valor específico de destino, e a primeira expansão é para esse destino, então o
o valor específico de destino também será válido para todos os outros contextos. Este é um bug e
será corrigido no futuro.

+=
VARIÁVEL + = expr
substituir VARIABLE + = expr

Acrescenta a string ao conteúdo anterior da variável, separado por um espaço. Se
a variável foi previamente atribuída com ": =", então o lado direito é avaliado
antes de anexar.

&=
VARIÁVEL & = expr
substituir VARIABLE & = expr

Anexa a string ao conteúdo anterior da variável, separado por um espaço.
Se a variável foi atribuída anteriormente com ": =", então o lado direito é
avaliado antes de anexar.

Por exemplo, uma forma de garantir que "CFLAGS", o que mais o usuário pode inserir,
sempre começa com "-Wall" são estas duas linhas:

CFLAGS = -O2 # Possivelmente substituído na linha de comando
substituir CFLAGS & = -Wall # incondicionalmente prefixado

Em makefiles antigos, você normalmente tinha que fazer algo assim, que tinha o lado
efeito de forçar o tipo a ": =" para evitar recursão infinita:

VARIÁVEL: = expr $ (VARIÁVEL)

?=
VARIÁVEL? = Expr
override VARIABLE? = expr # Inútil, mas legal

Define o valor da variável, mas apenas se a variável não for especificada anteriormente em
o makefile, na linha de comando ou no ambiente. A tarefa acima é
exatamente equivalente a

ifndef VARIÁVEL
VARIÁVEL = expr
endif

!=
VARIABLE! = Comando shell
substituir VARIABLE! = comando shell

Executa o comando shell e define a variável para conter a saída padrão do comando.
Isso é exatamente equivalente a

VARIÁVEL: = $ (comando shell)

Multilinha variáveis

A instrução "define" é o equivalente multilinha das instruções simples acima. o
operador após a variável é opcional. Se ausente, é equivalente a "definir VARIÁVEL
= ". Os operadores" & = "e" + = "são ligeiramente diferentes aqui, na medida em que colam isso
o valor antigo com uma nova linha, em vez de um espaço. Não deve haver nada, exceto um
comentário após a declaração, ou seja, o valor começa na próxima linha.

definir VARIÁVEL: =
primeira linha do valor da variável
segunda linha do valor da variável
terceira linha do valor da variável
fim

substituir definir VARIÁVEL
...
enddef

As palavras-chave antes de "definir" podem ser combinações de "exportar" ou "global" e
"sobrepor".

Se você precisa que o valor de uma variável contenha novas linhas, você deve usar a instrução "define" como
mostrado (ou você pode atribuir o valor diretamente em Perl). ("endef" foi escolhido para
compatibilidade com GNU make. Você também pode usar "enddef".) Isso é útil principalmente para
"sequências de comando predefinidas", por exemplo, algo como isto:

definir COMPILE_C_PROGRAM
@ & echo "Compilando $ (entrada)"
@ $ (CC) $ (CFLAGS) $ (CPPFLAGS) $ (INCLUI) -c $ (entrada) -o $ (saída)
fim

Então você pode usar esta variável multilinha em várias regras, como esta:

% .o:% .c
$ (COMPILE_C_PROGRAM)

$ (ARCH) /%. O: $ (ARCH) /%. C
$ (COMPILE_C_PROGRAM)

Observe que muitas vezes você pode obter o mesmo efeito usando um ponto-e-vírgula em vez de uma nova linha,
porque o shell interpreta isso como um delimitador de comando também. Por exemplo,

COMPILE_C_PROGRAM = @echo "Compilando $ (entrada)"; \
$ (CC) $ (CFLAGS) $ (CPPFLAGS) $ (INCLUI) -c $ (entrada) -o $ (saída)

terá o mesmo efeito, exceto que o ponto e vírgula força o Perl a passá-lo para o shell,
em vez de executar o comando diretamente e com mais eficiência. Você também tem que colocar cada
embutido em uma linha própria, o que significa que você deve alternar para o eco externo no
caso de ponto e vírgula.

Há uma especialidade ao expandir em "definir", ou seja, "definir X: =" ou em um
variável que já era ": =", "define X & =" e "define X + =". Neste caso, o
"$ (comando shell ...)" ou incorporado "$ (& command ...)" não transforma as novas linhas em
espaços.

Exportando variáveis para subprocessos

exportar VAR ...
exportar VAR = valor
substituir exportação VAR + = valor

A primeira forma marca as variáveis ​​fornecidas para exportação para subprocessos, com qualquer valor
a variável então tem. A segunda forma, que se aplica apenas a uma variável, adicionalmente
atribui um valor imediatamente. Todas as variantes de atribuição são permitidas.

compartilhando variáveis em arquivos criados

VAR global ...
VAR = valor global
substituir VAR global & = valor

A primeira forma marca as variáveis ​​fornecidas como globais para todos os makefiles. Se algum deles
já tinha um valor, esse valor é movido da variável local makefile para o global
XNUMX. No entanto, se, no momento em que esta declaração for vista, qualquer outro makefiles já tinha um
valor para qualquer um deles, então esses makefiles não verão o global.

A segunda forma, que se aplica apenas a uma variável, adicionalmente atribui um valor certo
longe. Todas as variantes de atribuição são permitidas. Observe que ": =" se expandirá imediatamente
para os valores no makefile local. Ao contrário, as variáveis ​​"=" se expandirão para o
valores no ponto de uso.

Variáveis ​​globais podem ser difíceis de lidar, porque makepp pode carregar makefiles em qualquer
ordem, conforme surge a necessidade de construir algum destino para o qual nenhuma regra ou makefiles sejam carregados.
Por este motivo, é recomendável ter um Arquivo RootMakepp e carregar explicitamente todos
outros que modificam ou usam a variável com "load-makefile".

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

Observe também que seu projeto pode algum dia ser construído junto com outros projetos. Por esta
Por isso, é recomendável sempre incluir o nome do projeto em qualquer nome de variável global.

Alvo específico atribuições

alvo: VARIABLE = string
alvo: VARIABLE: = string
destino: substituir VARIABLE + = string

Define um valor específico de destino da variável. Um valor específico de destino está em vigor só
em uma ação que produz o alvo dado. Isso é usado principalmente para coisas como
esta:

CFLAGS: = -O2

meu_prog: arquivo1.o arquivo2.o arquivo_especial.o

arquivo_especial.o: CFLAGS: = -g

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

O que acontece aqui é que todos os arquivos ".c" serão compilados com otimização ("-O2") exceto
"special_file.c", que é compilado em modo de depuração ("-g"). Esta é uma maneira conveniente de
especifique opções de compilação diferentes para apenas alguns arquivos.

Atribuições de variáveis ​​específicas de destino como essa se aplicam apenas às ações da regra; elas
não estão em vigor ao avaliar os destinos ou as dependências de uma regra. Se uma regra
tem mais de um destino, as atribuições de variáveis ​​específicas do destino são retiradas apenas do
primeiro alvo. Observe também que as variáveis ​​específicas do alvo do makepp são ligeiramente diferentes
do GNU make's em que eles só se aplicam à regra para o arquivo mencionado, e não para
qualquer um de seus predecessores.

A expansão do curinga é realizada no destino, então você pode fazer algo assim:

teste _ *. o: CFLAGS + = -DTEST

Para compatibilidade com GNU make, "%" pode ser usado no lugar de "*".

Variável Substituição
As regras de substituição de variáveis ​​do Makepp são semelhantes às de outras marcas, mas de alguma forma
mais poderoso. Como em todas as marcas, "$ (CC)" ou "$ {CC}" representam o valor do
variável CC. Se você precisar de um cifrão literal, coloque um cifrão duplo ($$), como
esta:

alvo: dep1 dep2 dep3 dep4
& rm -f $ (saída)
para arquivo em $ (entradas); fazer cat $$ arquivo >> $ (saída); feito

Além disso, o makepp tem uma sintaxe "$ [VARIABLE]", que faz a mesma coisa que o outro
dois, mas antes que o makepp grite qualquer outra coisa. Isso permite usá-lo para regras completas
e / ou condicionais:

definir bracket_rule =
ifdef SOME_VAR
suporte:
& echo, esta é uma regra -o $ (saída)
endif
enddef

$ [bracket_rule]

estilo rc substituição

Por padrão, makepp usa substituição de estilo rc (assim chamado porque foi criado pelo
shell rc). Isso é melhor ilustrado por um exemplo:

MÓDULOS = abcd

mylib.a: module_dir / $ (MODULES) .o $ (OTHER_OBJECTS)
$ (CXX) $ (dependências) -o $ (destino)

O prefixo "module_dir /" é prefixado a cada palavra em MODULES, e o sufixo ".o" é
anexado a cada palavra.

Você também pode usar a substituição de estilo rc sem nem mesmo colocar a lista de palavras em um
variável; a sintaxe é "$ (palavra1 palavra2)". Observe o espaço entre o parêntese e o
primeira palavra. Portanto, o exemplo acima poderia ter sido escrito como:

mylib.a: module_dir / $ (abcd) .o $ (OTHER_OBJECTS)
$ (CXX) $ (dependências) -o $ (destino)

Uma variável fornecerá substituição de estilo rc apenas quando houver mais de uma palavra nela.
Com uma palavra, é como fazer tradicional. Infelizmente, quando a variável está vazia, há um
conflito. O tradicional faz simplesmente expandi-lo para a string vazia. Mas quando você pensa em
como uma lista, você gostaria que "-I $ (DIRLIST)" desaparecesse, não para dar um "-I" solitário. o
solução é envolvê-lo em uma lista que começa com um espaço: "-I $ ($ (DIRLIST))" dá a você
exatamente tantas opções quanto palavras na lista.

Se você colocar várias variáveis ​​na mesma palavra que se expandem para matrizes de palavras, estilo rc
substituição realmente leva o produto cartesiano, então você pode fazer algo assim se
você quer:

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

e FILES conterá a string

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

Além do espaço em branco, a substituição do estilo rc para em qualquer citação, qualquer redondo, encaracolado ou quadrado
parênteses e qualquer um de ",:; = # @". Observe que isso pode ser surpreendente e, novamente, precisa
uma lista explícita. Digamos que você queira procurar cabeçalhos por curinga em todos os diretórios
começando com uma letra maiúscula:

RUIM: = [AZ] * / ** / *. $ (Hpp h) # [AZ] * / ** / *. Hpp * / ** / *. H
BOM: = $ ([AZ] * / ** / *.) $ (Hpp h) # [AZ] * / ** / *. Hpp [AZ] * / ** / *. H

Se a substituição de estilo rc atrapalhar, ou se você precisar ter
espaço em branco em suas variáveis ​​de make, então você pode desligar a substituição de estilo rc configurando
a variável "makepp_simple_concatenation = 1". Você pode desligá-lo globalmente com o comando
linha ou como uma variável de ambiente. Ou em uma base por makefile, definindo a variável em
seu makefile. Você deve fazer isso próximo ao topo do makefile, ou então você pode encontrar
situações engraçadas em que a substituição do estilo rc é usada para algumas avaliações e não para outras.
(Todas as expressões avaliadas antes da atribuição usarão substituições de estilo rc, e todos
expressões avaliadas após não. Desde a época da avaliação das expressões em
makefiles é complicado e nem sempre óbvio a partir da ordem das declarações no
makefile, é melhor definir "makepp_simple_concatenation" o mais cedo possível.) Você pode
até mesmo defina-o apenas para um alvo:

destino: makepp_simple_concatenation = 1
alvo:
& echo before_first $ (LIST) after_last -o $ (output)

Porque "$ [VARIABLE]" é avaliado antes de "$ (VARIABLE)", combinando os dois em rc-
a substituição não dará o resultado que você espera, a menos que você o envolva em uma
Lista:

A = ab
N = 1 2
RUIM: = $ (A) $ [N]
BOM: = $ (A) $ ($ [N])

As últimas linhas são lidas como

RUIM: = $ (A) 1 2 # a1 b1 2
BOM: = $ (A) $ (1 2) # a1 a2 b1 b2

Substituição Referências

Uma referência de substituição tem a forma "$ (VAR: A = B)", onde A é um padrão para corresponder e B é
um padrão para substituí-lo. As referências de substituição são uma abreviatura para o
função "patsubst". Por exemplo:

source_files = ac bc cc dc
object_files = $ (source_files:%. c =%. o)

irá definir "$ (object_files)" para "ao bo co do". O "%" é um caractere especial que corresponde
qualquer string arbitrária. Se A e B começam com "%", um caso comum ao substituir
sufixos, eles podem ser omitidos:

object_files = $ (source_files: .c = .o)
object_files = $ (source_files: c = o) # mesmo, porque. não é especial

Espaço em branco in variáveis

Se você precisa controlar o espaço em branco em uma variável, você deve (atualmente) desativar o estilo rc
substituição (definindo "makepp_simple_concatenation = 1") e, em seguida, use uma sintaxe como esta:

nulo =
T = -o $ (nulo)

ou, com uma avaliação vazia:

T = -o $ ()

Ao fazer isso, a variável "T" contém "-o" seguido por um espaço.

Esse tipo de técnica para lidar com espaços em branco não é recomendado. Se você precisa de variáveis
em seu makefile para conter espaços, você deve pensar seriamente sobre o que está fazendo.
Se você precisa lidar com espaços, geralmente é muito melhor colocar o código Perl em seu
makefile para cuidar disso (usando as instruções "perl_begin" ou "sub"), ou para lidar com isso
em instruções shell nas ações das regras.

Esses casos normalmente surgem quando as pessoas tentam usar as mesmas regras para diferentes
arquiteturas que não usam sintaxe de comando Unix típica. Por exemplo, às vezes se vê
coisas assim em makefiles:

ifeq ($ (ARCH), weirdarch)
O: = / SAÍDA =
outro
nulo: =
O: = -o $ (nulo)
endif

% .o:% .c
$ (COMPILADOR) $ (entrada) $ (O) $ (saída)

Você pode fazer isso com o makepp se realmente quiser, mas provavelmente descobrirá que seu
makefiles são substancialmente mais legíveis se você tiver variáveis ​​menos complicadas
substituição, por exemplo,

ifeq ($ (ARCH), weirdarch)
% .o:% .c
$ (WEIRD_COMPILER) $ (entrada) / SAÍDA = $ (saída)
outro
% .o:% .c
$ (CC) -c $ (entrada) -o $ (saída)
endif

Espaços em branco nunca são permitidos em nomes de variáveis, apenas em seus valores. Isso é diferente
de algumas implementações de make.

Automático Variáveis
Variáveis ​​automáticas são variáveis ​​que assumem valores diferentes dependendo de qual regra
eles são avaliados em. Makepp suporta a maioria das variáveis ​​automáticas que outros
versões de fazer uso. Além disso, tem nomes menos enigmáticos e mais longos para a maioria deles
que você pode usar em seu lugar. (Para makefiles legados que redefinem esses nomes, o
definição no makefile sobrescreve o significado padrão. Por exemplo, se você disser
"target = abc" em seu makefile, então "$ (target)" sempre se expandirá para "abc", e não
mais ser equivalente a $ @.)

A seguir está uma lista completa de todas as variáveis ​​automáticas que o makepp suporta:

saída
alvo
$ @ O destino da regra atual. Na verdade, uma vez que makepp suporta vários destinos para
qualquer regra, esta é a primeiro alvo. Por exemplo, na seguinte regra

y.tab.c y.tab.h: parser.y
$ (YACC) -o $ (saída) $ (YFLAGS) $ (entrada)

"$ (saída)" conterá o valor y.tab.c. Uma vez que essas variáveis ​​mágicas são de fato
funções, você também pode passar um índice como argumento. Isso conta de 1 ou para trás
a partir de 1. Portanto, "$ (output 2)" ou "$ (output -1)" conterá o valor y.tab.h.

Embora todas as três formas desta variável tenham o mesmo valor, há uma diferença em
interpretação para regras multitarget. Se você usar o nome enigmático antigo $ @,
makepp irá interpretar isso como um conjunto de regras de estilo antigo, ao invés de uma regra moderna que
produz todos esses alvos de uma vez:

ab: # realmente: uma regra para a e b
toque em $ @

cd: # erro: mpp reclama que não foi compilado d
toque em $ (saída)

outputs
tem como alvo
Todos os alvos da regra atual. O mesmo que "$ (target)", a menos que haja mais de um
alvo. No exemplo acima, "$ (saídas)" será y.tab.c y.tab.h. Você pode passar um
lista de índices, então "$ (saídas 2 1)" será y.tab.h y.tab.c.

dependência
entrada
$ <A primeira dependência explícita da regra. Por exemplo, nesta regra

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

"$ (input)" será o nome do .c arquivo, independentemente do que .h arquivos makepp
descobre. Se você especificar mais de uma dependência, poderá obtê-las passando um
índice: "$ (input $ (INDEX))" é a dependência INDEX.

dependências
inputs
$ ^ Todas as dependências explícitas do destino, não incluindo .h arquivos descobertos por
makepp_scanning para inclusões.

Por exemplo, na regra

myprog.o: * .o
$ (CC) $ (CFLAGS) $ (entradas) -o $ (saída)

"$ (entradas)" serão todos os arquivos .o no diretório. Você pode escolher apenas aqueles que você
deseja passando uma lista de índices. Se você especificar explicitamente diferentes tipos de arquivos,
você pode selecioná-los como em "$ (entradas 2 3 4)" (mas com um caractere curinga isso não é muito
promissor).

ordenadas_dependências
ordenadas_entradas
$ + Todas as dependências do destino, em ordem de classificação, com as duplicatas removidas.
Equivalente a "$ (sort $ (inputs))".

changes_dependencies
changes_inputs
$? As dependências do destino que foram alteradas. Isso inclui apenas explícito
dependências (ou seja, aquelas que você lista no makefile), não descobertas implicitamente
dependências da digitalização (como arquivos .h).

Isso é comumente usado em comandos como este:

libmine.a: $ (MODULES): build_check ignore_action
$ (AR) ru $ @ $?

ou seja, ar é instruído a substituir apenas os módulos que foram alterados. (Note o
regra de verificação de construção "ignore_action". Se você não especificar isso, o makepp irá forçar o
ação a ser executada sempre que houver alteração. Se nenhuma dependência mudou, o
string de ação será "ar ru libmine.a", que provavelmente é diferente do que era
da última vez que você o executou, sem "ignore_action" o makepp irá executá-lo. Nisso
caso, é inofensivo, mas com outros comandos, pode ser um problema. Ver
makepp_build_check para detalhes sobre "ignore_action".)

Construir arquivos como este não é uma boa ideia porque tornará suas construções menos
de confiança. O problema com isso é que, se você construir o arquivo, remova um dos
os módulos da lista de MÓDULOS, os módulos ainda estarão no arquivo e
makepp

haste
$ * O radical em uma regra de padrão (ou seja, qualquer que seja o '%' correspondente). Alternativamente, se este
não é uma regra padrão, retorna o nome do arquivo sem a extensão (ou seja, é
equivalente a "$ (basename $ (input))".

Isso é principalmente para compatibilidade com versões anteriores. Por exemplo, em versões antigas do make the
única maneira de dizer como compilar qualquer .c arquivo no correspondente .o arquivo era como
esta:

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

Esta é uma maneira péssima de escrever a regra. É muito mais claro usar o estilo GNU-make
regras de padrão, como esta:

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

foreach
O nome do arquivo atual da cláusula "foreach". cláusulas "foreach" raramente são usadas,
mas eles são o tipo de regra de padrão de propósito mais geral que o makepp suporta. Para
exemplo,

#
# Crie arquivos .c com algum tipo de pré-processador especial:
#
% .c:% .k
$ (pré-processador) $ (entrada)> $ (saída)

#
# Compilar arquivos .c em arquivos .o:
#
% .o:% .c
$ (CC) $ (CFLAGS) -c $ (entrada) -o $ (saída)

#
# Sinalizadores de compilação alternativos especiais para arquivos .c derivados
# de arquivos .k:
#
$ (foreach:%. k =%. o): $ (foreach:%. k =%. c): foreach * .k
$ (CC) $ (SPECIAL_K_FLAGS) -c $ (entrada) -o $ (saída)

Consulte a documentação sobre a cláusula foreach nas regras para obter mais detalhes e exemplos.

$ / Esta é essencialmente uma constante, "/" ou no Windows nativo "\". Você precisa disso, se
você deseja iniciar um programa portável, por exemplo, um que você construiu no diretório atual:

minha saída:
. $ / meuprog> $ (saída)

Para nomes de arquivos passados ​​como argumentos, não é tão necessário, pois o Windows pode lidar com Unix
sintaxe lá.

Opção Variáveis
Você pode configurá-los de todas as maneiras explicadas acima (exceto se indicado de outra forma) para modificar
o bahaviour do makepp. Por padrão, eles são todos indefinidos.

MAKEPP_DEBUG
Se você exportar isso com um valor verdadeiro antes de chamar makepp, você obterá mais depuração
informações Este é o "RULE_SOURCE" dos arquivos construídos enquanto isto está em vigor sob
makeppinfo, mppi e detalhes sobre expansão variável e correspondência de regra em
makepplog, mppl. Isso também irá mostrar se o makepp fica sem memória ou trava,
porque está continuamente expandindo as mesmas variáveis:

A = $ A # avaliação adiada, necessidade: =
B = $ C
C = $ B

MAKEPP_LN_CP
Veja a nota em & ln.

makepp_percent_subdirs
Defina isso para algum valor verdadeiro (como 1) para ter "%" nos destinos ou dependências correspondentes
em mais de um diretório.

makepp_require_phony
Defina isso para algum valor verdadeiro (como 1) para evitar falsidade implícita (ou seja, se uma regra
obtém sucesso sem produzir seu alvo). Esta variável deve ser verdadeira por padrão, para
evitar cadeias de dependência quebradas, mas isso quebraria a compatibilidade com versões anteriores
makefiles desleixados.

makepp_signature_C_flat
Esta é uma opção para a assinatura C. Defina isso com algum valor verdadeiro (como 1) para tratar o seu
fontes como achatadas, ou seja, todas as novas linhas (exceto em torno das instruções do pré-processador) são
tratadas como espaço em branco e as diretivas "#line" são ignoradas.

makepp_simple_concatenation
Defina isso para algum valor verdadeiro (como 1) para evitar "substituição de estilo rc".

PERL
Você pode definir isso para o perl exato que você está usando para executar os scripts no makepp
suite e exportá-lo. Isso pode ajudar a executar sub-scripts com o mesmo perl. Isto é
principalmente útil para o conjunto de testes, a instalação e para compilações recursivas.

VPATH
Definir esta variável para algum valor chama implicitamente "vpath% value".

Predefinido Variáveis
O makepp predefine algumas variáveis, que você pode substituir:

AR Padrão: "ar".

BANDEIRAS
Padrão: "rv".

AS Padrão: "Como".

CC Padrão: O primeiro encontrado entre "gcc", "egcc", "pgcc", "c89" ou "cc", ou no Windows
adicionalmente, "cl" ou "bcc32".

FLAGAS
Padrão: Se "$ (CC)" for um compilador GNU "-g -Wall", se for um dos dois Windows
compiladores nada, senão "-g".

CURDIR
O diretório no qual o Makefile atual reside.

CXX Padrão: O primeiro encontrado entre "g ++", "c ++", "pg ++", "cxx", "C" "C" ou "aCC" ou em
Windows adicionalmente "cl" ou "bcc32".

CXXBANDEIRAS
Padrão: Se "$ (CXX)" for um compilador GNU "-g -Wall", se for um dos dois Windows
compiladores nada, senão "-g".

F77 Padrão: O primeiro encontrado entre "f77", "g77" ou "fort77".

FC Padrão: "$ (F77)".

LD Padrão: "ld".

LEX Padrão: O primeiro encontrado entre "lex" ou "flex".

LIBTOOL
Padrão: "libtool".

FAÇA
Esta variável possui dois valores distintos, dependendo da presença ou não de
"--traditional-recursive-make". Makepp reconhece quando esta variável é usada e
desativa alguns recursos, mesmo antes que a recursão realmente ocorra. Isso pode ser
indesejável enquanto você o elimina gradualmente, então primeiro converta as chamadas para um
específico do makepp "$ ((MAKE))", que não desligará recursos. Você não deve configurá-lo
porque isso quebra nossa solução de recursão inteligente.

FAZER OBJETIVOS
Esta variável é definida, mas não é usada pelo makepp. Você pode consultá-lo para fazer algo apenas se
um determinado alvo foi solicitado.

Padrão: Quaisquer que sejam os alvos explícitos do usuário (ou uma invocação recursiva) fornecida.
Vazio ao construir implicitamente o destino padrão.

ifneq $ (filtro de destino especial, $ (MAKECMDGOALS))
# special-target é um dos alvos explícitos atuais
else ifeq $ (MAKECMDGOALS)
# sem alvos explícitos
endif

MAKEFLAGS (exportado)
As opções padrão com as quais o makepp foi chamado. Aqueles que possuem uma única letra
forma são combinadas no início sem um "-" inicial (Deus sabe por que o gmake escolheu
para eliminar o "-").

MAKEINFO
Padrão: "makeinfo".

MAKEPPFLAGS (exportado)
É definido com o mesmo valor de MAKEFLAGS, mas apenas se esta variável estiver presente em
ambiente do makepp.

_MAKEPPFLAGS (exportado)
As opções específicas de makepp necessárias para compatibilidade POSIX / gmake, com as quais makepp
foi chamado. Eles estão em uma variável separada, então um makefile legado não pode quebrar
compatibilidade desabilitando MAKEFLAGS. Isso só é definido com
"--fazer tradicional-recursivo".

MAKEPP_VERSION
A versão do makepp com a qual você está executando. Se for uma versão beta, terá um
hífen seguido por AAMMDD mais alguns dados internos. Você pode usar isso para "ifdef"
para ocultar construções específicas de makepp de outras marcas.

Padrão: O mesmo valor exibido por "makepp --version"

PWD Um alias para "CURDIR".

RM Padrão: "rm -f". Isso se destina a Makefiles legados. Para novos, de preferência, use
o comando embutido & rm diretamente. Se você quiser escrever uma regra de limpeza falsa, olhe para
o comando "makeppclean -r" em vez disso.

ROOT
O caminho relativo para a raiz do seu sistema de compilação, ou seja, o diretório mais acima em
que você tem um "RootMakeppfile (.mk)". Se você não tiver um, esta variável é
esvaziar.

SHELL
Esta variável só é respeitada se você a "exportar". Nesse caso é a Shell
que é usado para executar ações não embutidas com algum caractere especial nele (simples
aqueles sendo executados diretamente). No Windows Strawberry ou ActiveState Perl, se você tiver
um Shell semelhante ao Unix, você deve, em vez disso, definir sua variável SHELL com um valor que termina em "sh"
ou "sh.exe" antes chamando makepp.

Padrão: O primeiro encontrado entre "/ usr / xpg4 / bin / sh" (por exemplo, Solaris) ou "/ sbin / xpg4 / sh"
(por exemplo, Reliant Unix) ou "/ Bin / sh".

YACC
Padrão: O primeiro encontrado entre "bison -y" ou "yacc".

Variáveis e Perl
Os valores das variáveis ​​são armazenados como escalares Perl comuns, para que você possa acessá-los diretamente do
Código Perl se você precisar fazer qualquer manipulação complicada com eles; veja makepp_extending
para obter detalhes.

O acesso às variáveis ​​globais do Perl é obtido prefixando-as com "Mpp :: global"
pacote. Na verdade, qualquer variável, ainda não presente no makefile atual, e que você
atribuir a neste pacote será, a partir de então, global, como se você tivesse acabado de emitir o
declaração "global" para ele.

No entanto, este acesso direto está sujeito a erros! O usuário pode ter substituído essas variáveis
na linha de comando ou por meio do ambiente. Algum outro makefile carregado antes deste
pode-se ter tornado a variável global ou específica do alvo. Nestes casos, você não
encontrar o valor da variável, ou ao atribuí-lo, pode tirar sua propriedade
(equivalente a um modificador de "substituição", exceto para especificações de destino.)

Com o acesso direto você também ignora a expansão dessas variáveis, se forem do tipo
"=" ou "; =". Variáveis ​​especiais como "$ (CC)" começam como funções, até que sejam
atribuído a. Portanto, em muitos casos, você não verá seu valor.

Por essas razões, é melhor deixar o makepp determinar o valor correto. Você pode usar o
variante "makeperl", em que a variável foi avaliada antes de o código Perl obter
interpretado:

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

Se você precisa de uma variável nos blocos perl do makefile, isto é conseguido através da variável Perl
$ makefile da seguinte forma:

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

As funções sempre obtêm o objeto makefile passado como o segundo argumento $ _ [1]:

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

Os comandos devem ser chamados dentro de uma ação de regra, onde o objeto makefile é
acessível via "$ Mpp :: Subs :: rule -> {MAKEFILE}":

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

Use makepp_variables online usando serviços onworks.net