makepp_build_algorithm - Online na nuvem

PROGRAMA:

NOME

makepp_build_algorithm - Como makepp executa um makefile

DESCRIÇÃO

Os componentes internos do Makepp diferem do make padrão do Unix de maneiras fundamentais. Esta página
descreve a filosofia diferente em detalhes.

Reverter vs para a frente inferência
Makepp funciona na direção oposta do make padrão do Unix. Marca Unix tradicional
recebe um alvo para construir e, em seguida, encontra uma regra que corresponde aos personagens no
nome do arquivo de destino. Se o destino for mais antigo do que qualquer uma de suas dependências da regra, ele
é reconstruído.

Por exemplo, considere esta regra de padrão:

% .o:% .cxx
$ (CXX) $ (CXXFLAGS) -c $ (entrada) -o $ (saída)

Quando o make percebe que precisa fazer um arquivo chamado "xyz.o", ele pesquisa em sua lista de
regras de padrão até ver que "xyz.o" corresponde ao padrão "% .o", e então se aplica
Esta regra.

Makepp funciona na direção oposta. Ele primeiro calcula todos os arquivos que pode possivelmente
construir aplicando regras que correspondem aos caracteres nos nomes de arquivo de dependência. Então quando
ele precisa construir um arquivo, ele simplesmente olha para ver se é um dos arquivos que conhece
como construir. A lista de arquivos conhecidos é armazenada com base no nome do arquivo absoluto.

Quando o makepp encontra a regra padrão acima, ele procura por todos os arquivos no diretório
correspondendo ao padrão "% .cxx" (ou seja, "* .cxx"). Para cada um desses arquivos, ele então se lembra
que ele pode produzir o arquivo ".o" correspondente. Se posteriormente o makepp descobrir que
pode fazer outro arquivo ".cxx" que não existe atualmente, esta regra também será aplicada
e o arquivo ".o" correspondente será marcado.

Isso pode parecer um pouco ineficiente, mas não é tão lento na maioria dos casos,
e muitas vezes é verdade que virtualmente todos os arquivos que podem ser compilados são de fato compilados.
E conhecer a lista completa de arquivos que podem ser construídos tem várias vantagens:

· Os curingas podem corresponder a arquivos que ainda não existem, mas podem ser criados.

· Arquivos de cabeçalho que foram detectados pelo verificador automático de dependência não têm
existir; makepp sabe onde eles estarão. (A maioria das outras soluções para este problema
suponha que quaisquer cabeçalhos que ainda não existam estejam no diretório atual.)

· Repositórios são muito mais simples de implementar, pois makepp sabe de antemão quais arquivos ele
pode fazer. (Veja makepp_repositories para detalhes.)

· É possível determinar facilmente quais arquivos podem ser construídos (veja o
função "$ (only_targets)".

· A função "$ (infer_objects)" do Makepp é bastante simplificada por saber o que são os objetos
disponíveis.

Arquivos vs textual padrões
Makepp associa comandos de construção a um arquivo de destino, não a um padrão textual para um
nome do arquivo. Portanto, não é confundido com nomes diferentes para o mesmo arquivo. Assim, para
exemplo, makepp saberá que "./xyz" e "xyz" são o mesmo arquivo, enquanto outro make
utilitários não podem.

Isto é particularmente importante porque (ao contrário do make padrão) makepp carrega makefiles
de diretórios diferentes. Para que os makefiles sejam relativamente independentes, com
nenhuma posição especial dada a um makefile de nível superior, cada makefile refere-se a todos os arquivos
em relação ao seu próprio diretório. Portanto, se você carregar um makefile do subdiretório
"other_stuff", e esse makefile se refere a "../xyz", makepp vai perceber novamente que é
o mesmo arquivo referido acima. (Também não será confundido com diretório vinculado por software
nomes.)

Armazenado construir INFORMAÇÕES
O Makepp armazena muito mais informações sobre cada arquivo que ele constrói além da data
carimbo (que é tudo o que o padrão faz se preocupa). Essas informações incluem:

· A assinatura deste arquivo na última compilação, para que possamos saber se o próprio arquivo possui
alterado.

· Os nomes de cada arquivo de dependência, incluindo arquivos de inclusão e outros arquivos inferidos
automaticamente. Se esta lista mudar, o makepp assume que precisa ser reconstruída.

· A assinatura de cada dependência. Dessa forma, o makepp sabe como reconstruir não só quando o
dependências são mais recentes do que o destino, mas quando elas mudam em tudo. Isso também faz
é possível usar outros tipos de assinaturas, como somas de verificação criptográficas, em vez
do que a data do arquivo.

· O comando de construção inteiro (e seu cwd). Desta forma, se você alterar o comando de construção
(por exemplo, mudar as opções do compilador), makepp sabe como reconstruir mesmo se os arquivos
eles próprios não mudaram.

· A arquitetura. Se você compilou seu programa no Linux e depois mude para
Solaris, makepp sabe automaticamente como recompilar tudo.

Makepp cria um subdiretório em cada diretório que toca, denominado ".makepp". o
construir informações para um arquivo nome do arquivo em um diretório é armazenado em .makepp / nome do arquivo. Se
você deletar este subdiretório ou alterar os arquivos, makepp irá reconstruir todos os arquivos afetados.

Implícito carregamento
Se makepp está tentando construir um alvo em um diretório e não tem uma regra para isso ainda,
ou se estiver procurando por arquivos que correspondam a um caractere curinga em um diretório, ele irá procurar
diretório para ver se um makefile está presente. Se for assim, o makefile será carregado
automaticamente.

Isso significa que você geralmente não precisa dizer explicitamente ao makepp onde encontrar
makefiles - tudo que você precisa fazer é referenciar um arquivo em outro diretório, e o makepp irá
descobrir automaticamente como construí-lo.

O carregamento implícito ocorrerá apenas se o diretório for gravável para você. Portanto, se você quiser
evite que o makepp tente construir um monte de coisas que nunca mudam, simplesmente faça o
diretório somente leitura.

O carregamento implícito não ocorrerá se você estiver em uma árvore sob um RootMakeppfile (.mk) e os votos de
outro makefile está fora dessa árvore. Se você quiser uma vez, você pode dar um
Opção "--do-build = /" para makepp, para fazer tudo fora da árvore construível. Se você
sempre quiser isso, você pode colocar uma instrução "load_makefile" em algum lugar dentro da árvore para
conecte-o explicitamente à árvore.

Se o carregamento implícito atrapalhar (ou seja, o makepp carrega muitos makefiles e desperdiça
tempo, ou então você realmente não quer tentar reconstruir todas as coisas descritas no
makefiles), você pode desligá-lo para todos os diretórios usando o comando "--noimplicit_load"
opção de linha, ou você pode desligá-lo para diretórios selecionados usando "no_implicit_load"
declaração em seu makefile.

Use makepp_build_algorithm online usando serviços onworks.net