Incrémentation automatique du numéro de build dans Qt Creator

Question

J'aimerais avoir une variable (ou #define ) en source C ++ qui sera incrémentée chaque fois que j'utilise Qt Creator pour générer le code source. Est-ce que je peux le faire, peut-être un plugin Qt Creator ou similaire? S'il existe un moyen de le faire si j'utilise " make " en ligne de commande pour construire?

Answer 1

Dans votre fichier .pro, vous pouvez créer une variable contenant les résultats d'un programme en ligne de commande. Vous pouvez ensuite l'utiliser pour créer une définition.

BUILDNO = $(command_to_get_the_build_number)
DEFINES += BUILD=${BUILDNO}

Si vous voulez juste un simple numéro incrémenté, vous pouvez utiliser un script assez simple:

#!/bin/bash
number=`cat build_number`
let number += 1
echo "$number" | tee build_number #<-- output and save the number back to file

Je dois noter que cela entraînerait une incrémentation du numéro de construction à chaque construction, ainsi qu'une incrémentation si vous essayez de construire mais que cela échoue. Un meilleur moyen consiste à obtenir un numéro de build en fonction de l'état du code. De nombreux outils de contrôle de version peuvent vous obtenir une chaîne de texte, sinon un nombre.

Answer 2

Comme je l'ai déjà écrit après quelques tests, j'ai constaté que la solution d'origine posait un problème, car le numéro de version n'était pas mis à jour à chaque nouvelle création. Dans de nombreux cas, j'avais édité un fichier source, exécuté la construction, mais j'avais toujours le même numéro de construction ... Le processus de construction a simplement décidé que rien n'était changé et ignoré l'étape qui aurait mis à jour le numéro de construction. J'ai d'abord essayé de trouver un moyen de forcer cette étape, mais je ne pouvais pas le comprendre. Finalement, j'ai décidé de faire autrement. Maintenant, j'utilise le script pour générer un fichier d'en-tête build_number.h qui contient un #define BUILD avec le numéro mis à jour derrière. Le script Calebs est donc un peu modifié ( build_number.sh ):

#!/bin/bash
number=`cat build_number`
let number++
echo "$number" | tee build_number #<-- output and save the number back to file
echo "#define BUILD ""$number" | tee ../MyProject/build_number.h

Le numéro d'incrémentation est toujours stocké dans un fichier appelé numéro_de_compilation . J'aurais pu éviter un troisième fichier en analysant le fichier d'en-tête généré pour le numéro, mais j'ai décidé de ne pas l'utiliser. Notez que le script et l'en-tête généré se trouvent dans le répertoire projects alors que le fichier build_number se trouve dans le répertoire de construction. Ce n’est pas parfait, mais je peux vivre avec.

Afin de mettre les choses ensemble, il y a maintenant plus de choses à faire. Tout d'abord, le fichier d'en-tête généré doit être ajouté au projet dans Qt Designer ... Cliquez avec le bouton droit sur Fichiers d'en-tête et sélectionnez "Ajouter un fichier existant". Deuxièmement, il doit être inclus dans le fichier C ++ - où le BUILD définit à l'intérieur est accédé ... #include "numéro_de_compilation.h" ... et enfin, quelques ajouts doivent être dans le fichier de projet ( MyProject.pro ). Notez que j'ai supprimé les éléments de la solution Calebs, nous partons donc de zéro ici:

build_nr.commands = ../MyProject/build_number.sh
build_nr.depends = FORCE
QMAKE_EXTRA_TARGETS += build_nr
PRE_TARGETDEPS += build_nr

Ces lignes (je les mets avant la section HEADERS) forcent l'exécution du script, qui lit le dernier numéro de build à partir de build_number , l'incrémente, le réécrit et génère également une version mise à jour de le fichier build_number.h . Comme cela fait partie de la source du projet, la nouvelle valeur est liée au code à chaque fois.

Il y a une chose à mentionner - maintenant, le processus de construction n’est jamais à l’opinion que rien n’a changé. Ainsi, même si vous laissez votre code inchangé, une nouvelle exécution de make générera un nouveau numéro de version et construira un nouveau fichier binaire. L'ancienne solution laissait le numéro lorsque le code changeait, cette nouvelle solution impose une nouvelle construction même lorsque la source est inchangée, car je force un changement dans ce fichier d'en-tête. On aurait préféré quelque chose entre les deux, mais comme l'en-tête n'est inclus qu'à un endroit, la reconstruction est très rapide et ne fait pas trop mal. Mais quand même, si quelqu'un sait comment tirer le meilleur parti des deux mondes, veuillez le conseiller. Au moins maintenant, je n'aurai pas deux fichiers binaires différents avec le même numéro de version.

Answer 3

L'équivalent Windows de la solution améliorée de Joerg Beutel https://stackoverflow.com/a/5967447/1619432 :

.pro:

build_nr.commands = build_inc.bat
build_nr.depends = FORCE
QMAKE_EXTRA_TARGETS += build_nr
PRE_TARGETDEPS += build_nr

HEADERS  += build.h

build_inc.bat:

@echo off 
set /p var= <build.txt 
set /a var= %var%+1 
echo %var% >build.txt
echo #define BUILD %var% >build.h
echo %var%

Utilisation

#include "build.h"
...
qDebug() << "Build number:" << BUILD;

Answer 4

La suggestion de Caleb est excellente, mais n'a pas fonctionné "out of the box". dans mon cas. J'ai eu quelques erreurs à la place et il a fallu quelques lectures pour les corriger. Les changements sont très mineurs. J'utilisais Qt 4.7 sur Ubuntu Linux ... Le premier changement, si vous pouvez le croire, consistait dans le script shell à passer de let number + = 1 à let number ++ ... J'utilise normalement / programme Windoze, donc je ne peux pas l'expliquer, mais lorsque j'exécute le script à partir d'une ligne de commande (invite du shell) dans le cas d'origine, des erreurs sont signalées. Dans le cas modifié, tout va bien et les numéros incrémentés sont retournés ...

Etant donné que Caleb ne l'a pas complètement signalé - j'ai utilisé build_number.sh comme nom du script shell et créé un autre fichier portant le nom build_number (sans .sh ) et ne mettez qu'un zéro à l'intérieur, rien d'autre.

Le dernier bogue le plus odieux a été corrigé en remplaçant BUILDNO = $$ (command_to_get_the_build_number) par BUILDNO = $$ système (./ build_number.sh) dans Qt fichier de projet. Notez le système après $$ et le ./ requis devant le nom du fichier. Ce dernier est élémentaire pour un utilisateur Linux ordinaire, mais pas autant pour un utilisateur Windows.

J'espère que cela facilite la tâche des personnes novices, comme moi. Vous pouvez en savoir plus dans la section Aide de Qt Designer si vous recherchez qmake, y compris la référence de la fonction, l'utilisation avancée, etc.

Oh, un dernier mot ... J'ai aussi dû changer DEFINES + = -DBUILD = $$ {BUILDNO} en DEFINES + = BUILD = $$ {BUILDNO} , le -D a donc disparu. Dans votre code C ++, vous utiliseriez BUILD comme si vous aviez écrit #define BUILD 1234 en haut de votre fichier.

Answer 5

Voici une solution pour Win7 basée sur la solution du handle . Cette solution oblige également Windows à donner votre version # lorsque vous cliquez avec le bouton droit de la souris sur votre cible et que vous choisissez Propriétés | Détails. Cela fonctionne sous Win7 et probablement avec la plupart des versions antérieures.

Ok, vous faites votre build_inc.bat:

@echo off
copy /b myapp.rc +,,
set /p var= <build.txt 
set /a var= %var%+1 
echo %var% >build.txt
echo #define BUILD %var% >build.h

et mettez-le dans votre dossier proj. ( copy / b myapp.rc + ,, est impénétrable Microsoft-eese pour "tactile" - pour mettre à jour l'horodatage d'un fichier.) Jusqu'ici, tout va bien - et alors? !! ??

Cette partie est facultative, si vous n'avez pas besoin de la version encodée dans le binaire. Créez un fichier .rc, par exemple:

#include "build.h"

1 VERSIONINFO
FILEFLAGS 32
FILEVERSION 1, 0, BUILD, 0
PRODUCTVERSION 1, 0, BUILD, 0
FILEOS 4
FILETYPE 1

{
    BLOCK "StringFileInfo"
    {
        BLOCK "040904B0"
        {
            VALUE "FileDescription", "program"
            VALUE "OriginalFilename", "program.exe"
            VALUE "CompanyName", "you"
            VALUE "FileVersion", "Release"
            VALUE "LegalCopyright", "Copyright (c) 2016, you, fool!"
            VALUE "ProductName", "Yer proggie"
            VALUE "ProductVersion", "Release"
        }
    }
    BLOCK "VarFileInfo"
    {
        VALUE "Translation", 0x0409, 0x04B0
    }
}

Une version plus complète est disponible ici: DLL de version . BTW: Cela ne fonctionnera pas sans le bloc VarFileInfo. Ce .rc est utilisé pour des choses comme un clic droit et obtenir cette information dans Propriétés | Détails. J'ai à la fois un fichier M $ .rc pour cette information et l'icône de l'application, et j'ajoute d'autres ressources dans Qt Creator sous Ressources.

Pas si facultatif: Voici la partie que j'ai passé du temps à chercher. Dans Qt Creator, lorsque votre projet est ouvert, cliquez sur la petite icône de l'ordinateur et mettez-la en mode de libération. Cliquez sur "Projets". Cliquez sur "Ajouter une étape de construction", choisissez une étape de processus personnalisée, puis cliquez sur l'icône "&"; ^ " jusqu'à ce qu'il soit en haut de la liste. Supposons que vous ayez nommé votre .rc, "myapp.rc". Faites en sorte que l’étape de construction se lise comme suit:

Command: cmd.exe
Arguments:/c build_inc.bat
Working Directory: %{CurrentProject:Path}

Bien qu'une version basée sur qmake puisse fonctionner correctement à partir de la ligne de commande ou des outils de ligne de commande appelés à partir d'un IDE, dans Qt Creator, les étapes de construction sont préférables, je crois. Qt Creator n'exécute pas réellement qmake pour chaque construction; mais les étapes de construction sont exécutées à chaque construction.

Maintenant, ajoutez ceci à votre fichier .pro:

RC_FILE +=  myapp.rc

Ajoutez également myapp.rc à votre projet. Il apparaîtra sous "Autres fichiers".

Maintenant reconstruisez. Chaque reconstruction entraînera une manipulation du fichier de ressources, ce qui lancera l'option "rc". à chaque fois. Sinon, le numéro de build ne sera pas encodé dans le droit binaire. Ça court vite pour moi. Chaque reconstruction augmentera ce nombre. Je ne me suis soucié que de les ajouter à la "Libération". construire; alors les versions de débogage n'incrémentent pas cela. Ils vont juste utiliser le numéro de la dernière construction. Je crois que vous devrez l'exécuter une fois dans la version pour éviter une erreur. Cela fonctionne sans avoir à réexécuter séparément qmake à chaque fois dans Qt Creator; et vous donne un numéro de construction différent à chaque fois. Cela ne déclenche aucune autre recompilation. Vous avez le temps d’arrière de l’exécution de " rc " et reliant à chaque fois, au lieu de ne rien faire si tout est à jour; mais OTOH, je le fais uniquement pour les versions release; vous vous connectez presque toujours pour une construction ou une exécution de toute façon; et encore, " rc " est rapide.

Facultatif: vous pouvez déplacer le symbole du préprocesseur BUILD où vous voulez dans votre vers. #. (Remarque: vous pouvez également ajouter votre icône d'application avec quelque chose comme ceci:

IDI_ICON1 ICON DISCARDABLE "Icons/myicon.ico"

Cela le fait apparaître dans l'Explorateur avant même que le fichier ne soit exécuté.)

Vous pouvez également ajouter " build.h " Pour vous inscrire officiellement dans Qt Creator, incluez-le dans un fichier dans lequel vous voulez utiliser le numéro de construction et utilisez-le sous forme de chaîne, par exemple. avec:

#include <QDebug>
#include "build.h"

#define STR_EXPAND(tok) #tok
#define STR(tok) STR_EXPAND(tok)

qDebug() << QString("(build ")+STR(BUILD)+")";

Je viens de remarquer un effet secondaire: si vous le faites de cette façon, il sera reconstruit avant chaque exécution dans Release. Je suppose que ce n'est pas trop mauvais prix à payer. Je suppose que je peux toujours copier les runtimes dans le répertoire de publication et les exécuter à partir de l'explorateur; ou tout simplement supporter la compilation supplémentaire de mon about.h, la série de "rc" et le lien avec chaque exécution en version. D'ailleurs, je pourrais simplement créer un outil externe pour l'exécuter avec un raccourci clavier. Je suis certainement ouvert à toute amélioration à ce sujet. Pour le moment, ça ne me dérange pas, je viens juste de compiler "about.cpp", de lancer "rc". et la liaison avec chaque course ne prend pas très longtemps. Toujours, les gens: numéros de construction automatiques!

& # 9774;!

Modifier: Facultatif: afin de l’incrémenter uniquement lorsque vous générez ou reconstruisez votre projet, mais pas lorsque vous l’exécutez (même si une génération aura toujours lieu dans la version), accédez à Projets | Construire et exécuter | Cliquez sur Exécuter, puis sur "Ajouter une étape de déploiement". et choisissez "Etape de processus personnalisée":

Command: cmd.exe
Arguments: /c if exist build.old copy /y build.old build.txt
Working Directory: %{CurrentProject:Path}

Ajoutez ensuite

copy /y build.txt build.old

après @echo dans le fichier .bat. Il est même possible, bien que impliqué, de créer de nouveaux modèles de projet personnalisés: Extension Manuel Qt Creator

Éditer: je l’ai maintenant fait fonctionner avec une, pas deux, étapes de construction personnalisées.