Related
I often find myself writing helper debugger methods that return a printable string, given some enum value. The reason for this is when you typically log an enum, all you get is a number really. I hate having to go back to my source to figure out what that enum is. So I would do something like
typedef enum
{
kOne = 1,
kTwo,
kThree,
}
MyEnum;
NSString *debugStringForEnum(MyEnum e)
{
switch ( e )
case kOne:
return #"One";
case kTwo:
return #"Two";
....
}
....
NSLog(#"My debug log: %#", debugStringForEnum(someVariable));
So my question is, is there any way to avoid writing all this helper code, just to see the label value of enum?
Thanks
If you're willing to write "naughty" code that makes other developers cry, then yes. Try this:
#define ENUM(name, ...) typedef enum { M_FOR_EACH(ENUM_IDENTITY, __VA_ARGS__) } name; \
char * name ## _DEBUGSTRINGS [] = { M_FOR_EACH(ENUM_STRINGIZE, __VA_ARGS__) };
#define ENUM_IDENTITY(A) A,
#define ENUM_STRINGIZE(A) #A,
ENUM(MyEnum,
foo, bar, baz, boo
)
You obviously need a for-each macro to make this work. Here's a simple one:
#define M_NARGS(...) M_NARGS_(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define M_NARGS_(_10, _9, _8, _7, _6, _5, _4, _3, _2, _1, N, ...) N
#define M_CONC(A, B) M_CONC_(A, B)
#define M_CONC_(A, B) A##B
#define M_FOR_EACH(ACTN, ...) M_CONC(M_FOR_EACH_, M_NARGS(__VA_ARGS__)) (ACTN, __VA_ARGS__)
#define M_FOR_EACH_0(ACTN, E) E
#define M_FOR_EACH_1(ACTN, E) ACTN(E)
#define M_FOR_EACH_2(ACTN, E, ...) ACTN(E) M_FOR_EACH_1(ACTN, __VA_ARGS__)
#define M_FOR_EACH_3(ACTN, E, ...) ACTN(E) M_FOR_EACH_2(ACTN, __VA_ARGS__)
#define M_FOR_EACH_4(ACTN, E, ...) ACTN(E) M_FOR_EACH_3(ACTN, __VA_ARGS__)
#define M_FOR_EACH_5(ACTN, E, ...) ACTN(E) M_FOR_EACH_4(ACTN, __VA_ARGS__)
#define M_FOR_EACH_6(ACTN, E, ...) ACTN(E) M_FOR_EACH_5(ACTN, __VA_ARGS__)
#define M_FOR_EACH_7(ACTN, E, ...) ACTN(E) M_FOR_EACH_6(ACTN, __VA_ARGS__)
#define M_FOR_EACH_8(ACTN, E, ...) ACTN(E) M_FOR_EACH_7(ACTN, __VA_ARGS__)
#define M_FOR_EACH_9(ACTN, E, ...) ACTN(E) M_FOR_EACH_8(ACTN, __VA_ARGS__)
#define M_FOR_EACH_10(ACTN, E, ...) ACTN(E) M_FOR_EACH_9(ACTN, __VA_ARGS__)
It should be obvious how to extend that loop to have a longer upper limit, but... space considerations for this answer. The loop can potentially be as long as you're willing to copy-and-paste extra iterations into this bit.
For the non-debug build, have an #ifdef choose a version of ENUM without the second line.
EDIT: To steal the designated initialisers idea from teppic, here's an even more horrific version that also works with non-ordered initialiser values:
#define ENUM(name, ...) typedef enum { M_FOR_EACH(ENUM_ENAME, __VA_ARGS__) } name; \
char * name ## _DEBUGSTRINGS [] = { M_FOR_EACH(ENUM_ELEM, __VA_ARGS__) };
#define ENUM_ENAME(A) M_IF(M_2ITEMS(M_ID A), (M_FIRST A = M_SECOND A), (A)),
#define ENUM_ELEM(A) M_IF(M_2ITEMS(M_ID A), ([M_FIRST A] = M_STR(M_FIRST A)), ([A] = M_STR(A))),
#define M_STR(A) M_STR_(A)
#define M_STR_(A) #A
#define M_IF(P, T, E) M_CONC(M_IF_, P)(T, E)
#define M_IF_0(T, E) M_ID E
#define M_IF_1(T, E) M_ID T
#define M_2ITEMS(...) M_2I_(__VA_ARGS__, 1, 0)
#define M_2I_(_2, _1, N, ...) N
#define M_FIRST(A, ...) A
#define M_SECOND(A, B, ...) B
#define M_ID(...) __VA_ARGS__
ENUM(MyEnum,
foo, bar, baz, boo
)
ENUM(NotherEnum,
A, B, (C, 12), D, (E, 8)
)
I cannot guarantee your personal safety if you use this kind of thing in code someone else has to maintain.
A simpler method is to set up an array of string literals that replicate the labels according to their position in the array , e.g.
char *enumlabels[] = { NULL, "KOne", "KTwo", "KThree"};
Here you'd need to fill in the gaps to make the enum values match the array positions.
Or, better, for C99 with designated initialisers:
char *enumlabels[] = { [1] = "KOne", [2] = "KTwo", [3] = "KThree"};
In this case, as long as the enum declaration comes first, you can swap the array subscripts directly for the enum values to make it much clearer, e.g. { [kOne] = "kOne", ... }.
then for MyEnum e you could just use printf("%s\n", enumlabels[e]); or some such.
I've written a bit of code to demonstrate this much better:
typedef enum {
white = 1,
red = 2,
green = 4,
blue = 8,
black = 16
} Colour; // be sure to update array below!
char *enum_colours[] = { [white] = "white", [red] = "red", [green] = "green",
[blue] = "blue", [black] = "black" };
Colour c = blue;
printf("The label for %d is %s\n", c, enum_colours[c]);
Output: The label for 8 is blue
If you have huge enum constants (e.g. 32767) this is obviously not an ideal solution, due to the size of array required. Without designated initialisers, you could assign the array values directly, if more laboriously, with enum_colours[white] = "white"; and so on, but only in a function.
You can't get to the enum names at run-time since those symbols are long gone by then, but you can use multi-character constants to create more meaningful values for your enums.
#import <Foundation/Foundation.h>
NSString* debugString(int en) {
return [NSString stringWithFormat:#"%c%c%c%c",
(en>>24) & 0xff,
(en>>16) & 0xff,
(en>>8) & 0xff,
en & 0xff];
}
typedef enum {
kOne = 'One.',
kTwo = 'Two.',
kThree = 'Thre',
} MyEnum;
int main(int argc, const char * argv[])
{
#autoreleasepool {
NSLog(#"kOne = %#", debugString(kOne));
NSLog(#"kTwo = %#", debugString(kTwo));
NSLog(#"kThree = %#", debugString(kThree));
}
return 0;
}
will print
kOne = One.
kTwo = Two.
kThree = Thre
on the console.
To keep debugString from generating garbage, each enum must be exactly four characters long (on OSX anyway). This is extremely compiler and platform dependent. It's good for debugging, but not much else.
Of course this won't work if you need the enums to have specific values or values that relate to each other.
The names themselves wont be available, but it is usually enough to give them an explicit number:
enum{
dog = 100,
cat = 200,
problem = dog+cat, //trailing comma legal in C and C++11
};
I am trying to create a simple unit test library for my projects. I can get most things working, but now I am trying to add some functionality: printing the expressions/input.
It works if I pass arguments by actual value (1, 2.456, false), but if I pass a function argument I get the function string printed.
Here is my code explaining the problem
I am not 100% sure what the STR(x) macro is doing, copied it from somewhere online...
The code actually works (the evaluation of LHS and RHS) just the printing does not, shown below.
#include <stdio.h>
#define STR(x) #x
#define TEST_COMPARE_EQ(TestName, LHS, RHS) \
do { \
if ((LHS) != (RHS)) { \
printf("[Test: %s] --- Failed at line %d in file %s\n", TestName, __LINE__, __FILE__); \
printf("\Got value %s\n", STR(LHS)); \
printf("\Expected value %s\n", STR(RHS)); \
} \
else { \
printf("[Test: %s] --- Passed\n", TestName); \
}\
} while (0)
// Calling code example
// This works, prints:
// Got value 123
// Expected value 124
TEST_COMPARE_EQ("PrintingWorks", 123, 124);
// This however does not work.
// It prints
// Got value my_fn_that_returns_false
// Expected value true
// How can I get it to print the return value of my_fn_that_returns_false, and not
// the actual function name?
TEST_COMPARE_EQ("PrintingDoesNotWork", my_fn_that_returns_false(), true);
what the STR(x) macro is doing,
It takes the code as it is and adds " in front and back. STR(anything) is "anything", just like that.
How can I get it to print the return value
You have to print it.
printf("Got value %d\n", LHS);
No, there are no templates in C. It is hard to write type generic functions in C. You have to handle each possible type separately - like TEST_COMPARE_EQ_INT TEST_COMPARE_EQ_FLOAT etc. For inspiration, take a look at Unity C unit testing library.
Writing that in a type-generic way sounds like a nice challenge in C. It would look basically like the following:
void test_eq_int(int a, const char *astr, int b, const char *btr) {
if (a != b) {
printf("%s = %s -> %d != %s\n", astr, bstr, a, b);
}
}
void test_eq_long(....) { .... }
void test_eq_some_other_type(...) { .... }
// etc. for each possible type
#define TEST_COMPARE_EQ(msg, a, b) \
_Generic(a, \
int: test_eq_int, \
long: test_eq_long, \
/* etc. for each type */ \
)(msg, a, #a, b, #b);
I am trying to test some packages written in C by checking the value of the local and global variables, I tried to use the GDB debugger and fprint as suggested by many people here and they worked well with simple and small programs, but with the package, it's not easy.
So, I need to extract all variables into a txt.file (each line has one variable) and then while running the program I need to print the value of these variables.
I used a normal print statement to take the name of variables from txt file, the problem is the exact character is printed.
Question: how do I use these characters from the text file as variables to print the values not the name?
variables.txt
x
y
d
main.c
in the main file, I included the header and called the func.
//printState.h
void printstate(){
char ch;
FILE *fp;
if(fp = fopen("Varaibles.txt", "r"))
{
ch=getc(fp);
while(ch != EOF)
{
printf("%c",ch);
ch = getc(fp);
}
fclose(fp);
}
}
int func(int x) {
int y = 0;
x = y + x;
if(x > 0){
x = x % 4;
printstate();
/* I want to know the value of x at this point.*/
}
else {
x = x + 1;
printstate();
/* I want to know the value of x at this point.*/
}
return x;
}
expected output:
is the value of x, y, d after the statement (x = x % 4) and (x = x + 1)
For example:
5
7
6
the actual output I got was:
x
y
d
This question implies the use of reflection on the local and global variables. Sadly, C doesn't have such concept.
I'm sure gdb can help you generate the list of local and global variables (maybe here?)
However, since you didn't explicitly say how to achieve this, I'll throw my 2 cents on this.
There are some projects implementing reflection on C, but my preference always goes into exploiting the preprocessor to achieve this. Although you can avoid the header-only library, I will use P99 to ease the macro programming.
a MWE can be the following one:
#include <P99/p99_for.h>
#include <P99/p99_args.h>
#include <stdio.h>
enum print_type {
PT_char,
PT_int,
PT_ptr,
PT_string,
};
#define FOR_PAIR(CONTEXT, OP, FUNC, ...) P99_PASTE2(_BASE_FOR_PAIR_, P99_NARG(__VA_ARGS__))(CONTEXT, OP, FUNC, ## __VA_ARGS__)
#define _BASE_FOR_PAIR_2(CONTEXT, OP, FUNC, value1, value2) FUNC(CONTEXT, 0, value1, value2)
#define _BASE_FOR_PAIR_4(CONTEXT, OP, FUNC, value1, value2, ...) OP(CONTEXT, 1, FUNC(CONTEXT, 1, value1, value2), _BASE_FOR_PAIR_2(CONTEXT, OP, FUNC, ## __VA_ARGS__))
#define _BASE_FOR_PAIR_6(CONTEXT, OP, FUNC, value1, value2, ...) OP(CONTEXT, 2, FUNC(CONTEXT, 2, value1, value2), _BASE_FOR_PAIR_4(CONTEXT, OP, FUNC, ## __VA_ARGS__))
#define _BASE_FOR_PAIR_8(CONTEXT, OP, FUNC, value1, value2, ...) OP(CONTEXT, 3, FUNC(CONTEXT, 3, value1, value2), _BASE_FOR_PAIR_6(CONTEXT, OP, FUNC, ## __VA_ARGS__))
#define _BASE_FOR_PAIR_10(CONTEXT, OP, FUNC, value1, value2, ...) OP(CONTEXT, 4, FUNC(CONTEXT, 4, value1, value2), _BASE_FOR_PAIR_8(CONTEXT, OP, FUNC, ## __VA_ARGS__))
#define _LENGTH_VAR _localsTrackingSystem_arrayLengths
#define _NAMES_VAR _localsTrackingSystem_names
#define _VARIABLES_VAR _localsTrackingSystem_variables
#define _PRINTMETHOD_VAR _localsTrackingSystem_printMethod
#define STR(x) #x
#define _NAMES_REDUCE(NAME, I, REC, RES) REC, RES
#define _NAMES_MAP(context, length, type, name) (STR(name))
#define _GENERATE_NAMES(...) FOR_PAIR(, _NAMES_REDUCE, _NAMES_MAP, ## __VA_ARGS__)
#define _POINTERS_REDUCE(NAME, I, REC, RES) REC; RES
#define _POINTERS_MAP(arrayLength, length, type, aname) _VARIABLES_VAR[arrayLength - length - 1] = ((void*)&aname)
#define _GENERATE_POINTERS(...) FOR_PAIR(P99_DIV(P99_NARG(__VA_ARGS__), 2), _POINTERS_REDUCE, _POINTERS_MAP, ## __VA_ARGS__)
#define _PRINT_REDUCE(NAME, I, REC, RES) REC, RES
#define _PRINT_MAP(context, length, type, name) (P99_PASTE2(PT_, type))
#define _GENERATE_PRINT(...) FOR_PAIR(, _PRINT_REDUCE, _PRINT_MAP, ## __VA_ARGS__)
//variadic needs to be always even
// _GENERATE_POINTERS needs to be initialized every time since pointers may change (although length doesn't)
#define TRACKED_FUNCTION(...) \
static const int _LENGTH_VAR = P99_DIV(P99_NARG(__VA_ARGS__), 2); \
static const char* _NAMES_VAR[] = {_GENERATE_NAMES(__VA_ARGS__)}; \
static const enum print_type _PRINTMETHOD_VAR[] = {_GENERATE_PRINT(__VA_ARGS__)}; \
static const void* _VARIABLES_VAR[P99_DIV(P99_NARG(__VA_ARGS__), 2)]; \
_GENERATE_POINTERS(__VA_ARGS__)
#define printState() _printState(_LENGTH_VAR, _NAMES_VAR, _VARIABLES_VAR, _PRINTMETHOD_VAR);
void _printState(int length, const char** nameArray, const void** pointerArray, const enum print_type* printMethodArray) {
for (int i=0; i<length; ++i) {
printf("at %p %s = ", pointerArray[i], nameArray[i]);
switch (printMethodArray[i]) {
case PT_char: {
printf("%c", *((char*)pointerArray[i]));
break;
}
case PT_int: {
printf("%d", *((int*)pointerArray[i]));
break;
}
case PT_ptr: {
printf("%p", *((void**)pointerArray[i]));
break;
}
case PT_string: {
printf("%s", *((char**)pointerArray[i]));
break;
}
default: {
exit(1);
}
}
printf("\n");
}
}
int func(int x, const char* name){
//LOCALS DEFINITIONS
int y = 0;
int* yPtr = &y;
x = y + x;
//declare which variables you want to track... like your "variables.txt" files
TRACKED_FUNCTION(int, x, int, y, ptr, yPtr, string, name);
//MAIN BODY
if(x > 0) {
x = x % 4;
printf("expected x=%d, y=%d, yPtr=%p name=%s\n", x, y, yPtr, name);
printState();
/* I want to know the value of x at this point.*/
} else {
x = x + 1;
printf("expected x=%d, y=%d, yPtr=%p name=%s\n", x, y, yPtr, name);
printState();
/* I want to know the value of x at this point.*/
}
return x;
}
int main() {
func(5, "Hello World!");
}
My output:
expected x=1, y=0, yPtr=0x7ffec1e5b5ec name=Hello World!
at 0x7ffec1e5b5dc x = 1
at 0x7ffec1e5b5ec y = 0
at 0x7ffec1e5b5f0 yPtr = 0x7ffec1e5b5ec
at 0x7ffec1e5b5d0 name = Hello World!
I've already treated a similar concept here, however let me briefly explain what this code does:
Usage: very simple; after having declared all the variables you're interested in printing, you call TRACKED_FUNCTION and pass a sequences of pairs of variables: the first element of the pair is a string representing how you wish to print the content of the variable (e.g., you might have a char, but maybe you want to print it as int); the second is the name of the variable itself; so in the example TRACKED_FUNCTION(int, x, int, y, ptr, yPtr, string, name); we want to track x which needs to be printed as an int, y as a int, yPtr as a pointer and name as a string; After calling such macro, you can call printState() whenever you want to obtain a list of all the variables you explicitly declared;
Internal details: my main idea is to create 4 "hidden" variables: an array containing all the variables names, another containing all the variables pointers, another one containing for each variable how to print it and an integer representing the length of all the arrays; TRACKED_FUNCTION generates those 3 arrays while printState() just print them. In particular, the first element of each pair in TRACKED_FUNCTION is actually concatenated into an identifier which belong to the enum print_type: this is the main reason why we can use a "type" string but we cannot use a type void*: PT_void* is not a vlaid enum identifier!
Pros: This implementation is, aside a bunch of headers of P99, library-free. Some macro programming is required though; Furthermore it is C99 compliant;
Cons: It's C99 compliant, but we can probably improve the method if we were on C11, however, OP didn't specify it in the tags, so whatever :). Another cons (I think you've guessed it) is the fact that this solution doesn't use the file at all. Even worse, it cannot work with the file because the lines fetched from the file cannot be handled in any way with macro programming. This is why I didn't use it. I don't know if you require to use the file or it suffices list in another way (with this solution in TRACKED_FUNCTION) the variables you're interested in.
Hope it helps
I often find myself writing helper debugger methods that return a printable string, given some enum value. The reason for this is when you typically log an enum, all you get is a number really. I hate having to go back to my source to figure out what that enum is. So I would do something like
typedef enum
{
kOne = 1,
kTwo,
kThree,
}
MyEnum;
NSString *debugStringForEnum(MyEnum e)
{
switch ( e )
case kOne:
return #"One";
case kTwo:
return #"Two";
....
}
....
NSLog(#"My debug log: %#", debugStringForEnum(someVariable));
So my question is, is there any way to avoid writing all this helper code, just to see the label value of enum?
Thanks
If you're willing to write "naughty" code that makes other developers cry, then yes. Try this:
#define ENUM(name, ...) typedef enum { M_FOR_EACH(ENUM_IDENTITY, __VA_ARGS__) } name; \
char * name ## _DEBUGSTRINGS [] = { M_FOR_EACH(ENUM_STRINGIZE, __VA_ARGS__) };
#define ENUM_IDENTITY(A) A,
#define ENUM_STRINGIZE(A) #A,
ENUM(MyEnum,
foo, bar, baz, boo
)
You obviously need a for-each macro to make this work. Here's a simple one:
#define M_NARGS(...) M_NARGS_(__VA_ARGS__, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
#define M_NARGS_(_10, _9, _8, _7, _6, _5, _4, _3, _2, _1, N, ...) N
#define M_CONC(A, B) M_CONC_(A, B)
#define M_CONC_(A, B) A##B
#define M_FOR_EACH(ACTN, ...) M_CONC(M_FOR_EACH_, M_NARGS(__VA_ARGS__)) (ACTN, __VA_ARGS__)
#define M_FOR_EACH_0(ACTN, E) E
#define M_FOR_EACH_1(ACTN, E) ACTN(E)
#define M_FOR_EACH_2(ACTN, E, ...) ACTN(E) M_FOR_EACH_1(ACTN, __VA_ARGS__)
#define M_FOR_EACH_3(ACTN, E, ...) ACTN(E) M_FOR_EACH_2(ACTN, __VA_ARGS__)
#define M_FOR_EACH_4(ACTN, E, ...) ACTN(E) M_FOR_EACH_3(ACTN, __VA_ARGS__)
#define M_FOR_EACH_5(ACTN, E, ...) ACTN(E) M_FOR_EACH_4(ACTN, __VA_ARGS__)
#define M_FOR_EACH_6(ACTN, E, ...) ACTN(E) M_FOR_EACH_5(ACTN, __VA_ARGS__)
#define M_FOR_EACH_7(ACTN, E, ...) ACTN(E) M_FOR_EACH_6(ACTN, __VA_ARGS__)
#define M_FOR_EACH_8(ACTN, E, ...) ACTN(E) M_FOR_EACH_7(ACTN, __VA_ARGS__)
#define M_FOR_EACH_9(ACTN, E, ...) ACTN(E) M_FOR_EACH_8(ACTN, __VA_ARGS__)
#define M_FOR_EACH_10(ACTN, E, ...) ACTN(E) M_FOR_EACH_9(ACTN, __VA_ARGS__)
It should be obvious how to extend that loop to have a longer upper limit, but... space considerations for this answer. The loop can potentially be as long as you're willing to copy-and-paste extra iterations into this bit.
For the non-debug build, have an #ifdef choose a version of ENUM without the second line.
EDIT: To steal the designated initialisers idea from teppic, here's an even more horrific version that also works with non-ordered initialiser values:
#define ENUM(name, ...) typedef enum { M_FOR_EACH(ENUM_ENAME, __VA_ARGS__) } name; \
char * name ## _DEBUGSTRINGS [] = { M_FOR_EACH(ENUM_ELEM, __VA_ARGS__) };
#define ENUM_ENAME(A) M_IF(M_2ITEMS(M_ID A), (M_FIRST A = M_SECOND A), (A)),
#define ENUM_ELEM(A) M_IF(M_2ITEMS(M_ID A), ([M_FIRST A] = M_STR(M_FIRST A)), ([A] = M_STR(A))),
#define M_STR(A) M_STR_(A)
#define M_STR_(A) #A
#define M_IF(P, T, E) M_CONC(M_IF_, P)(T, E)
#define M_IF_0(T, E) M_ID E
#define M_IF_1(T, E) M_ID T
#define M_2ITEMS(...) M_2I_(__VA_ARGS__, 1, 0)
#define M_2I_(_2, _1, N, ...) N
#define M_FIRST(A, ...) A
#define M_SECOND(A, B, ...) B
#define M_ID(...) __VA_ARGS__
ENUM(MyEnum,
foo, bar, baz, boo
)
ENUM(NotherEnum,
A, B, (C, 12), D, (E, 8)
)
I cannot guarantee your personal safety if you use this kind of thing in code someone else has to maintain.
A simpler method is to set up an array of string literals that replicate the labels according to their position in the array , e.g.
char *enumlabels[] = { NULL, "KOne", "KTwo", "KThree"};
Here you'd need to fill in the gaps to make the enum values match the array positions.
Or, better, for C99 with designated initialisers:
char *enumlabels[] = { [1] = "KOne", [2] = "KTwo", [3] = "KThree"};
In this case, as long as the enum declaration comes first, you can swap the array subscripts directly for the enum values to make it much clearer, e.g. { [kOne] = "kOne", ... }.
then for MyEnum e you could just use printf("%s\n", enumlabels[e]); or some such.
I've written a bit of code to demonstrate this much better:
typedef enum {
white = 1,
red = 2,
green = 4,
blue = 8,
black = 16
} Colour; // be sure to update array below!
char *enum_colours[] = { [white] = "white", [red] = "red", [green] = "green",
[blue] = "blue", [black] = "black" };
Colour c = blue;
printf("The label for %d is %s\n", c, enum_colours[c]);
Output: The label for 8 is blue
If you have huge enum constants (e.g. 32767) this is obviously not an ideal solution, due to the size of array required. Without designated initialisers, you could assign the array values directly, if more laboriously, with enum_colours[white] = "white"; and so on, but only in a function.
You can't get to the enum names at run-time since those symbols are long gone by then, but you can use multi-character constants to create more meaningful values for your enums.
#import <Foundation/Foundation.h>
NSString* debugString(int en) {
return [NSString stringWithFormat:#"%c%c%c%c",
(en>>24) & 0xff,
(en>>16) & 0xff,
(en>>8) & 0xff,
en & 0xff];
}
typedef enum {
kOne = 'One.',
kTwo = 'Two.',
kThree = 'Thre',
} MyEnum;
int main(int argc, const char * argv[])
{
#autoreleasepool {
NSLog(#"kOne = %#", debugString(kOne));
NSLog(#"kTwo = %#", debugString(kTwo));
NSLog(#"kThree = %#", debugString(kThree));
}
return 0;
}
will print
kOne = One.
kTwo = Two.
kThree = Thre
on the console.
To keep debugString from generating garbage, each enum must be exactly four characters long (on OSX anyway). This is extremely compiler and platform dependent. It's good for debugging, but not much else.
Of course this won't work if you need the enums to have specific values or values that relate to each other.
The names themselves wont be available, but it is usually enough to give them an explicit number:
enum{
dog = 100,
cat = 200,
problem = dog+cat, //trailing comma legal in C and C++11
};
Here's what I am trying to do:
typedef enum { ONE, TWO, THREE } Numbers;
I am trying to write a function that would do a switch case similar to the following:
char num_str[10];
int process_numbers_str(Numbers num) {
switch(num) {
case ONE:
case TWO:
case THREE:
{
strcpy(num_str, num); //some way to get the symbolic constant name in here?
} break;
default:
return 0; //no match
return 1;
}
Instead of defining at every case, is there a way to set it using the enum variable like I am trying to do above?
The technique from Making something both a C identifier and a string? can be used here.
As usual with such preprocessor stuff, writing and understanding the preprocessor part can be hard, and includes passing macros to other macros and involves using # and ## operators, but using it is real easy. I find this style very useful for long enums, where maintaining the same list twice can be really troublesome.
Factory code - typed only once, usually hidden in the header:
enumFactory.h:
// expansion macro for enum value definition
#define ENUM_VALUE(name,assign) name assign,
// expansion macro for enum to string conversion
#define ENUM_CASE(name,assign) case name: return #name;
// expansion macro for string to enum conversion
#define ENUM_STRCMP(name,assign) if (!strcmp(str,#name)) return name;
/// declare the access function and define enum values
#define DECLARE_ENUM(EnumType,ENUM_DEF) \
enum EnumType { \
ENUM_DEF(ENUM_VALUE) \
}; \
const char *GetString(EnumType dummy); \
EnumType Get##EnumType##Value(const char *string); \
/// define the access function names
#define DEFINE_ENUM(EnumType,ENUM_DEF) \
const char *GetString(EnumType value) \
{ \
switch(value) \
{ \
ENUM_DEF(ENUM_CASE) \
default: return ""; /* handle input error */ \
} \
} \
EnumType Get##EnumType##Value(const char *str) \
{ \
ENUM_DEF(ENUM_STRCMP) \
return (EnumType)0; /* handle input error */ \
} \
Factory used
someEnum.h:
#include "enumFactory.h"
#define SOME_ENUM(XX) \
XX(FirstValue,) \
XX(SecondValue,) \
XX(SomeOtherValue,=50) \
XX(OneMoreValue,=100) \
DECLARE_ENUM(SomeEnum,SOME_ENUM)
someEnum.cpp:
#include "someEnum.h"
DEFINE_ENUM(SomeEnum,SOME_ENUM)
The technique can be easily extended so that XX macros accepts more arguments, and you can also have prepared more macros to substitute for XX for different needs, similar to the three I have provided in this sample.
Comparison to X-Macros using #include / #define / #undef
While this is similar to X-Macros others have mentioned, I think this solution is more elegant in that it does not require #undefing anything, which allows you to hide more of the complicated stuff is in the factory the header file - the header file is something you are not touching at all when you need to define a new enum, therefore new enum definition is a lot shorter and cleaner.
// Define your enumeration like this (in say numbers.h);
ENUM_BEGIN( Numbers )
ENUM(ONE),
ENUM(TWO),
ENUM(FOUR)
ENUM_END( Numbers )
// The macros are defined in a more fundamental .h file (say defs.h);
#define ENUM_BEGIN(typ) enum typ {
#define ENUM(nam) nam
#define ENUM_END(typ) };
// Now in one and only one .c file, redefine the ENUM macros and reinclude
// the numbers.h file to build a string table
#undef ENUM_BEGIN
#undef ENUM
#undef ENUM_END
#define ENUM_BEGIN(typ) const char * typ ## _name_table [] = {
#define ENUM(nam) #nam
#define ENUM_END(typ) };
#undef NUMBERS_H_INCLUDED // whatever you need to do to enable reinclusion
#include "numbers.h"
// Now you can do exactly what you want to do, with no retyping, and for any
// number of enumerated types defined with the ENUM macro family
// Your code follows;
char num_str[10];
int process_numbers_str(Numbers num) {
switch(num) {
case ONE:
case TWO:
case THREE:
{
strcpy(num_str, Numbers_name_table[num]); // eg TWO -> "TWO"
} break;
default:
return 0; //no match
return 1;
}
// Sweet no ? After being frustrated by this for years, I finally came up
// with this solution for my most recent project and plan to reuse the idea
// forever
There's no built-in solution. The easiest way is with an array of char* where the enum's int value indexes to a string containing the descriptive name of that enum. If you have a sparse enum (one that doesn't start at 0 or has gaps in the numbering) where some of the int mappings are high enough to make an array-based mapping impractical then you could use a hash table instead.
There is definitely a way to do this -- use X() macros. These macros use the C preprocessor to construct enums, arrays and code blocks from a list of source data. You only need to add new items to the #define containing the X() macro. The switch statement would expand automatically.
Your example can be written as follows:
// Source data -- Enum, String
#define X_NUMBERS \
X(ONE, "one") \
X(TWO, "two") \
X(THREE, "three")
...
// Use preprocessor to create the Enum
typedef enum {
#define X(Enum, String) Enum,
X_NUMBERS
#undef X
} Numbers;
...
// Use Preprocessor to expand data into switch statement cases
switch(num)
{
#define X(Enum, String) \
case Enum: strcpy(num_str, String); break;
X_NUMBERS
#undef X
default: return 0; break;
}
return 1;
There are more efficient ways (i.e. using X Macros to create an string array and enum index), but this is the simplest demo.
I know you have a couple good solid answers, but do you know about the # operator in the C preprocessor?
It lets you do this:
#define MACROSTR(k) #k
typedef enum {
kZero,
kOne,
kTwo,
kThree
} kConst;
static char *kConstStr[] = {
MACROSTR(kZero),
MACROSTR(kOne),
MACROSTR(kTwo),
MACROSTR(kThree)
};
static void kConstPrinter(kConst k)
{
printf("%s", kConstStr[k]);
}
C or C++ does not provide this functionality, although I've needed it often.
The following code works, although it's best suited for non-sparse enums.
typedef enum { ONE, TWO, THREE } Numbers;
char *strNumbers[] = {"one","two","three"};
printf ("Value for TWO is %s\n",strNumbers[TWO]);
By non-sparse, I mean not of the form
typedef enum { ONE, FOUR_THOUSAND = 4000 } Numbers;
since that has huge gaps in it.
The advantage of this method is that it put the definitions of the enums and strings near each other; having a switch statement in a function spearates them. This means you're less likely to change one without the other.
KISS. You will be doing all sorts of other switch/case things with your enums so why should printing be different? Forgetting a case in your print routine isn't a huge deal when you consider there are about 100 other places you can forget a case. Just compile -Wall, which will warn of non-exhaustive case matches. Don't use "default" because that will make the switch exhaustive and you wont get warnings. Instead, let the switch exit and deal with the default case like so...
const char *myenum_str(myenum e)
{
switch(e) {
case ONE: return "one";
case TWO: return "two";
}
return "invalid";
}
Try Converting C++ enums to strings. The comments have improvements that solve the problem when enum items have arbitrary values.
The use of boost::preprocessor makes possible an elegant solution like the following:
Step 1: include the header file:
#include "EnumUtilities.h"
Step 2: declare the enumeration object with the following syntax:
MakeEnum( TestData,
(x)
(y)
(z)
);
Step 3: use your data:
Getting the number of elements:
td::cout << "Number of Elements: " << TestDataCount << std::endl;
Getting the associated string:
std::cout << "Value of " << TestData2String(x) << " is " << x << std::endl;
std::cout << "Value of " << TestData2String(y) << " is " << y << std::endl;
std::cout << "Value of " << TestData2String(z) << " is " << z << std::endl;
Getting the enum value from the associated string:
std::cout << "Value of x is " << TestData2Enum("x") << std::endl;
std::cout << "Value of y is " << TestData2Enum("y") << std::endl;
std::cout << "Value of z is " << TestData2Enum("z") << std::endl;
This looks clean and compact, with no extra files to include.
The code I wrote within EnumUtilities.h is the following:
#include <boost/preprocessor/seq/for_each.hpp>
#include <string>
#define REALLY_MAKE_STRING(x) #x
#define MAKE_STRING(x) REALLY_MAKE_STRING(x)
#define MACRO1(r, data, elem) elem,
#define MACRO1_STRING(r, data, elem) case elem: return REALLY_MAKE_STRING(elem);
#define MACRO1_ENUM(r, data, elem) if (REALLY_MAKE_STRING(elem) == eStrEl) return elem;
#define MakeEnum(eName, SEQ) \
enum eName { BOOST_PP_SEQ_FOR_EACH(MACRO1, , SEQ) \
last_##eName##_enum}; \
const int eName##Count = BOOST_PP_SEQ_SIZE(SEQ); \
static std::string eName##2String(const enum eName eel) \
{ \
switch (eel) \
{ \
BOOST_PP_SEQ_FOR_EACH(MACRO1_STRING, , SEQ) \
default: return "Unknown enumerator value."; \
}; \
}; \
static enum eName eName##2Enum(const std::string eStrEl) \
{ \
BOOST_PP_SEQ_FOR_EACH(MACRO1_ENUM, , SEQ) \
return (enum eName)0; \
};
There are some limitation, i.e. the ones of boost::preprocessor. In this case, the list of constants cannot be larger than 64 elements.
Following the same logic, you could also think to create sparse enum:
#define EnumName(Tuple) BOOST_PP_TUPLE_ELEM(2, 0, Tuple)
#define EnumValue(Tuple) BOOST_PP_TUPLE_ELEM(2, 1, Tuple)
#define MACRO2(r, data, elem) EnumName(elem) EnumValue(elem),
#define MACRO2_STRING(r, data, elem) case EnumName(elem): return BOOST_PP_STRINGIZE(EnumName(elem));
#define MakeEnumEx(eName, SEQ) \
enum eName { \
BOOST_PP_SEQ_FOR_EACH(MACRO2, _, SEQ) \
last_##eName##_enum }; \
const int eName##Count = BOOST_PP_SEQ_SIZE(SEQ); \
static std::string eName##2String(const enum eName eel) \
{ \
switch (eel) \
{ \
BOOST_PP_SEQ_FOR_EACH(MACRO2_STRING, _, SEQ) \
default: return "Unknown enumerator value."; \
}; \
};
In this case, the syntax is:
MakeEnumEx(TestEnum,
((x,))
((y,=1000))
((z,))
);
Usage is similar as above (minus the eName##2Enum function, that you could try to extrapolate from the previous syntax).
I tested it on mac and linux, but be aware that boost::preprocessor may not be fully portable.
By merging some of the techniques over here I came up with the simplest form:
#define MACROSTR(k) #k
#define X_NUMBERS \
X(kZero ) \
X(kOne ) \
X(kTwo ) \
X(kThree ) \
X(kFour ) \
X(kMax )
enum {
#define X(Enum) Enum,
X_NUMBERS
#undef X
} kConst;
static char *kConstStr[] = {
#define X(String) MACROSTR(String),
X_NUMBERS
#undef X
};
int main(void)
{
int k;
printf("Hello World!\n\n");
for (k = 0; k < kMax; k++)
{
printf("%s\n", kConstStr[k]);
}
return 0;
}
If you are using gcc, it's possible to use:
const char * enum_to_string_map[]={ [enum1]='string1', [enum2]='string2'};
Then just call for instance
enum_to_string_map[enum1]
Check out the ideas at Mu Dynamics Research Labs - Blog Archive. I found this earlier this year - I forget the exact context where I came across it - and have adapted it into this code. We can debate the merits of adding an E at the front; it is applicable to the specific problem addressed, but not part of a general solution. I stashed this away in my 'vignettes' folder - where I keep interesting scraps of code in case I want them later. I'm embarrassed to say that I didn't keep a note of where this idea came from at the time.
Header: paste1.h
/*
#(#)File: $RCSfile: paste1.h,v $
#(#)Version: $Revision: 1.1 $
#(#)Last changed: $Date: 2008/05/17 21:38:05 $
#(#)Purpose: Automated Token Pasting
*/
#ifndef JLSS_ID_PASTE_H
#define JLSS_ID_PASTE_H
/*
* Common case when someone just includes this file. In this case,
* they just get the various E* tokens as good old enums.
*/
#if !defined(ETYPE)
#define ETYPE(val, desc) E##val,
#define ETYPE_ENUM
enum {
#endif /* ETYPE */
ETYPE(PERM, "Operation not permitted")
ETYPE(NOENT, "No such file or directory")
ETYPE(SRCH, "No such process")
ETYPE(INTR, "Interrupted system call")
ETYPE(IO, "I/O error")
ETYPE(NXIO, "No such device or address")
ETYPE(2BIG, "Arg list too long")
/*
* Close up the enum block in the common case of someone including
* this file.
*/
#if defined(ETYPE_ENUM)
#undef ETYPE_ENUM
#undef ETYPE
ETYPE_MAX
};
#endif /* ETYPE_ENUM */
#endif /* JLSS_ID_PASTE_H */
Example source:
/*
#(#)File: $RCSfile: paste1.c,v $
#(#)Version: $Revision: 1.2 $
#(#)Last changed: $Date: 2008/06/24 01:03:38 $
#(#)Purpose: Automated Token Pasting
*/
#include "paste1.h"
static const char *sys_errlist_internal[] = {
#undef JLSS_ID_PASTE_H
#define ETYPE(val, desc) desc,
#include "paste1.h"
0
#undef ETYPE
};
static const char *xerror(int err)
{
if (err >= ETYPE_MAX || err <= 0)
return "Unknown error";
return sys_errlist_internal[err];
}
static const char*errlist_mnemonics[] = {
#undef JLSS_ID_PASTE_H
#define ETYPE(val, desc) [E ## val] = "E" #val,
#include "paste1.h"
#undef ETYPE
};
#include <stdio.h>
int main(void)
{
int i;
for (i = 0; i < ETYPE_MAX; i++)
{
printf("%d: %-6s: %s\n", i, errlist_mnemonics[i], xerror(i));
}
return(0);
}
Not necessarily the world's cleanest use of the C pre-processor - but it does prevent writing the material out multiple times.
Making something both a C identifier and a string
#define stringify( name ) # name
enum MyEnum {
ENUMVAL1
};
...stuff...
stringify(EnumName::ENUMVAL1); // Returns MyEnum::ENUMVAL1
Further discussion on this method
Preprocessor directive tricks for newcomers
If the enum index is 0-based, you can put the names in an array of char*, and index them with the enum value.
I have created a simple templated class streamable_enum that uses stream operators << and >> and is based on the std::map<Enum, std::string>:
#ifndef STREAMABLE_ENUM_HPP
#define STREAMABLE_ENUM_HPP
#include <iostream>
#include <string>
#include <map>
template <typename E>
class streamable_enum
{
public:
typedef typename std::map<E, std::string> tostr_map_t;
typedef typename std::map<std::string, E> fromstr_map_t;
streamable_enum()
{}
streamable_enum(E val) :
Val_(val)
{}
operator E() {
return Val_;
}
bool operator==(const streamable_enum<E>& e) {
return this->Val_ == e.Val_;
}
bool operator==(const E& e) {
return this->Val_ == e;
}
static const tostr_map_t& to_string_map() {
static tostr_map_t to_str_(get_enum_strings<E>());
return to_str_;
}
static const fromstr_map_t& from_string_map() {
static fromstr_map_t from_str_(reverse_map(to_string_map()));
return from_str_;
}
private:
E Val_;
static fromstr_map_t reverse_map(const tostr_map_t& eToS) {
fromstr_map_t sToE;
for (auto pr : eToS) {
sToE.emplace(pr.second, pr.first);
}
return sToE;
}
};
template <typename E>
streamable_enum<E> stream_enum(E e) {
return streamable_enum<E>(e);
}
template <typename E>
typename streamable_enum<E>::tostr_map_t get_enum_strings() {
// \todo throw an appropriate exception or display compile error/warning
return {};
}
template <typename E>
std::ostream& operator<<(std::ostream& os, streamable_enum<E> e) {
auto& mp = streamable_enum<E>::to_string_map();
auto res = mp.find(e);
if (res != mp.end()) {
os << res->second;
} else {
os.setstate(std::ios_base::failbit);
}
return os;
}
template <typename E>
std::istream& operator>>(std::istream& is, streamable_enum<E>& e) {
std::string str;
is >> str;
if (str.empty()) {
is.setstate(std::ios_base::failbit);
}
auto& mp = streamable_enum<E>::from_string_map();
auto res = mp.find(str);
if (res != mp.end()) {
e = res->second;
} else {
is.setstate(std::ios_base::failbit);
}
return is;
}
#endif
Usage:
#include "streamable_enum.hpp"
using std::cout;
using std::cin;
using std::endl;
enum Animal {
CAT,
DOG,
TIGER,
RABBIT
};
template <>
streamable_enum<Animal>::tostr_map_t get_enum_strings<Animal>() {
return {
{ CAT, "Cat"},
{ DOG, "Dog" },
{ TIGER, "Tiger" },
{ RABBIT, "Rabbit" }
};
}
int main(int argc, char* argv []) {
cout << "What animal do you want to buy? Our offering:" << endl;
for (auto pr : streamable_enum<Animal>::to_string_map()) { // Use from_string_map() and pr.first instead
cout << " " << pr.second << endl; // to have them sorted in alphabetical order
}
streamable_enum<Animal> anim;
cin >> anim;
if (!cin) {
cout << "We don't have such animal here." << endl;
} else if (anim == Animal::TIGER) {
cout << stream_enum(Animal::TIGER) << " was a joke..." << endl;
} else {
cout << "Here you are!" << endl;
}
return 0;
}
Here is a solution using macros with the following features:
only write each value of the enum once, so there are no double lists to maintain
don't keep the enum values in a separate file that is later #included, so I can write it wherever I want
don't replace the enum itself, I still want to have the enum type defined, but in addition to it I want to be able to map every enum name to the corresponding string (to not affect legacy code)
the searching should be fast, so preferably no switch-case, for those huge enums
https://stackoverflow.com/a/20134475/1812866
I thought that a solution like Boost.Fusion one for adapting structs and classes would be nice, they even had it at some point, to use enums as a fusion sequence.
So I made just some small macros to generate the code to print the enums. This is not perfect and has nothing to see with Boost.Fusion generated boilerplate code, but can be used like the Boost Fusion macros. I want to really do generate the types needed by Boost.Fusion to integrate in this infrastructure which allows to print names of struct members, but this will happen later, for now this is just macros :
#ifndef SWISSARMYKNIFE_ENUMS_ADAPT_ENUM_HPP
#define SWISSARMYKNIFE_ENUMS_ADAPT_ENUM_HPP
#include <swissarmyknife/detail/config.hpp>
#include <string>
#include <ostream>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/preprocessor/seq/for_each.hpp>
#define SWISSARMYKNIFE_ADAPT_ENUM_EACH_ENUMERATION_ENTRY_C( \
R, unused, ENUMERATION_ENTRY) \
case ENUMERATION_ENTRY: \
return BOOST_PP_STRINGIZE(ENUMERATION_ENTRY); \
break;
/**
* \brief Adapts ENUM to reflectable types.
*
* \param ENUM_TYPE To be adapted
* \param ENUMERATION_SEQ Sequence of enum states
*/
#define SWISSARMYKNIFE_ADAPT_ENUM(ENUM_TYPE, ENUMERATION_SEQ) \
inline std::string to_string(const ENUM_TYPE& enum_value) { \
switch (enum_value) { \
BOOST_PP_SEQ_FOR_EACH( \
SWISSARMYKNIFE_ADAPT_ENUM_EACH_ENUMERATION_ENTRY_C, \
unused, ENUMERATION_SEQ) \
default: \
return BOOST_PP_STRINGIZE(ENUM_TYPE); \
} \
} \
\
inline std::ostream& operator<<(std::ostream& os, const ENUM_TYPE& value) { \
os << to_string(value); \
return os; \
}
#endif
The old answer below is pretty bad, please don't use that. :)
Old answer:
I've been searching a way which solves this problem without changing too much the enums declaration syntax. I came to a solution which uses the preprocessor to retrieve a string from a stringified enum declaration.
I'm able to define non-sparse enums like this :
SMART_ENUM(State,
enum State {
RUNNING,
SLEEPING,
FAULT,
UNKNOWN
})
And I can interact with them in different ways:
// With a stringstream
std::stringstream ss;
ss << State::FAULT;
std::string myEnumStr = ss.str();
//Directly to stdout
std::cout << State::FAULT << std::endl;
//to a string
std::string myStr = State::to_string(State::FAULT);
//from a string
State::State myEnumVal = State::from_string(State::FAULT);
Based on the following definitions :
#define SMART_ENUM(enumTypeArg, ...) \
namespace enumTypeArg { \
__VA_ARGS__; \
std::ostream& operator<<(std::ostream& os, const enumTypeArg& val) { \
os << swissarmyknife::enums::to_string(#__VA_ARGS__, val); \
return os; \
} \
\
std::string to_string(const enumTypeArg& val) { \
return swissarmyknife::enums::to_string(#__VA_ARGS__, val); \
} \
\
enumTypeArg from_string(const std::string &str) { \
return swissarmyknife::enums::from_string<enumTypeArg>(#__VA_ARGS__, str); \
} \
} \
namespace swissarmyknife { namespace enums {
static inline std::string to_string(const std::string completeEnumDeclaration, size_t enumVal) throw (std::runtime_error) {
size_t begin = completeEnumDeclaration.find_first_of('{');
size_t end = completeEnumDeclaration.find_last_of('}');
const std::string identifiers = completeEnumDeclaration.substr(begin + 1, end );
size_t count = 0;
size_t found = 0;
do {
found = identifiers.find_first_of(",}", found+1);
if (enumVal == count) {
std::string identifiersSubset = identifiers.substr(0, found);
size_t beginId = identifiersSubset.find_last_of("{,");
identifiersSubset = identifiersSubset.substr(beginId+1);
boost::algorithm::trim(identifiersSubset);
return identifiersSubset;
}
++count;
} while (found != std::string::npos);
throw std::runtime_error("The enum declaration provided doesn't contains this state.");
}
template <typename EnumType>
static inline EnumType from_string(const std::string completeEnumDeclaration, const std::string &enumStr) throw (std::runtime_error) {
size_t begin = completeEnumDeclaration.find_first_of('{');
size_t end = completeEnumDeclaration.find_last_of('}');
const std::string identifiers = completeEnumDeclaration.substr(begin + 1, end );
size_t count = 0;
size_t found = 0;
do {
found = identifiers.find_first_of(",}", found+1);
std::string identifiersSubset = identifiers.substr(0, found);
size_t beginId = identifiersSubset.find_last_of("{,");
identifiersSubset = identifiersSubset.substr(beginId+1);
boost::algorithm::trim(identifiersSubset);
if (identifiersSubset == enumStr) {
return static_cast<EnumType>(count);
}
++count;
} while (found != std::string::npos);
throw std::runtime_error("No valid enum value for the provided string");
}
}}
When I'll need support for sparse enum and when I'll have more time I'll improve the to_string and from_string implementations with boost::xpressive, but this will costs in compilation time because of the important templating performed and the executable generated is likely to be really bigger. But this has the advantage that it will be more readable and maintanable than this ugly manual string manipulation code. :D
Otherwise I always used boost::bimap to perform such mappings between enums value and string, but it has to be maintained manually.
Because I prefer not to use macros for all the usual reasons, I used a more limited macro solution that has the advantage of keeping the enum declaration macro free. Disadvantages include having to copy paste the macro defintion for each enum, and having to explicitly add a macro invocation when adding values to the enum.
std::ostream& operator<<(std::ostream& os, provenance_wrapper::CaptureState cs)
{
#define HANDLE(x) case x: os << #x; break;
switch (cs) {
HANDLE(CaptureState::UNUSED)
HANDLE(CaptureState::ACTIVE)
HANDLE(CaptureState::CLOSED)
}
return os;
#undef HANDLE
}
There's a way simpler and imo sorta clearer approach
that was missing on this thread:
#define ENUM_PUSH(ENUM) ENUM,
#define STRING_PUSH(STR) #STR,
#define FETCH_MSG(X) \
X(string1) \
X(string2) \
static const char * msgStr[] = {
FETCH_MSG(STRING_PUSH)
};
enum msg {
FETCH_MSG(ENUM_PUSH)
};
static enum msg message;
void iterate(void) {
switch (message) {
case string1:
// do your thing here
break;
case string2:
break;
}
}
The only downside is that the last cell will be postceded by a comma,
though it appears to be acceptable by C/C++ compilers.