web-dev-qa-db-fra.com

script/outil pour convertir le fichier en tableau de code source C/C++

J'ai besoin d'un script/outil qui lit un fichier binaire et génère un tableau de code source C/C++ (qui représente le contenu du fichier). Y a-t-il?

(Cette question a été supprimée plus tôt. Je l'ai remise en question parce que c'est précieux. Je cherchais exactement cela sur Google et je n'ai rien trouvé. Bien sûr, il est trivial de se code aurait trouvé un tel script simple, donc il est précieux.

Cette question a également eu beaucoup de votes négatifs sans beaucoup d'explications. Veuillez commenter avant de voter pour la raison pourquoi vous pensez que cela n’a aucune valeur ou une valeur médiocre.

Cette question a également causé beaucoup de confusion sur ce que je demande. Si quelque chose n'est pas clair, demandez s'il vous plaît. Je ne sais pas vraiment comment le rendre plus clair. Voir les réponses pour des exemples.

Aussi (après avoir posé la question ici), j'ai déjà plusieurs réponses. Je veux juste les mettre/les lier ici (encore une fois) parce que je pense que cela pourrait être utile pour quelqu'un d'autre à la recherche de cela.)

cbinary
63
Albert

Sur Debian et d’autres distributions Linux est installé par défaut (avec vim), l’outil xxd qui, avec l’option -i, peut faire ce que vous voulez:

matteo@teodeb:~/Desktop$ echo Hello World\! > temp
matteo@teodeb:~/Desktop$ xxd -i temp 
unsigned char temp[] = {
  0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64, 0x21,
  0x0a
};
unsigned int temp_len = 13;
107
Matteo Italia

Un outil simple peut être trouvé ici :

#include <stdio.h>
#include <assert.h>

int main(int argc, char** argv) {
    assert(argc == 2);
    char* fn = argv[1];
    FILE* f = fopen(fn, "rb");
    printf("char a[] = {\n");
    unsigned long n = 0;
    while(!feof(f)) {
        unsigned char c;
        if(fread(&c, 1, 1, f) == 0) break;
        printf("0x%.2X,", (int)c);
        ++n;
        if(n % 10 == 0) printf("\n");
    }
    fclose(f);
    printf("};\n");
}
6
Albert

La réponse acceptée à l'aide de l'outil xxd est Nice si vous utilisez un système similaire à * nix. Voici un "one-liner" pour tout système ayant l'exécutable python sur le chemin:

python -c "import sys;a=sys.argv;open(a[2],'wb').write(('const unsigned char '+a[3]+'[] = {'+','.join([hex(b) for b in open(a[1],'rb').read()])+'};').encode('utf-8'))" <binary file> <header file> <array name>

<fichier binaire> est le nom du fichier que vous souhaitez transformer en en-tête C, <fichier en-tête> est le nom du fichier en-tête et <nom du tableau> est le nom que vous souhaitez attribuer au tableau.

La commande à une ligne Python ci-dessus a à peu près les mêmes fonctions que le programme Python suivant (beaucoup plus lisible):

import sys

with open(sys.argv[2],'wb') as result_file:
  result_file.write(b'const char %s[] = {' % sys.argv[3].encode('utf-8'))
  for b in open(sys.argv[1], 'rb').read():
    result_file.write(b'0x%02X,' % b)
  result_file.write(b'};')
1
astraujums

Cet outil est compilé dans la commande de développeur Prompt in C. Il produit une sortie vers le terminal en affichant le contenu dans le fichier "nom_ array.c" créé. Notez que certains terminaux peuvent afficher le caractère "\ b". 

    #include <stdio.h>
    #include <assert.h>

    int main(int argc, char** argv) {
    assert(argc == 2);
    char* fn = argv[1];

    // Open file passed by reference
    FILE* f = fopen(fn, "rb");
    // Opens a new file in the programs location
    FILE* fw = fopen("array_name.c","w");

    // Next two lines write the strings to the console and .c file
    printf("char array_name[] = {\n");
    fprintf(fw,"char hex_array[] = {\n");

    // Declare long integer for number of columns in the array being made
    unsigned long n = 0;

    // Loop until end of file
    while((!feof(f))){
        // Declare character that stores the bytes from hex file
        unsigned char c;

        // Ignore failed elements read
        if(fread(&c, 1, 1, f) == 0) break;
        // Prints to console and file, "0x%.2X" ensures format for all
        // read bytes is like "0x00"
        printf("0x%.2X,", (int)c);
        fprintf(fw,"0x%.2X,", (int)c);

        // Increment counter, if 20 columns have been made, begin new line
        ++n;
        if(n % 20 == 0){
            printf("\n");
            fprintf(fw,"\n");
        }
    }

    // fseek places cursor to overwrite extra "," made from previous loop
    // this is for the new .c file. Since "\b" is technically a character
    // to remove the extra "," requires overwriting it.
    fseek(fw, -1, SEEK_CUR);

    // "\b" moves cursor back one in the terminal
    printf("\b};\n");
    fprintf(fw,"};\n");
    fclose(f);
    fclose(fw);
}
0
m_h

C'est un fichier binaire vers le code source python du générateur de tableaux C qui est un programme identique dans la réponse d'Albert .

import sys
from functools import partial

if len(sys.argv) < 2:
  sys.exit('Usage: %s file' % sys.argv[0])
print("char a[] = {")
n = 0
with open(sys.argv[1], "rb") as in_file:
  for c in iter(partial(in_file.read, 1), b''):
    print("0x%02X," % ord(c), end='')
    n += 1
    if n % 16 == 0:
      print("")
print("};")
0
Hill

La question est ancienne mais permettez-moi de vous suggérer un outil simple qui peut être utilisé comme alternative ...

Vous pouvez utiliser un outil basé sur une interface graphique appelé Fluid. Il est en fait utilisé pour la conception d'une interface pour le toolkit FLTK, mais peut également générer un tableau de caractères non signé pour C++ à partir d'un fichier binaire. Téléchargez-le à partir de muquit .

 Fluid screenshot

0
WailenB