"#Include" un file di testo in un programma C come char []

C'è un modo per includere un intero file di testo come stringa in un programma C in fase di compilazione?

qualcosa di simile a:

• file.txt:

  This is
  a little
  text file
  

• main.c:

  #include <stdio.h>
  int main(void) {
     #blackmagicinclude("file.txt", content)
     /*
     equiv: char[] content = "This is\na little\ntext file";
     */
     printf("%s", content);
  }
  

ottenere un piccolo programma che stampa su stdout "Questo è un piccolo file di testo"

Al momento ho usato uno script python hacker, ma è brutto e limitato a un solo nome di variabile, puoi dirmi un altro modo per farlo?

Suggerirei di usare (unix util) xxd per questo. puoi usarlo in questo modo

$ echo hello world > a
$ xxd -i a

uscite:

unsigned char a[] = {
  0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, 0x0a
};
unsigned int a_len = 12;

La domanda riguardava C, ma nel caso in cui qualcuno provi a farlo con C ++ 11, allora può essere fatto solo con piccole modifiche al file di testo incluso grazie ai nuovi valori letterali non elaborati :

In C ++ fai questo:

const char *s =
#include "test.txt"
;

Nel file di testo, procedere come segue:

R"(Line 1
Line 2
Line 3
Line 4
Line 5
Line 6)"

Quindi ci deve essere solo un prefisso nella parte superiore del file e un suffisso alla fine di esso. In mezzo puoi fare quello che vuoi, non è necessario scappare se non hai bisogno della sequenza di caratteri )". Ma anche questo può funzionare se specifichi il tuo delimitatore personalizzato:

R"=====(Line 1
Line 2
Line 3
Now you can use "( and )" in the text file, too.
Line 5
Line 6)====="

Hai due possibilità:

1. Utilizzare le estensioni del compilatore / linker per convertire un file in un file binario, con simboli appropriati che indicano l'inizio e la fine dei dati binari. Vedi questa risposta: Includi il file binario con lo script GNU ld linker .
2. Converti il ​​tuo file in una sequenza di costanti di caratteri che possono inizializzare un array. Nota che non puoi semplicemente "" e estendere più righe. Avresti bisogno di un carattere di continuazione di riga ( \), di "caratteri di escape e altri per farlo funzionare. È più semplice scrivere un piccolo programma per convertire i byte in una sequenza simile '\xFF', '\xAB', ...., '\0'(o utilizzare lo strumento unix xxddescritto da un'altra risposta, se disponibile!):

Codice:

#include <stdio.h>

int main() {
    int c;
    while((c = fgetc(stdin)) != EOF) {
        printf("'\\x%X',", (unsigned)c);
    }
    printf("'\\0'"); // put terminating zero
}

(non testato). Quindi fa:

char my_file[] = {
#include "data.h"
};

Dove data.h è generato da

cat file.bin | ./bin2c > data.h

ok, ispirato al post di Daemin, ho testato il seguente semplice esempio:

a.data:

"this is test\n file\n"

test.c:

int main(void)
{
    char *test = 
#include "a.data"
    ;
    return 0;
}

gcc -E output test.c:

# 1 "test.c"
# 1 "<built-in>"
# 1 "<command line>"
# 1 "test.c"

int main(void)
{
    char *test =
# 1 "a.data" 1
"this is test\n file\n"
# 6 "test.c" 2
    ;
    return 0;
}

Quindi funziona ma richiede dati racchiusi tra virgolette.

Mi piace la risposta di Kayahr. Se tuttavia non si desidera toccare i file di input e se si utilizza CMake , è possibile aggiungere le sequenze di caratteri delimitatori sul file. Il seguente codice CMake, ad esempio, copia i file di input e li avvolge di conseguenza:

function(make_includable input_file output_file)
    file(READ ${input_file} content)
    set(delim "for_c++_include")
    set(content "R\"${delim}(\n${content})${delim}\"")
    file(WRITE ${output_file} "${content}")
endfunction(make_includable)

# Use like
make_includable(external/shaders/cool.frag generated/cool.frag)

Quindi includere in c ++ in questo modo:

constexpr char *test =
#include "generated/cool.frag"
;

Puoi farlo usando objcopy:

objcopy --input binary --output elf64-x86-64 myfile.txt myfile.o

Ora hai un file oggetto che puoi collegare al tuo eseguibile che contiene simboli per l'inizio, la fine e la dimensione del contenuto da myfile.txt.

Hai bisogno della mia xtrutility ma puoi farlo con a bash script. Questo è uno script che chiamo bin2inc. Il primo parametro è il nome del risultato char[] variable. Il secondo parametro è il nome di file. L'output è C include filecon il contenuto del file codificato (in minuscolo hex) come nome della variabile indicato. Il char arrayè zero terminated, e la lunghezza dei dati è memorizzato in$variableName_length

#!/bin/bash

fileSize ()

{

    [ -e "$1" ]  && {

        set -- `ls -l "$1"`;

        echo $5;

    }

}

echo unsigned char $1'[] = {'
./xtr -fhex -p 0x -s ', ' < "$2";
echo '0x00'
echo '};';
echo '';
echo unsigned long int ${1}_length = $(fileSize "$2")';'

PUOI OTTENERE XTR QUI xtr (character eXTRapolator) è GPLV3

Se sei disposto a ricorrere ad alcuni trucchi sporchi puoi diventare creativo con valori letterali di stringa grezzi e #includeper alcuni tipi di file.

Ad esempio, supponiamo che io voglia includere alcuni script SQL per SQLite nel mio progetto e desidero ottenere l'evidenziazione della sintassi ma non voglio alcuna infrastruttura di build speciale. Posso avere questo file test.sqlche è SQL valido per SQLite dove --inizia un commento:

--x, R"(--
SELECT * from TestTable
WHERE field = 5
--)"

E poi nel mio codice C ++ posso avere:

int main()
{
    auto x = 0;
    const char* mysql = (
#include "test.sql"
    );

    cout << mysql << endl;
}

L'output è:

--
SELECT * from TestTable
WHERE field = 5
--

O per includere un po 'di codice Python da un file test.pyche è uno script Python valido (perché #avvia un commento in Python ed passè un no-op):

#define pass R"(
pass
def myfunc():
    print("Some Python code")

myfunc()
#undef pass
#define pass )"
pass

E poi nel codice C ++:

int main()
{
    const char* mypython = (
#include "test.py"
    );

    cout << mypython << endl;
}

Che produrrà:

pass
def myfunc():
    print("Some Python code")

myfunc()
#undef pass
#define pass

Dovrebbe essere possibile giocare trucchi simili per vari altri tipi di codice che potresti voler includere come stringa. Non è sicuro che sia una buona idea. È una specie di hack pulito ma probabilmente non è qualcosa che vorresti nel vero codice di produzione. Potrebbe andare bene per un progetto di hack del fine settimana però.

Ho reimplementato xxd in python3, risolvendo tutti i fastidi di xxd:

• Costante correttezza
• tipo di dati lunghezza stringa: int → size_t
• Terminazione nulla (nel caso in cui si desideri)
• C string compatibile: rilascia unsignedsull'array.
• Output più piccolo e leggibile, come l'avresti scritto: ASCII stampabile viene prodotto così com'è; altri byte sono codificati in esadecimale.

Ecco lo script, filtrato da solo, quindi puoi vedere cosa fa:

pyxxd.c

#include <stddef.h>

extern const char pyxxd[];
extern const size_t pyxxd_len;

const char pyxxd[] =
"#!/usr/bin/env python3\n"
"\n"
"import sys\n"
"import re\n"
"\n"
"def is_printable_ascii(byte):\n"
"    return byte >= ord(' ') and byte <= ord('~')\n"
"\n"
"def needs_escaping(byte):\n"
"    return byte == ord('\\\"') or byte == ord('\\\\')\n"
"\n"
"def stringify_nibble(nibble):\n"
"    if nibble < 10:\n"
"        return chr(nibble + ord('0'))\n"
"    return chr(nibble - 10 + ord('a'))\n"
"\n"
"def write_byte(of, byte):\n"
"    if is_printable_ascii(byte):\n"
"        if needs_escaping(byte):\n"
"            of.write('\\\\')\n"
"        of.write(chr(byte))\n"
"    elif byte == ord('\\n'):\n"
"        of.write('\\\\n\"\\n\"')\n"
"    else:\n"
"        of.write('\\\\x')\n"
"        of.write(stringify_nibble(byte >> 4))\n"
"        of.write(stringify_nibble(byte & 0xf))\n"
"\n"
"def mk_valid_identifier(s):\n"
"    s = re.sub('^[^_a-z]', '_', s)\n"
"    s = re.sub('[^_a-z0-9]', '_', s)\n"
"    return s\n"
"\n"
"def main():\n"
"    # `xxd -i` compatibility\n"
"    if len(sys.argv) != 4 or sys.argv[1] != \"-i\":\n"
"        print(\"Usage: xxd -i infile outfile\")\n"
"        exit(2)\n"
"\n"
"    with open(sys.argv[2], \"rb\") as infile:\n"
"        with open(sys.argv[3], \"w\") as outfile:\n"
"\n"
"            identifier = mk_valid_identifier(sys.argv[2]);\n"
"            outfile.write('#include <stddef.h>\\n\\n');\n"
"            outfile.write('extern const char {}[];\\n'.format(identifier));\n"
"            outfile.write('extern const size_t {}_len;\\n\\n'.format(identifier));\n"
"            outfile.write('const char {}[] =\\n\"'.format(identifier));\n"
"\n"
"            while True:\n"
"                byte = infile.read(1)\n"
"                if byte == b\"\":\n"
"                    break\n"
"                write_byte(outfile, ord(byte))\n"
"\n"
"            outfile.write('\";\\n\\n');\n"
"            outfile.write('const size_t {}_len = sizeof({}) - 1;\\n'.format(identifier, identifier));\n"
"\n"
"if __name__ == '__main__':\n"
"    main()\n"
"";

const size_t pyxxd_len = sizeof(pyxxd) - 1;

Utilizzo (questo estrae lo script):

#include <stdio.h>

extern const char pyxxd[];
extern const size_t pyxxd_len;

int main()
{
    fwrite(pyxxd, 1, pyxxd_len, stdout);
}

Cosa potrebbe funzionare se fai qualcosa del tipo:

int main()
{
    const char* text = "
#include "file.txt"
";
    printf("%s", text);
    return 0;
}

Ovviamente dovrai stare attento a ciò che è effettivamente nel file , assicurandoti che non ci siano doppie virgolette, che tutti i caratteri appropriati siano sfuggiti, ecc.

Pertanto, potrebbe essere più semplice caricare semplicemente il testo da un file in fase di esecuzione o incorporare il testo direttamente nel codice.

Se volessi ancora il testo in un altro file, potresti averlo lì dentro, ma dovrebbe essere rappresentato lì come una stringa. Dovresti usare il codice come sopra ma senza le doppie virgolette. Per esempio:

file.txt

"Something evil\n"\
"this way comes!"

main.cpp

int main()
{
    const char* text =
#include "file.txt"
;
    printf("%s", text);
    return 0;
}

Quindi fondamentalmente avere una stringa di stile C o C ++ in un file di testo che includi. Renderebbe il codice più pulito perché non c'è questa enorme quantità di testo all'inizio del file.

Anche se può essere fatto in fase di compilazione (non credo che possa in generale), il testo sarebbe probabilmente l'intestazione preelaborata anziché il contenuto dei file alla lettera. Mi aspetto che dovrai caricare il testo dal file in fase di esecuzione o fare un brutto lavoro di taglia e incolla.

La risposta di Hasturkun usando l'opzione xxd -i è eccellente. Se vuoi incorporare il processo di conversione (testo -> hex include file) direttamente nella tua build, lo strumento / libreria hexdump.c ha recentemente aggiunto una funzionalità simile all'opzione -i di xxd (non ti dà l'intestazione completa - devi per fornire la definizione di array di caratteri, ma questo ha il vantaggio di consentire di scegliere il nome dell'array di caratteri):

http://25thandclement.com/~william/projects/hexdump.c.html

La sua licenza è molto più "standard" di xxd ed è molto liberale - un esempio di come usarlo per incorporare un file init in un programma può essere visto qui nei file CMakeLists.txt e schema.c:

https://github.com/starseeker/tinyscheme-cmake

Esistono vantaggi e svantaggi sia nell'includere i file generati negli alberi dei sorgenti sia nelle utilità di raggruppamento: il modo in cui gestirli dipenderà dagli obiettivi e dalle esigenze specifici del progetto. hexdump.c apre l'opzione di raggruppamento per questa applicazione.

Penso che non sia possibile solo con il compilatore e il preprocessore. gcc lo consente:

#define _STRGF(x) # x
#define STRGF(x) _STRGF(x)

    printk ( MODULE_NAME " built " __DATE__ " at " __TIME__ " on host "
            STRGF(
#               define hostname my_dear_hostname
                hostname
            )
            "\n" );

Ma sfortunatamente non questo:

#define _STRGF(x) # x
#define STRGF(x) _STRGF(x)

    printk ( MODULE_NAME " built " __DATE__ " at " __TIME__ " on host "
            STRGF(
#               include "/etc/hostname"
            )
            "\n" );

L'errore è:

/etc/hostname: In function ‘init_module’:
/etc/hostname:1:0: error: unterminated argument list invoking macro "STRGF"

Perché non collegare il testo al programma e usarlo come variabile globale! Ecco un esempio Sto pensando di usarlo per includere file shader Open GL all'interno di un eseguibile poiché gli shader GL devono essere compilati per la GPU in fase di esecuzione.

Ho avuto problemi simili e per file di piccole dimensioni la soluzione di Johannes Schaub sopra menzionata ha funzionato come un incantesimo per me.

Tuttavia, per file leggermente più grandi, si sono verificati problemi con il limite dell'array di caratteri del compilatore. Pertanto, ho scritto una piccola applicazione codificatore che converte il contenuto del file in una matrice di caratteri 2D di blocchi di dimensioni uguali (e possibilmente riempiendo zeri). Produce file di testo di output con dati di array 2D come questo:

const char main_js_file_data[8][4]= {
    {'\x69','\x73','\x20','\0'},
    {'\x69','\x73','\x20','\0'},
    {'\x61','\x20','\x74','\0'},
    {'\x65','\x73','\x74','\0'},
    {'\x20','\x66','\x6f','\0'},
    {'\x72','\x20','\x79','\0'},
    {'\x6f','\x75','\xd','\0'},
    {'\xa','\0','\0','\0'}};

dove 4 è in realtà una variabile MAX_CHARS_PER_ARRAY nell'encoder. Il file con il codice C risultante, chiamato ad esempio "main_js_file_data.h", può quindi essere facilmente incorporato nell'applicazione C ++, ad esempio in questo modo:

#include "main_js_file_data.h"

Ecco il codice sorgente dell'encoder:

#include <fstream>
#include <iterator>
#include <vector>
#include <algorithm>


#define MAX_CHARS_PER_ARRAY 2048


int main(int argc, char * argv[])
{
    // three parameters: input filename, output filename, variable name
    if (argc < 4)
    {
        return 1;
    }

    // buffer data, packaged into chunks
    std::vector<char> bufferedData;

    // open input file, in binary mode
    {    
        std::ifstream fStr(argv[1], std::ios::binary);
        if (!fStr.is_open())
        {
            return 1;
        }

        bufferedData.assign(std::istreambuf_iterator<char>(fStr), 
                            std::istreambuf_iterator<char>()     );
    }

    // write output text file, containing a variable declaration,
    // which will be a fixed-size two-dimensional plain array
    {
        std::ofstream fStr(argv[2]);
        if (!fStr.is_open())
        {
            return 1;
        }
        const std::size_t numChunks = std::size_t(std::ceil(double(bufferedData.size()) / (MAX_CHARS_PER_ARRAY - 1)));
        fStr << "const char " << argv[3] << "[" << numChunks           << "]"    <<
                                            "[" << MAX_CHARS_PER_ARRAY << "]= {" << std::endl;
        std::size_t count = 0;
        fStr << std::hex;
        while (count < bufferedData.size())
        {
            std::size_t n = 0;
            fStr << "{";
            for (; n < MAX_CHARS_PER_ARRAY - 1 && count < bufferedData.size(); ++n)
            {
                fStr << "'\\x" << int(unsigned char(bufferedData[count++])) << "',";
            }
            // fill missing part to reach fixed chunk size with zero entries
            for (std::size_t j = 0; j < (MAX_CHARS_PER_ARRAY - 1) - n; ++j)
            {
                fStr << "'\\0',";
            }
            fStr << "'\\0'}";
            if (count < bufferedData.size())
            {
                fStr << ",\n";
            }
        }
        fStr << "};\n";
    }

    return 0;
}

Questo problema mi irritava e xxd non funziona per il mio caso d'uso perché ha reso la variabile chiamata qualcosa come __home_myname_build_prog_cmakelists_src_autogen quando ho provato a scriverlo, quindi ho creato un'utilità per risolvere questo esatto problema:

https://github.com/Exaeta/brcc

Genera un file sorgente e di intestazione e consente di impostare esplicitamente il nome di ciascuna variabile in modo da poterle utilizzare tramite std :: begin (arrayname) e std :: end (arrayname).

L'ho incorporato nel mio progetto cmake in questo modo:

add_custom_command(
  OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/binary_resources.hpp ${CMAKE_CURRENT_BINARY_DIR}/binary_resources.cpp
  COMMAND brcc ${CMAKE_CURRENT_BINARY_DIR}/binary_resources RGAME_BINARY_RESOURCES_HH txt_vertex_shader ${CMAKE_CURRENT_BINARY_DIR}/src/vertex_shader1.glsl
  DEPENDS src/vertex_shader1.glsl)

Con piccole modifiche, suppongo che potrebbe funzionare anche per C.

in xh

"this is a "
"buncha text"

in main.c

#include <stdio.h>
int main(void)
{
    char *textFileContents =
#include "x.h"
    ;

    printf("%s\n", textFileContents);

    return 0
}

dovrebbe fare il lavoro.