Incremento automático del número de compilación en Qt Creator

Question

Me gustaría tener una variable (o #define ) en la fuente de C ++ que se incrementará cada vez que use Qt Creator para construir el código fuente. ¿Hay alguna forma de que pueda hacer esto, tal vez algún complemento Qt Creator o similar? Si hay una manera de hacerlo si uso " make " en la línea de comando para construir?

Answer 1

En su archivo .pro, puede crear una variable que contenga los resultados de un programa de línea de comandos. Luego puede usar eso para crear una definición.

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

Si solo desea un número incremental simple, puede usar un script bastante simple:

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

Debo tener en cuenta que esto provocaría que el número de compilación se incremente cada vez que compila, y también se incremente si intenta compilar pero falla. Una mejor manera es obtener un número de compilación basado en el estado del código, y muchas herramientas de control de versiones pueden obtener una cadena de texto para eso, si no un número.

Answer 2

Como escribí antes después de algunas pruebas, descubrí que la solución original tiene un problema ya que el número de versión no se actualiza cada vez que se realiza una nueva compilación. En muchos casos, edité un archivo fuente, ejecuté la compilación, pero aún obtuve el mismo número de compilación ... El proceso de compilación simplemente decidió que no había cambiado nada y omití el paso que habría actualizado el número de compilación. Primero intenté encontrar una manera de forzar ese paso, pero no pude resolverlo. Finalmente decidí ir por un camino diferente. Ahora uso el script para generar un archivo de encabezado build_number.h que contiene un #define BUILD con el número actualizado detrás. Entonces, el script de Calebs ahora está un poco modificado ( 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

El número incremental todavía se almacena dentro de un archivo llamado build_number . Podría haber evitado un tercer archivo analizando el archivo de encabezado generado para el número, pero decidí no hacerlo. Tenga en cuenta que la secuencia de comandos y el encabezado generado se encuentran en el directorio de proyectos mientras que el archivo build_number está en el directorio de compilación. Eso no es perfecto, pero puedo vivir con eso.

Para poner las cosas juntas, ahora hay algunas cosas más que hacer. Primero, el archivo de encabezado generado debe agregarse al proyecto en Qt Designer ... Haga clic con el botón derecho en Archivos de encabezado y " Agregar archivo existente " ;. En segundo lugar, debe incluirse en el archivo C ++ donde se accede a la definición de BUILD inside ... #include " build_number.h " ... y por último, pero no menos importante, algunas adiciones tienen que ser hecho al archivo del proyecto ( MyProject.pro ). Tenga en cuenta que eliminé las cosas de la solución Calebs, así que comenzamos desde cero aquí:

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

Estas líneas (las puse antes de la sección HEADERS) fuerzan la ejecución del script, que lee el último número de compilación de build_number , lo incrementa, lo escribe de nuevo y también genera una versión actualizada de el archivo build_number.h . Como es parte de la fuente del proyecto, el nuevo valor se vincula al código cada vez.

Hay una cosa para mencionar: ahora el proceso de construcción es nunca en la opinión de que nada ha cambiado. Entonces, incluso si deja su código sin cambios, una nueva ejecución de make generará un nuevo número de versión y generará un nuevo binario. La solución anterior dejó el número cuando el código cambió, esta nueva solución fuerza una nueva compilación incluso cuando la fuente no cambia, ya que forzo un cambio en ese archivo de encabezado. Uno hubiera preferido algo intermedio, pero dado que el encabezado solo se incluye en un lugar, la reconstrucción es muy rápida y no duele mucho. Pero aún así, si alguien sabe cómo obtener lo mejor de ambos mundos, por favor avise. Al menos ahora no tendré dos binarios diferentes con el mismo número de versión.

Answer 3

El equivalente de Windows para la solución mejorada 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%

Uso

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

Answer 4

La sugerencia de Caleb es genial, pero no funcionó "fuera de la caja" en mi caso. En su lugar, obtuve algunos errores y tomó algo de lectura solucionarlos. Los cambios son muy menores. Estaba usando Qt 4.7 en Ubuntu Linux ... El primer cambio, si puedes creerlo, fue en el script de shell para ir de let number + = 1 a let number ++ ... Normalmente uso / program Windoze, así que no puedo explicar eso, pero cuando ejecuto el script desde una línea de comando (indicador de comandos de shell) en el caso original recibo errores, en el caso cambiado todo va bien y se devuelven números incrementales ...

Como Caleb no lo ha informado por completo, utilicé build_number.sh como nombre del script de shell e hice otro archivo con el nombre build_number (sin .sh ) y poner solo un cero adentro, nada más.

El último y más desagradable error se corrigió reemplazando BUILDNO = $$ (command_to_get_the_build_number) con BUILDNO = $$ system (./ build_number.sh) en el Qt archivo de proyecto Observe el sistema después de $$ y el ./ requerido delante del nombre del archivo. El último es elemental para un usuario normal de Linux, pero no tanto para un usuario de Windows.

Espero que esto lo haga más sencillo para las personas nuevas en todo esto, como yo. Puede leer más en la sección Ayuda de Qt Designer si busca qmake, incluida la referencia de funciones, Uso avanzado, etc.

Oh, una última palabra ... También tuve que cambiar DEFINES + = -DBUILD = $$ {BUILDNO} a DEFINES + = BUILD = $$ {BUILDNO} , por lo que -D desaparece. Dentro de su código C ++ usaría BUILD como si hubiera escrito #define BUILD 1234 en la parte superior de su archivo.

Answer 5

Aquí hay una solución para Win7 que se me ocurrió basada en la solución del controlador . Esta solución también hace que Windows proporcione su número de versión cuando hace clic con el botón derecho en su destino y selecciona Propiedades | Detalles Funciona en Win7, y probablemente en la mayoría de las versiones anteriores.

Ok, haces tu 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

y póngalo en su carpeta de proyectos. ( copy / b myapp.rc + ,, es inescrutable por Microsoft para "tocar" - para actualizar la marca de tiempo de un archivo.) Hasta ahora, todo bien, ¡¿y qué? !!

Esta parte es opcional, si no necesita la versión codificada en el binario. Cree un archivo .rc, por ejemplo:

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

Una versión más completa está disponible aquí: DLL de versiones . Por cierto: no funcionará sin el bloque VarFileInfo. Este .rc se usa para cosas como hacer clic con el botón derecho y obtener esta información en Propiedades | Detalles Tengo un archivo M $ .rc para esta información y el ícono de la aplicación, y agrego otros recursos en Qt Creator en Recursos.

No es tan opcional: esta es la parte que he dedicado a hackear para encontrar. En Qt Creator, con su proyecto abierto, haga clic en el pequeño icono de la computadora y póngalo en modo de lanzamiento. Haga clic en " Proyectos " ;. Haga clic en " Agregar paso de compilación " ;, elija Paso de proceso personalizado y haga clic en el ícono del sombrero " ^ " hasta que esté en la parte superior de la lista. Digamos que ha nombrado su .rc, "myapp.rc". Haga que el paso de compilación se lea como sigue:

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

Si bien una versión basada en qmake podría funcionar bien desde la línea de comandos o las herramientas de línea de comandos llamadas desde un IDE, en Qt Creator, creo que es preferible seguir los pasos de compilación. Qt Creator en realidad no ejecuta qmake para cada compilación; pero los pasos de compilación se ejecutan en cada compilación.

Ahora, agregue esto a su archivo .pro:

RC_FILE +=  myapp.rc

Además, agregue myapp.rc a su proyecto. Aparecerá en "Otros archivos".

Ahora reconstruir. Cada reconstrucción activará un toque del archivo de recursos, ejecutando así "rc" cada vez. De lo contrario, el número de compilación no se codificará en el derecho binario. Se ejecuta rápidamente para mí. Cada reconstrucción incrementará este número. Solo me he molestado en agregarlos al " Release " construir; entonces las compilaciones de depuración no incrementan esto. Solo usarán el número de la última compilación. Necesitará ejecutarlo una vez en el lanzamiento para evitar un error, creo. Esto funciona sin volver a ejecutar qmake por separado cada vez en Qt Creator; y te da un número de compilación diferente cada vez. No activa ninguna otra recompilación. Tiene la sobrecarga de ejecutar " rc " y vincular cada vez, en lugar de no hacer nada si todo está actualizado; pero OTOH, lo hago solo para versiones de lanzamiento; casi siempre se vincula para una compilación o ejecución de todos modos; y de nuevo, "rc" es rápido.

Opcional: Puede mover el símbolo de preprocesador BUILD donde quiera en sus versiones. #. (Nota: también puede agregar su icono de aplicación con algo como esto:

IDI_ICON1 ICON DISCARDABLE "Icons/myicon.ico"

Esto hace que aparezca en Explorer incluso antes de que se ejecute el archivo).

También puede agregar " build.h " para realizar su proyecto formalmente en Qt Creator, inclúyalo en un archivo en el que desee usar el build # in y úselo como una cadena, p. con:

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

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

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

Acabo de notar un efecto secundario: si lo haces de esta manera, se reconstruirá antes de cada ejecución en Release. Supongo que no es un precio tan malo a pagar. Supongo que siempre puedo copiar los tiempos de ejecución en el directorio de lanzamiento y ejecutarlo desde Explorer; o simplemente soportar la compilación adicional de mi about.h, la ejecución de " rc " y el enlace con cada ejecución en el lanzamiento. Para el caso, podría crear una herramienta externa para ejecutarlo con un atajo de teclado. Ciertamente estoy abierto a cualquier mejora en esto. Por el momento, no me estoy molestando, ya que solo estoy compilando " about.cpp " ;, ejecutando " rc " y vincular con cada ejecución no lleva mucho tiempo. Aún así, personas: ¡números de compilación automáticos!

& # 9774 ;!

Editar: Opcional: para que incremente el número de compilación solo cuando compila o reconstruye su proyecto, pero no cuando lo ejecuta (aunque siempre se producirá una compilación en la Versión), vaya a Proyectos | Construir y ejecutar | Ejecutar, haga clic en " Agregar un paso de implementación " y elija "Paso de proceso personalizado":

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

Luego, agregue

copy /y build.txt build.old

después de @echo off en el archivo .bat. Incluso es posible, aunque involucrado, hacer nuevas plantillas de proyecto personalizadas: Extending Qt Creator Manual

Editar: ahora lo he hecho funcionar con uno, no dos pasos de compilación personalizados.