Skript / Tool zum Konvertieren einer Datei in ein C / C ++ - Quellcode-Array

Ich benötige ein Skript / Tool, das eine Binärdatei liest und ein C / C ++ - Quellcode-Array ausgibt (das den Dateiinhalt darstellt). Sind da welche?

(Diese Frage wurde früher gelöscht. Ich habe diese Frage wieder eingefügt, weil sie wertvoll ist. Ich habe bei Google genau danach gesucht und nichts gefunden. Natürlich ist es trivial, mich selbst zu codieren, aber ich hätte einige Minuten gespart, wenn ich hätte ein so einfaches Skript gefunden. Somit ist es wertvoll.

Diese Fragen hatten auch viele Abstimmungen ohne viel Erklärung. Bitte kommentieren Sie, bevor Sie abstimmen, warum Sie der Meinung sind, dass dies keinen oder einen schlechten Wert hat.

Diese Frage verursachte auch viel Verwirrung darüber, worüber ich frage. Wenn etwas unklar ist, fragen Sie bitte. Ich weiß nicht wirklich, wie ich es klarer machen soll. Beispiele finden Sie in den Antworten.

Auch (nachdem ich die Frage hier gestellt habe) habe ich bereits mehrere Antworten. Ich möchte sie nur (wieder) hier einfügen / verlinken, weil ich denke, dass es für jemanden nützlich sein könnte, der danach sucht.)

Unter Debian und anderen Linux-Distributionen ist standardmäßig (zusammen mit vim) das xxdTool installiert , das mit der -iOption tun kann, was Sie wollen:

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;

Ein einfaches Tool finden Sie hier :

#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");
}

Die akzeptierte Antwort mit dem xxd-Tool ist hilfreich, wenn Sie sich auf einem * nix-ähnlichen System befinden. Hier ist ein "Einzeiler" für jedes System, auf dessen Pfad Python ausführbar ist:

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>

<Binärdatei> ist der Name der Datei, die Sie in einen C-Header umwandeln möchten, <Headerdatei> ist der Name der Headerdatei und <Arrayname> ist der Name, den das Array haben soll.

Der obige einzeilige Python-Befehl entspricht in etwa dem folgenden (viel besser lesbaren) Python-Programm:

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'};')

Dieses Tool wird in der Entwickler-Eingabeaufforderung in C kompiliert. Es erzeugt eine Ausgabe an das Terminal und zeigt den Inhalt in der erstellten Datei "array_name.c" an. Beachten Sie, dass einige Terminals möglicherweise das Zeichen "\ b" anzeigen.

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

Dies ist eine Binärdatei für den Python-Quellcode des C-Array-Generators, die in Alberts Antwort mit dem Programm identisch ist .

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("};")

Die Frage ist alt, aber lassen Sie mich ein einfaches Werkzeug vorschlagen, das als Alternative verwendet werden kann ...

Sie können das GUI-basierte Tool Fluid verwenden. Es wird tatsächlich zum Entwerfen einer Schnittstelle für das FLTK-Toolkit verwendet, kann jedoch auch ein vorzeichenloses Zeichenarray für C ++ aus einer Binärdatei generieren. Laden Sie es von muquit herunter .

Ich habe alle verfügbaren Optionen überprüft und beschlossen, mein eigenes kleines Programm für die Konvertierung zu erstellen:

https://github.com/TheLivingOne/bin2array/blob/master/bin2array.c

Es funktioniert viel schneller als bin2c und sogar xxd, was für größere Dateien wichtig ist, insbesondere wenn Sie die Konvertierung in Ihr Build-System einbetten möchten. ZB für 50 Mb Datei auf meinem Computer:

bin2c.py> 20 Sek

Einfache Python-Skripte - ca. 10 Sek

xxd - ungefähr 3 Sek

bin2array - ca. 0,4 Sek

Außerdem wird eine viel kompaktere Ausgabe erzeugt und dem Array eine Ausrichtung hinzugefügt, falls Sie dort 32- oder 64-Bit-Werte einfügen möchten.