☰

Automake e autoconf são a maneira padrão de compilar código?

tag-icon • tag-icon compiling programming
Automake e autoconf são a maneira padrão de compilar código?

Às vezes compilo aplicativos a partir do código-fonte e tenho usado:

./configure
make
sudo make install

Mas recentemente, descobri ./autogen.shque gera os scripts configure e make para mim e os executa.

Que outros métodos existem para agilizar a compilação C/C++/C#(mono)? Make parece um pouco antigo. Existem novas ferramentas por aí? Dada a escolha, qual devo usar?

Responder1

Autoconf e Automake foram criados para resolver um problema evolutivo do Unix.

À medida que o Unix evoluiu em direções diferentes, os desenvolvedores que queriam código portátil tenderam a escrever código como este:

#if RUNNING_ON_BSD
Set things up in the BSD way
#if RUNNING_ON_SYSTEMV
Set things up in the SystemV way
#endif

À medida que o Unix foi bifurcado em diferentes implementações (BSD, SystemV, muitos forks de fornecedores e, posteriormente, Linux e outros sistemas semelhantes ao Unix), tornou-se importante para os desenvolvedores que queriam escrever código portátil escrever código que não dependesse de uma marca específica de sistema operacional. , mas em recursos expostos pelo sistema operacional. Isto é importante porque uma versão Unix introduziria um novo recurso, por exemplo a chamada de sistema "send", e posteriormente outros sistemas operacionais a adotariam. Em vez de ter um espaguete de código que verificava marcas e versões, os desenvolvedores começaram a investigar os recursos, então o código se tornou:

#if HAVE_SEND
Use Send here
#else
Use something else
#endif

A maioria dos arquivos README para compilar o código-fonte na década de 90 apontava os desenvolvedores para editar um arquivo config.h e comentar os recursos adequados disponíveis no sistema, ou enviariam arquivos config.h padrão para cada configuração de sistema operacional que foi testada.

Esse processo era complicado e sujeito a erros e foi assim que o Autoconf surgiu. Você deve pensar no Autoconf como uma linguagem composta de comandos shell com macros especiais que foram capazes de substituir o processo de edição humana do config.h por uma ferramenta que testou a funcionalidade do sistema operacional.

Você normalmente escreveria seu código de teste no arquivo configure.ac e então executaria o comando autoconf que compilaria este arquivo para o comando configure executável que você viu ser usado.

Portanto, ao executar, ./configure && makevocê estava testando os recursos disponíveis em seu sistema e, em seguida, construindo o executável com a configuração que foi detectada.

Quando os projetos de código aberto começaram a usar sistemas de controle de código-fonte, fazia sentido verificar o arquivo configure.ac, mas não o resultado da compilação (configure). O autogen.sh é apenas um pequeno script que invoca o compilador autoconf com os argumentos de comando corretos para você.

--

A Automake também cresceu a partir de práticas existentes na comunidade. O projeto GNU padronizou um conjunto regular de alvos para Makefiles:

  • make allconstruiria o projeto
  • make cleanremoveria todos os arquivos compilados do projeto
  • make installinstalaria o software
  • coisas como make diste make distcheckprepararia o código-fonte para distribuição e verificaria se o resultado era um pacote de código-fonte completo
  • e assim por diante...

Construir makefiles compatíveis tornou-se trabalhoso porque havia muitos clichês que eram repetidos indefinidamente. Portanto, o Automake era um novo compilador que se integrava ao autoconf e processava Makefiles de "fonte" (chamados Makefile.am) em Makefiles que poderiam então ser alimentados no Autoconf.

A cadeia de ferramentas automake/autoconf na verdade usa uma série de outras ferramentas auxiliares e elas são aumentadas por outros componentes para outras tarefas específicas. À medida que a complexidade de executar esses comandos em ordem crescia, nasceu a necessidade de um script pronto para execução, e foi daí que veio o autogen.sh.

Pelo que eu sei, o Gnome foi um projeto que introduziu o uso deste script auxiliar autogen.sh

Responder2

Existem dois “grandes jogadores” nesta área; Cmake e GNU Autotools.

  • GNU Autotools é a maneira GNU de fazer as coisas e é bastante focado em *nix. É uma espécie de sistema de meta-construção, fornecendo um conjunto de ferramentas que geram configurações específicas e criam arquivos para o que você está tentando fazer. Isso ajuda você a fazer mais alterações em seu código sem ter que manipular diretamente seu sistema de compilação e ajuda outros a construir seu código de maneiras que você não havia projetado - no *nix.

  • Cmake é a maneira multiplataforma de fazer as coisas. A equipe Cmake constrói software de muitas maneiras diferentes, com GCC, Visual Studio, XCode, Windows, OSX, Solaris, BSD, GNU/Linux, qualquer que seja. Se você está preocupado com a portabilidade de sua base de código, este é o caminho a seguir.

Como foi mencionado, algumas pessoas parecem gostar de Scons. Se você estiver familiarizado com Python, isso poderá fornecer mais consistência em seu ambiente de trabalho.

Ruby também tem uma espécie de sistema de meta-construção chamado Rake, que é muito legal por si só e é muito útil para aqueles que já estão familiarizados com Ruby.

Responder3

Desconsé um substituto possível, embora não tenha experiência pessoal. Também é implementado em Python, o que pode ser um problema, dependendo do ambiente de construção.

Responder4

Para C# você pode usar xbuild (e msbuild no Windows), que construirá o projeto a partir dos arquivos do seu projeto.

informação relacionada