Full macro in header file

Question

I found a header to define hashtable with the following code :

#ifndef HASH_H
#define HASH_H

#define DEFINE_HASHTABLE(name, type, key, h_list, hashfunc)\
\
struct list * hashtable;\
\
static int hashtable_init (size_t size)\
{\
    unsigned long i;\
    hashtable = (struct list*)malloc(size * sizeof (struct list_head));\
    if (!hashtable)\
        return -1;\
    for (i = 0; i < size; i++)\
        INIT_LIST_HEAD(&hashtable[i]);\
    return 0;\
}\
\
static inline void hashtable_add(type *elem)\
{\
    struct list_head *head = hashtable + hashfunc(elem->key);\
    list_add(&elem->h_list, head);\
}\
\
static inline void hashtable_del(type *elem)\
{\
    list_del(&elem->h_list);\
}\
\
static inline type * hashtable_find(unsigned long key)\
{\
    type *elem;\
    struct list_head *head = hashtable + hashfunc(key);\
\
    list_for_each_entry(elem, head, h_list){\
        if (elem->key == key) \
            return elem; \
    }\
    return NULL;\
}

#endif /* _HASH_H */

I never seen a header file such this one. What is the advantage of this way to write a header (I mean full macro)? Is it about genericity or things like that?

What is it that you don't understand? The functions that this macro generates when it is expanded? BTW, this is quite a bad design, having a global variable that has a fixed name. Probably this code is not finished, you caught him in the middle. — Jens Gustedt, Oct 23 '14 at 08:22

score 2 · Accepted Answer · edited May 23 '17 at 12:06

It's a way to try to ensure that all the hash function calls have their inline request granted, i.e. to reduce the number of function calls when doing hash table operations.

It's just an attempt, it can't guarantee that the functions will be inlined, but by making them static the chance at least improves. See this question for lots of discussion about this, in particular @Christoph's answer here.

Note that it will only work once per C file, since there's no "unique" part added to the function names.

If you do:

#include "hash.h"

DEFINE_HASHTABLE(foo, /* rest of arguments */);
DEFINE_HASHTABLE(bar, /* another bunch of args */);

you will get compilation errors, since all the hashtable_ functions will be defined twice. The macro writer could improve this by adding the name to all the things defined (variables and functions) by the set of macros.

I.e. this:

struct list * hashtable;\
\
static int hashtable_init (size_t size)\

should become something like:

static list *hashtable_ ##name;\
\
static int hashtable_ ##name ##_init(size_t size)\

and so on (where name is the first macro argument, i.e. the foo and bar from my example usage above).

Could you please elaborate on how the macro ensures that the `inline` request is granted? — Cantfindname, Oct 23 '14 at 08:43

Full macro in header file

1 Answers1