ANT + cpptasks vs. scons vs. make

StackOverflow https://stackoverflow.com/questions/1034138

Pergunta

Eu estou olhando para scons e eu só quero ter certeza que eu sei quais são as alternativas, antes de I investir um pedaço de células cerebrais em algo completamente diferente. Estou usando o GNU make no passado, mas nunca foram particularmente feliz com isso.

Particularmente: por que não é Ant usado mais frequentemente com projetos C / C ++? (Dado que há formiga cpptasks ) Eu li alguns posts que dizem que Ant é mais orientada em torno de Java (obviamente), mas qual é a desvantagem para fazê-lo? E por que é scons muito melhor do que fazer?

Eu estou trabalhando com um cross-compilador para TI DSPs, normalmente há 20-50 arquivos cpp em um projeto. Esta parece ser a parte mais difícil na gestão de construção é a verificação de dependência automática. Tudo o resto é apenas mapeando listas de arquivos juntamente com conjuntos de opções do compilador.

Editar: e porque muda cross-compilação de alguma coisa? é um compilador que é executado da mesma forma gcc corridas, só que ele produz arquivos de objetos / executáveis ??que não será executado no meu PC.

Foi útil?

Solução

Para cruz compilar Acho que seus melhores escolhas são ou CMake ou Autotools . Especialmente se você pode compilar o código para múltiplas arquiteturas / plataformas. I tipicamente compilar um subconjunto do meu código na máquina nativo para fins de teste de unidade e todo ele para a plataforma alvo. CMake lida com isso especialmente bem, pois permite que você especifique onde as bibliotecas compiladas Cross Live. Então, em vez de procurar a cruz compilado libpng em / usr / lib, ele pode ser dito para olhar em / opt / arm-EABI-gcc / ou onde quer que você tem as bibliotecas cadeia ferramenta instalada em sua máquina de compilação. Você pode criar vários diretórios compilação para as diferentes variantes e manualmente compilar cada variante com marca, ou acionar o lote com um braindead make recursiva enrolado à mão.

Ant tem o inconveniente de que é basicamente tão bom ou tão ruim como Marca baunilha, com a desvantagem adicional de que você está usando algo que não é particularmente mainstream para C ou C ++. Você tem que lidar com todas as suas próprias dependências - tanto os internos, tais como arquivo C para arquivo de cabeçalho para dependências externas de biblioteca ou executáveis, e também como ter de ligação com bibliotecas 3o partido. Além disso, eu não acho que as tarefas Ant C são realmente mantido muito. Todo mundo que eu vi que usos Ant para C defende chamando GCC com tarefas exec.

SCons é melhor, mas compilação cruzada não é seu ponto forte. Não é um "sistema de construção", como CMake ou Autotools quer, é apenas uma ferramenta de construção. Como ele diz em seu wiki, é praticamente "Make em Python" . Ele tem construído em manipulação de dependências, porém, o que significa que não tem que rolar o seu próprio lá com "gcc -MM -MD" ou qualquer outra coisa, o que é uma vantagem sobre Marca. SCons também tem suporte para detectar bibliotecas 3o partido que estão instalados, mas a forma como normalmente é feito pode acrescentar muito para o seu tempo de compilação. Ao contrário de outros sistemas, SCons corre o estágio de verificação cada vez que você executá-lo, embora a maioria dos resultados são armazenados em cache. SCons também é famoso por seus tempos de construção longos, embora por 50 arquivos que não seria um problema. apoio compilação Cruz em SCons é inexistente - você tem que rolar seus próprios como discutido sobre este tópico na lista de discussão . Normalmente você forçar a compilação para ser como uma plataforma Unix, em seguida, substituir o nome do compilador C. Construção de múltiplas variantes ou separar o diretório de compilação do diretório de origem está cheio de armadilhas, o que torna menos adequado se você cruzar e nativamente-compilar o código.

CMake e Autotools ter os problemas de dependência descobri muito bem, e cruz apoio compilação autotools é amadurecer. CMake teve compilação cruz desde a versão 2.6.0, que foi lançado em abril de 2008. Você recebe esses recursos de graça, além de outros como embalagem e executar testes de unidade ( "check-make" ou metas semelhantes). A desvantagem para essas duas ferramentas é que eles exigem bootstrapping. No caso de CMake, você precisa ter o binário CMake instalado para criar o Makefiles ou arquivos de solução do Visual Studio. No caso de Autotools É um pouco mais complicado, porque nem todos os que compila o software precisaria automake e autoconf instalado, apenas aqueles que necessidade de mudar o sistema de construção (adicionando novos arquivos conta como mudar o sistema de compilação). O bootstrapping 2 stage (configure.ac -> configure, configure + Makefile.in -> Makefile). É conceitualmente um complicado pouco para entender

Para o edit: compilação Cruz é uma dor de cabeça extra na sistemas de compilação para a razão que acrescenta complexidade à detecção automática de programas e bibliotecas. SCons não deal com este problema, deixa que até você para classificar para fora. Ant semelhante não faz nada. Autoconf lida com isso no caso autotools, mas você pode ter que fornecer "--with-libfoobar = / some caminho /" na linha de comando quando você configurar ou rosto quebrado ligando quando ele tenta usar / usr / lib na fase de ligação . A abordagem da CMake é um pouco mais heavywieght com o arquivo toolchain, mas isso significa que você não tem que especificar todos vocês ferramentas e bibliotecas (CC, CXX, ranlib, --with-ibfoo =, etc), como eles são descoberto a partir de uma convenção padrão. Em teoria, você pode reutilizar um arquivo toolchain CMake adequadamente trabalhada em vários projetos para compilar cruz-los. Na prática CMake não é suficiente generalizada para fazer este conveniente para a sua hackers média, embora possa ser útil se você estiver criando vários projetos proprietários.

Outras dicas

Eu usei Ant + CppTasks fortemente alguns anos atrás para a construção de bases de código muito grande a ser integrados em novo código Java via JNI, e estava muito satisfeito com o resultado do incremento muito confiável versões do código C ++, boa flexility (em construir arquivos ou via ajustes para o código). MAS, CppTasks é um projeto com nenhuma comunidade eo mantenedor (Curt Arnold) não tem feito nada com ele por um longo tempo. Resta muito bom e útil, mas esteja ciente de que muito poucas pessoas sabem ou uso CppTasks (a forma como os compiladores "oferta" para arquivos morder-me, por exemplo, quando eu precisava de um compilador específico para arquivos C, eo compilador diferente C ++ estava escolhendo-os para cima em vez disso).

A forma CppTasks mantém o controle de opções de compilação e verifica dinamicamente fontes para dependências de cabeçalho, o tempo todo ainda rápido o suficiente (há alguns cache de dependências), significou o único sistema que eu trabalhei com quem teve incremento precisa constrói, algo muito importante na construção de bases de código muito grandes.

Então, como eu já disse algumas vezes nas listas de usuários / dev Ant, se você tem um monte de coisas Java e já tem um investimento em Formiga, e não têm medo de mergulhar o doc e o código de CppTasks, e agora precisa construir JNI código "cola", e / ou o "legado" bibliotecas nativas expõe o código de cola, é um concorrente de valor, e as recompensas podem ser grande.

I facilmente integrado para o Windows DLL para adicionar completa informação de versão, por exemplo, escrever um pouco tarefa Ant para formato de arquivo corretamente os res. Ela trabalhou para mim, mas Ant + CppTasks é definitivamente mais para o "avançado" IMHO usuário / desenvolvedor Ant.

Espero que isso ajude. --DD

Gostaria de recomendar terp para a construção de projetos C ++ a partir de ANT. Nós desenvolvemos terp porque ANT é a nossa ferramenta de construção escolhido e os CppTasks foram ficando um pouco longo no dente e porque queríamos trabalhar em um nível diferente de abstração. terp suporta um monte de diferentes compiladores e é apoiado por nossa empresa. Para a maioria de projeto não é livre embora.

Nós projetamos terp principalmente para reconstruções completas ao invés de compilações incrementais com análise de dependência. Estamos chegando lá, mas ele não está lá ainda. O ponto ideal para terp está em multi-plataforma, multi-procarch, lançamentos multi-compilador onde você não querem manter n diferentes configurações para todas as combinações. Neste ponto (julho '09) está em beta público, mas ele vai ser lançado em breve.

Eu tenho trabalhado em um projeto nos últimos cinco anos que faz x86 e braço constrói usando formiga. Nós mexido cpptasks para os nossos propósitos para produzir um compilador genérico que acabamos de passar em um prefixo para ... como o braço-gum-linux gnueabi- e, em seguida, que será anexado à ferramenta real tais como g ++ ou Ar ou o que quer. Nenhum meio de prefixo que você começa as plataformas de desenvolvimento de ferramentas de compilação. Os toolchains para a compilação cruzada tem esses prefixos em seus binários da ferramenta de construção. Quase toda a razão para ir com Ant, em vez de qualquer coisa fazer com base foi cpptasks capacidade de fazer inremental constrói e o emaranhado uttter de coisas que tem que acontecer para manter autoconf feliz. Somos capazes de suportar o paradigma que quase qualquer arquivo de origem, particularmente aqueles em uma estrutura de árvore de pastas para um conjunto de biblioteca, podem ser criados / renomeado / excluído e não edições precisam acontecer para os arquivos de compilação. Um pequeno inconveniente é que vincular arquivos de atualizações propriedades de uma forma que fará com que reconstruir um desnecessário. 

<target name="lib.cvp">
<fetch.and.log.version 
    svnvers.target="common/cvp" 
    svnvers.property="libcvp.version"/>
    <cc objdir="${obj.dir}/common/cvp" 
        commandPrefix="${command.prefix}" 
        compilerName="${compiler.name}"
        outfile="${lib.dir}/cvp" outtype="static">
        <compiler extends="base.compiler"/>
        <compilerarg 
            value="-D__CVP_LIB_BUILD_VERSION__=&quot;${libcvp.version}&quot;"/>
        <compilerarg 
            value="-D__BUILD_NOTES__=&quot;${libcvp.toolversion}&quot;"/>
        <compilerarg if="is.x86" value="-DARCH_X86"/>
        <linker extends="base.linker"/>
        <includepath refid="common.inc"/>
        <fileset dir="${project.home}/common/cvp">
            <include name="*.c"/>
            <include name="*.cpp"/>
        </fileset>
    </cc>
</target>

Ant tem um muito Java-heavy user-base (por razões naturais). O fato de que Ant pode ser muito útil em um cenário muito mais amplo é algo que a maioria dos desenvolvedores não-Java desconhecem. Como resultado, se você usar Ant para construir o seu C / C ++ -. Código de seu muito mais em seu próprio país que se você usar um sistema com base maior de usuários (CMake ou SCons)

Pessoalmente, eu fui muito feliz com CMake, principalmente porque é o único sistema de construção que pode gerar projetos reais do Visual Studio. SCons pode demasiado, mas eles só fazer uma chamada externa para SCons, whileas CMake gera projetos que usam próprio mecanismo de compilação do Visual Studio. Isto é muito útil se você estiver trabalhando em conjunto com as pessoas que são utilizados para Visual Studio.

Eu não tenho certeza que eu chamaria o apoio da CMake para crosscompilation "maduro", uma vez que ainda muito jovem. Mas as pessoas CEfectue é sério sobre isso, então eu não hesitaria em experimentá-lo.

Licenciado em: CC-BY-SA com atribuição
Não afiliado a StackOverflow
scroll top