P1967. Use with a capable compiler. Errors if your compiler doesn't have the built-in or a way to detect the built-in.

CC0.

• Clang Progress:

  • #embed <> vs. #embed "" handled properly
  • Parameters (suffix(token-soup), prefix(token-soup), limit(token-soup), is_empty(token-soup))
  • Unknown parameters are warned on
  • __has_embed
  • Re-done builtin for optimizations.

• GCC Progress:

  • Maybe some other day when I am not exhausted.

• MSVC Progress:

  • I can't propose features to that compiler. ¯\_(ツ)_/¯

More examples that are used to test the compiler can be found in this directory.

Filesystem:

- 📁 bar
- 📂 baz
  |-- 📄 art.txt
- 📄 foo.txt
- 💻 main.c

Files:

foo.txt:

Foo

art.txt:

           __  _
       .-.'  `; `-._  __  _
      (_,         .-:'  `; `-._
    ,'o"(        (_,           )
   (__,-'      ,'o"(            )>
      (       (__,-'            )
       `-'._.--._(             )
          |||  |||`-'._.--._.-'
                     |||  |||

clang -std=c2x -binary-dir ./baz main.c

(Works with g++ / in C++ mode too.)

main.c:

#include <stdint.h>
#include <stdio.h>

int main () {
	const unsigned char str_data[] = {
#embed "art.txt" suffix(,)
		0
		// add your own null termination to data;
		// can put additional initializers 
		// anywhere before / after
	};
	puts(str_data);
	return 0;
}

clang -std=c2x -binary-dir=./baz main.c

main.c:

#include <stdint.h>
#include <assert.h>
#include <stdbool.h>

#define ARRAY_SIZE(x) (sizeof(arr_val) / sizeof(arr_val[0]))

int main () {
	const unsigned char data[] = {
#embed "art.txt"
	};

	const int size = ARRAY_SIZE(data);
	bool is_null_terminated = data[size - 1] == '\0';
	assert(not is_null_terminated);

	return 0;
}

clang -std=c2x main.c

(Works with g++ / in C++ mode too.)

main.c:

#include <stdint.h>
#include <assert.h>

#define ARRAY_SIZE(x) (sizeof(arr_val) / sizeof(arr_val[0]))

int main () {
	const unsigned char data[] = {
#embed "/dev/urandom" limit(4)
	};

	assert(ARRAY_SIZE(data) == 4);

	// ¯\_(ツ)_/¯
	return data[0];
}

WARNING: The following code was done back when an implementation existed for both GCC and Clang. The implementation has been changed since then, so these numbers are currently not reproducible since I'm very much a derp and destroyed my Clang and GCC repositories for both implementations 😭.

Below are timing results for a file of random bytes using a specific strategy. The file is of the size specified at the top of the column. Files are kept the same between strategies and tests.

• Intel Core i7 @ 2.60 GHz
• 24.0 GB RAM
• Debian Sid or Windows 10
• Method: Gather timings from time *nix program | Measure-Command { ... } PowerShell, average

Below is the peak memory usage (heap usage) for a file of random bytes using a specific strategy. The file is of the size specified at the top of the column. Files are kept the same between strategies and tests.

• Intel Core i7 @ 2.60 GHz
• 24.0 GB RAM
• Debian Sid or Windows 10
• Method: /usr/bin/time -v or Execute command hundreds of times, stare at Task Manager