Encontrar fornecedor de compilador / versão usando qmake

Question

Existe alguma maneira para obter a versão e fornecedor do compilador usado pelo usuário através qmake? O que eu preciso é desativar a construção de algumas metas do meu projeto quando g ++ 3.x é usado e permitir-lhes quando g ++ 4.x é usado.

Update: A maioria das respostas alvo o pré-processador. Isso é algo que eu quero evitar. Eu não quero um alvo a ser construído para uma versão do compilador específico e eu quero esta decisão a ser tomada pelo sistema de compilação.

Answer 1

Além ashcatch 's resposta, qmake permite consulta na linha de comando e obter de volta a resposta como uma variável. Então você podia para algo como isto:

linux-g++ {
    system( g++ --version | grep -e "\<4.[0-9]" ) {
        message( "g++ version 4.x found" )
        CONFIG += g++4
    }
    else system( g++ --version | grep -e "\<3.[0-9]" ) {
        message( "g++ version 3.x found" )
        CONFIG += g++3
    }
    else {
        error( "Unknown system/compiler configuration" )
    }
}

Então, mais tarde, quando você quiser usá-lo para especificar alvos, você pode usar as regras de configuração de escopo:

SOURCES += blah blah2 blah3
g++4: SOURCES += blah4 blah5

Answer 2

A minha resposta com base em Caleb Huitt - cjhuitt 's. Mas sua abordagem não funciona para mim.

*-g++ {
    GCC_VERSION = $$system("g++ -dumpversion")
    contains(GCC_VERSION, 6.[0-9]) {
        message( "g++ version 6.x found" )
        CONFIG += g++6
    } else {
        contains(GCC_VERSION, 5.[0-9]) {
            message( "g++ version 5.x found" )
            CONFIG += g++5
        } else {
            contains(GCC_VERSION, 4.[0-9]) {
                message( "g++ version 4.x found" )
                CONFIG += g++4
            } else {
                message( "Unknown GCC configuration" )
            }
        }
    }
}

Como você pode ver, você pode obter a versão do GCC e, em seguida, compará-lo com expressão regex.

A maneira como o uso é o mesmo:

SOURCES += blah blah2 blah3
g++4: SOURCES += blah4 blah5

Answer 3

Como um começo, eu olhava para o recurso de escopo que suportes qmake:

Scopes e Condições

Mas enquanto eu li sobre isso, parece que por padrão você pode usar condições gerais de plataforma como win32 ou unix ou você pode usar o nome do qmake especificação como linux-g++. Você pode testar a versão Visual Studio como esta (desde as diferentes versões do Visual Studio usar diferentes especificações qmake), mas eu não acho que você pode testar a versão gcc assim (pelo menos eu não sei como).

Answer 4

eu

isEmpty(MGWVER) {
    MGW_MAJ = $$system(echo | gcc -dM -E - | fgrep __GNUC__ | cut -d\" \" -f 3)
    MGW_MIN = $$system(echo | gcc -dM -E - | fgrep __GNUC_MINOR__ | cut -d\" \" -f 3)
    MGWVER =$$MGW_MAJ$$MGW_MIN
    message(MGWVER $$MGWVER)
}

Ele retorna "48". Eu usá-lo para ligar bibliotecas de impulso adequados:

USER_BOOST_CFG=mgw$${MGWVER}-mt-s-$$(BOOST_VER)
message($$USER_BOOST_CFG)
LIBS *= -L$$(BOOST_ROOT)/lib
LIBS *= -L$$(BOOST_ROOT)/stage/lib

LIBS *= -lboost_system-$$USER_BOOST_CFG
LIBS *= -lboost_filesystem-$$USER_BOOST_CFG
LIBS *= -lboost_date_time-$$USER_BOOST_CFG

efetivamente dando: -lboost_system-mgw48-mt-s-1_54

Eu estou em mingw.

Outra idéia é olhar para QMAKESPEC vaariable e analisar a partir dele, dica:

message(QMAKESPEC $$QMAKESPEC)
SPLITED=$$section(QMAKESPEC, "/", 0, -3)
message(SPLITED $$SPLITED)

Answer 5

A minha resposta é baseada na resposta
Nós podemos simplesmente extrair o número da versão principal usando $$ str_member

gcc | clang {
    COMPILER_VERSION = $$system($$QMAKE_CXX " -dumpversion")
    COMPILER_MAJOR_VERSION = $$str_member($$COMPILER_VERSION)
    greaterThan(COMPILER_MAJOR_VERSION, 3): message("gcc 4 or later")
    greaterThan(COMPILER_MAJOR_VERSION, 4): message("gcc 5 or later")
    greaterThan(COMPILER_MAJOR_VERSION, 5): message("gcc 6 or later")
    greaterThan(COMPILER_MAJOR_VERSION, 6): message("gcc 7 or later")
}

Answer 6

Cada uso fornecedor compilador para definir alguns símbolos específicos que identificam o compilador e versão. Você poderia fazer a verificação usando esses símbolos.

Eu sei, por exemplo, que _MSC_VER dá a versão do Microsoft C ++ Compiler.

O que eu também sei que bibliotecas de impulso usar esse tipo de seleção de recursos e adaptação.

Você pode dar uma olhada para impulsionar cabeçalhos de configuração, encontrada em incluem pasta, pelo caminho:. Boost / config / *, especialmente no select_compiler_config.hpp

Ao usar esses símbolos do compilador específico, você pode fazer seleção de funções com pré-processamento fase de construção do código.

Answer 7

As seguintes macros são definidas na minha versão do gcc e g ++

#define __GNUC__ 4 
#define __GNUC_MINOR__ 0
#define __GNUC_PATCHLEVEL__ 1

Adicionalmente o g ++ define:

#define __GNUG__ 4