logo

drewdevault.com

[mirror] blog and personal website of Drew DeVault git clone https://hacktivis.me/git/mirror/drewdevault.com.git

Embedding-files-in-C.md (2521B)

    

  1. ---
  2. date: 2018-05-29
  3. layout: post
  4. title: Embedding files in C programs with koio
  5. tags: [C, announcement]
  6. ---
  8. Quick blog post today to introduce a new tool I wrote:
  9. [koio](https://git.sr.ht/~sircmpwn/koio). This is a small tool which takes a
  10. list of files and embeds them in a C file. A library provides an fopen shim
  11. which checks the list of embedded files before resorting to the real filesystem.
  13. I made this tool for [chopsui](https://github.com/SirCmpwn/chopsui), where I
  14. eventually want to be able to bundle up sui markup, stylesheets, images, and so
  15. on in a statically linked chopsui program. Many projects have small tools which
  16. serve a similar purpose, but it was simple enough and useful enough that I chose
  17. to make something generic so it could be used on several projects.
  19. The usage is pretty simple. I can embed `ko_fopen.c` in a C file with this
  20. command:
  22. ```sh
  23. $ koio -o bundle.c ko_fopen.c://ko_fopen.c
  24. ```
  26. I can compile and link with `bundle.c` and do something like this:
  28. ```c
  29. #include <koio.h>
  31. void koio_load_assets(void);
  32. void koio_unload_assets(void);
  34. int main(int argc, char **argv) {
  35.     koio_load_assets();
  36.     FILE *src = ko_fopen("//ko_fopen.c", "r");
  37.     int c;
  38.     while ((c = fgetc(src)) != EOF) {
  39.         putchar(c);
  40.     }
  41.     fclose(src);
  42.     koio_unload_assets();
  43.     return 0;
  44. }
  45. ```
  47. The generated `bundle.c` looks like this:
  49. ```c
  50. #include <koio.h>
  52. static struct {
  53. 	const char *path;
  54. 	size_t len;
  55. 	char *data;
  56. } files[] = {
  57. 	{
  58. 		.path = "//ko_fopen.c",
  59. 		.len = 408,
  60. 		.data =
  61. "#define _POSIX_C_SOURCE 200809L\n#include <errno.h>\n#include <stdlib.h>\n#inc"
  62. "lude <stdio.h>\n#include \"koio_private.h\"\n\nFILE *ko_fopen(const char *path"
  63. ", const char *mode) {\n\tstruct file_entry *entry = hashtable_get(&koio_vfs, p"
  64. "ath);\n\tif (entry) {\n\t\tif (mode[0] != 'r' || mode[1] != '\\0') {\n\t\t\ter"
  65. "rno = ENOTSUP;\n\t\t\treturn NULL;\n\t\t}\n\t\treturn fmemopen(entry->data, en"
  66. "try->len, \"r\");\n\t}\n\treturn fopen(path, mode);\n}\n",
  67. 	},
  68. };
  70. void koio_load_assets(void) {
  71. 	ko_add_file(files[0].path, files[0].data, files[0].len);
  72. }
  74. void koio_unload_assets(void) {
  75. 	ko_del_file(files[0].path);
  76. }
  77. ```
  79. A very simple tool, but one that I hope people will find useful. It's very
  80. lightweight:
  82. - 312 lines of C
  83. - /bin/koio is ~40 KiB statically linked to musl
  84. - libkoio.a is ~18 KiB
  85. - Only mandatory dependencies are POSIX 2008 and a C99 compiler
  86. - Only optional dependency is [scdoc](https://git.sr.ht/~sircmpwn/scdoc) for the
  87.   manual, which is similarly lightweight
  89. Enjoy!