nm-macros-internal.h 63.3 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager -- Network link manager
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
19
 * (C) Copyright 2012 Colin Walters <walters@verbum.org>.
20 21 22
 * (C) Copyright 2014 Red Hat, Inc.
 */

23 24
#ifndef __NM_MACROS_INTERNAL_H__
#define __NM_MACROS_INTERNAL_H__
25

26
#include <stdio.h>
27
#include <stdlib.h>
28
#include <errno.h>
29 30 31 32 33
#include <string.h>

#include <gio/gio.h>

/*****************************************************************************/
34

35 36 37 38 39
#define _nm_packed           __attribute__ ((__packed__))
#define _nm_unused           __attribute__ ((__unused__))
#define _nm_used             __attribute__ ((__used__))
#define _nm_pure             __attribute__ ((__pure__))
#define _nm_const            __attribute__ ((__const__))
40
#define _nm_printf(a,b)      __attribute__ ((__format__ (__printf__, a, b)))
41 42
#define _nm_align(s)         __attribute__ ((__aligned__ (s)))
#define _nm_section(s)       __attribute__ ((__section__ (s)))
43 44
#define _nm_alignof(type)    __alignof (type)
#define _nm_alignas(type)    _nm_align (_nm_alignof (type))
45
#define nm_auto(fcn)         __attribute__ ((__cleanup__(fcn)))
46

47

48 49 50 51 52 53 54 55 56 57 58 59
/* This is required to make LTO working.
 *
 * See https://gitlab.freedesktop.org/NetworkManager/NetworkManager/merge_requests/76#note_112694
 *     https://gcc.gnu.org/bugzilla/show_bug.cgi?id=48200#c28
 */
#ifndef __clang__
#define _nm_externally_visible __attribute__ ((__externally_visible__))
#else
#define _nm_externally_visible
#endif


60
#if __GNUC__ >= 7
61
#define _nm_fallthrough      __attribute__ ((__fallthrough__))
62 63 64 65
#else
#define _nm_fallthrough
#endif

66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81
/*****************************************************************************/

#ifdef thread_local
#define _nm_thread_local thread_local
/*
 * Don't break on glibc < 2.16 that doesn't define __STDC_NO_THREADS__
 * see http://gcc.gnu.org/bugzilla/show_bug.cgi?id=53769
 */
#elif __STDC_VERSION__ >= 201112L && !(defined(__STDC_NO_THREADS__) || (defined(__GNU_LIBRARY__) && __GLIBC__ == 2 && __GLIBC_MINOR__ < 16))
#define _nm_thread_local _Thread_local
#else
#define _nm_thread_local __thread
#endif

/*****************************************************************************/

82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103
/* most of our code is single-threaded with a mainloop. Hence, we usually don't need
 * any thread-safety. Sometimes, we do need thread-safety (nm-logging), but we can
 * avoid locking if we are on the main-thread by:
 *
 *   - modifications of shared data is done infrequently and only from the
 *     main-thread (nm_logging_setup())
 *   - read-only access is done frequently (nm_logging_enabled())
 *     - from the main-thread, we can do that without locking (because
 *       all modifications are also done on the main thread.
 *     - from other threads, we need locking. But this is expected to be
 *       done infrequently too. Important is the lock-free fast-path on the
 *       main-thread.
 *
 * By defining NM_THREAD_SAFE_ON_MAIN_THREAD you indicate that this code runs
 * on the main-thread. It is by default defined to "1". If you have code that
 * is also used on another thread, redefine the define to 0 (to opt in into
 * the slow-path).
 */
#define NM_THREAD_SAFE_ON_MAIN_THREAD 1

/*****************************************************************************/

104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136
#define NM_AUTO_DEFINE_FCN_VOID(CastType, name, func) \
static inline void name (void *v) \
{ \
	func (*((CastType *) v)); \
}

#define NM_AUTO_DEFINE_FCN_VOID0(CastType, name, func) \
static inline void name (void *v) \
{ \
	if (*((CastType *) v)) \
		func (*((CastType *) v)); \
}

#define NM_AUTO_DEFINE_FCN(Type, name, func) \
static inline void name (Type *v) \
{ \
	func (*v); \
}

#define NM_AUTO_DEFINE_FCN0(Type, name, func) \
static inline void name (Type *v) \
{ \
	if (*v) \
		func (*v); \
}

/*****************************************************************************/

/**
 * gs_free:
 *
 * Call g_free() on a variable location when it goes out of scope.
 */
137
#define gs_free nm_auto(gs_local_free)
138
NM_AUTO_DEFINE_FCN_VOID0 (void *, gs_local_free, g_free)
139 140 141 142 143 144 145 146

/**
 * gs_unref_object:
 *
 * Call g_object_unref() on a variable location when it goes out of
 * scope.  Note that unlike g_object_unref(), the variable may be
 * %NULL.
 */
147
#define gs_unref_object nm_auto(gs_local_obj_unref)
148 149 150 151 152 153 154 155 156
NM_AUTO_DEFINE_FCN_VOID0 (GObject *, gs_local_obj_unref, g_object_unref)

/**
 * gs_unref_variant:
 *
 * Call g_variant_unref() on a variable location when it goes out of
 * scope.  Note that unlike g_variant_unref(), the variable may be
 * %NULL.
 */
157
#define gs_unref_variant nm_auto(gs_local_variant_unref)
158 159 160 161 162 163 164 165 166 167
NM_AUTO_DEFINE_FCN0 (GVariant *, gs_local_variant_unref, g_variant_unref)

/**
 * gs_unref_array:
 *
 * Call g_array_unref() on a variable location when it goes out of
 * scope.  Note that unlike g_array_unref(), the variable may be
 * %NULL.

 */
168
#define gs_unref_array nm_auto(gs_local_array_unref)
169 170 171 172 173 174 175 176 177 178
NM_AUTO_DEFINE_FCN0 (GArray *, gs_local_array_unref, g_array_unref)

/**
 * gs_unref_ptrarray:
 *
 * Call g_ptr_array_unref() on a variable location when it goes out of
 * scope.  Note that unlike g_ptr_array_unref(), the variable may be
 * %NULL.

 */
179
#define gs_unref_ptrarray nm_auto(gs_local_ptrarray_unref)
180 181 182 183 184 185 186 187 188
NM_AUTO_DEFINE_FCN0 (GPtrArray *, gs_local_ptrarray_unref, g_ptr_array_unref)

/**
 * gs_unref_hashtable:
 *
 * Call g_hash_table_unref() on a variable location when it goes out
 * of scope.  Note that unlike g_hash_table_unref(), the variable may
 * be %NULL.
 */
189
#define gs_unref_hashtable nm_auto(gs_local_hashtable_unref)
190 191 192 193 194 195 196 197
NM_AUTO_DEFINE_FCN0 (GHashTable *, gs_local_hashtable_unref, g_hash_table_unref)

/**
 * gs_free_slist:
 *
 * Call g_slist_free() on a variable location when it goes out
 * of scope.
 */
198
#define gs_free_slist nm_auto(gs_local_free_slist)
199
NM_AUTO_DEFINE_FCN0 (GSList *, gs_local_free_slist, g_slist_free)
200 201 202 203 204 205 206 207

/**
 * gs_unref_bytes:
 *
 * Call g_bytes_unref() on a variable location when it goes out
 * of scope.  Note that unlike g_bytes_unref(), the variable may
 * be %NULL.
 */
208
#define gs_unref_bytes nm_auto(gs_local_bytes_unref)
209 210 211 212 213 214 215
NM_AUTO_DEFINE_FCN0 (GBytes *, gs_local_bytes_unref, g_bytes_unref)

/**
 * gs_strfreev:
 *
 * Call g_strfreev() on a variable location when it goes out of scope.
 */
216
#define gs_strfreev nm_auto(gs_local_strfreev)
217
NM_AUTO_DEFINE_FCN0 (char **, gs_local_strfreev, g_strfreev)
218 219 220 221 222 223

/**
 * gs_free_error:
 *
 * Call g_error_free() on a variable location when it goes out of scope.
 */
224
#define gs_free_error nm_auto(gs_local_free_error)
225 226 227 228 229 230 231
NM_AUTO_DEFINE_FCN0 (GError *, gs_local_free_error, g_error_free)

/**
 * gs_unref_keyfile:
 *
 * Call g_key_file_unref() on a variable location when it goes out of scope.
 */
232
#define gs_unref_keyfile nm_auto(gs_local_keyfile_unref)
233 234 235 236
NM_AUTO_DEFINE_FCN0 (GKeyFile *, gs_local_keyfile_unref, g_key_file_unref)

/*****************************************************************************/

237 238 239 240
#include "nm-glib.h"

/*****************************************************************************/

241 242
#define nm_offsetofend(t,m) (G_STRUCT_OFFSET (t,m) + sizeof (((t *) NULL)->m))

243
/*****************************************************************************/
244

245
static inline int nm_close (int fd);
246

247 248 249 250
/**
 * nm_auto_free:
 *
 * Call free() on a variable location when it goes out of scope.
251 252 253 254 255 256 257 258 259
 * This is for pointers that are allocated with malloc() instead of
 * g_malloc().
 *
 * In practice, since glib 2.45, g_malloc()/g_free() always wraps malloc()/free().
 * See bgo#751592. In that case, it would be safe to free pointers allocated with
 * malloc() with gs_free or g_free().
 *
 * However, let's never mix them. To free malloc'ed memory, always use
 * free() or nm_auto_free.
260
 */
261
NM_AUTO_DEFINE_FCN_VOID0 (void *, _nm_auto_free_impl, free)
262
#define nm_auto_free nm_auto(_nm_auto_free_impl)
263

264
NM_AUTO_DEFINE_FCN0 (GVariantIter *, _nm_auto_free_variant_iter, g_variant_iter_free)
265
#define nm_auto_free_variant_iter nm_auto(_nm_auto_free_variant_iter)
266

267
NM_AUTO_DEFINE_FCN0 (GVariantBuilder *, _nm_auto_unref_variant_builder, g_variant_builder_unref)
268
#define nm_auto_unref_variant_builder nm_auto(_nm_auto_unref_variant_builder)
269

270 271
#define nm_auto_clear_variant_builder nm_auto(g_variant_builder_clear)

272
NM_AUTO_DEFINE_FCN0 (GList *, _nm_auto_free_list, g_list_free)
273
#define nm_auto_free_list nm_auto(_nm_auto_free_list)
274

275
NM_AUTO_DEFINE_FCN0 (GChecksum *, _nm_auto_checksum_free, g_checksum_free)
276
#define nm_auto_free_checksum nm_auto(_nm_auto_checksum_free)
277

278
#define nm_auto_unset_gvalue nm_auto(g_value_unset)
279

280
NM_AUTO_DEFINE_FCN_VOID0 (void *, _nm_auto_unref_gtypeclass, g_type_class_unref)
281 282
#define nm_auto_unref_gtypeclass nm_auto(_nm_auto_unref_gtypeclass)

283 284 285
NM_AUTO_DEFINE_FCN0 (GByteArray *, _nm_auto_unref_bytearray, g_byte_array_unref)
#define nm_auto_unref_bytearray nm_auto(_nm_auto_unref_bytearray)

286
static inline void
287
_nm_auto_free_gstring (GString **str)
288 289 290 291
{
	if (*str)
		g_string_free (*str, TRUE);
}
292
#define nm_auto_free_gstring nm_auto(_nm_auto_free_gstring)
293

294
static inline void
295
_nm_auto_close (int *pfd)
296 297 298 299
{
	if (*pfd >= 0) {
		int errsv = errno;

300
		(void) nm_close (*pfd);
301 302 303
		errno = errsv;
	}
}
304
#define nm_auto_close nm_auto(_nm_auto_close)
305 306

static inline void
307
_nm_auto_fclose (FILE **pfd)
308 309 310 311 312 313 314 315
{
	if (*pfd) {
		int errsv = errno;

		(void) fclose (*pfd);
		errno = errsv;
	}
}
316
#define nm_auto_fclose nm_auto(_nm_auto_fclose)
317

318 319 320 321 322 323 324
static inline void
_nm_auto_protect_errno (int *p_saved_errno)
{
	errno = *p_saved_errno;
}
#define NM_AUTO_PROTECT_ERRNO(errsv_saved) nm_auto(_nm_auto_protect_errno) _nm_unused const int errsv_saved = (errno)

325
NM_AUTO_DEFINE_FCN0 (GSource *, _nm_auto_unref_gsource, g_source_unref);
326 327
#define nm_auto_unref_gsource nm_auto(_nm_auto_unref_gsource)

328 329 330
NM_AUTO_DEFINE_FCN0 (GMainLoop *, _nm_auto_unref_gmainloop, g_main_loop_unref);
#define nm_auto_unref_gmainloop nm_auto(_nm_auto_unref_gmainloop)

331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
static inline void
_nm_auto_freev (gpointer ptr)
{
	gpointer **p = ptr;
	gpointer *_ptr;

	if (*p) {
		for (_ptr = *p; *_ptr; _ptr++)
			g_free (*_ptr);
		g_free (*p);
	}
}
/* g_free a NULL terminated array of pointers, with also freeing each
 * pointer with g_free(). It essentially does the same as
 * gs_strfreev / g_strfreev(), but not restricted to strv arrays. */
#define nm_auto_freev nm_auto(_nm_auto_freev)

348
/*****************************************************************************/
349

350 351 352 353 354 355 356 357 358 359
/* http://stackoverflow.com/a/11172679 */
#define  _NM_UTILS_MACRO_FIRST(...)                           __NM_UTILS_MACRO_FIRST_HELPER(__VA_ARGS__, throwaway)
#define __NM_UTILS_MACRO_FIRST_HELPER(first, ...)             first

#define  _NM_UTILS_MACRO_REST(...)                            __NM_UTILS_MACRO_REST_HELPER(__NM_UTILS_MACRO_REST_NUM(__VA_ARGS__), __VA_ARGS__)
#define __NM_UTILS_MACRO_REST_HELPER(qty, ...)                __NM_UTILS_MACRO_REST_HELPER2(qty, __VA_ARGS__)
#define __NM_UTILS_MACRO_REST_HELPER2(qty, ...)               __NM_UTILS_MACRO_REST_HELPER_##qty(__VA_ARGS__)
#define __NM_UTILS_MACRO_REST_HELPER_ONE(first)
#define __NM_UTILS_MACRO_REST_HELPER_TWOORMORE(first, ...)    , __VA_ARGS__
#define __NM_UTILS_MACRO_REST_NUM(...) \
360 361 362
    __NM_UTILS_MACRO_REST_SELECT_30TH(__VA_ARGS__, \
                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
363 364 365 366
                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
                TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE, TWOORMORE,\
                TWOORMORE, TWOORMORE, TWOORMORE, ONE, throwaway)
367
#define __NM_UTILS_MACRO_REST_SELECT_30TH(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, a30, ...) a30
368

369
/*****************************************************************************/
370

371 372 373
/* http://stackoverflow.com/a/2124385/354393
 * https://stackoverflow.com/questions/11317474/macro-to-count-number-of-arguments
 */
374 375

#define NM_NARG(...) \
376
         _NM_NARG(, ##__VA_ARGS__, _NM_NARG_RSEQ_N())
377 378 379
#define _NM_NARG(...) \
         _NM_NARG_ARG_N(__VA_ARGS__)
#define _NM_NARG_ARG_N( \
380
          _0, \
381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
          _1, _2, _3, _4, _5, _6, _7, _8, _9,_10, \
         _11,_12,_13,_14,_15,_16,_17,_18,_19,_20, \
         _21,_22,_23,_24,_25,_26,_27,_28,_29,_30, \
         _31,_32,_33,_34,_35,_36,_37,_38,_39,_40, \
         _41,_42,_43,_44,_45,_46,_47,_48,_49,_50, \
         _51,_52,_53,_54,_55,_56,_57,_58,_59,_60, \
         _61,_62,_63,N,...) N
#define _NM_NARG_RSEQ_N() \
         63,62,61,60,                   \
         59,58,57,56,55,54,53,52,51,50, \
         49,48,47,46,45,44,43,42,41,40, \
         39,38,37,36,35,34,33,32,31,30, \
         29,28,27,26,25,24,23,22,21,20, \
         19,18,17,16,15,14,13,12,11,10, \
         9,8,7,6,5,4,3,2,1,0

397
/*****************************************************************************/
398

399 400 401 402 403 404 405 406 407 408 409 410
#if defined (__GNUC__)
#define _NM_PRAGMA_WARNING_DO(warning)       G_STRINGIFY(GCC diagnostic ignored warning)
#elif defined (__clang__)
#define _NM_PRAGMA_WARNING_DO(warning)       G_STRINGIFY(clang diagnostic ignored warning)
#endif

/* you can only suppress a specific warning that the compiler
 * understands. Otherwise you will get another compiler warning
 * about invalid pragma option.
 * It's not that bad however, because gcc and clang often have the
 * same name for the same warning. */

411
#if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
412
#define NM_PRAGMA_WARNING_DISABLE(warning) \
413
        _Pragma("GCC diagnostic push") \
414 415 416
        _Pragma(_NM_PRAGMA_WARNING_DO(warning))
#elif defined (__clang__)
#define NM_PRAGMA_WARNING_DISABLE(warning) \
417
        _Pragma("clang diagnostic push") \
418
        _Pragma(_NM_PRAGMA_WARNING_DO("-Wunknown-warning-option")) \
419 420 421 422 423
        _Pragma(_NM_PRAGMA_WARNING_DO(warning))
#else
#define NM_PRAGMA_WARNING_DISABLE(warning)
#endif

424
#if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
425 426 427 428 429 430 431 432 433
#define NM_PRAGMA_WARNING_REENABLE \
    _Pragma("GCC diagnostic pop")
#elif defined (__clang__)
#define NM_PRAGMA_WARNING_REENABLE \
    _Pragma("clang diagnostic pop")
#else
#define NM_PRAGMA_WARNING_REENABLE
#endif

434
/*****************************************************************************/
435

Thomas Haller's avatar
Thomas Haller committed
436 437
/**
 * NM_G_ERROR_MSG:
438
 * @error: (allow-none): the #GError instance
Thomas Haller's avatar
Thomas Haller committed
439 440 441 442 443 444 445 446 447 448 449 450
 *
 * All functions must follow the convention that when they
 * return a failure, they must also set the GError to a valid
 * message. For external API however, we want to be extra
 * careful before accessing the error instance. Use NM_G_ERROR_MSG()
 * which is safe to use on NULL.
 *
 * Returns: the error message.
 **/
static inline const char *
NM_G_ERROR_MSG (GError *error)
{
451
	return error ? (error->message ?: "(null)") : "(no-error)"; \
Thomas Haller's avatar
Thomas Haller committed
452 453
}

454
/*****************************************************************************/
Thomas Haller's avatar
Thomas Haller committed
455

456
/* macro to return strlen() of a compile time string. */
457
#define NM_STRLEN(str)     ( sizeof (""str"") - 1 )
458

459 460 461 462 463 464 465 466 467 468
/* returns the length of a NULL terminated array of pointers,
 * like g_strv_length() does. The difference is:
 *  - it operats on arrays of pointers (of any kind, requiring no cast).
 *  - it accepts NULL to return zero. */
#define NM_PTRARRAY_LEN(array) \
	({ \
		typeof (*(array)) *const _array = (array); \
		gsize _n = 0; \
		\
		if (_array) { \
469 470
			_nm_unused gconstpointer _type_check_is_pointer = _array[0]; \
			\
471 472 473 474 475 476
			while (_array[_n]) \
				_n++; \
		} \
		_n; \
	})

477 478 479 480 481
/* Note: @value is only evaluated when *out_val is present.
 * Thus,
 *    NM_SET_OUT (out_str, g_strdup ("hallo"));
 * does the right thing.
 */
482 483 484 485 486 487 488 489 490
#define NM_SET_OUT(out_val, value) \
	G_STMT_START { \
		typeof(*(out_val)) *_out_val = (out_val); \
		\
		if (_out_val) { \
			*_out_val = (value); \
		} \
	} G_STMT_END

491
/*****************************************************************************/
492

493
#ifndef _NM_CC_SUPPORT_AUTO_TYPE
494 495 496 497 498
#if (defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9 )))
#define _NM_CC_SUPPORT_AUTO_TYPE 1
#else
#define _NM_CC_SUPPORT_AUTO_TYPE 0
#endif
499
#endif
500

501
#ifndef _NM_CC_SUPPORT_GENERIC
502 503 504 505
/* In the meantime, NetworkManager requires C11 and _Generic() should always be available.
 * However, shared/nm-utils may also be used in VPN/applet, which possibly did not yet
 * bump the C standard requirement. Leave this for the moment, but eventually we can
 * drop it. */
506
#if (defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9 ))) || (defined (__clang__))
507 508 509 510
#define _NM_CC_SUPPORT_GENERIC 1
#else
#define _NM_CC_SUPPORT_GENERIC 0
#endif
511 512 513 514 515
#endif

#if _NM_CC_SUPPORT_AUTO_TYPE
#define _nm_auto_type __auto_type
#endif
516 517

#if _NM_CC_SUPPORT_GENERIC
518
#define _NM_CONSTCAST_FULL_1(type, obj_expr, obj) \
519
	(_Generic ((obj_expr), \
520 521 522 523 524 525 526 527 528
	           const void        *const: ((const type *) (obj)), \
	           const void        *     : ((const type *) (obj)), \
	                 void        *const: ((      type *) (obj)), \
	                 void        *     : ((      type *) (obj)), \
	           const type        *const: ((const type *) (obj)), \
	           const type        *     : ((const type *) (obj)), \
	                 type        *const: ((      type *) (obj)), \
	                 type        *     : ((      type *) (obj))))
#define _NM_CONSTCAST_FULL_2(type, obj_expr, obj, alias_type2) \
529
	(_Generic ((obj_expr), \
530 531 532 533 534 535 536 537 538 539 540 541 542
	           const void        *const: ((const type *) (obj)), \
	           const void        *     : ((const type *) (obj)), \
	                 void        *const: ((      type *) (obj)), \
	                 void        *     : ((      type *) (obj)), \
	           const alias_type2 *const: ((const type *) (obj)), \
	           const alias_type2 *     : ((const type *) (obj)), \
	                 alias_type2 *const: ((      type *) (obj)), \
	                 alias_type2 *     : ((      type *) (obj)), \
	           const type        *const: ((const type *) (obj)), \
	           const type        *     : ((const type *) (obj)), \
	                 type        *const: ((      type *) (obj)), \
	                 type        *     : ((      type *) (obj))))
#define _NM_CONSTCAST_FULL_3(type, obj_expr, obj, alias_type2, alias_type3) \
543
	(_Generic ((obj_expr), \
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584
	           const void        *const: ((const type *) (obj)), \
	           const void        *     : ((const type *) (obj)), \
	                 void        *const: ((      type *) (obj)), \
	                 void        *     : ((      type *) (obj)), \
	           const alias_type2 *const: ((const type *) (obj)), \
	           const alias_type2 *     : ((const type *) (obj)), \
	                 alias_type2 *const: ((      type *) (obj)), \
	                 alias_type2 *     : ((      type *) (obj)), \
	           const alias_type3 *const: ((const type *) (obj)), \
	           const alias_type3 *     : ((const type *) (obj)), \
	                 alias_type3 *const: ((      type *) (obj)), \
	                 alias_type3 *     : ((      type *) (obj)), \
	           const type        *const: ((const type *) (obj)), \
	           const type        *     : ((const type *) (obj)), \
	                 type        *const: ((      type *) (obj)), \
	                 type        *     : ((      type *) (obj))))
#define _NM_CONSTCAST_FULL_4(type, obj_expr, obj, alias_type2, alias_type3, alias_type4) \
	(_Generic ((obj_expr), \
	           const void        *const: ((const type *) (obj)), \
	           const void        *     : ((const type *) (obj)), \
	                 void        *const: ((      type *) (obj)), \
	                 void        *     : ((      type *) (obj)), \
	           const alias_type2 *const: ((const type *) (obj)), \
	           const alias_type2 *     : ((const type *) (obj)), \
	                 alias_type2 *const: ((      type *) (obj)), \
	                 alias_type2 *     : ((      type *) (obj)), \
	           const alias_type3 *const: ((const type *) (obj)), \
	           const alias_type3 *     : ((const type *) (obj)), \
	                 alias_type3 *const: ((      type *) (obj)), \
	                 alias_type3 *     : ((      type *) (obj)), \
	           const alias_type4 *const: ((const type *) (obj)), \
	           const alias_type4 *     : ((const type *) (obj)), \
	                 alias_type4 *const: ((      type *) (obj)), \
	                 alias_type4 *     : ((      type *) (obj)), \
	           const type        *const: ((const type *) (obj)), \
	           const type        *     : ((const type *) (obj)), \
	                 type        *const: ((      type *) (obj)), \
	                 type        *     : ((      type *) (obj))))
#define _NM_CONSTCAST_FULL_x(type, obj_expr, obj, n, ...)   (_NM_CONSTCAST_FULL_##n (type, obj_expr, obj,                        ##__VA_ARGS__))
#define _NM_CONSTCAST_FULL_y(type, obj_expr, obj, n, ...)   (_NM_CONSTCAST_FULL_x   (type, obj_expr, obj, n,                     ##__VA_ARGS__))
#define NM_CONSTCAST_FULL(   type, obj_expr, obj,    ...)   (_NM_CONSTCAST_FULL_y   (type, obj_expr, obj, NM_NARG (dummy, ##__VA_ARGS__), ##__VA_ARGS__))
585
#else
586
#define NM_CONSTCAST_FULL(   type, obj_expr, obj,    ...)   ((type *) (obj))
587 588
#endif

589 590
#define NM_CONSTCAST(type, obj, ...) \
	NM_CONSTCAST_FULL(type, (obj), (obj), ##__VA_ARGS__)
591

592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609 610 611 612 613
#if _NM_CC_SUPPORT_GENERIC
#define NM_UNCONST_PTR(type, arg) \
	_Generic ((arg), \
	          const type *: ((type *) (arg)), \
	                type *: ((type *) (arg)))
#else
#define NM_UNCONST_PTR(type, arg) \
	((type *) (arg))
#endif

#if _NM_CC_SUPPORT_GENERIC
#define NM_UNCONST_PPTR(type, arg) \
	_Generic ((arg), \
	          const type *     *: ((type **) (arg)), \
	                type *     *: ((type **) (arg)), \
	          const type *const*: ((type **) (arg)), \
	                type *const*: ((type **) (arg)))
#else
#define NM_UNCONST_PPTR(type, arg) \
	((type **) (arg))
#endif

614
#define NM_GOBJECT_CAST(type, obj, is_check, ...) \
615 616 617
	({ \
		const void *_obj = (obj); \
		\
618 619
		nm_assert (_obj || (is_check (_obj))); \
		NM_CONSTCAST_FULL (type, (obj), _obj, GObject, ##__VA_ARGS__); \
620
	})
621 622

#define NM_GOBJECT_CAST_NON_NULL(type, obj, is_check, ...) \
623 624 625 626
	({ \
		const void *_obj = (obj); \
		\
		nm_assert (is_check (_obj)); \
627
		NM_CONSTCAST_FULL (type, (obj), _obj, GObject, ##__VA_ARGS__); \
628 629
	})

630 631 632 633 634 635 636 637 638 639 640 641
#if _NM_CC_SUPPORT_GENERIC
/* returns @value, if the type of @value matches @type.
 * This requires support for C11 _Generic(). If no support is
 * present, this returns @value directly.
 *
 * It's useful to check the let the compiler ensure that @value is
 * of a certain type. */
#define _NM_ENSURE_TYPE(type, value) (_Generic ((value), type: (value)))
#else
#define _NM_ENSURE_TYPE(type, value) (value)
#endif

642 643 644 645 646 647 648 649 650 651 652
#if _NM_CC_SUPPORT_GENERIC
/* these macros cast (value) to
 *  - "const char **"      (for "MC", mutable-const)
 *  - "const char *const*" (for "CC", const-const)
 * The point is to do this cast, but only accepting pointers
 * that are compatible already.
 *
 * The problem is, if you add a function like g_strdupv(), the input
 * argument is not modified (CC), but you want to make it work also
 * for "char **". C doesn't allow this form of casting (for good reasons),
 * so the function makes a choice like g_strdupv(char**). That means,
Rafael Fontenelle's avatar
Rafael Fontenelle committed
653
 * every time you want to call it with a const argument, you need to
654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676
 * explicitly cast it.
 *
 * These macros do the cast, but they only accept a compatible input
 * type, otherwise they will fail compilation.
 */
#define NM_CAST_STRV_MC(value) \
	(_Generic ((value), \
	           const char *     *: (const char *     *) (value), \
	                 char *     *: (const char *     *) (value), \
	                       void *: (const char *     *) (value)))
#define NM_CAST_STRV_CC(value) \
	(_Generic ((value), \
	           const char *const*: (const char *const*) (value), \
	           const char *     *: (const char *const*) (value), \
	                 char *const*: (const char *const*) (value), \
	                 char *     *: (const char *const*) (value), \
	                 const void *: (const char *const*) (value), \
	                       void *: (const char *const*) (value)))
#else
#define NM_CAST_STRV_MC(value) ((const char *     *) (value))
#define NM_CAST_STRV_CC(value) ((const char *const*) (value))
#endif

677 678 679 680 681 682 683 684 685 686
#if _NM_CC_SUPPORT_GENERIC
#define NM_PROPAGATE_CONST(test_expr, ptr) \
	(_Generic ((test_expr), \
	           const typeof (*(test_expr)) *: ((const typeof (*(ptr)) *) (ptr)), \
	                                 default: (_Generic ((test_expr), \
	                                                     typeof (*(test_expr)) *: (ptr)))))
#else
#define NM_PROPAGATE_CONST(test_expr, ptr) (ptr)
#endif

687 688 689
/* with the way it is implemented, the caller may or may not pass a trailing
 * ',' and it will work. However, this makes the macro unsuitable for initializing
 * an array. */
690
#define NM_MAKE_STRV(...) \
691
	((const char *const[(sizeof (((const char *const[]) { __VA_ARGS__ })) / sizeof (const char *)) + 1]) { __VA_ARGS__ })
692

693 694
/*****************************************************************************/

695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712
#define _NM_IN_SET_EVAL_1( op, _x, y)           (_x == (y))
#define _NM_IN_SET_EVAL_2( op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_1  (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_3( op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_2  (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_4( op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_3  (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_5( op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_4  (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_6( op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_5  (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_7( op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_6  (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_8( op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_7  (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_9( op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_8  (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_10(op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_9  (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_11(op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_10 (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_12(op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_11 (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_13(op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_12 (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_14(op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_13 (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_15(op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_14 (op, _x, __VA_ARGS__)
#define _NM_IN_SET_EVAL_16(op, _x, y, ...)      (_x == (y)) op _NM_IN_SET_EVAL_15 (op, _x, __VA_ARGS__)

#define _NM_IN_SET_EVAL_N2(op, _x, n, ...)      (_NM_IN_SET_EVAL_##n(op, _x, __VA_ARGS__))
713
#define _NM_IN_SET_EVAL_N(op, type, x, n, ...)                      \
714
    ({                                                              \
715 716 717 718 719
        type _x = (x);                                              \
                                                                    \
        /* trigger a -Wenum-compare warning */                      \
        nm_assert (TRUE || _x == (x));                              \
                                                                    \
720
        !!_NM_IN_SET_EVAL_N2(op, _x, n, __VA_ARGS__);               \
721 722
    })

723 724
#define _NM_IN_SET(op, type, x, ...)        _NM_IN_SET_EVAL_N(op, type, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)

725 726
/* Beware that this does short-circuit evaluation (use "||" instead of "|")
 * which has a possibly unexpected non-function-like behavior.
Rafael Fontenelle's avatar
Rafael Fontenelle committed
727
 * Use NM_IN_SET_SE if you need all arguments to be evaluated. */
728
#define NM_IN_SET(x, ...)                   _NM_IN_SET(||, typeof (x), x, __VA_ARGS__)
729 730 731 732

/* "SE" stands for "side-effect". Contrary to NM_IN_SET(), this does not do
 * short-circuit evaluation, which can make a difference if the arguments have
 * side-effects. */
733 734 735 736 737 738 739 740
#define NM_IN_SET_SE(x, ...)                _NM_IN_SET(|,  typeof (x), x, __VA_ARGS__)

/* the *_TYPED forms allow to explicitly select the type of "x". This is useful
 * if "x" doesn't support typeof (bitfields) or you want to gracefully convert
 * a type using automatic type conversion rules (but not forcing the conversion
 * with a cast). */
#define NM_IN_SET_TYPED(type, x, ...)       _NM_IN_SET(||, type,       x, __VA_ARGS__)
#define NM_IN_SET_SE_TYPED(type, x, ...)    _NM_IN_SET(|,  type,       x, __VA_ARGS__)
741

742
/*****************************************************************************/
Thomas Haller's avatar
Thomas Haller committed
743 744 745 746 747 748 749

static inline gboolean
_NM_IN_STRSET_streq (const char *x, const char *s)
{
	return s && strcmp (x, s) == 0;
}

750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767
#define _NM_IN_STRSET_EVAL_1( op, _x, y)        _NM_IN_STRSET_streq (_x, y)
#define _NM_IN_STRSET_EVAL_2( op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_1  (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_3( op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_2  (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_4( op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_3  (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_5( op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_4  (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_6( op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_5  (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_7( op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_6  (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_8( op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_7  (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_9( op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_8  (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_10(op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_9  (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_11(op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_10 (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_12(op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_11 (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_13(op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_12 (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_14(op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_13 (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_15(op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_14 (op, _x, __VA_ARGS__)
#define _NM_IN_STRSET_EVAL_16(op, _x, y, ...)   _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_15 (op, _x, __VA_ARGS__)

#define _NM_IN_STRSET_EVAL_N2(op, _x, n, ...)   (_NM_IN_STRSET_EVAL_##n(op, _x, __VA_ARGS__))
Thomas Haller's avatar
Thomas Haller committed
768 769 770
#define _NM_IN_STRSET_EVAL_N(op, x, n, ...)                       \
    ({                                                            \
        const char *_x = (x);                                     \
771 772
        (   ((_x == NULL) && _NM_IN_SET_EVAL_N2    (op, ((const char *) NULL), n, __VA_ARGS__)) \
         || ((_x != NULL) && _NM_IN_STRSET_EVAL_N2 (op, _x,                    n, __VA_ARGS__)) \
Thomas Haller's avatar
Thomas Haller committed
773 774 775 776 777
        ); \
    })

/* Beware that this does short-circuit evaluation (use "||" instead of "|")
 * which has a possibly unexpected non-function-like behavior.
Rafael Fontenelle's avatar
Rafael Fontenelle committed
778
 * Use NM_IN_STRSET_SE if you need all arguments to be evaluated. */
Thomas Haller's avatar
Thomas Haller committed
779 780 781 782 783 784 785
#define NM_IN_STRSET(x, ...)               _NM_IN_STRSET_EVAL_N(||, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)

/* "SE" stands for "side-effect". Contrary to NM_IN_STRSET(), this does not do
 * short-circuit evaluation, which can make a difference if the arguments have
 * side-effects. */
#define NM_IN_STRSET_SE(x, ...)            _NM_IN_STRSET_EVAL_N(|, x, NM_NARG (__VA_ARGS__), __VA_ARGS__)

786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831
#define NM_STRCHAR_ALL(str, ch_iter, predicate) \
	({ \
		gboolean _val = TRUE; \
		const char *_str = (str); \
		\
		if (_str) { \
			for (;;) { \
				const char ch_iter = _str[0]; \
				\
				if (ch_iter != '\0') { \
					if (predicate) {\
						_str++; \
						continue; \
					} \
					_val = FALSE; \
				} \
				break; \
			} \
		} \
		_val; \
	})

#define NM_STRCHAR_ANY(str, ch_iter, predicate) \
	({ \
		gboolean _val = FALSE; \
		const char *_str = (str); \
		\
		if (_str) { \
			for (;;) { \
				const char ch_iter = _str[0]; \
				\
				if (ch_iter != '\0') { \
					if (predicate) { \
						; \
					} else { \
						_str++; \
						continue; \
					} \
					_val = TRUE; \
				} \
				break; \
			} \
		} \
		_val; \
	})

832 833
/*****************************************************************************/

834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849
/* NM_CACHED_QUARK() returns the GQuark for @string, but caches
 * it in a static variable to speed up future lookups.
 *
 * @string must be a string literal.
 */
#define NM_CACHED_QUARK(string) \
	({ \
		static GQuark _nm_cached_quark = 0; \
		\
		(G_LIKELY (_nm_cached_quark != 0) \
			? _nm_cached_quark \
			: (_nm_cached_quark = g_quark_from_static_string (""string""))); \
	})

/* NM_CACHED_QUARK_FCN() is essentially the same as G_DEFINE_QUARK
 * with two differences:
850
 * - @string must be a quoted string-literal
851 852 853 854 855 856 857 858 859 860 861 862 863 864 865 866 867
 * - @fcn must be the full function name, while G_DEFINE_QUARK() appends
 *   "_quark" to the function name.
 * Both properties of G_DEFINE_QUARK() are non favorable, because you can no
 * longer grep for string/fcn -- unless you are aware that you are searching
 * for G_DEFINE_QUARK() and omit quotes / append _quark(). With NM_CACHED_QUARK_FCN(),
 * ctags/cscope can locate the use of @fcn (though it doesn't recognize that
 * NM_CACHED_QUARK_FCN() defines it).
 */
#define NM_CACHED_QUARK_FCN(string, fcn) \
GQuark \
fcn (void) \
{ \
	return NM_CACHED_QUARK (string); \
}

/*****************************************************************************/

868 869 870 871 872 873 874 875 876 877 878 879
static inline gboolean
nm_streq (const char *s1, const char *s2)
{
	return strcmp (s1, s2) == 0;
}

static inline gboolean
nm_streq0 (const char *s1, const char *s2)
{
	return    (s1 == s2)
	       || (s1 && s2 && strcmp (s1, s2) == 0);
}
880

881 882 883
#define NM_STR_HAS_PREFIX(str, prefix) \
	(strncmp ((str), ""prefix"", NM_STRLEN (prefix)) == 0)

884 885 886 887 888 889 890 891 892 893 894
#define NM_STR_HAS_SUFFIX(str, suffix) \
	({ \
		const char *_str = (str); \
		gsize _l = strlen (_str); \
		\
		(   (_l >= NM_STRLEN (suffix)) \
		 && (memcmp (&_str[_l - NM_STRLEN (suffix)], \
		             ""suffix"", \
		             NM_STRLEN (suffix)) == 0)); \
	})

895 896
/*****************************************************************************/

897 898 899 900 901 902 903 904 905 906
static inline GString *
nm_gstring_prepare (GString **l)
{
	if (*l)
		g_string_set_size (*l, 0);
	else
		*l = g_string_sized_new (30);
	return *l;
}

907 908 909 910 911 912 913 914
static inline GString *
nm_gstring_add_space_delimiter (GString *str)
{
	if (str->len > 0)
		g_string_append_c (str, ' ');
	return str;
}

915 916 917 918 919
static inline const char *
nm_str_not_empty (const char *str)
{
	return str && str[0] ? str : NULL;
}
920 921 922 923 924 925 926

static inline char *
nm_strdup_not_empty (const char *str)
{
	return str && str[0] ? g_strdup (str) : NULL;
}

Thomas Haller's avatar
Thomas Haller committed
927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945
static inline char *
nm_str_realloc (char *str)
{
	gs_free char *s = str;

	/* Returns a new clone of @str and frees @str. The point is that @str
	 * possibly points to a larger chunck of memory. We want to freshly allocate
	 * a buffer.
	 *
	 * We could use realloc(), but that might not do anything or leave
	 * @str in its memory pool for chunks of a different size (bad for
	 * fragmentation).
	 *
	 * This is only useful when we want to keep the buffer around for a long
	 * time and want to re-allocate a more optimal buffer. */

	return g_strdup (s);
}

946 947
/*****************************************************************************/

948 949 950 951
#define NM_PRINT_FMT_QUOTED(cond, prefix, str, suffix, str_else) \
	(cond) ? (prefix) : "", \
	(cond) ? (str) : (str_else), \
	(cond) ? (suffix) : ""
952
#define NM_PRINT_FMT_QUOTE_STRING(arg) NM_PRINT_FMT_QUOTED((arg), "\"", (arg), "\"", "(null)")
953

954
/*****************************************************************************/
955

956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971
/* glib/C provides the following kind of assertions:
 *   - assert() -- disable with NDEBUG
 *   - g_return_if_fail() -- disable with G_DISABLE_CHECKS
 *   - g_assert() -- disable with G_DISABLE_ASSERT
 * but they are all enabled by default and usually even production builds have
 * these kind of assertions enabled. It also means, that disabling assertions
 * is an untested configuration, and might have bugs.
 *
 * Add our own assertion macro nm_assert(), which is disabled by default and must
 * be explicitly enabled. They are useful for more expensive checks or checks that
 * depend less on runtime conditions (that is, are generally expected to be true). */

#ifndef NM_MORE_ASSERTS
#define NM_MORE_ASSERTS 0
#endif

972
#if NM_MORE_ASSERTS
973
#define nm_assert(cond) G_STMT_START { g_assert (cond); } G_STMT_END
974
#define nm_assert_se(cond) G_STMT_START { if (G_LIKELY (cond)) { ; } else { g_assert (FALSE && (cond)); } } G_STMT_END
975
#define nm_assert_not_reached() G_STMT_START { g_assert_not_reached (); } G_STMT_END
976
#else
977
#define nm_assert(cond) G_STMT_START { if (FALSE) { if (cond) { } } } G_STMT_END
978
#define nm_assert_se(cond) G_STMT_START { if (G_LIKELY (cond)) { ; } } G_STMT_END
979
#define nm_assert_not_reached() G_STMT_START { ; } G_STMT_END
980 981 982
#endif

/*****************************************************************************/
983

984
#define NM_GOBJECT_PROPERTIES_DEFINE_BASE(...) \
985
typedef enum { \
986
	PROP_0, \
987 988 989
	__VA_ARGS__ \
	_PROPERTY_ENUMS_LAST, \
} _PropertyEnums; \
990 991 992 993
static GParamSpec *obj_properties[_PROPERTY_ENUMS_LAST] = { NULL, }

#define NM_GOBJECT_PROPERTIES_DEFINE(obj_type, ...) \
NM_GOBJECT_PROPERTIES_DEFINE_BASE (__VA_ARGS__); \
994
static inline void \
995
_nm_gobject_notify_together_impl (obj_type *obj, guint n, const _PropertyEnums *props) \
996
{ \
997 998
	const gboolean freeze_thaw = (n > 1); \
	\
999
	nm_assert (G_IS_OBJECT (obj)); \
1000 1001 1002 1003 1004 1005 1006
	nm_assert (n > 0); \
	\
	if (freeze_thaw) \
		g_object_freeze_notify ((GObject *) obj); \
	while (n-- > 0) { \
		const _PropertyEnums prop = *props++; \
		\
1007 1008 1009 1010 1011
		if (prop != PROP_0) { \
			nm_assert ((gsize) prop < G_N_ELEMENTS (obj_properties)); \
			nm_assert (obj_properties[prop]); \
			g_object_notify_by_pspec ((GObject *) obj, obj_properties[prop]); \
		} \
1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027
	} \
	if (freeze_thaw) \
		g_object_thaw_notify ((GObject *) obj); \
} \
\
static inline void \
_notify (obj_type *obj, _PropertyEnums prop) \
{ \
	_nm_gobject_notify_together_impl (obj, 1, &prop); \
} \

/* invokes _notify() for all arguments (of type _PropertyEnums). Note, that if
 * there are more than one prop arguments, this will involve a freeze/thaw
 * of GObject property notifications. */
#define nm_gobject_notify_together(obj, ...) \
	_nm_gobject_notify_together_impl (obj, NM_NARG (__VA_ARGS__), (const _PropertyEnums[]) { __VA_ARGS__ })
1028 1029 1030

/*****************************************************************************/

1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041
#define _NM_GET_PRIVATE(self, type, is_check, ...) (&(NM_GOBJECT_CAST_NON_NULL (type, (self), is_check, ##__VA_ARGS__)->_priv))
#if _NM_CC_SUPPORT_AUTO_TYPE
#define _NM_GET_PRIVATE_PTR(self, type, is_check, ...) \
	({ \
		_nm_auto_type _self = NM_GOBJECT_CAST_NON_NULL (type, (self), is_check, ##__VA_ARGS__); \
		\
		NM_PROPAGATE_CONST (_self, _self->_priv); \
	})
#else
#define _NM_GET_PRIVATE_PTR(self, type, is_check, ...) (NM_GOBJECT_CAST_NON_NULL (type, (self), is_check, ##__VA_ARGS__)->_priv)
#endif
1042

1043 1044
/*****************************************************************************/

1045 1046 1047 1048 1049 1050 1051 1052
static inline gpointer
nm_g_object_ref (gpointer obj)
{
	/* g_object_ref() doesn't accept NULL. */
	if (obj)
		g_object_ref (obj);
	return obj;
}
1053
#define nm_g_object_ref(obj) ((typeof (obj)) nm_g_object_ref (obj))
1054 1055 1056 1057 1058

static inline void
nm_g_object_unref (gpointer obj)
{
	/* g_object_unref() doesn't accept NULL. Usully, we workaround that
Rafael Fontenelle's avatar
Rafael Fontenelle committed
1059
	 * by using g_clear_object(), but sometimes that is not convenient
1060 1061 1062 1063 1064 1065
	 * (for example as as destroy function for a hash table that can contain
	 * NULL values). */
	if (obj)
		g_object_unref (obj);
}

1066 1067
/* Assigns GObject @obj to destination @pp, and takes an additional ref.
 * The previous value of @pp is unrefed.
1068 1069 1070 1071 1072 1073 1074
 *
 * It makes sure to first increase the ref-count of @obj, and handles %NULL
 * @obj correctly.
 * */
#define nm_g_object_ref_set(pp, obj) \
	({ \
		typeof (*(pp)) *const _pp = (pp); \
1075 1076
		typeof (*_pp) const _obj = (obj); \
		typeof (*_pp) _p; \
1077 1078
		gboolean _changed = FALSE; \
		\
1079 1080 1081
		nm_assert (!_pp || !*_pp || G_IS_OBJECT (*_pp)); \
		nm_assert (!_obj || G_IS_OBJECT (_obj)); \
		\
1082 1083
		if (   _pp \
		    && ((_p = *_pp) != _obj)) { \
1084
			nm_g_object_ref (_obj); \
1085
			*_pp = _obj; \
1086
			nm_g_object_unref (_p); \
1087 1088 1089 1090 1091
			_changed = TRUE; \
		} \
		_changed; \
	})

1092 1093 1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117
#define nm_clear_pointer(pp, destroy) \
	({ \
		typeof (*(pp)) *_pp = (pp); \
		typeof (*_pp) _p; \
		gboolean _changed = FALSE; \
		\
		if (   _pp \
		    && (_p = *_pp)) { \
			_nm_unused gconstpointer _p_check_is_pointer = _p; \
			\
			*_pp = NULL; \
			/* g_clear_pointer() assigns @destroy first to a local variable, so that
			 * you can call "g_clear_pointer (pp, (GDestroyNotify) destroy);" without
			 * gcc emitting a warning. We don't do that, hence, you cannot cast
			 * "destroy" first.
			 *
			 * On the upside: you are not supposed to cast fcn, because the pointer
			 * types are preserved. If you really need a cast, you should cast @pp.
			 * But that is hardly ever necessary. */ \
			(destroy) (_p); \
			\
			_changed = TRUE; \
		} \
		_changed; \
	})

1118 1119 1120 1121 1122 1123 1124 1125 1126 1127
/* basically, replaces
 *   g_clear_pointer (&location, g_free)
 * with
 *   nm_clear_g_free (&location)
 *
 * Another advantage is that by using a macro and typeof(), it is more
 * typesafe and gives you for example a compiler warning when pp is a const
 * pointer or points to a const-pointer.
 */
#define nm_clear_g_free(pp) \
1128
	nm_clear_pointer (pp, g_free)
1129 1130

#define nm_clear_g_object(pp) \
1131
	nm_clear_pointer (pp, g_object_unref)
1132

1133 1134 1135
static inline gboolean
nm_clear_g_source (guint *id)
{
1136 1137 1138 1139
	guint v;

	if (   id
	    && (v = *id)) {
1140
		*id = 0;
1141
		g_source_remove (v);
1142 1143 1144 1145 1146
		return TRUE;
	}
	return FALSE;
}

1147
static inline gboolean
1148
nm_clear_g_signal_handler (gpointer self, gulong *id)
1149
{
1150 1151 1152 1153
	gulong v;

	if (   id
	    && (v = *id)) {
1154
		*id = 0;
1155
		g_signal_handler_disconnect (self, v);
1156 1157 1158 1159 1160
		return TRUE;
	}
	return FALSE;
}

1161 1162 1163
static inline gboolean
nm_clear_g_variant (GVariant **variant)
{
1164 1165 1166 1167
	GVariant *v;

	if (   variant
	    && (v = *variant)) {
1168
		*variant = NULL;
1169
		g_variant_unref (v);
1170 1171 1172 1173 1174
		return TRUE;
	}
	return FALSE;
}

1175 1176 1177
static inline gboolean
nm_clear_g_cancellable (GCancellable **cancellable)
{
1178 1179 1180 1181
	GCancellable *v;

	if (   cancellable
	    && (v = *cancellable)) {
1182
		*cancellable = NULL;
1183 1184
		g_cancellable_cancel (v);
		g_object_unref (v);
1185 1186 1187
		return TRUE;
	}
	return FALSE;
1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209
}

/* If @cancellable_id is not 0, clear it and call g_cancellable_disconnect().
 * @cancellable may be %NULL, if there is nothing to disconnect.
 *
 * It's like nm_clear_g_signal_handler(), except that it uses g_cancellable_disconnect()
 * instead of g_signal_handler_disconnect().
 *
 * Note the warning in glib documentation about dead-lock and what g_cancellable_disconnect()
 * actually does. */
static inline gboolean
nm_clear_g_cancellable_disconnect (GCancellable *cancellable, gulong *cancellable_id)
{
	gulong id;

	if (   cancellable_id
	    && (id = *cancellable_id) != 0) {
		*cancellable_id = 0;
		g_cancellable_disconnect (cancellable, id);
		return TRUE;
	}
	return FALSE;
1210 1211
}

1212 1213
/*****************************************************************************/

1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230
static inline GVariant *
nm_g_variant_ref (GVariant *v)
{
	if (v)
		g_variant_ref (v);
	return v;
}

static inline void
nm_g_variant_unref (GVariant *v)
{
	if (v)
		g_variant_unref (v);
}

/*****************************************************************************/

1231
/* Determine whether @x is a power of two (@x being an integer type).
1232 1233
 * Basically, this returns TRUE, if @x has exactly one bit set.
 * For negative values and zero, this always returns FALSE. */
1234
#define nm_utils_is_power_of_two(x) ({ \
1235
		typeof(x) __x = (x); \
1236
		\
1237 1238
		(    (__x > ((typeof(__x)) 0)) \
		 && ((__x & (__x - (((typeof(__x)) 1)))) == ((typeof(__x)) 0))); \
1239 1240
	})

1241 1242 1243 1244 1245 1246 1247 1248
#define NM_DIV_ROUND_UP(x, y) \
	({ \
		const typeof(x) _x = (x); \
		const typeof(y) _y = (y); \
		\
		(_x / _y + !!(_x % _y)); \
	})

1249
/*****************************************************************************/
1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278

#define NM_UTILS_LOOKUP_DEFAULT(v)            return (v)
#define NM_UTILS_LOOKUP_DEFAULT_WARN(v)       g_return_val_if_reached (v)
#define NM_UTILS_LOOKUP_DEFAULT_NM_ASSERT(v)  { nm_assert_not_reached (); return (v); }
#define NM_UTILS_LOOKUP_ITEM(v, n)            (void) 0; case v: return (n); (void) 0
#define NM_UTILS_LOOKUP_STR_ITEM(v, n)        NM_UTILS_LOOKUP_ITEM(v, ""n"")
#define NM_UTILS_LOOKUP_ITEM_IGNORE(v)        (void) 0; case v: break; (void) 0
#define NM_UTILS_LOOKUP_ITEM_IGNORE_OTHER()   (void) 0; default: break; (void) 0

#define _NM_UTILS_LOOKUP_DEFINE(scope, fcn_name, lookup_type, result_type, unknown_val, ...) \
scope result_type \
fcn_name (lookup_type val) \
{ \
	switch (val) { \
		(void) 0, \
		__VA_ARGS__ \
		(void) 0; \
	}; \
	{ unknown_val; } \
}

#define NM_UTILS_LOOKUP_STR_DEFINE(fcn_name, lookup_type, unknown_val, ...) \
	_NM_UTILS_LOOKUP_DEFINE (, fcn_name, lookup_type, const char *, unknown_val, __VA_ARGS__)
#define NM_UTILS_LOOKUP_STR_DEFINE_STATIC(fcn_name, lookup_type, unknown_val, ...) \
	_NM_UTILS_LOOKUP_DEFINE (static, fcn_name, lookup_type, const char *, unknown_val, __VA_ARGS__)

/* Call the string-lookup-table function @fcn_name. If the function returns
 * %NULL, the numeric index is converted to string using a alloca() buffer.
 * Beware: this macro uses alloca(). */
1279
#define NM_UTILS_LOOKUP_STR_A(fcn_name, idx) \
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
	({ \
		typeof (idx) _idx = (idx); \
		const char *_s; \
		\
		_s = fcn_name (_idx); \
		if (!_s) { \
			_s = g_alloca (30); \
			\
			g_snprintf ((char *) _s, 30, "(%lld)", (long long) _idx); \
		} \
		_s; \
	})

/*****************************************************************************/
1294

1295 1296 1297
/* check if @flags has exactly one flag (@check) set. You should call this
 * only with @check being a compile time constant and a power of two. */
#define NM_FLAGS_HAS(flags, check)  \
1298
    ( G_STATIC_ASSERT_EXPR ((check) > 0 && ((check) & ((check) - 1)) == 0), NM_FLAGS_ANY ((flags), (check)) )
1299 1300 1301 1302

#define NM_FLAGS_ANY(flags, check)  ( ( ((flags) & (check)) != 0       ) ? TRUE : FALSE )
#define NM_FLAGS_ALL(flags, check)  ( ( ((flags) & (check)) == (check) ) ? TRUE : FALSE )

1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325
#define NM_FLAGS_SET(flags, val)  ({ \
		const typeof(flags) _flags = (flags); \
		const typeof(flags) _val = (val); \
		\
		_flags | _val; \
	})

#define NM_FLAGS_UNSET(flags, val)  ({ \
		const typeof(flags) _flags = (flags); \
		const typeof(flags) _val = (val); \
		\
		_flags & (~_val); \
	})

#define NM_FLAGS_ASSIGN(flags, val, assign)  ({ \
		const typeof(flags) _flags = (flags); \
		const typeof(flags) _val = (val); \
		\
		(assign) \
			? _flags | (_val) \
			: _flags & (~_val); \
	})

1326 1327
/*****************************************************************************/

1328 1329
#define _NM_BACKPORT_SYMBOL_IMPL(version, return_type, orig_func, versioned_func, args_typed, args) \
return_type versioned_func args_typed; \
1330
_nm_externally_visible return_type versioned_func args_typed \
1331
{ \
1332
    return orig_func args; \
1333
} \
1334 1335
return_type orig_func args_typed; \
__asm__(".symver "G_STRINGIFY(versioned_func)", "G_STRINGIFY(orig_func)"@"G_STRINGIFY(version))
1336

1337 1338
#define NM_BACKPORT_SYMBOL(version, return_type, func, args_typed, args) \
_NM_BACKPORT_SYMBOL_IMPL(version, return_type, func, _##func##_##version, args_typed, args)
1339 1340 1341

/*****************************************************************************/

1342 1343 1344
/* mirrors g_ascii_isspace() and what we consider spaces in general. */
#define NM_ASCII_SPACES "\t\n\f\r "

1345 1346
#define nm_str_skip_leading_spaces(str) \
	({ \
1347 1348
		typeof (*(str)) *_str_sls = (str); \
		_nm_unused const char *const _str_type_check = _str_sls; \
1349
		\
1350 1351 1352
		if (_str_sls) { \
			while (g_ascii_isspace (_str_sls[0])) \
				_str_sls++; \
1353
		} \
1354
		_str_sls; \
1355 1356
	})

1357 1358 1359 1360 1361 1362 1363
static inline char *
nm_strstrip (char *str)
{
	/* g_strstrip doesn't like NULL. */
	return str ? g_strstrip (str) : NULL;
}

1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
static inline const char *
nm_strstrip_avoid_copy (const char *str, char **str_free)
{
	gsize l;
	char *s;

	nm_assert (str_free && !*str_free);

	if (!str)
		return NULL;

	str = nm_str_skip_leading_spaces (str);
	l = strlen (str);
	if (   l == 0
	    || !g_ascii_isspace (str[l - 1]))
		return str;
	while (   l > 0
	       && g_ascii_isspace (str[l - 1]))
		l--;

	s = g_new (char, l + 1);
	memcpy (s, str, l);
	s[l] = '\0';
	*str_free = s;
	return s;
}

1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418
#define nm_strstrip_avoid_copy_a(alloca_maxlen, str, out_str_free) \
	({ \
		const char *_str_ssac = (str); \
		char **_out_str_free_ssac = (out_str_free); \
		\
		G_STATIC_ASSERT_EXPR ((alloca_maxlen) > 0); \
		\
		nm_assert ( _out_str_free_ssac || ((alloca_maxlen) > (str ? strlen (str) : 0u))); \
		nm_assert (!_out_str_free_ssac || !*_out_str_free_ssac); \
		\
		if (_str_ssac) { \
			_str_ssac = nm_str_skip_leading_spaces (_str_ssac); \
			if (_str_ssac[0] != '\0') { \
				gsize _l = strlen (_str_ssac); \
				\
				if (g_ascii_isspace (_str_ssac[--_l])) { \
					while (   _l > 0 \
					       && g_ascii_isspace (_str_ssac[_l - 1])) { \
						_l--; \
					} \
					_str_ssac = nm_strndup_a ((alloca_maxlen), _str_ssac, _l, _out_str_free_ssac); \
				} \
			} \
		} \
		\
		_str_ssac; \
	})

1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432
/* g_ptr_array_sort()'s compare function takes pointers to the
 * value. Thus, you cannot use strcmp directly. You can use
 * nm_strcmp_p().
 *
 * Like strcmp(), this function is not forgiving to accept %NULL. */
static inline int
nm_strcmp_p (gconstpointer a, gconstpointer b)
{
	const char *s1 = *((const char **) a);
	const char *s2 = *((const char **) b);

	return strcmp (s1, s2);
}

1433 1434
/*****************************************************************************/

1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476
/* Taken from systemd's UNIQ_T and UNIQ macros. */

#define NM_UNIQ_T(x, uniq) G_PASTE(__unique_prefix_, G_PASTE(x, uniq))
#define NM_UNIQ __COUNTER__

/*****************************************************************************/

/* glib's MIN()/MAX() macros don't have function-like behavior, in that they evaluate
 * the argument possibly twice.
 *
 * Taken from systemd's MIN()/MAX() macros. */

#define NM_MIN(a, b) __NM_MIN(NM_UNIQ, a, NM_UNIQ, b)
#define __NM_MIN(aq, a, bq, b) \
	({ \
		typeof (a) NM_UNIQ_T(A, aq) = (a); \
		typeof (b) NM_UNIQ_T(B, bq) = (b); \
		((NM_UNIQ_T(A, aq) < NM_UNIQ_T(B, bq)) ? NM_UNIQ_T(A, aq) : NM_UNIQ_T(B, bq)); \
	})

#define NM_MAX(a, b) __NM_MAX(NM_UNIQ, a, NM_UNIQ, b)
#define __NM_MAX(aq, a, bq, b) \
	({ \
		typeof (a) NM_UNIQ_T(A, aq) = (a); \
		typeof (b) NM_UNIQ_T(B, bq) = (b); \
		((NM_UNIQ_T(A, aq) > NM_UNIQ_T(B, bq)) ? NM_UNIQ_T(A, aq) : NM_UNIQ_T(B, bq)); \
	})

#define NM_CLAMP(x, low, high) __NM_CLAMP(NM_UNIQ, x, NM_UNIQ, low, NM_UNIQ, high)
#define __NM_CLAMP(xq, x, lowq, low, highq, high) \
	({ \
		typeof(x)NM_UNIQ_T(X,xq) = (x); \
		typeof(low) NM_UNIQ_T(LOW,lowq) = (low); \
		typeof(high) NM_UNIQ_T(HIGH,highq) = (high); \
		\
		( (NM_UNIQ_T(X,xq) > NM_UNIQ_T(HIGH,highq)) \
		  ? NM_UNIQ_T(HIGH,highq) \
		  : (NM_UNIQ_T(X,xq) < NM_UNIQ_T(LOW,lowq)) \
		     ? NM_UNIQ_T(LOW,lowq) \
		     : NM_UNIQ_T(X,xq)); \
	})

1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
#define NM_MAX_WITH_CMP(cmp, a, b) \
	({ \
		typeof (a) _a = (a); \
		typeof (b) _b = (b); \
		\
		(  ((cmp (_a, _b)) >= 0) \
		 ? _a \
		 : _b); \
	})

1487 1488 1489 1490 1491 1492 1493 1494
/* evaluates to (void) if _A or _B are not constant or of different types */
#define NM_CONST_MAX(_A, _B) \
	(__builtin_choose_expr ((   __builtin_constant_p (_A) \
	                         && __builtin_constant_p (_B) \
	                         && __builtin_types_compatible_p (typeof (_A), typeof (_B))), \
	                        ((_A) > (_B)) ? (_A) : (_B),                            \
	                        ((void)  0)))

1495 1496
/*****************************************************************************/

1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608
/* like g_memdup(). The difference is that the @size argument is of type
 * gsize, while g_memdup() has type guint. Since, the size of container types
 * like GArray is guint as well, this means trying to g_memdup() an
 * array,
 *    g_memdup (array->data, array->len * sizeof (ElementType))
 * will lead to integer overflow, if there are more than G_MAXUINT/sizeof(ElementType)
 * bytes. That seems unnecessarily dangerous to me.
 * nm_memdup() avoids that, because its size argument is always large enough
 * to contain all data that a GArray can hold.
 *
 * Another minor difference to g_memdup() is that the glib version also
 * returns %NULL if @data is %NULL. E.g. g_memdup(NULL, 1)
 * gives %NULL, but nm_memdup(NULL, 1) crashes. I think that
 * is desirable, because @size MUST be correct at all times. @size
 * may be zero, but one must not claim to have non-zero bytes when
 * passing a %NULL @data pointer.
 */
static inline gpointer
nm_memdup (gconstpointer data, gsize size)
{
	gpointer p;

	if (size == 0)
		return NULL;
	p = g_malloc (size);
	memcpy (p, data, size);
	return p;
}

static inline char *
_nm_strndup_a_step (char *s, const char *str, gsize len)
{
	NM_PRAGMA_WARNING_DISABLE ("-Wstringop-truncation");
	if (len > 0)
		strncpy (s, str, len);
	s[len] = '\0';
	return s;
	NM_PRAGMA_WARNING_REENABLE;
}

/* Similar to g_strndup(), however, if the string (including the terminating
 * NUL char) fits into alloca_maxlen, this will alloca() the memory.
 *
 * It's a mix of strndup() and strndupa(), but deciding based on @alloca_maxlen
 * which one to use.
 *
 * In case malloc() is necessary, @out_str_free will be set (this string
 * must be freed afterwards). It is permissible to pass %NULL as @out_str_free,
 * if you ensure that len < alloca_maxlen.
 *
 * Note that just like g_strndup(), this always returns a buffer with @len + 1
 * bytes, even if strlen(@str) is shorter than that (NUL terminated early). We fill
 * the buffer with strncpy(), which means, that @str is copied up to the first
 * NUL character and then filled with NUL characters. */
#define nm_strndup_a(alloca_maxlen, str, len, out_str_free) \
	({ \
		const gsize _alloca_maxlen_snd = (alloca_maxlen); \
		const char *const _str_snd = (str); \
		const gsize _len_snd = (len); \
		char **const _out_str_free_snd = (out_str_free); \
		char *_s_snd; \
		\
		G_STATIC_ASSERT_EXPR ((alloca_maxlen) <= 300); \
		\
		if (   _out_str_free_snd \
		    && _len_snd >= _alloca_maxlen_snd) { \
			_s_snd = g_malloc (_len_snd + 1); \
			*_out_str_free_snd = _s_snd; \
		} else { \
			g_assert (_len_snd < _alloca_maxlen_snd); \
			_s_snd = g_alloca (_len_snd + 1); \
		} \
		_nm_strndup_a_step (_s_snd, _str_snd, _len_snd); \
	})

/*****************************************************************************/

/* generic macro to convert an int to a (heap allocated) string.
 *
 * Usually, an inline function nm_strdup_int64() would be enough. However,
 * that cannot be used for guint64. So, we would also need nm_strdup_uint64().
 * This causes subtle error potential, because the caller needs to ensure to
 * use the right one (and compiler isn't going to help as it silently casts).
 *
 * Instead, this generic macro is supposed to handle all integers correctly. */
#if _NM_CC_SUPPORT_GENERIC
#define nm_strdup_int(val) \
	_Generic ((val), \
	          char:               g_strdup_printf ("%d",   (int)                (val)), \
	          \
	          signed char:        g_strdup_printf ("%d",   (signed)             (val)), \
	          signed short:       g_strdup_printf ("%d",   (signed)             (val)), \
	          signed:             g_strdup_printf ("%d",   (signed)             (val)), \
	          signed long:        g_strdup_printf ("%ld",  (signed long)        (val)), \
	          signed long long:   g_strdup_printf ("%lld", (signed long long)   (val)), \
	          \
	          unsigned char:      g_strdup_printf ("%u",   (unsigned)           (val)), \
	          unsigned short:     g_strdup_printf ("%u",   (unsigned)           (val)), \
	          unsigned:           g_strdup_printf ("%u",   (unsigned)           (val)), \
	          unsigned long:      g_strdup_printf ("%lu",  (unsigned long)      (val)), \
	          unsigned long long: g_strdup_printf ("%llu", (unsigned long long) (val))  \
	)
#else
#define nm_strdup_int(val) \
	(  (   sizeof (val) == sizeof (guint64) \
	    && ((typeof (val)) -1) > 0) \
	 ? g_strdup_printf ("%"G_GUINT64_FORMAT, (guint64) (val)) \
	 : g_strdup_printf ("%"G_GINT64_FORMAT, (gint64) (val)))
#endif

/*****************************************************************************/

1609
static inline guint
1610 1611
nm_encode_version (guint major, guint minor, guint micro)
{
1612 1613 1614 1615 1616
	/* analog to the preprocessor macro NM_ENCODE_VERSION(). */
	return (major << 16) | (minor << 8) | micro;
}

static inline void
1617 1618
nm_decode_version (guint version, guint *major, guint *minor, guint *micro)
{
1619 1620 1621 1622
	*major = (version & 0xFFFF0000u) >> 16;
	*minor = (version & 0x0000FF00u) >>  8;
	*micro = (version & 0x000000FFu);
}
1623

1624 1625
/*****************************************************************************/

1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
/* taken from systemd's DECIMAL_STR_MAX()
 *
 * Returns the number of chars needed to format variables of the
 * specified type as a decimal string. Adds in extra space for a
 * negative '-' prefix (hence works correctly on signed
 * types). Includes space for the trailing NUL. */
#define NM_DECIMAL_STR_MAX(type) \
    (2+(sizeof(type) <= 1 ? 3 : \
        sizeof(type) <= 2 ? 5 : \
        sizeof(type) <= 4 ? 10 : \
        sizeof(type) <= 8 ? 20 : sizeof(int[-2*(sizeof(type) > 8)])))

/*****************************************************************************/

1640
/* if @str is NULL, return "(null)". Otherwise, allocate a buffer using
1641 1642 1643 1644
 * alloca() of and fill it with @str. @str will be quoted with double quote.
 * If @str is longer then @trunc_at, the string is truncated and the closing
 * quote is instead '^' to indicate truncation.
 *
1645 1646
 * Thus, the maximum stack allocated buffer will be @trunc_at+3. The maximum
 * buffer size must be a constant and not larger than 300. */
1647
#define nm_strquote_a(trunc_at, str) \
1648
	({ \
1649
		const char *const _str = (str); \
1650
		\
1651 1652 1653 1654 1655 1656
		(_str \
			? ({ \
				const gsize _trunc_at = (trunc_at); \
				const gsize _strlen_trunc = NM_MIN (strlen (_str), _trunc_at); \
				char *_buf; \
				\
1657 1658
				G_STATIC_ASSERT_EXPR ((trunc_at) <= 300); \
				\
1659 1660 1661 1662 1663 1664 1665 1666
				_buf = g_alloca (_strlen_trunc + 3); \
				_buf[0] = '"'; \
				memcpy (&_buf[1], _str, _strlen_trunc); \
				_buf[_strlen_trunc + 1] = _str[_strlen_trunc] ? '^' : '"'; \
				_buf[_strlen_trunc + 2] = '\0'; \
				_buf; \
			}) \
			: "(null)"); \
1667 1668
	})

1669 1670
#define nm_sprintf_buf(buf, format, ...) \
	({ \
1671
		char * _buf = (buf); \
1672
		int _buf_len; \
1673 1674 1675 1676
		\
		/* some static assert trying to ensure that the buffer is statically allocated.
		 * It disallows a buffer size of sizeof(gpointer) to catch that. */ \
		G_STATIC_ASSERT (G_N_ELEMENTS (buf) == sizeof (buf) && sizeof (buf) != sizeof (char *)); \
1677 1678 1679
		_buf_len = g_snprintf (_buf, sizeof (buf), \
		                       ""format"", ##__VA_ARGS__); \
		nm_assert (_buf_len < sizeof (buf)); \
1680 1681
		_buf; \
	})