shared/nm-macros-internal.h

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
   2 /* NetworkManager -- Network link manager
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA 02110-1301 USA.
  18  *
  19  * (C) Copyright 2014 Red Hat, Inc.
  20  */
  21
  22 #ifndef __NM_MACROS_INTERNAL_H__
  23 #define __NM_MACROS_INTERNAL_H__
  24
  25 #include <stdlib.h>
  26
  27 /********************************************************/
  28
  29 #define nm_auto(fcn) __attribute ((cleanup(fcn)))
  30
  31 /**
  32  * nm_auto_free:
  33  *
  34  * Call free() on a variable location when it goes out of scope.
  35  */
  36 #define nm_auto_free nm_auto(_nm_auto_free_impl)
  37 GS_DEFINE_CLEANUP_FUNCTION(void*, _nm_auto_free_impl, free)
  38
  39 /********************************************************/
  40
  41 /* http://stackoverflow.com/a/11172679 */
  42 #define  _NM_UTILS_MACRO_FIRST(...)                           __NM_UTILS_MACRO_FIRST_HELPER(__VA_ARGS__, throwaway)
  43 #define __NM_UTILS_MACRO_FIRST_HELPER(first, ...)             first
  44
  45 #define  _NM_UTILS_MACRO_REST(...)                            __NM_UTILS_MACRO_REST_HELPER(__NM_UTILS_MACRO_REST_NUM(__VA_ARGS__), __VA_ARGS__)
  46 #define __NM_UTILS_MACRO_REST_HELPER(qty, ...)                __NM_UTILS_MACRO_REST_HELPER2(qty, __VA_ARGS__)
  47 #define __NM_UTILS_MACRO_REST_HELPER2(qty, ...)               __NM_UTILS_MACRO_REST_HELPER_##qty(__VA_ARGS__)
  48 #define __NM_UTILS_MACRO_REST_HELPER_ONE(first)
  49 #define __NM_UTILS_MACRO_REST_HELPER_TWOORMORE(first, ...)    , __VA_ARGS__
  50 #define __NM_UTILS_MACRO_REST_NUM(...) \
  51     __NM_UTILS_MACRO_REST_SELECT_20TH(__VA_ARGS__, \
  52                 TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
  53                 TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
  54                 TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
  55                 TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway)
  56 #define __NM_UTILS_MACRO_REST_SELECT_20TH(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, ...) a20
  57
  58 /********************************************************/
  59
  60 /* http://stackoverflow.com/a/2124385/354393 */
  61
  62 #define NM_NARG(...) \
  63          _NM_NARG(__VA_ARGS__,_NM_NARG_RSEQ_N())
  64 #define _NM_NARG(...) \
  65          _NM_NARG_ARG_N(__VA_ARGS__)
  66 #define _NM_NARG_ARG_N( \
  67           _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
  68          _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
  69          _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
  70          _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
  71          _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
  72          _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
  73          _61,_62,_63,N,...) N
  74 #define _NM_NARG_RSEQ_N() \
  75          63,62,61,60,                   \
  76          59,58,57,56,55,54,53,52,51,50, \
  77          49,48,47,46,45,44,43,42,41,40, \
  78          39,38,37,36,35,34,33,32,31,30, \
  79          29,28,27,26,25,24,23,22,21,20, \
  80          19,18,17,16,15,14,13,12,11,10, \
  81          9,8,7,6,5,4,3,2,1,0
  82
  83 /********************************************************/
  84
  85 #if defined (__GNUC__)
  86 #define _NM_PRAGMA_WARNING_DO(warning)       G_STRINGIFY(GCC diagnostic ignored warning)
  87 #elif defined (__clang__)
  88 #define _NM_PRAGMA_WARNING_DO(warning)       G_STRINGIFY(clang diagnostic ignored warning)
  89 #endif
  90
  91 /* you can only suppress a specific warning that the compiler
  92  * understands. Otherwise you will get another compiler warning
  93  * about invalid pragma option.
  94  * It's not that bad however, because gcc and clang often have the
  95  * same name for the same warning. */
  96
  97 #if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
  98 #define NM_PRAGMA_WARNING_DISABLE(warning) \
  99         _Pragma("GCC diagnostic push") \
 100         _Pragma(_NM_PRAGMA_WARNING_DO(warning))
 101 #elif defined (__clang__)
 102 #define NM_PRAGMA_WARNING_DISABLE(warning) \
 103         _Pragma("clang diagnostic push") \
 104         _Pragma(_NM_PRAGMA_WARNING_DO(warning))
 105 #else
 106 #define NM_PRAGMA_WARNING_DISABLE(warning)
 107 #endif
 108
 109 #if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
 110 #define NM_PRAGMA_WARNING_REENABLE \
 111     _Pragma("GCC diagnostic pop")
 112 #elif defined (__clang__)
 113 #define NM_PRAGMA_WARNING_REENABLE \
 114     _Pragma("clang diagnostic pop")
 115 #else
 116 #define NM_PRAGMA_WARNING_REENABLE
 117 #endif
 118
 119 /********************************************************/
 120
 121 /**
 122  * NM_G_ERROR_MSG:
 123  * @error: (allow none): the #GError instance
 124  *
 125  * All functions must follow the convention that when they
 126  * return a failure, they must also set the GError to a valid
 127  * message. For external API however, we want to be extra
 128  * careful before accessing the error instance. Use NM_G_ERROR_MSG()
 129  * which is safe to use on NULL.
 130  *
 131  * Returns: the error message.
 132  **/
 133 static inline const char *
 134 NM_G_ERROR_MSG (GError *error)
 135 {
 136         return error ? (error->message ? : "(null)") : "(no-error)"; \
 137 }
 138
 139 /********************************************************/
 140
 141 /* macro to return strlen() of a compile time string. */
 142 #define NM_STRLEN(str)     ( sizeof ("" str) - 1 )
 143
 144 #define NM_SET_OUT(out_val, value) \
 145         G_STMT_START { \
 146                 typeof(*(out_val)) *_out_val = (out_val); \
 147                 \
 148                 if (_out_val) { \
 149                         *_out_val = (value); \
 150                 } \
 151         } G_STMT_END
 152
 153 /********************************************************/
 154
 155 #define _NM_IN_SET_EVAL_1(op, _x, y1)                               \
 156     (_x == (y1))
 157
 158 #define _NM_IN_SET_EVAL_2(op, _x, y1, y2)                           \
 159     (   (_x == (y1))                                                \
 160      op (_x == (y2))                                                \
 161     )
 162
 163 #define _NM_IN_SET_EVAL_3(op, _x, y1, y2, y3)                       \
 164     (   (_x == (y1))                                                \
 165      op (_x == (y2))                                                \
 166      op (_x == (y3))                                                \
 167     )
 168
 169 #define _NM_IN_SET_EVAL_4(op, _x, y1, y2, y3, y4)                   \
 170     (   (_x == (y1))                                                \
 171      op (_x == (y2))                                                \
 172      op (_x == (y3))                                                \
 173      op (_x == (y4))                                                \
 174     )
 175
 176 #define _NM_IN_SET_EVAL_5(op, _x, y1, y2, y3, y4, y5)               \
 177     (   (_x == (y1))                                                \
 178      op (_x == (y2))                                                \
 179      op (_x == (y3))                                                \
 180      op (_x == (y4))                                                \
 181      op (_x == (y5))                                                \
 182     )
 183
 184 #define _NM_IN_SET_EVAL_6(op, _x, y1, y2, y3, y4, y5, y6)           \
 185     (   (_x == (y1))                                                \
 186      op (_x == (y2))                                                \
 187      op (_x == (y3))                                                \
 188      op (_x == (y4))                                                \
 189      op (_x == (y5))                                                \
 190      op (_x == (y6))                                                \
 191     )
 192
 193 #define _NM_IN_SET_EVAL_N2(op, _x, n, ...)        _NM_IN_SET_EVAL_##n(op, _x, __VA_ARGS__)
 194 #define _NM_IN_SET_EVAL_N(op, x, n, ...)                            \
 195     ({                                                              \
 196         typeof(x) _x = (x);                                         \
 197         !!_NM_IN_SET_EVAL_N2(op, _x, n, __VA_ARGS__);               \
 198     })
 199
 200 /* Beware that this does short-circuit evaluation (use "||" instead of "|")
 201  * which has a possibly unexpected non-function-like behavior.
 202  * Use NM_IN_SET_SE if you need all arguments to be evaluted. */
 203 #define NM_IN_SET(x, ...)               _NM_IN_SET_EVAL_N(||, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)
 204
 205 /* "SE" stands for "side-effect". Contrary to NM_IN_SET(), this does not do
 206  * short-circuit evaluation, which can make a difference if the arguments have
 207  * side-effects. */
 208 #define NM_IN_SET_SE(x, ...)            _NM_IN_SET_EVAL_N(|, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)
 209
 210 /********************************************************/
 211
 212 static inline gboolean
 213 _NM_IN_STRSET_streq (const char *x, const char *s)
 214 {
 215         return s && strcmp (x, s) == 0;
 216 }
 217
 218 #define _NM_IN_STRSET_EVAL_1(op, _x, y1)                            \
 219     _NM_IN_STRSET_streq (_x, y1)
 220
 221 #define _NM_IN_STRSET_EVAL_2(op, _x, y1, y2)                        \
 222     (   _NM_IN_STRSET_streq (_x, y1)                                \
 223      op _NM_IN_STRSET_streq (_x, y2)                                \
 224     )
 225
 226 #define _NM_IN_STRSET_EVAL_3(op, _x, y1, y2, y3)                    \
 227     (   _NM_IN_STRSET_streq (_x, y1)                                \
 228      op _NM_IN_STRSET_streq (_x, y2)                                \
 229      op _NM_IN_STRSET_streq (_x, y3)                                \
 230     )
 231
 232 #define _NM_IN_STRSET_EVAL_4(op, _x, y1, y2, y3, y4)                \
 233     (   _NM_IN_STRSET_streq (_x, y1)                                \
 234      op _NM_IN_STRSET_streq (_x, y2)                                \
 235      op _NM_IN_STRSET_streq (_x, y3)                                \
 236      op _NM_IN_STRSET_streq (_x, y4)                                \
 237     )
 238
 239 #define _NM_IN_STRSET_EVAL_5(op, _x, y1, y2, y3, y4, y5)            \
 240     (   _NM_IN_STRSET_streq (_x, y1)                                \
 241      op _NM_IN_STRSET_streq (_x, y2)                                \
 242      op _NM_IN_STRSET_streq (_x, y3)                                \
 243      op _NM_IN_STRSET_streq (_x, y4)                                \
 244      op _NM_IN_STRSET_streq (_x, y5)                                \
 245     )
 246
 247 #define _NM_IN_STRSET_EVAL_6(op, _x, y1, y2, y3, y4, y5, y6)        \
 248     (   _NM_IN_STRSET_streq (_x, y1)                                \
 249      op _NM_IN_STRSET_streq (_x, y2)                                \
 250      op _NM_IN_STRSET_streq (_x, y3)                                \
 251      op _NM_IN_STRSET_streq (_x, y4)                                \
 252      op _NM_IN_STRSET_streq (_x, y5)                                \
 253      op _NM_IN_STRSET_streq (_x, y6)                                \
 254     )
 255
 256 #define _NM_IN_STRSET_EVAL_N2(op, _x, n, ...) _NM_IN_STRSET_EVAL_##n(op, _x, __VA_ARGS__)
 257 #define _NM_IN_STRSET_EVAL_N(op, x, n, ...)                       \
 258     ({                                                            \
 259         const char *_x = (x);                                     \
 260         (   ((_x == NULL) && _NM_IN_SET_EVAL_N2    (op, (const char *) NULL, n, __VA_ARGS__)) \
 261          || ((_x != NULL) && _NM_IN_STRSET_EVAL_N2 (op, _x,                  n, __VA_ARGS__)) \
 262         ); \
 263     })
 264
 265 /* Beware that this does short-circuit evaluation (use "||" instead of "|")
 266  * which has a possibly unexpected non-function-like behavior.
 267  * Use NM_IN_STRSET_SE if you need all arguments to be evaluted. */
 268 #define NM_IN_STRSET(x, ...)               _NM_IN_STRSET_EVAL_N(||, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)
 269
 270 /* "SE" stands for "side-effect". Contrary to NM_IN_STRSET(), this does not do
 271  * short-circuit evaluation, which can make a difference if the arguments have
 272  * side-effects. */
 273 #define NM_IN_STRSET_SE(x, ...)            _NM_IN_STRSET_EVAL_N(|, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)
 274
 275 /*****************************************************************************/
 276
 277 #define nm_streq(s1, s2)  (strcmp (s1, s2) == 0)
 278 #define nm_streq0(s1, s2) (g_strcmp0 (s1, s2) == 0)
 279
 280 /*****************************************************************************/
 281
 282 #define NM_PRINT_FMT_QUOTED(cond, prefix, str, suffix, str_else) \
 283         (cond) ? (prefix) : "", \
 284         (cond) ? (str) : (str_else), \
 285         (cond) ? (suffix) : ""
 286 #define NM_PRINT_FMT_QUOTE_STRING(arg) NM_PRINT_FMT_QUOTED((arg), "\"", (arg), "\"", "(null)")
 287
 288 /*****************************************************************************/
 289
 290 #if NM_MORE_ASSERTS
 291 #define nm_assert(cond) G_STMT_START { g_assert (cond); } G_STMT_END
 292 #define nm_assert_not_reached() G_STMT_START { g_assert_not_reached (); } G_STMT_END
 293 #else
 294 #define nm_assert(cond) G_STMT_START { if (FALSE) { if (cond) { } } } G_STMT_END
 295 #define nm_assert_not_reached() G_STMT_START { ; } G_STMT_END
 296 #endif
 297
 298 /*****************************************************************************/
 299
 300 #define NM_GOBJECT_PROPERTIES_DEFINE_BASE(...) \
 301 typedef enum { \
 302         _PROPERTY_ENUMS_0, \
 303         __VA_ARGS__ \
 304         _PROPERTY_ENUMS_LAST, \
 305 } _PropertyEnums; \
 306 static GParamSpec *obj_properties[_PROPERTY_ENUMS_LAST] = { NULL, }
 307
 308 #define NM_GOBJECT_PROPERTIES_DEFINE(obj_type, ...) \
 309 NM_GOBJECT_PROPERTIES_DEFINE_BASE (__VA_ARGS__); \
 310 static inline void \
 311 _notify (obj_type *obj, _PropertyEnums prop) \
 312 { \
 313         nm_assert (G_IS_OBJECT (obj)); \
 314         nm_assert ((gsize) prop < G_N_ELEMENTS (obj_properties)); \
 315         g_object_notify_by_pspec ((GObject *) obj, obj_properties[prop]); \
 316 }
 317
 318 /*****************************************************************************/
 319
 320 #define nm_unauto(pp)                                               \
 321     ({                                                              \
 322         G_STATIC_ASSERT (sizeof *(pp) == sizeof (gpointer));        \
 323         gpointer *_pp = (gpointer *) (pp);                          \
 324         gpointer _p = *_pp;                                         \
 325                                                                     \
 326         *_pp = NULL;                                                \
 327         _p;                                                         \
 328     })
 329
 330 /*****************************************************************************/
 331
 332 static inline gpointer
 333 nm_g_object_ref (gpointer obj)
 334 {
 335         /* g_object_ref() doesn't accept NULL. */
 336         if (obj)
 337                 g_object_ref (obj);
 338         return obj;
 339 }
 340
 341 static inline void
 342 nm_g_object_unref (gpointer obj)
 343 {
 344         /* g_object_unref() doesn't accept NULL. Usully, we workaround that
 345          * by using g_clear_object(), but sometimes that is not convinient
 346          * (for example as as destroy function for a hash table that can contain
 347          * NULL values). */
 348         if (obj)
 349                 g_object_unref (obj);
 350 }
 351
 352 static inline gboolean
 353 nm_clear_g_source (guint *id)
 354 {
 355         if (id && *id) {
 356                 g_source_remove (*id);
 357                 *id = 0;
 358                 return TRUE;
 359         }
 360         return FALSE;
 361 }
 362
 363 static inline gboolean
 364 nm_clear_g_signal_handler (gpointer self, gulong *id)
 365 {
 366         if (id && *id) {
 367                 g_signal_handler_disconnect (self, *id);
 368                 *id = 0;
 369                 return TRUE;
 370         }
 371         return FALSE;
 372 }
 373
 374 static inline gboolean
 375 nm_clear_g_variant (GVariant **variant)
 376 {
 377         if (variant && *variant) {
 378                 g_variant_unref (*variant);
 379                 *variant = NULL;
 380                 return TRUE;
 381         }
 382         return FALSE;
 383 }
 384
 385 static inline gboolean
 386 nm_clear_g_cancellable (GCancellable **cancellable)
 387 {
 388         if (cancellable && *cancellable) {
 389                 g_cancellable_cancel (*cancellable);
 390                 g_object_unref (*cancellable);
 391                 *cancellable = NULL;
 392                 return TRUE;
 393         }
 394         return FALSE;
 395 }
 396
 397 /*****************************************************************************/
 398
 399 /* Determine whether @x is a power of two (@x being an integer type).
 400  * For the special cases @x equals zero or one, it also returns true.
 401  * For negative @x, always returns FALSE. That only applies, if the data
 402  * type of @x is signed. */
 403 #define nm_utils_is_power_of_two(x) ({ \
 404                 typeof(x) __x = (x); \
 405                 \
 406                 /* Check if the value is negative. In that case, return FALSE.
 407                  * The first expression is a compile time constant, depending on whether
 408                  * the type is signed. The second expression is a clumsy way for (__x >= 0),
 409                  * which causes a compiler warning for unsigned types. */ \
 410                     ( ( ((typeof(__x)) -1) > ((typeof(__x)) 0) ) || (__x > 0) || (__x == 0) ) \
 411                  && ((__x & (__x - 1)) == 0); \
 412         })
 413
 414 /*****************************************************************************/
 415
 416 /* check if @flags has exactly one flag (@check) set. You should call this
 417  * only with @check being a compile time constant and a power of two. */
 418 #define NM_FLAGS_HAS(flags, check)  \
 419     ( (G_STATIC_ASSERT_EXPR ( ((check) != 0) && ((check) & ((check)-1)) == 0 )), (NM_FLAGS_ANY ((flags), (check))) )
 420
 421 #define NM_FLAGS_ANY(flags, check)  ( ( ((flags) & (check)) != 0       ) ? TRUE : FALSE )
 422 #define NM_FLAGS_ALL(flags, check)  ( ( ((flags) & (check)) == (check) ) ? TRUE : FALSE )
 423
 424 #define NM_FLAGS_SET(flags, val)  ({ \
 425                 const typeof(flags) _flags = (flags); \
 426                 const typeof(flags) _val = (val); \
 427                 \
 428                 _flags | _val; \
 429         })
 430
 431 #define NM_FLAGS_UNSET(flags, val)  ({ \
 432                 const typeof(flags) _flags = (flags); \
 433                 const typeof(flags) _val = (val); \
 434                 \
 435                 _flags & (~_val); \
 436         })
 437
 438 #define NM_FLAGS_ASSIGN(flags, val, assign)  ({ \
 439                 const typeof(flags) _flags = (flags); \
 440                 const typeof(flags) _val = (val); \
 441                 \
 442                 (assign) \
 443                         ? _flags | (_val) \
 444                         : _flags & (~_val); \
 445         })
 446
 447 /*****************************************************************************/
 448
 449 #define _NM_BACKPORT_SYMBOL_IMPL(VERSION, RETURN_TYPE, ORIG_FUNC, VERSIONED_FUNC, ARGS_TYPED, ARGS) \
 450 RETURN_TYPE VERSIONED_FUNC ARGS_TYPED; \
 451 RETURN_TYPE VERSIONED_FUNC ARGS_TYPED \
 452 { \
 453     return ORIG_FUNC ARGS; \
 454 } \
 455 RETURN_TYPE ORIG_FUNC ARGS_TYPED; \
 456 __asm__(".symver "G_STRINGIFY(VERSIONED_FUNC)", "G_STRINGIFY(ORIG_FUNC)"@"G_STRINGIFY(VERSION))
 457
 458 #define NM_BACKPORT_SYMBOL(VERSION, RETURN_TYPE, FUNC, ARGS_TYPED, ARGS) \
 459 _NM_BACKPORT_SYMBOL_IMPL(VERSION, RETURN_TYPE, FUNC, _##FUNC##_##VERSION, ARGS_TYPED, ARGS)
 460
 461 /*****************************************************************************/
 462
 463 static inline char *
 464 nm_strstrip (char *str)
 465 {
 466         /* g_strstrip doesn't like NULL. */
 467         return str ? g_strstrip (str) : NULL;
 468 }
 469
 470 /*****************************************************************************/
 471
 472 static inline guint
 473 nm_encode_version (guint major, guint minor, guint micro) {
 474         /* analog to the preprocessor macro NM_ENCODE_VERSION(). */
 475         return (major << 16) | (minor << 8) | micro;
 476 }
 477
 478 static inline void
 479 nm_decode_version (guint version, guint *major, guint *minor, guint *micro) {
 480         *major = (version & 0xFFFF0000u) >> 16;
 481         *minor = (version & 0x0000FF00u) >>  8;
 482         *micro = (version & 0x000000FFu);
 483 }
 484 /*****************************************************************************/
 485
 486 #define nm_sprintf_buf(buf, format, ...) ({ \
 487                 char * _buf = (buf); \
 488                 \
 489                 /* some static assert trying to ensure that the buffer is statically allocated.
 490                  * It disallows a buffer size of sizeof(gpointer) to catch that. */ \
 491                 G_STATIC_ASSERT (G_N_ELEMENTS (buf) == sizeof (buf) && sizeof (buf) != sizeof (char *)); \
 492                 g_snprintf (_buf, sizeof (buf), \
 493                             ""format"", ##__VA_ARGS__); \
 494                 _buf; \
 495         })
 496
 497 #define nm_sprintf_bufa(n_elements, format, ...) \
 498         ({ \
 499                 char *_buf; \
 500                 \
 501                 G_STATIC_ASSERT (sizeof (char[MAX ((n_elements), 1)]) == (n_elements)); \
 502                 _buf = g_alloca (n_elements); \
 503                 g_snprintf (_buf, n_elements, \
 504                             ""format"", ##__VA_ARGS__); \
 505                 _buf; \
 506         })
 507
 508 /*****************************************************************************/
 509
 510 /**
 511  * The boolean type _Bool is C99 while we mostly stick to C89. However, _Bool is too
 512  * convinient to miss and is effectively available in gcc and clang. So, just use it.
 513  *
 514  * Usually, one would include "stdbool.h" to get the "bool" define which aliases
 515  * _Bool. We provide this define here, because we want to make use of it anywhere.
 516  * (also, stdbool.h is again C99).
 517  *
 518  * Using _Bool has advantages over gboolean:
 519  *
 520  * - commonly _Bool is one byte large, instead of gboolean's 4 bytes (because gboolean
 521  *   is a typedef for gint). Especially when having boolean fields in a struct, we can
 522  *   thereby easily save some space.
 523  *
 524  * - _Bool type guarantees that two "true" expressions compare equal. E.g. the follwing
 525  *   will not work:
 526  *        gboolean v1 = 1;
 527  *        gboolean v2 = 2;
 528  *        g_assert_cmpint (v1, ==, v2); // will fail
 529  *   For that, we often to use !! to coerce gboolean values to 0 or 1:
 530  *        g_assert_cmpint (!!v2, ==, TRUE);
 531  *   With _Bool type, this will be handled properly by the compiler.
 532  *
 533  * - For structs, we might want to safe even more space and use bitfields:
 534  *       struct s1 {
 535  *           gboolean v1:1;
 536  *       };
 537  *   But the problem here is that gboolean is signed, so that
 538  *   v1 will be either 0 or -1 (not 1, TRUE). Thus, the following
 539  *   fails:
 540  *      struct s1 s = { .v1 = TRUE, };
 541  *      g_assert_cmpint (s1.v1, ==, TRUE);
 542  *   It will however work just fine with bool/_Bool while retaining the
 543  *   notion of having a boolean value.
 544  *
 545  * Also, add the defines for "true" and "false". Those are nicely highlighted by the editor
 546  * as special types, contrary to glib's "TRUE"/"FALSE".
 547  */
 548
 549 #ifndef bool
 550 #define bool _Bool
 551 #define true    1
 552 #define false   0
 553 #endif
 554
 555 /*****************************************************************************/
 556
 557 #endif /* __NM_MACROS_INTERNAL_H__ */