将枚举转换为c的宏

Question

I'm trying this for over a week with no success.

I'm creating a logger interface between two processors and I need help with defining automated MACROS.

What do I mean? Let's say I have a logger message defined as LOGGER_MSG_ID_2 that takes two parameter of uint8 and uint16 types.

I have an enum defined as:

typedef enum{
    PARAM_NONE,
    PARAM_SIZE_UINT8,
    PARAM_SIZE_UINT16,
    PARAM_SIZE_UINT32
}paramSize_e;

So LOGGER_MSG_ID_2 will have a bitmap defined as:

#define LOGGER_MSG_ID_2_BITMAP   (PARAM_SIZE_UINT16 << 2 | PARAM_SIZE_UINT8)

This bitmap is 1 Byte size, so the maximum number of parameters is 4. Later on I have a list that defines all parameters type according to message ID:

#define ID_2_P0_TYPE                                uint8  // first parameter
#define ID_2_P1_TYPE                                uint16 // 2nd parameter
#define ID_2_P2_TYPE                                0      // 3rd parameter
#define ID_2_P3_TYPE                                0      // 4th parameter

As I said, I have a limitation of 4 parameters, so I would like to define them and let the MACRO decide weather to use them or not. I defined them as 0 but it can be whatever that works.

I have other MACROS that uses the bitmap to get all kind of attributes, such as number of parameters and message size.

Now it's the tricky part. I want to build a MACRO that creates a bitmap from types. The reason is that I don't want redundancy between the bitmap and parameters definitions. My problem is that everything I tried failed to compile.

Eventually I would like to have a MACRO such as:

#define GET_ENUM_FROM_TYPE(_type)

that gives me PARAM_SIZE_UINT8, PARAM_SIZE_UINT16 or PARAM_SIZE_UINT32 according to type.

Limitations: I'm using arm compiler on windows (armcl.exe) and C99. I can't use C11 Generic() .

I tried the following:

#define GET_ENUM_FROM_TYPE(_type)       \
(_type == uint8) ? PARAM_SIZE_UINT8 : \
        ((_type == uint16) ? PARAM_SIZE_UINT16 : \
                ((_type == uint32) ? PARAM_SIZE_UINT32 : PARAM_NONE))

Eventually I want to use it like:

 #define LOGGER_MSG_ID_2_BITMAP              \
    (GET_ENUM_FROM_TYPE(ID_2_P3_TYPE) << 6 | \ 
     GET_ENUM_FROM_TYPE(ID_2_P2_TYPE) << 4 | \ 
     GET_ENUM_FROM_TYPE(ID_2_P1_TYPE) << 2 | \
     GET_ENUM_FROM_TYPE(ID_2_P0_TYPE))

But when I use it, it doesn't compile.

I have a table of bitmaps:

uint8 paramsSizeBitmap [] = {
    LOGGER_MSG_ID_1_BITMAP,                         /*  LOGGER_MSG_ID_1   */
    LOGGER_MSG_ID_2_BITMAP,                         /*  LOGGER_MSG_ID_2   */
    LOGGER_MSG_ID_3_BITMAP,                         /*  LOGGER_MSG_ID_3   */
    LOGGER_MSG_ID_4_BITMAP,                         /*  LOGGER_MSG_ID_4   */
    LOGGER_MSG_ID_5_BITMAP,                         /*  LOGGER_MSG_ID_5   */
    LOGGER_MSG_ID_6_BITMAP,                         /*  LOGGER_MSG_ID_6   */
    LOGGER_MSG_ID_7_BITMAP,                         /*  LOGGER_MSG_ID_7   */
    LOGGER_MSG_ID_8_BITMAP,                         /*  LOGGER_MSG_ID_8   */
    LOGGER_MSG_ID_9_BITMAP,                         /*  LOGGER_MSG_ID_9   */
    LOGGER_MSG_ID_10_BITMAP,                        /*  LOGGER_MSG_ID_10  */
};

And I get this error:

line 39: error #18: expected a ")"
line 39: error #29: expected an expression

(line 39 is LOGGER_MSG_ID_2_BITMAP )

Where do I go wrong?

----- Edit -----

For now I have a workaround that I don't really like. I don't use uint64 so I made a use of sizeof() MACRO and now my MACRO looks like this:

#define GET_ENUM_FROM_TYPE(_type)       \
(sizeof(_type) == sizeof(uint8)) ? PARAM_SIZE_UINT8 : \
        ((sizeof(_type) == sizeof(uint16)) ? PARAM_SIZE_UINT16 : \
                ((sizeof(_type) == sizeof(uint32)) ? PARAM_SIZE_UINT32 : PARAM_NONE))

and my paraemters list is:

#define NO_PARAM                                    uint64

#define ID_2_P0_TYPE                                uint8
#define ID_2_P1_TYPE                                uint16
#define ID_2_P2_TYPE                                NO_PARAM
#define ID_2_P3_TYPE                                NO_PARAM

It works fine but... you know...

Answer 1

I believe the solution is to use concatenation operator ## , and helper defines.

// These must match your enum
#define HELPER_0      PARAM_NONE
#define HELPER_uint8  PARAM_SIZE_UINT8
#define HELPER_uint16 PARAM_SIZE_UINT16
#define HELPER_uint32 PARAM_SIZE_UINT32

// Secondary macro to avoid expansion to HELPER__type
#define CONCAT(a, b) a ## b

// Outer parenthesis not strictly necessary here
#define GET_ENUM_FROM_TYPE(_type) (CONCAT(HELPER_, _type))

With that GET_ENUM_FROM_TYPE(ID_2_P1_TYPE) will expand to (PARAM_SIZE_UINT16) after preprocessing.

Note that suffix in HELPER_*** defines has to match exactly the content of ID_*_P*_TYPE macros. For example HELPER_UINT8 won't work (invalid case). (Thanks @cxw)

Answer 2

The basic problem is that == is not supported for types , only for values . Given

uint8 foo;

you can say foo==42 but not foo == uint8 . This is because types are not first class in C.

One hack would be to use the C preprocessor stringification operator # ( gcc docs ). However, this moves all your computation to runtime and may not be suitable for an embedded environment. For example:

#define GET_ENUM_FROM_TYPE(_type)   (    \
(strcmp(#_type, "uint8")==0) ? PARAM_SIZE_UINT8 : \
        ((strcmp(#_type, "uint16")==0) ? PARAM_SIZE_UINT16 : \
                ((strcmp(#_type, "uint32")==0) ? PARAM_SIZE_UINT32 : PARAM_NONE)) \
)

With that definition,

GET_ENUM_FROM_TYPE(uint8)

expands to

( (strcmp("uint8", "uint8")==0) ? PARAM_SIZE_UINT8 : ((strcmp("uint8", "uint16")==0) ? PARAM_SIZE_UINT16 : ((strcmp("uint8", "uint32")==0) ? PARAM_SIZE_UINT32 : PARAM_NONE)) )

which should do what you want, although at runtime.

Answer 3

Sorry, this doesn't directly answer the question. But you should reconsider this whole code.

First of all, _Generic would have solved this elegantly.

The dirty alternative to untangle groups of macros like these, would be to use so-called X macros , which are perfect for cases such as "I don't want redundancy between the bitmap and parameters definitions". You can likely rewrite your code with X macros and get rid of a lot of superfluous defines and macros. How readable it will end up is another story.

However, whenever you find yourself this deep inside some macro meta-programming jungle, it is almost always a certain indication of poor program design. All of this smells like an artificial solution to a problem that could have been solved in much better ways - it is a "XY problem" . (not to be confused with X macros :) ). The best solution most likely involves rewriting this entirely in simpler ways. Your case doesn't sound unique in any way, it seems that you just want to generate a bunch of bit masks.

Good programmers always try to make their code simpler, rather than making it more complex.

---

In addition, you may have more or less severe bugs all over the code, caused by the C language type system. It can be summarized as:

• Bit shifts or other bitwise arithmetic should never be used on signed types. Doing so can lead to all manner of subtle bugs and poorly-defined behavior.
• Enumeration constants are always of type int which is signed. You should avoid mixing them with bitwise arithmetic. Avoid enums entirely for programs like this.
• Small integer types such as uint8_t or uint16_t get implicitly type promoted to int when used in an expression. Meaning that the C language will bandwagon most of your attempts to get the correct type and replace everything with int anyway.
• The resulting type of your macros will be int , which is not what you want.