Modification fichier ressource rc

Version imprimable

Bonjour,

J'ai souvenir d'avoir vu un jour une solution permettant de mettre des macro dans un fichier rc, mais je n'arrive pas à me souvenir si j'hallucine ou pas.

Voici mon soucis:
Nous avons plusieurs dll qui sont toutes livrées de concert.
Pour chaque dll nous avons un .rc:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 VS_VERSION_INFO VERSIONINFO FILEVERSION 2,10,1,7 PRODUCTVERSION 2,10,1,7 FILEFLAGSMASK 0x3fL FILEFLAGS 0x0L FILEOS 0x4L FILETYPE 0x2L FILESUBTYPE 0x0L BEGIN BLOCK "StringFileInfo" BEGIN BLOCK "040904b0" BEGIN VALUE "Comments", "Version 2.10\0" VALUE "CompanyName", "\0" VALUE "FileDescription", "Module base\0" VALUE "FileVersion", "2,10,1,7\0" VALUE "InternalName", "Module base\0" VALUE "LegalCopyright", "Copyright 2002\0" VALUE "LegalTrademarks", "\0" VALUE "OLESelfRegister", "\0" VALUE "OriginalFilename", "MBase.DLL\0" VALUE "PrivateBuild", "\0" VALUE "ProductName", "Module base\0" VALUE "ProductVersion", "2,10,1,7\0" VALUE "SpecialBuild", "\0" END END BLOCK "VarFileInfo" BEGIN VALUE "Translation", 0x409, 1200 END END
Ceux sont les informations qui apparaissent lors d'un click droit sur le fichier.

Et aujourd'hui nous avons fait un script qui modifie chaque fichier rc de chaque dll, mais je trouve ça un peu lourd.
Est-il possible de faire:
Dans un seul fichier .h:
Code:

1 2 #define FILE_VERSION "2,10,1,7\0"
Et dans tous les .rc:
Code:

1 2 3 4 5 6 #include "fichier.h" /* */ VALUE "FileVersion", FILE_VERSION /* */
De sorte que l'on ait plus que un seul fichier à modifier! ça limite les checkout checkin et les modifications à un fichier!

Faut-il utiliser les .rc2?
Je regarde les fichiers .rc2 mais je ne comprend pas trop comment ca marche?! est-ce que je dois redéfinir la structure ou la déplacer?

Merci

Salut,
Est-ce qu'en utilisant un include ça marcherait ?
file_version.rc

Code:

VALUE "FileVersion", "2,10,1,7\0"

dll_resource.rc

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
VS_VERSION_INFO VERSIONINFO
 FILEVERSION 2,10,1,7
 PRODUCTVERSION  2,10,1,7
 FILEFLAGSMASK 0x3fL
 FILEFLAGS 0x0L
 FILEOS 0x4L
 FILETYPE 0x2L
 FILESUBTYPE 0x0L
BEGIN
    BLOCK "StringFileInfo"
    BEGIN
        BLOCK "040904b0"
        BEGIN
            VALUE "Comments", "Version 2.10\0"
            VALUE "CompanyName", "\0"
            VALUE "FileDescription", "Module base\0"
            #include "file_version.rc"
            VALUE "InternalName", "Module base\0"
            VALUE "LegalCopyright", "Copyright 2002\0"
            VALUE "LegalTrademarks", "\0"
            VALUE "OLESelfRegister", "\0"
            VALUE "OriginalFilename", "MBase.DLL\0"
            VALUE "PrivateBuild", "\0"
            VALUE "ProductName", "Module base\0"
            VALUE "ProductVersion", "2,10,1,7\0"
            VALUE "SpecialBuild", "\0"
        END
    END
    BLOCK "VarFileInfo"
    BEGIN
        VALUE "Translation", 0x409, 1200
    END
END

Il faut en effet inclure un .H dans ton fichier .RC pour que ça marche, mais on peut faire bien mieux :
Soit tu passes des paramètres directement dans les arguments du fichier .RC (Propriétés .RC => Ressources => Général => Définitions de préprocesseur), par exemple : FILEVERSION_TXT=\"1.2.3.4\"
Attention aux "\" devant les guillemets, ils sont cruciaux !!!
Soit tu fais la même chose dans un fichier .H inclus par ton .RC, via un #define FILEVERSION_TXT "1.2.3.4"
Dans ton .RC, tu écrira la ligne suivante :

Code:

VALUE "FileVersion", FILEVERSION_TXT

Mais ça reste lourd et/ou pénible... Notamment à cause de la version "numérique" dans le .RC, qu'il faudrait impérativement définir en double par rapport à la VALUE FileVersion qui reprends la même chose en texte.

Donc, comment ne plus avoir qu'un seul et unique point d'entrée pour la version ? Ben on va sévèrement augmenter le .H inclus... Voilà quoi mettre dans le .H :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 // Version in numeric format #define MAJOR_NUM 1 #define MINOR_NUM 2 #define REV_NUM 3 #define BUILD_NUM 4 // Num to text macros #define TO_TEXT(p) TO_STRING(p) #define TO_STRING(s) #s #define EVALUATE(p) p // Dotted version numbers #define MAJOR(DOT_CHAR) EVALUATE(MAJOR_NUM) ## DOT_CHAR #define MINOR(DOT_CHAR) EVALUATE(MINOR_NUM) ## DOT_CHAR #define REV(DOT_CHAR) EVALUATE(REV_NUM) ## DOT_CHAR #define BUILD(DOT_CHAR) EVALUATE(BUILD_NUM) // Version in text format #define VERSION_TEXT TO_TEXT(MAJOR(.)MINOR(.)REV(.)BUILD(.))
Et dans le .RC :
Code:

1 2 3 4 5 #include "MyVersionHeader.h" .... FILEVERSION MAJOR_NUM,MINOR_NUM,REV_NUM,BUILD_NUM .... VALUE "FileVersion", VERSION_TEXT
Bien sûr, tu peux faire passer la version numérique (les macros "*_NUM") par quasiment tout moyen adéquat pour toi. Par exemple, ceci devrait marcher (pas testé toutefois) :
Code:

1 2 3 4 5 6 7 8 #define MAJOR_NUM \ #include "MAJOR_NUM.txt" #define MINOR_NUM \ #include "MINOR_NUM.txt" #define REV_NUM \ #include "REV_NUM.txt" #define BUILD_NUM \ #include "BUILD_NUM.txt"
Les fichiers .TXT devant simplement avoir un format "une seule ligne contenant le numéro" pour que ça fonctionne.
Ce numéro peut par exemple être issu du système de gestion de configuration de façon à incrémenter automatiquement le "Build", ou gérer les évolutions mineures/révisions directement via la création (ou pas) des branches.

Au final, via ces macros, tu peux avoir un .RC et un (ou plusieurs) .H qui le remplissent, et complètement automatiser la création de l'information de version par rapport à une "autorité" de versionnage, qui sera souvent la gestion de configuration bien entendu.