"#Include" um arquivo de texto em um programa C como um caractere []

Existe uma maneira de incluir um arquivo de texto inteiro como uma string em um programa C em tempo de compilação?

algo como:

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

obtendo um pequeno programa que imprime no stdout "Este é um pequeno arquivo de texto"

No momento, usei um script python hackish, mas é feio e limitado a apenas um nome de variável. Você pode me dizer outra maneira de fazer isso?

Eu sugiro usar (unix util) xxd para isso. você pode usá-lo assim

$ echo hello world > a
$ xxd -i a

saídas:

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

A pergunta era sobre C, mas, se alguém tentar fazer isso com o C ++ 11, isso poderá ser feito com apenas pequenas alterações no arquivo de texto incluído, graças aos novos literais de cadeia de caracteres brutos :

Em C ++, faça o seguinte:

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

No arquivo de texto, faça o seguinte:

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

Portanto, deve haver apenas um prefixo na parte superior do arquivo e um sufixo no final dele. Entre elas, você pode fazer o que quiser, sem escapes especiais, desde que não precise da sequência de caracteres )". Mas mesmo isso pode funcionar se você especificar seu próprio delimitador personalizado:

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

Você tem duas possibilidades:

1. Use as extensões do compilador / vinculador para converter um arquivo em um arquivo binário, com os símbolos adequados apontando para o início e o fim dos dados binários. Veja esta resposta: Inclua arquivo binário com o script do vinculador GNU ld .
2. Converta seu arquivo em uma sequência de constantes de caracteres que podem inicializar uma matriz. Note que você não pode "" simplesmente fazer e abranger várias linhas. Você precisaria de um caractere de continuação de linha ( \), "caracteres de escape e outros para fazer esse trabalho. É mais fácil escrever um pequeno programa para converter os bytes em uma sequência como '\xFF', '\xAB', ...., '\0'(ou usar a ferramenta unix xxddescrita por outra resposta, se você a tiver disponível!):

Código:

#include <stdio.h>

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

(não testado). Então faça:

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

Onde data.h é gerado por

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

ok, inspirado no post de Daemin, testei o seguinte exemplo simples:

a.data:

"this is test\n file\n"

test.c:

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

gcc -E test.c output:

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

Portanto, está funcionando, mas exige dados entre aspas.

Eu gosto da resposta do kayahr. No entanto, se você não quiser tocar nos arquivos de entrada e se estiver usando o CMake , poderá adicionar as seqüências de caracteres de delimitação no arquivo. O seguinte código do CMake, por exemplo, copia os arquivos de entrada e agrupa o conteúdo adequadamente:

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)

Em seguida, inclua no c ++ assim:

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

Você pode fazer isso usando objcopy:

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

Agora você tem um arquivo de objeto que pode ser vinculado ao seu executável, que contém símbolos para o início, fim e tamanho do conteúdo myfile.txt.

Você precisa do meu xtrutilitário, mas pode fazê-lo com um bash script. Este é um script que eu chamo bin2inc. O primeiro parâmetro é o nome do resultante char[] variable. O segundo parâmetro é o nome do file. A saída é C include filecom o conteúdo do arquivo codificado (em minúsculas hex) como o nome da variável fornecido. O char arrayé zero terminated, e o comprimento dos dados é armazenado em$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")';'

VOCÊ PODE OBTER XTR AQUI xtr (eXTRapolator de caracteres) é GPLV3

Se você estiver disposto a recorrer a alguns truques sujos, poderá ser criativo com literais de string brutos e #includepara certos tipos de arquivos.

Por exemplo, digamos que eu queira incluir alguns scripts SQL para SQLite no meu projeto e que eu queira obter destaque de sintaxe, mas não quero nenhuma infraestrutura de construção especial. Eu posso ter este arquivo test.sqlque é SQL válido para SQLite, onde --inicia um comentário:

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

E então, no meu código C ++, posso ter:

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

    cout << mysql << endl;
}

A saída é:

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

Ou, para incluir algum código Python de um arquivo test.pyque é um script Python válido (porque #inicia um comentário no Python e passnão funciona):

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

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

E então no código C ++:

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

    cout << mypython << endl;
}

Qual saída:

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

myfunc()
#undef pass
#define pass

Deve ser possível executar truques semelhantes para vários outros tipos de código que você pode querer incluir como uma string. Se é uma boa ideia ou não, não tenho certeza. É uma espécie de truque, mas provavelmente não é algo que você deseja em um código de produção real. Pode ser bom para um projeto de hack de fim de semana.

Reimplementei o xxd no python3, corrigindo todos os aborrecimentos do xxd:

• Const correção
• tipo de dados comprimento da cadeia: int → size_t
• Rescisão nula (no caso de você querer isso)
• Compatível com string C: solte unsignedna matriz.
• Saída menor e legível, como você teria escrito: Ascii imprimível é produzido como está; outros bytes são codificados em hexadecimal.

Aqui está o script, filtrado por si só, para que você possa ver o que ele faz:

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;

Uso (extrai o script):

#include <stdio.h>

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

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

O que pode funcionar é se você fizer algo como:

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

É claro que você terá que ter cuidado com o que está realmente no arquivo , certificando-se de que não haja aspas duplas, que todos os caracteres apropriados sejam escapados etc.

Portanto, pode ser mais fácil se você apenas carregar o texto de um arquivo em tempo de execução ou incorporar o texto diretamente no código.

Se você ainda quisesse o texto em outro arquivo, poderia tê-lo lá, mas ele teria que ser representado lá como uma string. Você usaria o código como acima, mas sem aspas duplas. Por exemplo:

file.txt

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

main.cpp

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

Então, basicamente, ter uma string de estilo C ou C ++ em um arquivo de texto que você incluir. Isso tornaria o código mais limpo, porque não há muito texto no início do arquivo.

Mesmo que isso possa ser feito em tempo de compilação (acho que não em geral), o texto provavelmente será o cabeçalho pré-processado, e não o conteúdo dos arquivos literalmente. Espero que você precise carregar o texto do arquivo em tempo de execução ou fazer um trabalho desagradável de cortar e colar.

A resposta de Hasturkun usando a opção xxd -i é excelente. Se você deseja incorporar o processo de conversão (texto -> arquivo de inclusão hexadecimal) diretamente na sua compilação, a ferramenta / biblioteca hexdump.c adicionou recentemente um recurso semelhante à opção -i do xxd (ele não fornece o cabeçalho completo - você precisa para fornecer a definição da matriz de caracteres, mas com a vantagem de permitir que você escolha o nome da matriz de caracteres):

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

Sua licença é muito mais "padrão" que o xxd e é muito liberal - um exemplo de como usá-lo para incorporar um arquivo init em um programa pode ser visto nos arquivos CMakeLists.txt e schema.c aqui:

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

Existem prós e contras na inclusão de arquivos gerados nas árvores de origem e nos utilitários de empacotamento - como lidar com isso dependerá dos objetivos e necessidades específicos do seu projeto. O hexdump.c abre a opção de empacotamento para este aplicativo.

Eu acho que não é possível apenas com o compilador e o pré-processador. O gcc permite isso:

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

Mas infelizmente não é isso:

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

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

O erro é:

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

Por que não vincular o texto ao programa e usá-lo como uma variável global! Aqui está um exemplo. Estou pensando em usar isso para incluir arquivos de sombreador Open GL em um executável, pois os sombreadores GL precisam ser compilados para a GPU em tempo de execução.

Eu tive problemas semelhantes e, para arquivos pequenos, a solução de Johannes Schaub acima mencionada funcionou como um encanto para mim.

No entanto, para arquivos um pouco maiores, houve problemas com o limite da matriz de caracteres do compilador. Portanto, escrevi um pequeno aplicativo de codificador que converte o conteúdo do arquivo em uma matriz de caracteres 2D de pedaços de tamanho igual (e possivelmente preenchendo zeros). Produz arquivos de texto de saída com dados de matriz 2D como este:

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

onde 4 é realmente uma variável MAX_CHARS_PER_ARRAY no codificador. O arquivo com o código C resultante, chamado, por exemplo "main_js_file_data.h", pode ser facilmente incorporado ao aplicativo C ++, por exemplo:

#include "main_js_file_data.h"

Aqui está o código fonte do codificador:

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

Esse problema estava me irritando e o xxd não funciona no meu caso de uso, porque fez a variável chamada algo como __home_myname_build_prog_cmakelists_src_autogen quando tentei fazer o script, então criei um utilitário para resolver esse problema exato:

https://github.com/Exaeta/brcc

Ele gera um arquivo de origem e de cabeçalho e permite definir explicitamente o nome de cada variável para que você possa usá-los via std :: begin (nome da matriz) e std :: end (nome da matriz).

Eu o incorporei no meu projeto cmake da seguinte forma:

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)

Com pequenos ajustes, acho que também poderia funcionar para C.

em xh

"this is a "
"buncha text"

em main.c

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

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

    return 0
}

deveria fazer o trabalho.