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 compilar el código fuente. ¿Hay alguna forma de que pueda hacer esto, tal vez algún plugin de Qt Creator o similar? Si hay una forma de hacerlo si uso "make" en la línea de comandos para compilar?

Answer 1

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

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

Si lo que desea es un número incremental sencilla, se puede usar un guión 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 señalar que esto haría que el número de compilación para incrementar cada vez que se construye, y también incrementar si intentas construir pero falla. Una mejor forma 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, sino un número.

Answer 2

La sugerencia de Caleb es genial, pero no funcionó "de fábrica" ​​en mi caso. Obtuve algunos errores y me tomó un tiempo leerlos para solucionarlos. Los cambios son muy menores. Estaba usando Qt 4.7 en Ubuntu Linux ... El primer cambio, si puedes creerlo, estaba en el script de shell para ir de let number += 1 a let number++ ... Normalmente uso/programo Windoze, así que no puedo explicar eso, pero cuando ejecuto el script desde una línea de comando (indicador de shell) en el caso original recibo errores informados, en el caso cambiado todo va bien y se devuelven números incrementales ...

Dado que Caleb no lo informó por completo - Usé build_number.sh como el nombre del script de shell e hice otro archivo con el nombre build_number (sin .sh) y puse solo un cero adentro, nada más.

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

Espero que esto sea más sencillo para las personas que conozcan todo esto, como yo. Puede leer más en la sección de Ayuda diseñador Qt si usted busca para qmake, incluyendo la referencia de función, etc. Uso avanzado

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

Answer 3

Como escribí antes después de algunas pruebas, encontré 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, he editado un archivo de código fuente, ejecuto la compilación, pero aún tengo el mismo número de compilación ... El proceso de compilación simplemente decidió que no se cambió nada y omitió 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 la secuencia de comandos para generar un archivo de encabezado build_number.h que contiene un #define BUILD con el número actualizado detrás. Así guión Calebs es ahora 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 en un archivo llamado build_number.Pude haber evitado un tercer archivo al analizar el archivo de encabezado generado para el número, pero decidí no hacerlo. Tenga en cuenta que el script y el encabezado generado se encuentran en el directorio de proyectos, mientras que el archivo build_number se encuentra en el directorio de compilación. Eso no es perfecto, pero puedo vivir con eso.

Con el fin de 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 Header-Files y "Add existing file". En segundo lugar, debe incluirse en el archivo C++ donde se accede a la definición de BUILD en el interior ... #include "build_number.h" ... y por último, pero no por ello menos importante, algunas adiciones deben realizarse en el archivo del proyecto (MyProject.pro). Tenga en cuenta que he eliminado el material de la solución de Caleb, por lo que empezar 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 (los pongo antes de la sección de cabeceras) forzar la ejecución de la secuencia de comandos, que lee el último número de compilación de build_number , lo incrementa, lo escribe y también genera una versión actualizada del archivo build_number.h. Como eso 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. Por lo tanto, incluso si no modifica su código, una nueva ejecución de make generará un nuevo número de versión y creará un nuevo binario. La solución anterior dejó el número cuando cambió el código, esta nueva solución fuerza una nueva compilación incluso cuando la fuente no ha cambiado, ya que fuerzo un cambio en ese archivo de encabezado. Uno hubiera preferido algo intermedio, pero como el encabezado solo está incluido en un lugar, la reconstrucción es muy rápida y no duele demasiado. Pero aún así, si alguien sabe cómo obtener lo mejor de ambos mundos, asesórese. Al menos ahora no tendré dos binarios diferentes con el mismo número de versión.

Answer 4

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

Todas las soluciones que he visto hasta ahora han sido excesivamente intrincadas para mi gusto. He cocinado una solución bastante simple que funciona en plataforma cruzada dentro de QtCreator. http://refaqtory.net/blog/?p=34

Answer 6

Aquí hay una solución para Win7 que se me ocurrió basado en handle's solution. Esta solución también hace que Windows le entregue su versión # cuando haga clic con el botón derecho sobre su objetivo y elija Propiedades | Detalles. Funciona en Win7, y probablemente en la mayoría de las versiones anteriores.

Ok, haces yer 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 ponerlo en la carpeta yer proj. (copy /b myapp.rc +,, es inescrutable Microsoft-eese para "toque" - 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. Crea un archivo .rc, p.:

#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 en toda regla está disponible aquí: Versioning DLLs. Por cierto: no funcionará sin el bloque VarFileInfo. Este .rc se usa para cosas como hacer clic 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 tan opcional: esta es la parte que he estado buscando hace tiempo. En Qt Creator, con su proyecto abierto, haga clic en el icono de la pequeña computadora y colóquelo 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 de sombrero "^" hasta que esté en la parte superior de la lista. Digamos que ha llamado a su yer .rc, "myapp.rc". Hacer tha paso de generación texto es el siguiente:

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

Mientras que una versión basada en qmake puede funcionar bien desde la línea de comandos o herramientas de línea de comando se llama desde un IDE, en Qt Creator, los pasos de generación son preferibles, creo. Qt Creator en realidad no ejecuta qmake para cada compilación; pero los pasos de compilación se ejecutan en cada compilación.

Ahora, añadir esto a yer archivo .pro:

RC_FILE += myapp.rc 

Además, agregue MyApp.rc a yer proj. Aparecerá en "Otros archivos".

Ahora reconstruir. Cada reconstrucción activará un toque del archivo de recursos, ejecutando "rc" cada vez. De lo contrario, el número de compilación no se codificará en el derecho binario. Funciona rápido para mí. Cada reconstrucción incrementará este número. Solo me molesté en agregarlos a la versión "Release"; para que las compilaciones de depuración no incrementen esto. Simplemente usarán el número de la última compilación. Necesitarás ejecutarlo una vez en versión para evitar un error, creo. Esto funciona sin volver a ejecutar qmake por separado cada vez en Qt Creator; y le da un número de compilación diferente cada vez. No desencadena 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 compilaciones de lanzamiento; casi siempre se vincula para una compilación o se ejecuta de todos modos; y nuevamente, "rc" es rápido.

Opcional: Puede mover el símbolo del preprocesador BUILD donde quiera en su verso. #. (Nota: También puede agregar yer icono de la aplicación con algo como esto:.

IDI_ICON1 ICON DISCARDABLE "Icons/myicon.ico" 

Esto hace que se muestre en el Explorador incluso antes de que se ejecute el archivo)

También puede añadir "build.h" Haz tu proyecto formalmente en Qt Creator, inclúyelo en un archivo en el que quieras usar el # de compilación, y úsalo como una cadena, por ej. 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 carrera en el lanzamiento. Supongo que no es un precio tan malo como para pagar. Supongo que siempre puedo copiar los tiempos de ejecución en el directorio de versiones y ejecutarlo desde Explorer; o simplemente aguanta la compilación extra de mi about.h, la ejecución de "rc" y el enlace con cada ejecución en lanzamiento. Para el caso, podría simplemente crear una herramienta externa para ejecutarlo con un atajo de teclado. Estoy ciertamente abierto a cualquier mejora en esto. Por el momento, no me molesto, ya que solo compilar "about.cpp", ejecutar "rc" y vincular con cada ejecución no toma mucho tiempo. Aún así, personas: ¡números de construcción automáticos!

☮!

Editar: Opcional: Para que incremente el número de compilación solo cuando construye o reconstruye su proyecto, pero no cuando lo ejecuta (aunque siempre se producirá una compilación en Release), vaya a Proyectos | Construir y ejecutar | Ejecutar, haga clic en "Agregar una Implementar Paso" y elija "Custom Paso del proceso":

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

A continuación, añadir

copy /y build.txt build.old 

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

Editar: Ahora he hecho que funcione con uno, no dos, pasos de compilación personalizados.