Workaround to avoid CLANG unused function warnings

m-algo.h

@@ -31,8 +31,10 @@
    which oplist is 'contOp', as static inline functions.
    USAGE:
    ALGO_DEF(algogName, containerOplist|type if oplist has been registered) */
-#define ALGO_DEF(name, cont_oplist)             \
+#define ALGO_DEF(name, cont_oplist)                     \
-  ALGOI_DEF_P1(name, M_GLOBAL_OPLIST(cont_oplist))
+  M_BEGIN_PROTECTED_CODE                                \
+  ALGOI_DEF_P1(name, M_GLOBAL_OPLIST(cont_oplist))      \
+  M_END_PROTECTED_CODE
 
 
 /* Map a function (or a macro) to all elements of a container.

m-array.h

@@ -30,9 +30,11 @@
 /* Define a dynamic array of the given type and its associated functions.
    USAGE: ARRAY_DEF(name, type [, oplist_of_the_type]) */
 #define ARRAY_DEF(name, ...)                                            \
+  M_BEGIN_PROTECTED_CODE                                                \
   ARRAYI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
              ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t), M_C(name,_it_t) ), \
-              (name, __VA_ARGS__,                                      M_C(name,_t), M_C(name,_it_t))))
+              (name, __VA_ARGS__,                                      M_C(name,_t), M_C(name,_it_t)))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a dynamic array given its name and its oplist.

m-bptree.h

@@ -35,18 +35,22 @@
    BPTREE_DEF2(name, N, key_t, value_t)
 */
 #define BPTREE_DEF2(name, N, key_type, ...)                             \
+  M_BEGIN_PROTECTED_CODE                                                \
   BPTREEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                            \
                  ((name, N, key_type, M_GLOBAL_OPLIST_OR_DEF(key_type)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 1, 0, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ), \
-                  (name, N, key_type, __VA_ARGS__,                                                                            1, 0, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t))))
+                  (name, N, key_type, __VA_ARGS__,                                                                            1, 0, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t)))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define a B+tree of a given type, of size N.
    with its associated functions
    USAGE: BPTREE_DEF(name, N, type, [, oplist_of_the_type]) */
 #define BPTREE_DEF(name, N, ...)					\
+  M_BEGIN_PROTECTED_CODE                                                \
   BPTREEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)				\
                  ((name, N, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 0, 0, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ), \
-                  (name, N, __VA_ARGS__,                                    __VA_ARGS__,                                            0, 0, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) )))
+                  (name, N, __VA_ARGS__,                                    __VA_ARGS__,                                            0, 0, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define a B+tree of size 'N' that maps a 'key' to a 'value',
@@ -58,9 +62,11 @@
    BPTREE_MULTI_DEF2(name, N, key_t, value_t)
 */
 #define BPTREE_MULTI_DEF2(name, N, key_type, ...)                       \
+  M_BEGIN_PROTECTED_CODE                                                \
   BPTREEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                            \
                  ((name, N, key_type, M_GLOBAL_OPLIST_OR_DEF(key_type)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 1, 1, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ), \
-                  (name, N, key_type, __VA_ARGS__,                                                                            1, 1, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t))))
+                  (name, N, key_type, __VA_ARGS__,                                                                            1, 1, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t)))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define a B+tree of a given type, of size N.
@@ -68,9 +74,11 @@
    with its associated functions
    USAGE: BPTREE_MULTI_DEF(name, N, type, [, oplist_of_the_type]) */
 #define BPTREE_MULTI_DEF(name, N, ...)					\
+  M_BEGIN_PROTECTED_CODE                                                \
   BPTREEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)				\
                  ((name, N, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), 0, 1, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ), \
-                  (name, N, __VA_ARGS__,                                    __VA_ARGS__,                                            0, 1, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) )))
+                  (name, N, __VA_ARGS__,                                    __VA_ARGS__,                                            0, 1, M_C(name, _t), M_C(name, _node_t), M_C(name, _pit_t), M_C(name, _it_t) ))) \
+  M_BEGIN_PROTECTED_CODE
 
 
 

m-buffer.h

@@ -53,9 +53,11 @@ typedef enum {
 /* Define a lock based buffer.
    USAGE: BUFFER_DEF(name, type, size_of_buffer_or_0, policy[, oplist]) */
 #define BUFFER_DEF(name, type, m_size, ... )                            \
+  M_BEGIN_PROTECTED_CODE                                                \
   BUFFERI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                            \
               ((name, type, m_size,__VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), M_C(name,_t)), \
-               (name, type, m_size,__VA_ARGS__,                                      M_C(name,_t))))
+               (name, type, m_size,__VA_ARGS__,                                      M_C(name,_t)))) \
+  M_END_PROTECTED_CODE
 
 /* Define the oplist of a lock based buffer given its name and its oplist.
    USAGE: BUFFER_OPLIST(name[, oplist of the type]) */
@@ -69,18 +71,22 @@ typedef enum {
    Size of created queue can only a power of 2.
 */
 #define QUEUE_MPMC_DEF(name, type, ...)					\
+  M_BEGIN_PROTECTED_CODE                                                \
   QUEUEI_MPMC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
                   ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), M_C(name,_t)), \
-                   (name, type, __VA_ARGS__,                                      M_C(name,_t))))
+                   (name, type, __VA_ARGS__,                                      M_C(name,_t)))) \
+  M_END_PROTECTED_CODE
 
 /* Define a wait-free queue for Single Producer Single Consummer
    Much faster than queue of BUFFER_DEF in heavy communication scenario
    Size of created queue can only a power of 2.
 */
 #define QUEUE_SPSC_DEF(name, type, ...)					\
+  M_BEGIN_PROTECTED_CODE                                                \
   QUEUEI_SPSC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
                   ((name, type, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(type)(), M_C(name,_t)), \
-                   (name, type, __VA_ARGS__,                                      M_C(name,_t))))
+                   (name, type, __VA_ARGS__,                                      M_C(name,_t)))) \
+  M_END_PROTECTED_CODE
 
 
 

m-c-mempool.h

@@ -35,11 +35,13 @@ M_BEGIN_PROTECTED_CODE
 #define C_MEMPOOL_MIN_NODE_PER_GROUP 16
 
 #define C_MEMPOOL_DEF(name, type_t)                     \
+  M_BEGIN_PROTECTED_CODE                                \
   C_MEMPOOL_DEF_SINGLY_LIST(name, type_t)               \
   C_MEMPOOL_DEF_LF_QUEUE(name, type_t)                  \
   C_MEMPOOL_DEF_LFMP_THREAD_MEMPOOL(name, type_t)       \
   C_MEMPOOL_DEF_SYSTEM_ALLOC(name, type_t)              \
-  C_MEMPOOL_DEF_LF_MEMPOOL(name, type_t)
+  C_MEMPOOL_DEF_LF_MEMPOOL(name, type_t)                \
+  M_END_PROTECTED_CODE
 
 /* Classic Singly List without allocation */
 #define C_MEMPOOL_DEF_SINGLY_LIST(name, type_t)                         \

m-concurrent.h

@@ -33,9 +33,11 @@
    based on the given container.
    USAGE: CONCURRENT_DEF(name, type [, oplist_of_the_type]) */
 #define CONCURRENT_DEF(name, ...)                                       \
+  M_BEGIN_PROTECTED_CODE                                                \
   CONCURRENTI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
                ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t) ), \
-                (name, __VA_ARGS__,                                        M_C(name,_t) )))
+                (name, __VA_ARGS__,                                        M_C(name,_t) ))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a protected concurrent container given its name and its oplist.
@@ -51,9 +53,11 @@
    can be done in parallel.
    USAGE: CONCURRENT_RP_DEF(name, type [, oplist_of_the_type]) */
 #define CONCURRENT_RP_DEF(name, ...)                                    \
+  M_BEGIN_PROTECTED_CODE                                                \
   CONCURRENTI_RP_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
                ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t) ), \
-                (name, __VA_ARGS__,                                        M_C(name,_t) )))
+                (name, __VA_ARGS__,                                        M_C(name,_t) ))) \
+  M_END_PROTECTED_CODE
 
 
 /********************************** INTERNAL ************************************/

m-deque.h

@@ -30,9 +30,11 @@
 /* Define a deque of a given type and its associated functions.
    USAGE: DEQUE_DEF(name, type [, oplist_of_the_type]) */
 #define DEQUE_DEF(name, ...)                                            \
+  M_BEGIN_PROTECTED_CODE                                                \
   DEQUEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
                 ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t), M_C(name,_it_t), M_C(name, _node_t) ), \
-                 (name, __VA_ARGS__,                                        M_C(name,_t), M_C(name,_it_t), M_C(name, _node_t))))
+                 (name, __VA_ARGS__,                                        M_C(name,_t), M_C(name,_it_t), M_C(name, _node_t)))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a deque of a type.

m-dict.h

@@ -37,9 +37,11 @@
      DICT_DEF2(name, key_type, value_type)
 */
 #define DICT_DEF2(name, key_type, ...)                                  \
+  M_BEGIN_PROTECTED_CODE                                                \
   DICTI_DEF2_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
                 ((name, key_type, M_GLOBAL_OPLIST_OR_DEF(key_type)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
-                 (name, key_type, __VA_ARGS__)))
+                 (name, key_type, __VA_ARGS__)))                        \
+  M_END_PROTECTED_CODE
 
 
 /* Define a dictionary asssociating the key key_type to the value value_type and its associated functions.
@@ -51,9 +53,11 @@
      DICT_STOREHASH_DEF2(name, key_type[, key_oplist], value_type[, value_oplist])
 */
 #define DICT_STOREHASH_DEF2(name, key_type, ...)                        \
+  M_BEGIN_PROTECTED_CODE                                                \
   DICTI_SHASH_DEF2_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                       \
                       ((name, key_type, M_GLOBAL_OPLIST_OR_DEF(key_type)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
-                       (name, key_type, __VA_ARGS__)))
+                       (name, key_type, __VA_ARGS__))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define a dictionary associating the key key_type to the value value_type
@@ -65,9 +69,11 @@
      DICT_OA_DEF2(name, key_type, value_type)
 */
 #define DICT_OA_DEF2(name, key_type, ...)                               \
+  M_BEGIN_PROTECTED_CODE                                                \
   DICTI_OA_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                           \
                   ((name, key_type, M_GLOBAL_OPLIST_OR_DEF(key_type)(), __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
-                   (name, key_type, __VA_ARGS__)))
+                   (name, key_type, __VA_ARGS__))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define a set of the key key_type and its associated functions.
@@ -75,9 +81,11 @@
    USAGE: DICT_SET_DEF(name, key_type[, key_oplist])
 */
 #define DICT_SET_DEF(name, ...)                                         \
+  M_BEGIN_PROTECTED_CODE                                                \
   DICTI_SET_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
                    ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)()), \
-                    (name, __VA_ARGS__)))
+                    (name, __VA_ARGS__))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define a set of the key key_type 
@@ -86,9 +94,11 @@
    USAGE: DICT_OASET_DEF(name, key_type[, key_oplist])
 */
 #define DICT_OASET_DEF(name, ...)                                         \
+  M_BEGIN_PROTECTED_CODE                                                \
   DICTI_OASET_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                          \
                      ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)()), \
-                      (name, __VA_ARGS__)))
+                      (name, __VA_ARGS__))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a dictionnary (DICT_DEF2, DICT_STOREHASH_DEF2 or DICT_OA_DEF2).

m-funcobj.h

@@ -33,7 +33,9 @@
  *    FUNC_OBJ_ITF_DEF(name, retcode type, type of param1, type of param 2, ...)
  */
 #define FUNC_OBJ_ITF_DEF(name, ...)                                     \
-  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_ITF_NO_PARAM_DEF, FUNCOBJI_ITF_PARAM_DEF)(name, __VA_ARGS__)
+  M_BEGIN_PROTECTED_CODE                                                \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_ITF_NO_PARAM_DEF, FUNCOBJI_ITF_PARAM_DEF)(name, __VA_ARGS__) \
+  M_END_PROTECTED_CODE
 
 
 /* Define a function object instance of name 'name' based on the interface 'base_name'
@@ -55,7 +57,9 @@
  *   FUNC_OBJ_INS_DEF(name, base_name, (param1, ...), { return param1 * self->member1 }, (member1, int), ...)
  */
 #define FUNC_OBJ_INS_DEF(name, base_name, param_list, ...)              \
-  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_INS_NO_ATTR_DEF, FUNCOBJI_INS_ATTR_DEF)(name, base_name, param_list, __VA_ARGS__)
+  M_BEGIN_PROTECTED_CODE                                                \
+  M_IF_NARGS_EQ1(__VA_ARGS__)(FUNCOBJI_INS_NO_ATTR_DEF, FUNCOBJI_INS_ATTR_DEF)(name, base_name, param_list, __VA_ARGS__) \
+  M_END_PROTECTED_CODE
 
 
 /* OPLIST of the instanced function object

m-i-list.h

@@ -46,9 +46,11 @@
    USAGE:
      ILIST_DEF(name, type [, oplist_of_the_type]) */
 #define ILIST_DEF(name, ...)                                            \
+  M_BEGIN_PROTECTED_CODE                                                \
   ILISTI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                             \
                 ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name, _t), M_C(name, _it_t) ), \
-                 (name, __VA_ARGS__,                                      M_C(name, _t), M_C(name, _it_t) )))
+                 (name, __VA_ARGS__,                                      M_C(name, _t), M_C(name, _it_t) ))) \
+  M_END_PROTECTED_CODE
 
 /* Define the oplist of a doubly-linked instrusive list of type.
    USAGE:

m-i-shared.h

@@ -37,6 +37,7 @@ M_BEGIN_PROTECTED_CODE
                          ((__VA_ARGS__, M_DEFAULT_OPLIST),           \
                           (__VA_ARGS__ )))
 
+
 /* Interface to add to a structure to allow intrusive support.
    name: name of the intrusive shared pointer.
    type: name of the type of the structure (aka. struct test_s) - not used currently.
@@ -48,9 +49,11 @@ M_BEGIN_PROTECTED_CODE
 /* Define the intrusive shared pointer type and its static inline functions.
    USAGE: ISHARED_PTR_DEF(name, type, [, oplist]) */
 #define ISHARED_PTR_DEF(name, ...)                                      \
+  M_BEGIN_PROTECTED_CODE                                                \
   ISHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                       \
                       ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
-                       (name, __VA_ARGS__ )))
+                       (name, __VA_ARGS__ ))) \
+  M_END_PROTECTED_CODE
 
 
 /********************************** INTERNAL ************************************/

m-list.h

@@ -30,17 +30,21 @@
 /* Define a singly linked list of a given type.
    USAGE: LIST_DEF(name, type [, oplist_of_the_type]) */
 #define LIST_DEF(name, ...)                                             \
+  M_BEGIN_PROTECTED_CODE                                                \
   LISTI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                              \
                ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t), M_C(name, _it_t) ), \
-                (name, __VA_ARGS__,                                      M_C(name,_t), M_C(name, _it_t) )))
+                (name, __VA_ARGS__,                                      M_C(name,_t), M_C(name, _it_t) ))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define a singly linked list of a given type allowing both push.
    USAGE: LIST_DUAL_PUSH_DEF(name, type [, oplist_of_the_type]) */
 #define LIST_DUAL_PUSH_DEF(name, ...)                                   \
+  M_BEGIN_PROTECTED_CODE                                                \
   LISTI_DUAL_PUSH_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                    \
                          ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t), M_C(name, _it_t) ), \
-                          (name, __VA_ARGS__,                                      M_C(name,_t), M_C(name, _it_t) )))
+                          (name, __VA_ARGS__,                                      M_C(name,_t), M_C(name, _it_t) ))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a list of type.

m-mempool.h

@@ -37,11 +37,27 @@
      *ptr = 17;
      mempool_uint_free(m, ptr);
      mempool_uint_clear(m); // Give back memory to system
+   NOTE: Can not use m-list since it may be expanded from LIST_DEF
 */
-// NOTE: Can not use m-list since it may be expanded from LIST_DEF
-
 #define MEMPOOL_DEF(name, type)                                         \
-  									\
+  M_BEGIN_PROTECTED_CODE                                                \
+  MEMPOOL_DEF_P2(name, type)                                            \
+  M_END_PROTECTED_CODE
+
+
+/* User shall be able to cutomize the size of the segment and/or
+   the minimun number of elements.
+*/
+#ifndef MEMPOOL_MAX_PER_SEGMENT
+#define MEMPOOL_MAX_PER_SEGMENT(type)					\
+  M_MAX((16*1024-sizeof(unsigned int) - 2*sizeof(void*)) / sizeof (type), 256U)
+#endif
+
+
+/********************************** INTERNAL ************************************/
+
+#define MEMPOOL_DEF_P2(name, type)                                      \
+                                                                        \
   typedef union M_C(name,_union_s) {					\
     type t;                                                             \
     union M_C(name,_union_s) *next;					\
@@ -129,16 +145,6 @@
     MEMPOOLI_CONTRACT(mem, type);                                       \
   }                                                                     \
 
-/* User shall be able to cutomize the size of the segment and/or
-   the minimun number of elements.
-*/
-#ifndef MEMPOOL_MAX_PER_SEGMENT
-#define MEMPOOL_MAX_PER_SEGMENT(type)					\
-  M_MAX((16*1024-sizeof(unsigned int) - 2*sizeof(void*)) / sizeof (type), 256U)
-#endif
-
-/********************************** INTERNAL ************************************/
-
 
 #define MEMPOOLI_CONTRACT(mempool, type) do {                           \
     assert((mempool) != NULL);                                          \

m-prioqueue.h

@@ -32,10 +32,12 @@
 
 /* Define a prioqueue of a given type and its associated functions.
    USAGE: PRIOQUEUE_DEF(name, type [, oplist_of_the_type]) */
-#define PRIOQUEUE_DEF(name, ...)                                            \
+#define PRIOQUEUE_DEF(name, ...)                                        \
+  M_BEGIN_PROTECTED_CODE                                                \
   PRIOQUEUEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                         \
                     ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), M_C(name,_t), M_C(name,_it_t) ), \
-                     (name, __VA_ARGS__,                                        M_C(name,_t), M_C(name,_it_t))))
+                     (name, __VA_ARGS__,                                        M_C(name,_t), M_C(name,_it_t)))) \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a prioqueue of type.

m-rbtree.h

@@ -30,11 +30,13 @@
 /* Define a Red/Black binary tree of a given type.
    USAGE: RBTREE_DEF(name, type [, oplist_of_the_type]) */
 #define RBTREE_DEF(name, ...)                                           \
+  M_BEGIN_PROTECTED_CODE                                                \
   RBTREEI_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                            \
               ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), \
                 M_C(name, _t), M_C(name, _node_t), M_C(name, _it_t)), \
                (name, __VA_ARGS__ ,                                     \
-                M_C(name, _t), M_C(name, _node_t), M_C(name, _it_t))))
+                M_C(name, _t), M_C(name, _node_t), M_C(name, _it_t))))  \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a rbtree of type.

m-shared.h

@@ -42,17 +42,21 @@ M_BEGIN_PROTECTED_CODE
 /* Define shared pointer and its function.
    USAGE: SHARED_PTR_DEF(name, type, [, oplist]) */
 #define SHARED_PTR_DEF(name, ...)                                       \
+  M_BEGIN_PROTECTED_CODE                                                \
   SHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
                      ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), SHAREDI_ATOMIC_OPLIST ), \
-                      (name, __VA_ARGS__ , SHAREDI_ATOMIC_OPLIST)))
+                      (name, __VA_ARGS__ , SHAREDI_ATOMIC_OPLIST)))     \
+  M_END_PROTECTED_CODE
 
 
 /* Define relaxed shared pointer and its function (thread unsafe).
    USAGE: SHARED_PTR_RELAXED_DEF(name, type, [, oplist]) */
 #define SHARED_PTR_RELAXED_DEF(name, ...)                               \
+  M_BEGIN_PROTECTED_CODE                                                \
   SHAREDI_PTR_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                        \
                      ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)(), SHAREDI_INTEGER_OPLIST ), \
-                      (name, __VA_ARGS__ , SHAREDI_INTEGER_OPLIST)))
+                      (name, __VA_ARGS__ , SHAREDI_INTEGER_OPLIST)))    \
+  M_END_PROTECTED_CODE
 
 
 /* Define shared resource and its function.

m-snapshot.h

@@ -34,25 +34,31 @@ M_BEGIN_PROTECTED_CODE
 /* Define a Single Producer Single Consummer snapshot and its functions
    USAGE: SNAPSHOT_SPSC_DEF(name, type[, oplist]) */
 #define SNAPSHOT_SPSC_DEF(name, ...)                                    \
+  M_BEGIN_PROTECTED_CODE                                                \
   SNAPSHOTI_SPSC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
                         ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
-                         (name, __VA_ARGS__ )))
+                         (name, __VA_ARGS__ )))                         \
+  M_END_PROTECTED_CODE
 
 
 /* Define a Single Producer Multiple Consummer snapshot and its functions
    USAGE: SNAPSHOT_SPMC_DEF(name, type[, oplist]) */
 #define SNAPSHOT_SPMC_DEF(name, ...)                                    \
+  M_BEGIN_PROTECTED_CODE                                                \
   SNAPSHOTI_SPMC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
                         ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
-                         (name, __VA_ARGS__ )))
+                         (name, __VA_ARGS__ )))                         \
+  M_END_PROTECTED_CODE
 
 
 /* Define a Multiple Producer Multiple Consummer snapshot and its functions
    USAGE: SNAPSHOT_MPMC_DEF(name, type[, oplist]) */
 #define SNAPSHOT_MPMC_DEF(name, ...)                                    \
+  M_BEGIN_PROTECTED_CODE                                                \
   SNAPSHOTI_MPMC_DEF_P1(M_IF_NARGS_EQ1(__VA_ARGS__)                     \
                         ((name, __VA_ARGS__, M_GLOBAL_OPLIST_OR_DEF(__VA_ARGS__)() ), \
-                         (name, __VA_ARGS__ )))
+                         (name, __VA_ARGS__ )))                         \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a snapshot (SPSC, SPMC or MPMC).

m-string.h

@@ -1753,6 +1753,8 @@ namespace m_string {
 #undef M_GET_STR_METHOD_FOR_ENUM_TYPE
 #define M_GET_STR_METHOD_FOR_ENUM_TYPE GET_STR(M_ENUM_GET_STR)
 
+
+
 /***********************************************************************/
 /*                                                                     */
 /*                BOUNDED STRING, aka char[N+1]                        */
@@ -1765,7 +1767,12 @@ namespace m_string {
   } while (0)
 
 #define BOUNDED_STRING_DEF(name, max_size)                              \
-                                                                        \
+  M_BEGIN_PROTECTED_CODE                                                \
+  BOUNDED_STRING_DEF_P2(name, max_size)                                 \
+  M_END_PROTECTED_CODE
+
+
+#define BOUNDED_STRING_DEF_P2(name, max_size)                           \
   typedef char M_C(name, _array_t)[max_size+1];                         \
                                                                         \
   typedef struct M_C(name, _s) {                                        \

m-tuple.h

@@ -32,8 +32,10 @@
 /* Define the tuple type and functions.
    USAGE:
    TUPLE_DEF2(name, [(field1, type1[, oplist1]), (field2, type2[, oplist2]), ...] ) */
-#define TUPLE_DEF2(name, ...)                   \
+#define TUPLE_DEF2(name, ...)                                           \
-  TUPLEI_DEF2_P1( (name TUPLEI_INJECT_GLOBAL(__VA_ARGS__)) )
+  M_BEGIN_PROTECTED_CODE                                                \
+  TUPLEI_DEF2_P1( (name TUPLEI_INJECT_GLOBAL(__VA_ARGS__)) )            \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a tuple.

m-variant.h

@@ -34,7 +34,9 @@
    USAGE:
      VARIANT_DEF2(name, [(field1, type1, oplist1), (field2, type2, oplist2), ...] ) */
 #define VARIANT_DEF2(name, ...)                                         \
-  VARIANTI_DEF2_P1( (name VARIANTI_INJECT_GLOBAL(__VA_ARGS__)) )
+  M_BEGIN_PROTECTED_CODE                                                \
+  VARIANTI_DEF2_P1( (name VARIANTI_INJECT_GLOBAL(__VA_ARGS__)) )        \
+  M_END_PROTECTED_CODE
 
 
 /* Define the oplist of a variant.