makepp_incompatabilities - Online na nuvem

PROGRAMA:

NOME

makepp_incompatabilities - Incompatibilidades entre makepp e GNU make

DESCRIÇÃO

Makepp foi projetado para ser o mais próximo possível do GNU make
(<http://www.gnu.org/software/make/manual/make.html>). GNU autotools
(<http://www.gnu.org/software/automake/manual/automake.html>), CMake
(<http://www.cmake.org/>), Premake (http://industriousone.com/premake> e veja a observação
abaixo) ou sistemas de compilação legados feitos à mão devem ser compiláveis ​​com makepp. Isto é tão
você pode migrar projetos sem esforço. Ou se você não quiser aproveitar tudo de
vantagens do makepp (por exemplo, para que outros ainda possam construir seu projeto com GNU make) enquanto você
lucre com a vantagem de confiabilidade para o seu desenvolvimento.

No entanto, por causa da diferença de filosofia, alguns dos makes do GNU ou POSIX
(<http://pubs.opengroup.org/onlinepubs/009695399/utilities/make.html>) os recursos não podem ser
suportado. Alguns não foram implementados porque não tivemos tempo. A maioria dos
diferenças do GNU make são bastante técnicas e raramente causam problemas. Ai de
soluções alternativas para as deficiências da marca tradicional estão se tornando cada vez mais complexas,
e estão dificultando o make do makepp.

Em suma, se não for montado fora da caixa, tente:

makepp --no-warn makepp_simple_concatenation = 1 makepp_percent_subdirs = 1 \
--build-check = target_newer --last-chance-rules --no-remake-makefiles

Se conseguir, você pode tentar eliminar esses argumentos um por um. Mas se isso falhar,
tente adicionar:

--tradicional-recursivo-make

Se isso também falhar, o sistema de construção precisa de alguns ajustes para cooperar com o makepp. Até
se algumas opções descritas aqui tornam algo edificável, ainda é recomendado adaptar
ligeiramente, para que se tornem compatíveis fora da caixa com ambas as marcas.

Forçando mais POSIX or GNU fazer compatibilidade

Aqui estão algumas possibilidades de linha de comando para fazer muitos sistemas de compilação legados funcionarem
sem modificação. Eles fazem com que o makepp emule o comportamento do GNU make com precisão.

Compatibilidade via que o opção: "--build-check = target_newer"
Por padrão, o makepp tentará reconstruir todos os destinos se qualquer uma das dependências tiver
mudou desde a última compilação, ou se o comando mudou (veja makepp_build_check para
detalhes). Normalmente é isso que você deseja. Às vezes, no entanto, você não quer o alvo
a ser reconstruído se tiver sido modificado fora do controle do makepp (por exemplo, editando
ou executando um programa manualmente para criar o arquivo). Você pode forçar o makepp a usar o
algoritmo de make tradicional, que só reconstrói se algum dos alvos for mais recente que o
dependências, adicionando esta opção à linha de comando.

Compatibilidade via que o opção: "--dont-build = config.status"
Existem pacotes que tentam se autoconfigurar, ou fazem outras coisas, que gmake
ignora a menos que seja solicitado, como:

config.status: configure
./config.status --recheck

configure: configure.in aclocal.m4
autoconf

A maioria das pessoas nem mesmo tem o "autoconf" instalado, então conscienciosamente fazendo tudo
as regras, como faz o makepp, irão falhar. Esta opção evita que, se você descobrir o que
não construir.

Compatibilidade via que o opção: "- regras da última chance"
As regras padrão (regras de padrão sem dependências de padrão) normalmente não são suportadas.
O Makepp instancia todas as regras com base nos arquivos existentes, de modo que esteja ciente de cada
arquivo que pode ser gerado. Infelizmente, desta forma ele não sabe como instanciar um padrão
regra sem dependência de padrão. O mecanismo: last_chance corrige parcialmente isso.
Onde isso é bom o suficiente para makefiles legados, esta opção permite ativá-lo globalmente.

Compatibilidade via que o opção: "--não avisar"
Este não melhora o resultado. O makepp irá dar mensagens de aviso para muitas coisas
que o Unix tradicional faz, aceita sem vacilar. Isso é porque existem
melhores maneiras de fazê-los com makepp. Se esses avisos o incomodam, você pode desativá-los
com esta opção.

Compatibilidade via que o opção: "--hybrid-recursive-make"
As invocações recursivas de make são frequentemente consideradas uma prática insegura (consulte "Melhor
sistema para construções hierárquicas "no makepp para detalhes), mas são extremamente comuns em
makefiles existentes. Makepp suporta make recursivo para compatibilidade com versões anteriores; para novo
makefiles, é muito melhor usar a instrução "load_makefile" ou o implícito do makepp
mecanismo de carregamento de makefile.

A fim de ser capaz de usar repositórios para versões variantes, e para ajudar a tornar recursiva
invocações de make seguro, makepp normalmente não invoca a si mesmo recursivamente
mesmo se você disser. Em vez disso, um subprocesso se comunica com o processo pai e
a construção real é feita pelo processo pai.

Isso funciona na maioria dos casos, mas você não pode invocar vários makefiles do mesmo
diretório, por exemplo, o seguinte não funcionará:

alvo: dependências
$ (MAKE) -f alvos de other_makefile

Nesse caso, o makepp percebe que está carregando um segundo makefile e reclama. Com esta opção
em vez disso, ele voltará à forma tradicional de construção a partir de makefiles adicionais em
um processo makepp separado para cada um.

Nota: Tecnicamente, carregar vários makefiles não seria problema, mas eles geralmente têm o
mesmos nomes falsos de destino. Manter isso separado significaria uma reformulação completa do makepp
internals. No entanto, isso funcionará, mas não é equivalente:

alvo: dependências
cd subdir && $ (MAKE) -f other_makefile targets

Compatibilidade via que o opção: "--traditional-recursive-make"
Às vezes, a opção anterior não é suficiente, especialmente se as invocações recursivas usam
opções contraditórias. Makepp usa apenas um conjunto de opções globais, então um submake não é
permitido modificá-los, pois isso também pertenceria a outros makefiles.

Adicionar esta opção à linha de comando tem os seguintes efeitos colaterais indesejáveis:

· As marcas recursivas não são executadas em paralelo internamente, mesmo que o pai o faça.
Ao contrário do gmake, não há coordenação geral do número de processos. Isso vai
não deve ser implementado porque essa forma de trabalhar não é um objetivo de design do makepp.

· Os processos make recursivos não sabem nada sobre repositórios.

· Cada processo make recursivo produz seu próprio arquivo de log, no diretório que é invocado
em, em vez de produzir um arquivo de log para toda a construção.

· Uma vez que o makepp geralmente constrói mais do que o make tradicional considera necessário, e uma vez que muitos
sistemas de construção fornecem chamadas recursivas em todas as direções, o que pode levar a intermináveis
recursão. Makepp irá puxar o freio após 50 rodadas e lhe dirá como aumentar
isso, caso você realmente tenha um aninhamento tão profundo.

Mesmo com a opção "--traditional-recursive-make", as variáveis ​​de ambiente
"MAKEOVERRIDES" e "MFLAGS" não são configurados e são ignorados, então makefiles que dependem de
aqueles não vão funcionar.

A Pré-fabricação gerado Makefile é apenas um wrapper engraçado para uma invocação de sub-make no mesmo
diretório. Se você tem algum objetivo de projeto XYZ terá uma linha como

@ $ {MAKE} --no-print-directory -C. -f XYZ.make

Neste caso você pode evitar a opção "--traditional-recursive-make" invocando diretamente
makepp com aquele "-f XYZ.make " opção.

Compatibilidade sem que o opção: "- empregos =n"
Makefiles legados às vezes não listam todas as dependências, dependendo da ordem de
execução para torná-los a tempo. Nesta situação, o makepp pode conseguir chamar uma regra antes
suas dependências foram todas feitas. Então os resultados podem ser melhores com menos, ou mesmo sem
execução paralela.

Compatibilidade via que o variável: "makepp_simple_concatenation = 1"
A substituição de estilo Rc é a forma padrão que o makepp realiza a substituição de variáveis ​​em texto
strings porque muito raramente quebra os makefiles legados e muitas vezes é útil em novos
makefiles. No entanto, introduz incompatibilidades ocasionais na substituição de
variáveis ​​não circundadas por espaços. Por exemplo,

INCLUDE_PREFIX: = -I / some / include / dir -I
INCLUI: = $ (INCLUDE_PREFIX) / outro / incluir / dir

irá definir "INCLUDES" para "-I / some / include / dir / other / include / dir -I / other / include / dir" se rc-
a substituição de estilo está habilitada, enquanto o GNU make iria configurá-lo para
"-I / algum / incluir / dir -I / outro / incluir / dir". Por exemplo, ao compilar o Redis 2.6.5, ele tenta
execute "printfgcc". Essa concatenação engraçada de dois comandos é uma forte indicação de que
essa variável é necessária para retroceder para fazer a semântica.

Também há uma incompatibilidade no tratamento de espaços em branco em uma variável:

nulo: =
T: = -o $ (null) # T contém -o seguido por um espaço.
OUTFILE = $ (T) arquivo de saída

irá definir "OUTFILE" para "-ooutfile" se a substituição no estilo rc estiver habilitada, enquanto o GNU make
iria configurá-lo para "-o outfile".

Ambas as incompatibilidades são removidas definindo o "makepp_simple_concatenation"
variável. Observe, no entanto, que mesmo com "makepp_simple_concatenation", makepp ainda
trata o espaço em branco de forma incompatível em algumas situações:

T: = -o # Não exclua este comentário.

GNU make define "T" para conter "-o" seguido por um espaço, enquanto makepp remove o
espaço à direita de qualquer maneira. Se você quiser o espaço final, você deve definir
"makepp_simple_concatenation" e também definir "T" usando a técnica que envolve um manequim
variável como "null", conforme mostrado acima.

Solução opção "--no-remake-makefiles"
O código-fonte aberto típico requer a chamada de "configure" para criar os makefiles. Mas então estes
makefiles podem conter regras para refazer o makefile, chamando algum comando. Makepp irá
felizmente cumpra e atualize-o de acordo com a regra. Mas às vezes isso é prejudicial, então
apenas pule.

Compatibilidade via que o variável: "makepp_percent_subdirs = 1"
Por padrão, "%" em uma regra de padrão não corresponde a diretórios. Isso significa que uma regra como
esta:

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

não será aplicado a arquivos como "../shared/xyz.c". Se você quiser que ele corresponda a arquivos em
subdiretórios também, em seguida, defina a variável "makepp_percent_subdirs = 1" na linha de comando
ou próximo ao início de um makefile.

Compatibilidade via que o meio Ambiente variável: $ MAKEPP_IGNORE_OPTS
Às vezes, as invocações recursivas legadas passam opções que o makepp não entende.
Esperançosamente, a opção não é importante, mas impede que o makepp seja executado. Com isso
variável de ambiente você pode pedir ao makepp para ignorar silenciosamente certas opções. O valor que
deve ser uma lista de opções separada por espaços, que pode vir em 4 variantes:

--longo=x
Uma opção longa que espera um argumento. Este fato deve ser declarado por meio dos iguais
sinal, embora o uso real também possa ser separado por espaços em branco, "--long = bla" ou
"--long bla".

--longo
Uma longa opção sem argumento.

-sx Uma opção curta que espera um argumento. Este fato deve ser declarado adicionando
algo diretamente após a opção, embora o uso real também possa ser separado por
espaço em branco, "-sbla" ou "-s bla".

-s Uma opção curta sem argumento.

Por exemplo, sobrescrever a opção -R do makepp por um sem um argumento e aceitar a depuração do gmake
opção com um argumento:

exportar MAKEPP_IGNORE_OPTS = '- R --debug = x'

Incompatibilidades que requerer Makefile alterar

· Makefiles que chamam explicitamente o make evitam que o makepp crie tudo sozinho.
O próprio "ExtUtils :: MakeMaker" de Alas Perl compromete a segunda das duas formas seguintes de
este erro até a versão 6.56 (Perl 5.12.1):

subdiretório:
cd subdir; faço

FAZER = fazer

· Definir a variável "VPATH" para algum valor chama implicitamente "vpath% value". "vpath"
declarações são emuladas com o mecanismo de repositório. Então, onde o gmake substitui
o caminho para o arquivo encontrado no vpath, makepp irá vinculá-lo simbolicamente a
onde é necessário. Assim, o makepp fornecerá uma string não modificada, que geralmente é
não é um problema.

Os destinos em um vpath não são suportados. (Gmake os considera se eles forem mais novos que
suas dependências, mas se não, o destino será recriado no diretório atual
- bastante inconsistente.) A desconfiguração de vpaths não é suportada.

· Uma regra de padrão presente posteriormente em um makefile substitui uma que estava presente anteriormente.
Este é o retrocesso do GNU make.

· O conjunto de regras implícitas embutidas é um pouco diferente daquelas para o GNU make,
embora os nomes das variáveis ​​sejam amplamente compatíveis. As regras embutidas devem
compilar programas C / C ++ / Fortran com sucesso e, de fato, pode ser capaz de adivinhar o
bibliotecas adequadas em alguns casos também. Suporte para Modula-2 e RatFor e outros raros
idiomas está deliberadamente ausente, porque eu continuei tendo problemas com o GNU
regras do make quando reutilizei acidentalmente as extensões para esses idiomas.

· Um prefixo de ação "+" é silenciosamente ignorado.

· Membros do arquivo não são suportados, nem as variáveis ​​automáticas associadas
$%, "$ (% D)" e "$ (% F)".

· Não há suporte para SCCS.

· Espaços em branco à esquerda e à direita em atribuições de variáveis ​​são ignorados (mesmo se o
o espaço em branco é seguido por um comentário). Para obter mais detalhes sobre o manuseio de espaços em branco
incompatibilidades, consulte "Espaços em branco nas variáveis" em makepp_variables.

· Makepp não tenta reconstruir arquivos incluídos com a instrução "include" a menos que
o makefile contém uma regra para construí-los antes que a instrução include seja vista.
(Ele tentará reconstruir o próprio makefile, no entanto.) Isso normalmente é usado para
manipulação incluem dependências de arquivo, e não é tão útil com makepp, uma vez que você não
precisa fazer isso de qualquer maneira.

· A variável "SHELL" está parcialmente ignorada. Makepp sempre usa / Bin / sh
a menos que / usr / xpg4 / bin / sh or / sbin / xpg4 / sh for encontrado ou a menos que você exporte o "SHELL"
variável em seu makefile. Mas se você fizer isso, o analisador de comandos pode não ser totalmente
entenda o que seu comando shell faz. No Windows Strawberry ou ActiveState Perl
você deve, em vez disso, definir sua variável SHELL antes chamando makepp.

· Dependências de qualquer coisa no Makefile ainda funcionam, mas geralmente são desnecessárias.
Isso geralmente é usado para forçar uma reconstrução quando as opções de compilação são alteradas. Makepp sabe
quando os comandos de construção foram alterados sem nada de especial no makefile; armazena
isso em uma base de arquivo por arquivo. Se você alterar o makefile, ele saberá exatamente qual
os arquivos precisam ser recompilados.

· Arquivos intermediários não são excluídos. (Porque makepp insiste em ter todo o arquivo
as datas devem ser iguais às da última compilação, todos os arquivos intermediários devem ser
presente ou então reconstruções ocorrerão.) Não há nenhum status especial concedido a
arquivos intermediários.

· O único destino especial suportado é ".PHONY" e parcialmente ".SUFFIXES". o
os restantes são simplesmente ingeridos.

Especificamente, o GNU make tem os seguintes alvos especiais:

.SUFIXOS
Makepp ignora ".SUFFIXES" exceto para o caso especial de ".SUFFIXES" sem
dependências, como esta:

.SUFIXOS:

que diz a ele para não carregar nenhuma de suas regras padrão.

.INTERMEDIÁRIO, .SECUNDÁRIO, .PRECIOSO
Nenhum status especial é concedido aos arquivos intermediários e, portanto, esses alvos não são
significativo.

.IGNORAR
Este alvo é ignorado. Se você quiser ignorar os erros, coloque a palavra "ignore_error"
(ou um sinal de menos) na frente do comando cujo status de saída deve ser ignorado.

.SILENCIOSO
Este alvo é ignorado. Se você quiser que os comandos não ecoem, coloque a palavra "noecho"
(ou o caractere "@") na frente do comando que não deve ser ecoado,
ou use a opção "--silent" para fazer o makepp.

.DELETE_ON_ERROR
.EXPORT_ALL_VARIABLES
.NOEXPORT
.POSIX
.PADRÃO
Esses destinos não são suportados e são simplesmente ignorados.

· As funções GNU make "eval", "flavour" e "value" não são suportadas atualmente. Vocês
pode conseguir o mesmo que eval de uma forma mais direta com "$ [...]"
expansão de variável ou função.

· As regras de dois pontos duplos não são totalmente suportadas. (Eles não podem ser: no paradigma do makepp,
não pode haver mais de uma maneira de atualizar um alvo.) Atualmente, cada uma
regra de dois pontos duplos para um determinado alvo simplesmente anexa sua string de comando e dependência
list para a string de comando e lista de dependências para este destino. Por exemplo, se você
escreva isso:

um :: b
& cat b -oa

# Mais tarde em seu makefile:
um :: c
& cat c -o >> a

isto é exatamente o mesmo como se você tivesse escrito

a: bc
& cat b -oa
& cat c -o >> a

Certamente não é para isso que as regras de dois pontos se destinam, e nem sempre
funciona, mas funciona para destinos como "limpar" ou para todas as coisas que
ExtUtils :: MakeMaker coloca em seus makefiles. Não conte com isso para outra coisa
do que makefiles legados.

· A função "$ (curinga)" corresponde não apenas aos arquivos existentes, mas também aos arquivos
ainda não existem, mas que têm uma regra que makepp viu na época o
A função "$ (curinga)" é avaliada.

· A instrução "define" é suportada, mas o tratamento de "@" anterior é feito
de forma diferente. Atualmente no makepp, "@" na frente de uma variável que tem várias linhas
valor suprimirá apenas o eco da primeira linha. Por exemplo,

definir linhas de eco
& echo linha1 -o $ @
& echo linha2 -o >> $ @
fim

x:
@ $ (linhas de eco)

não irá suprimir a impressão de "& echo line2" como faz no GNU make; vai apenas
suprimir a impressão de "& echo line1".

· Makepp não suporta as seguintes variáveis ​​de ambiente (não as configura,
e simplesmente os ignora):

REFORMA
MFLAG

Incompatibilidades in ordem of expressão expansão
· No makepp, as ações da regra são expandidas antes que todas as dependências sejam garantidas para
foram construídos. Você pode contornar isso alterando regras como estas:

foo: barra
genfoo <$ (shell cat bar)

para isso:

foo: barra
genfoo <`cat bar`

ou isto, que fará com que o arquivo durante a expansão:

foo: barra
genfoo <$ (& cat $ (fazer barra))

Isso é preferível aqui, porque o arquivo listado em Barra também é uma dependência deste
regra, e makepp agora pode pegá-lo ao analisar lexicamente o redirecionamento.

· Embora eu não tenha visto isso sendo usado, o GNU make permite o seguinte:

dois pontos =:
a $ (dois pontos) b
echo $ ^

Makepp expande "$ (dois pontos)" tarde demais para que isso funcione. No entanto, oferece o
sintaxe alternativa "$ [dois pontos]", que pode fazer muito mais do que GNU make, porque é
expandido muito cedo.

"$ (MAKE)" pode incluir espaços
Em um makepp desinstalado ou se a plataforma não parece suportar a inicialização de um script Perl
por número mágico ou com "--traditional-recursive-make" esta variável irá incluir pelo menos
um espaço. Isso não é um problema ao usá-lo como um comando. Mas ao passar como um
parâmetro não cotado para um script (como o sistema de compilação Perl 5.14.0 faz), ele irá rasgá-lo
separados em parâmetros separados, levando à confusão. Portanto, como parâmetro, é mais seguro
cite-o como '$ (MAKE)'. que não quebra a compatibilidade com versões anteriores.

Alvo específico atribuições não propagar
As variáveis ​​específicas do alvo do Makepp são ligeiramente diferentes das do GNU make's no sentido de que
aplica-se apenas à regra para o arquivo mencionado, e não a qualquer de seus predecessores; Vejo
Atribuições específicas de destino.

Parênteses or suspensórios não ninho
O makepp termina as expressões no primeiro parêntese ou chave correspondente. Em vez disso

$ (alguma função ... () ...) # estilo GNU make

você deve usar qualquer um destes

$ {somefunction ... () ...} # GNU torna compatível
$ ((alguma função ... () ...)) # Extensão Makepp

Isso provavelmente será corrigido na versão 2.1, talvez opcionalmente.

Menor pontos
Dependências de padrão não correspondem a alvos falsos
% .a:% .b; ...
$ (falso xb):; ... # não fornece uma maneira de construir xa

Os comentários não têm linhas de continuação
# Isto é \
NÃO é um comentário de 2 linhas

Command linha incompatibilidades

Makepp suporta algumas das opções de linha de comando mais úteis do make. A seguir, no entanto,
não são suportados:

-d ou --debug
-f-
Os objetos makefile internos do Makepp estão vinculados a objetos de arquivo, por isso não podem manipular
padrão

-i
-l ou --load-average ou --max-load
-m A opção "-m" do Makepp tem a ver com a seleção do método de assinatura, enquanto o GNU make
ignora -m.

-p ou --print-data-base
-q ou --question
-R ou --no-builtin-variables
A opção "-R" do Makepp realmente faz algo completamente diferente.

-S --no-keep-going ou --stop
A opção "--stop" para (coloca para dormir) o makepp após aprender todas as regras, então você
pode continuar editando.

-t ou --touch
-w ou --print-directory
Isso acontece automaticamente.

--warn-variáveis-indefinidas

Alguns deles podem ser facilmente suportados, se alguém se importar.

Variável incompatibilidades

Makepp procura em $ PATH por um comando correspondente para retornar por variáveis ​​como "$ (CC)" ou
"$ (CXX)", enquanto o GNU make tem padrões estáticos. Também makepp dá preferência a "gcc" e
"g ++" enquanto o GNU make surpreendentemente retorna "cc" para o primeiro, mas o mesmo para o
último. Você pode substituí-los no makefile, na linha de comando ou exportando um
variável com o mesmo nome antes de invocar o makepp.

Use makepp_incompatabilities online usando serviços onworks.net