Trouver le fournisseur / la version du compilateur en utilisant qmake

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

Question

Existe-t-il un moyen d'obtenir la version et le fournisseur du compilateur utilisés par l'utilisateur via qmake? Ce dont j'ai besoin, c’est de désactiver la construction de certaines cibles de mon projet lorsque g ++ 3.x est utilisé et de les activer lorsque g ++ 4.x est utilisé.

Mise à jour : la plupart des réponses visaient le préprocesseur. C'est quelque chose que je veux éviter. Je ne souhaite pas qu'une cible soit générée pour une version spécifique du compilateur et que cette décision soit prise par le système de compilation.

Était-ce utile?

La solution

En plus de la réponse de ashcatch , < code> qmake vous permet de interrogez la ligne de commande et récupérez la réponse sous forme de variable. Donc, vous pourriez faire quelque chose comme ça: 

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" )
    }
}

Ensuite, lorsque vous souhaitez l'utiliser pour spécifier des cibles, vous pouvez utiliser les règles de configuration de la configuration: 

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

Autres conseils

Ma réponse est basée sur Caleb Huitt - cjhuitt . Mais sa démarche ne fonctionne pas pour moi. 

*-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" )
            }
        }
    }
}

Comme vous le voyez, vous pouvez obtenir une version de GCC, puis la comparer avec une expression regex.

La manière d’utiliser est la même: 

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

Pour commencer, examinons la fonctionnalité de cadrage prise en charge par qmake:

Portées et conditions

Mais pendant que je lisais ces informations, il semble que vous puissiez utiliser par défaut les conditions générales de la plate-forme, telles que win32 ou unix , ou le nom de la spécification qmake, comme linux-g ++ . Vous pouvez tester la version de Visual Studio comme ceci (car les différentes versions de Visual Studio utilisent différentes spécifications de qmake), mais je ne pense pas que vous puissiez tester la version de gcc comme ceci (du moins je ne sais pas comment).

je fais 

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)
}

Il renvoie "48". Je l'utilise pour lier des bibliothèques boost appropriées: 

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

donnant effectivement: -lboost_system-mgw48-mt-s-1_54

Je suis sur mingw.

Une autre idée consiste à examiner le fichier de valeur QMAKESPEC et à en analyser le résultat, indice: 

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

Ma réponse est basée sur la réponse de dismine
Nous pouvons simplement extraire le numéro de version majeur en utilisant $$ 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")
}

Chaque fournisseur de compilateur définit des symboles spécifiques qui identifient le compilateur et sa version. Vous pouvez faire la vérification en utilisant ces symboles.

Je sais, par exemple, que _MSC_VER donne la version du compilateur Microsoft C ++.

Ce que je sais aussi, c’est que les bibliothèques Boost utilisent ce type de sélection et d’adaptation des fonctionnalités.

Vous pouvez consulter les en-têtes de configuration Boost, qui se trouvent dans le dossier include, dans le chemin: boost / config / *, en particulier dans select_compiler_config.hpp.

En utilisant ces symboles spécifiques au compilateur, vous pouvez sélectionner des fonctionnalités lors de la phase de prétraitement de la construction du code.

Les macros suivantes sont définies dans ma version de gcc et g ++ 

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

De plus, le g ++ définit: 

#define __GNUG__ 4
Licencié sous: CC-BY-SA avec attribution
Non affilié à StackOverflow
scroll top