Intégration des ressources dans l'exécutable en utilisant GCC

Il y a deux possibilités:

• utilisez la capacité de ld à transformer n'importe quel fichier en un objet ( intégration de blobs binaires utilisant gcc mingw ):

  ld -r -b binary -o binary.o foo.bar  # then link in binary.o
  

• utilisez un utilitaire bin2c / bin2h pour transformer n'importe quel fichier en un tableau d'octets ( intègre l'image dans le code, sans utiliser la section de ressource ou les images externes )

mise à jour: voici un exemple plus complet de la façon d'utiliser les données liées dans l'exécutable en utilisant ld -r -b binary :

#include <stdio.h>

// a file named foo.bar with some example text is 'imported' into 
// an object file using the following command:
//
//      ld -r -b binary -o foo.bar.o foo.bar
//
// That creates an bject file named "foo.bar.o" with the following 
// symbols:
//
//      _binary_foo_bar_start
//      _binary_foo_bar_end
//      _binary_foo_bar_size
//
// Note that the symbols are addresses (so for example, to get the 
// size value, you have to get the address of the _binary_foo_bar_size
// symbol).
//
// In my example, foo.bar is a simple text file, and this program will
// dump the contents of that file which has been linked in by specifying
// foo.bar.o as an object file input to the linker when the progrma is built

extern char _binary_foo_bar_start[];
extern char _binary_foo_bar_end[];

int main(void)
{
    printf( "address of start: %p\n", &_binary_foo_bar_start);
    printf( "address of end: %p\n", &_binary_foo_bar_end);

    for (char* p = _binary_foo_bar_start; p != _binary_foo_bar_end; ++p) {
        putchar( *p);
    }

    return 0;
}

mise à Jour 2 - Obtenir la ressource de la taille: je ne pouvais pas lire _binary_foo_bar_size correctement. A l'exécution, gdb me montre la bonne taille de la ressource texte en utilisant display (unsigned int)&_binary_foo_bar_size . Mais attribuer cela à une variable donnait toujours une mauvaise valeur. J'ai pu résoudre ce numéro de la façon suivante:

unsigned int iSize =  (unsigned int)(&_binary_foo_bar_end - &_binary_foo_bar_start)

c'est un contournement, mais il fonctionne bien et n'est pas trop laid.