É automácea e autoconf a maneira padrão de compilar o código?
Às vezes compile aplicativos da fonte e eu estava usando:
./configure
make
Sudo make install
Mas recentemente, me deparei ./autogen.sh que gera a configuração e torna os scripts para mim e os executa.
Quais outros métodos para simplificar a compilação C/C++/C # (mono)? Fazer parece um pouco velho. Existem novas ferramentas lá fora? Dada a escolha, qual deles devo usar?
Autoconf e automácea foram estabelecidos para resolver um problema evolucionário do Unix.
Como o UNIX evoluiu para diferentes direções, os desenvolvedores que desejavam o código portátil tendiam 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
Como o UNIX foi bifurcado em diferentes implementações (BSD, SystemV, muitos garfos de fornecedores, e posteriormente Linux e outros sistemas semelhantes a UNIX) tornou-se importante para os desenvolvedores que queriam escrever código portátil para escrever código que dependia de uma marca específica de sistema operacional , mas em recursos expostos pelo sistema operacional. Isso é importante porque uma versão UNIX apresentaria um novo recurso, por exemplo, a chamada do sistema "Enviar" e, posteriormente, outros sistemas operacionais adotariam. Em vez de ter um espaguete de código que verifiquei as marcas e versões, os desenvolvedores começaram a investigar por recursos, então o código se tornou:
#if HAVE_SEND
Use Send here
#else
Use something else
#endif
Mais README arquivos para compilar o código-fonte de volta nos desenvolvedores pontiagudos dos anos 90 para editar um arquivo config.h e comentar que os recursos adequados disponíveis no sistema ou enviariam arquivos padrão para cada configuração do sistema operacional que foi testada.
Este processo foi incômodo e propenso a erros e é assim que o AutoConf chegou a ser. Você deve pensar no AutoConf como uma linguagem composta de comandos de shell com macros especiais capazes de substituir o processo de edição humana da config.h com uma ferramenta que sondou o sistema operacional para a funcionalidade.
Você normalmente escreveria seu código de sondagem no arquivo configure.ac e, em seguida, executar o comando autoconf que compilaria esse arquivo para o comando executável de configuração que você viu usado.
Então, quando você executa ./configure && make Você estava procurando para os recursos disponíveis em seu sistema e, em seguida, construir o executável com a configuração que foi detectada.
Quando os projetos de código aberto começaram a usar os sistemas de controle de código-fonte, ele fez sentido verificar no arquivo configure.ac, mas não o resultado da compilação (configure). O Autogen.SH é meramente um pequeno script que invoca o compilador AutoConf com os argumentos de comando corretos para você.
-
A automake cresceu também das práticas existentes na comunidade. O projeto GNU padronizou um conjunto regular de alvos para makefiles:
make allConstruiria o projetomake cleanRemoveria todos os arquivos compilados do projetomake installInstalaria o software- coisas como
make distemake distcheckPrepararia a fonte para distribuição e verificou que o resultado foi um pacote completo de código-fonte - e assim por diante...
Construindo makefiles compatíveis se tornou onerosa porque havia muita boilerplata que foi repetida repetidamente. Assim, a automapaça foi um novo compilador que integrado com o Autoconf e processou "fonte" de makefile (nomeado Makefile.am) em makefiles que poderiam ser alimentados ao AutoConf.
O automáctico/AutoConf Toolchain usa uma série de outras ferramentas auxiliares e são aumentadas por outros componentes para outras tarefas específicas. À medida que a complexidade de executar esses comandos em ordem cresceu, a necessidade de um roteiro pronto para correr nasceu, e é onde veio Autogen.sh.
Tanto quanto eu sei, o Gnome foi projeto que introduziu o uso desse script auxiliar Autogen.sh
Existem dois "grandes jogadores" nesta área; Cmake e GNU AutoTools.
O GNU AutoTools é o GNU maneira de fazer as coisas, e é bastante focado em * nix. É uma espécie de sistema de meta-build, fornecendo um conjunto de ferramentas que geram configuração específica e fazer arquivos para o que Você está tentando fazer. Isso ajuda a criar mais alterações no seu código sem ter que manipular diretamente o seu sistema de compilação, e isso ajuda os outros a criar seu código de maneiras que você não projetou - sob * NIX.
Cmake é a maneira de plataforma cruzada de fazer as coisas. A equipe Cmake constrói software em muitas maneiras diferentes, com GCC, Visual Studio, Xcode, Windows, OSX, Solaris, BSD, GNU/Linux, o que for. Se você estiver preocupado com a portabilidade da sua base de código, este é o caminho a percorrer.
Como foi mencionado, algumas pessoas parecem gostar de scons. Se você estiver familiarizado com Python Isso pode fornecer mais consistência em seu ambiente de trabalho.
Ruby também tem uma espécie de sistema de meta-build chamado Rake, que é muito legal em seu próprio direito, e é muito útil para aqueles já familiarizados com o Ruby.
SCONS é um substituto possível, embora não tenha experiência pessoal. Também é implementado em Python, que poderia ser um problema, dependendo do ambiente de construção.
Se você estiver usando o C #/Mono, você pode usar o MSBuild (os arquivos .sln/.csproj usados pelo monodevelop e do Visual Studio) para gerenciar todo o seu processo de compilação.
Você pode então construir de monodevelop ou executar o comando xbuild no seu terminal favorito (funciona melhor em mono> = 2.6). Isso é extremamente fácil e requer praticamente nenhum trabalho de sua parte, porque o monodevelop lidará com os arquivos do MSBuild para você, e você não precisará editá-los a menos que você queira ajustar as coisas além do que a interface do monodevelop pode fazer por você.
Eu não estou familiarizado com como as pessoas que dependem do MSBUild lidam com as instalações para seus projetos, mas você sempre pode perguntar isso. ;-)
Para C # você pode usar o Xbuild (e MSBuild no Windows), o que irá construir o projeto de seus arquivos de projeto.