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