How can I use the C/C++ preprocessor to concatenate string literals and byte values

I'm writing some code for a microcontroller, and I'm trying to shave off quite a bit of the program memory required by converting a whole slew of function calls with string, char, and byte parameters into compile time constant strings that are then interpreted as control codes. The values used are all known at compile time, so I'm not expecting any magic here. The problem is I can't find any way to join a string with a byte value, e.g. if I have a control character of "W" and a value of "32" I want to create a 3 byte char * which contains "W\x20\x0" Having NULL values embedded within the string is not an issue with the way it's going to be parsed.

Most questions I find on the subject offer solutions for concatenating the stringified value of the byte, which in theory would work, but it makes parsing the control sequence more complex since now a single byte can be up to 3 characters, and this also takes up more space within the string which rather defeats the purpose of the exercise.

So far I've tried:

• Treat everything as a character to create a comma delimited char array. Works great for the char values and bytes (obviously), but there seems to be no way to add a string literal to a char[] using macros and manually coverting all string literals to char arrays isn't great for readability
• Treat everything as a string, which maintains a good amount of readability for strings and characters, but now the byte values are problematic. I can find no way of getting the preprocessor to turn 32 into "\x20" (or even "\x32"). The best workaround I've found is to actually convert all byte values into strings as an input to the macro, but DO_SOME_COMMAND("\x20") is a fair bit worse than being able to do DO_SOME_COMMAND(32). (So far this seems to be the best option available)
• Forget macros and concatenate character arrays and strings using memcpy or printf, and rely on the compiler to optimize it down to a compile time constant. This seems to work for simple cases but I'm unsure how crazy I can get before the compiler chokes on it. I'm finding a lot of down sides to this method as well, namely that it requires nesting macros instead of just chaining them one after another and/or creating a bunch of variations for handling different mixes of char * and byte values. Additionally this makes it impossible to have it be compiled into program memory directly, even if the compiler is able to reduce it to a simple string assignment, which somewhat limits my options.
• And of course there's always just process the inputs externally and paste them back in the source code as a single string literal, but that almost seems like cheating and would be impossible to maintain. I'm hoping to keep it as a macro so somebody can look at it and see e.g. SET_CURSOR(20,40) rather than "C\x14\x28"

Maybe I'm asking too much from the preprocessor here, but it feels like there should be some kind of workable approach to this. So, is this possible, or am I actually asking too much?

> SET_CURSOR(20,40) rather than "C\x14\x28"

A simple way in C would be to just do a compound literal:

#define SET_CURSOR(a, b)  (const char[]){'C', a, b}

In C++, the above code is invalid, which shows the differences between languages. In C++ you can instantiate a template:

template<int x, int y>
struct SetCursorDetail {
    constexpr static const char value[3] = {'C', x, y};
};
#define SET_CURSOR(x, y)  SetCursorDetail<x, y>::value
const char *str = SET_CURSOR(20, 40);

We can do "real" replacing to get a string literal by replacing the numbers with a string literal using a dictionary of all possible values. Then, consecutive string literals are concatenated by the compiler. So we can do this:

/* dictionary integer to character */
#define ITOC_0  "\x0"
#define ITOC_1  "\x1"
#define ITOC_2  "\x2"
#define ITOC_3  "\x3"
/* etc */
#define ITOC_20  "\x14"
/* etc */
#define ITOC_40  "\x28"
/* etc */
#define ITOC(x)  ITOC_##x

#define SET_CURSOR(a, b)  "C" ITOC(a) ITOC(b)

const char *str = SET_CURSOR(20, 40);  // "C" "\x14" "\x28";