C宏示例

Question

I come across this C macro:

    #define __COMMAND(_section, _symname, _name, _args, _nlcmd, _flags, _hidden, _idby, _handler, _help, _sel)\
    static struct cmd                       \
    __cmd ## _ ## _symname ## _ ## _handler ## _ ## _nlcmd ## _ ## _idby ## _ ## _hidden\
    __attribute__((used)) __attribute__((section("__cmd"))) = { \
        .name = (_name),                    \
        .args = (_args),                    \
        .cmd = (_nlcmd),                    \
        .nl_msg_flags = (_flags),               \
        .hidden = (_hidden),                    \
        .idby = (_idby),                    \
        .handler = (_handler),                  \
        .help = (_help),                    \
        .parent = _section,                 \
        .selector = (_sel),                 \
    }

I vaguely understand that it tries to define a struct of type cmd from a bunch of input params of the macro. But I don't really get what these two lines mean:

 __cmd ## _ ## _symname ## _ ## _handler ## _ ## _nlcmd ## _ ## _idby ## _ ## _hidden\
 __attribute__((used)) __attribute__((section("__cmd")))     = {     \

Can someone explain? thanks.

Answer 1

The token ## is used to concatenate the arguments.

Eg

#define CONCAT(A, B) A ## B

int a = CONCAT(My, Function)();

That is equivalent to saying:

int a = MyFunction();

You can see further details at http://en.cppreference.com/w/c/preprocessor/replace .

Answer 2

Given the macro definition you posted, a call of

__COMMAND( Section, Symname, Name, Args, Nlccmd, Flags, Hidden, Idby, Handler, Help, Sel );

will resolve to:

static struct cmd
__cmd_Symname_Handler_Nlcmd_Idby_Hidden
__attribute__((used)) __attribute__((section("__cmd"))) = {
    .name = (Name),
    .args = (Args),
    .cmd = (Nlcmd),
    .nl_msg_flags = (Flags),
    .hidden = (Hidden),
    .idby = (Idby),
    .handler = (Handler),
    .help = (Help),
    .parent = (Section),
    .selector = (Sel ),
};

The line

static struct cmd

starts the definition of a static object of type struct cmd (declared elsewhere).

The macro line

__cmd ## _ ## _symname ## _ ## _handler ## _ ## _nlcmd ## _ ## _idby ## _ ## _hidden\

uses the arguments of the macro to concatenate the identifier of that struct cmd (obviously in hopes that it will be unique).

Others have linked to the relevant documentation of the ## operator; I won't steal from them.

At this point it should be noted that identifiers starting with __ are reserved for the implementation (of the compiler and the standard library), so strictly speaking this makes the program non-conforming with the language standard. (Not that it matters because the use of __attribute__ below is non-portable anyway.)

The line

__attribute__((used)) __attribute__((section("__cmd"))) = { \

sets "attributes" of the struct. This is a compiler-specific syntax extension. From the GCC docs:

used

This attribute, attached to a variable with static storage, means that the variable must be emitted even if it appears that the variable is not referenced.

section ("section-name")

Normally, the compiler places the objects it generates in sections like data and bss. Sometimes, however, you need additional sections, or you need certain particular variables to appear in special sections, for example to map to special hardware. The section attribute specifies that a variable (or function) lives in a particular section. [...]

It then goes on to initialize the struct members with the arguments passed to the macro.