// SPDX-License-Identifier: LGPL-2.1+ /* * Copyright (C) 2012 Colin Walters . * Copyright (C) 2014 Red Hat, Inc. */ #ifndef __NM_MACROS_INTERNAL_H__ #define __NM_MACROS_INTERNAL_H__ #include #include #include #include #include /*****************************************************************************/ #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__)) #define _nm_printf(a,b) __attribute__ ((__format__ (__printf__, a, b))) #define _nm_align(s) __attribute__ ((__aligned__ (s))) #define _nm_section(s) __attribute__ ((__section__ (s))) #define _nm_alignof(type) __alignof (type) #define _nm_alignas(type) _nm_align (_nm_alignof (type)) #define nm_auto(fcn) __attribute__ ((__cleanup__(fcn))) /* 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 #if __GNUC__ >= 7 #define _nm_fallthrough __attribute__ ((__fallthrough__)) #else #define _nm_fallthrough #endif /*****************************************************************************/ #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 /*****************************************************************************/ /* 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 /*****************************************************************************/ #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. */ #define gs_free nm_auto(gs_local_free) NM_AUTO_DEFINE_FCN_VOID0 (void *, gs_local_free, g_free) /** * 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. */ #define gs_unref_object nm_auto(gs_local_obj_unref) 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. */ #define gs_unref_variant nm_auto(gs_local_variant_unref) 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. */ #define gs_unref_array nm_auto(gs_local_array_unref) 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. */ #define gs_unref_ptrarray nm_auto(gs_local_ptrarray_unref) 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. */ #define gs_unref_hashtable nm_auto(gs_local_hashtable_unref) 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. */ #define gs_free_slist nm_auto(gs_local_free_slist) NM_AUTO_DEFINE_FCN0 (GSList *, gs_local_free_slist, g_slist_free) /** * 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. */ #define gs_unref_bytes nm_auto(gs_local_bytes_unref) 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. */ #define gs_strfreev nm_auto(gs_local_strfreev) NM_AUTO_DEFINE_FCN0 (char **, gs_local_strfreev, g_strfreev) /** * gs_free_error: * * Call g_error_free() on a variable location when it goes out of scope. */ #define gs_free_error nm_auto(gs_local_free_error) 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. */ #define gs_unref_keyfile nm_auto(gs_local_keyfile_unref) NM_AUTO_DEFINE_FCN0 (GKeyFile *, gs_local_keyfile_unref, g_key_file_unref) /** * gs_free_option_context: * * Call g_option_context_free() on a variable location when it goes out of scope. */ #define gs_free_option_context nm_auto(gs_local_option_context) NM_AUTO_DEFINE_FCN0 (GOptionContext *, gs_local_option_context, g_option_context_free); /*****************************************************************************/ #include "nm-glib.h" /*****************************************************************************/ #define nm_offsetofend(t,m) (G_STRUCT_OFFSET (t,m) + sizeof (((t *) NULL)->m)) /*****************************************************************************/ static inline int nm_close (int fd); /** * nm_auto_free: * * Call free() on a variable location when it goes out of scope. * 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. */ NM_AUTO_DEFINE_FCN_VOID0 (void *, _nm_auto_free_impl, free) #define nm_auto_free nm_auto(_nm_auto_free_impl) NM_AUTO_DEFINE_FCN0 (GVariantIter *, _nm_auto_free_variant_iter, g_variant_iter_free) #define nm_auto_free_variant_iter nm_auto(_nm_auto_free_variant_iter) NM_AUTO_DEFINE_FCN0 (GVariantBuilder *, _nm_auto_unref_variant_builder, g_variant_builder_unref) #define nm_auto_unref_variant_builder nm_auto(_nm_auto_unref_variant_builder) #define nm_auto_clear_variant_builder nm_auto(g_variant_builder_clear) NM_AUTO_DEFINE_FCN0 (GList *, _nm_auto_free_list, g_list_free) #define nm_auto_free_list nm_auto(_nm_auto_free_list) NM_AUTO_DEFINE_FCN0 (GChecksum *, _nm_auto_checksum_free, g_checksum_free) #define nm_auto_free_checksum nm_auto(_nm_auto_checksum_free) #define nm_auto_unset_gvalue nm_auto(g_value_unset) NM_AUTO_DEFINE_FCN_VOID0 (void *, _nm_auto_unref_gtypeclass, g_type_class_unref) #define nm_auto_unref_gtypeclass nm_auto(_nm_auto_unref_gtypeclass) NM_AUTO_DEFINE_FCN0 (GByteArray *, _nm_auto_unref_bytearray, g_byte_array_unref) #define nm_auto_unref_bytearray nm_auto(_nm_auto_unref_bytearray) static inline void _nm_auto_free_gstring (GString **str) { if (*str) g_string_free (*str, TRUE); } #define nm_auto_free_gstring nm_auto(_nm_auto_free_gstring) static inline void _nm_auto_close (int *pfd) { if (*pfd >= 0) { int errsv = errno; (void) nm_close (*pfd); errno = errsv; } } #define nm_auto_close nm_auto(_nm_auto_close) static inline void _nm_auto_fclose (FILE **pfd) { if (*pfd) { int errsv = errno; (void) fclose (*pfd); errno = errsv; } } #define nm_auto_fclose nm_auto(_nm_auto_fclose) 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) NM_AUTO_DEFINE_FCN0 (GSource *, _nm_auto_unref_gsource, g_source_unref); #define nm_auto_unref_gsource nm_auto(_nm_auto_unref_gsource) NM_AUTO_DEFINE_FCN0 (guint, _nm_auto_remove_source, g_source_remove); #define nm_auto_remove_source nm_auto(_nm_auto_remove_source) NM_AUTO_DEFINE_FCN0 (GIOChannel *, _nm_auto_unref_io_channel, g_io_channel_unref) #define nm_auto_unref_io_channel nm_auto(_nm_auto_unref_io_channel) NM_AUTO_DEFINE_FCN0 (GMainLoop *, _nm_auto_unref_gmainloop, g_main_loop_unref); #define nm_auto_unref_gmainloop nm_auto(_nm_auto_unref_gmainloop) 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) /*****************************************************************************/ #define _NM_MACRO_SELECT_ARG_64( \ _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 /* http://stackoverflow.com/a/2124385/354393 * https://stackoverflow.com/questions/11317474/macro-to-count-number-of-arguments */ #define NM_NARG(...) \ _NM_MACRO_SELECT_ARG_64(, ##__VA_ARGS__, \ 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) #define NM_NARG_MAX1(...) \ _NM_MACRO_SELECT_ARG_64(, ##__VA_ARGS__, \ 1, 1, 1, \ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, \ 1, 1, 1, 1, 1, 1, 1, 1, 1, 0) #define NM_NARG_MAX2(...) \ _NM_MACRO_SELECT_ARG_64(, ##__VA_ARGS__, \ 2, 2, 2, \ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, \ 2, 2, 2, 2, 2, 2, 2, 2, 1, 0) #define _NM_MACRO_CALL(macro, ...) macro (__VA_ARGS__) /*****************************************************************************/ #define _NM_MACRO_COMMA_IF_ARGS(...) _NM_MACRO_CALL (G_PASTE (__NM_MACRO_COMMA_IF_ARGS_, NM_NARG_MAX1(__VA_ARGS__)), __VA_ARGS__) #define __NM_MACRO_COMMA_IF_ARGS_0() #define __NM_MACRO_COMMA_IF_ARGS_1(...) , /*****************************************************************************/ /* 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_MACRO_CALL (G_PASTE (__NM_UTILS_MACRO_REST_, NM_NARG_MAX2(__VA_ARGS__)), __VA_ARGS__) #define __NM_UTILS_MACRO_REST_0() #define __NM_UTILS_MACRO_REST_1(first) #define __NM_UTILS_MACRO_REST_2(first, ...) , __VA_ARGS__ /*****************************************************************************/ #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. */ #if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #define NM_PRAGMA_WARNING_DISABLE(warning) \ _Pragma("GCC diagnostic push") \ _Pragma(_NM_PRAGMA_WARNING_DO(warning)) #elif defined (__clang__) #define NM_PRAGMA_WARNING_DISABLE(warning) \ _Pragma("clang diagnostic push") \ _Pragma(_NM_PRAGMA_WARNING_DO("-Wunknown-warning-option")) \ _Pragma(_NM_PRAGMA_WARNING_DO(warning)) #else #define NM_PRAGMA_WARNING_DISABLE(warning) #endif #if defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) #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 /*****************************************************************************/ /** * NM_G_ERROR_MSG: * @error: (allow-none): the #GError instance * * 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) { return error ? (error->message ?: "(null)") : "(no-error)"; \ } /*****************************************************************************/ /* macro to return strlen() of a compile time string. */ #define NM_STRLEN(str) ( sizeof (""str"") - 1 ) /* 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) { \ _nm_unused gconstpointer _type_check_is_pointer = _array[0]; \ \ while (_array[_n]) \ _n++; \ } \ _n; \ }) /* Note: @value is only evaluated when *out_val is present. * Thus, * NM_SET_OUT (out_str, g_strdup ("hallo")); * does the right thing. */ #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 /*****************************************************************************/ #ifndef _NM_CC_SUPPORT_AUTO_TYPE #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 #endif #ifndef _NM_CC_SUPPORT_GENERIC /* 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. */ #if (defined (__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 9 ))) || (defined (__clang__)) #define _NM_CC_SUPPORT_GENERIC 1 #else #define _NM_CC_SUPPORT_GENERIC 0 #endif #endif #if _NM_CC_SUPPORT_AUTO_TYPE #define _nm_auto_type __auto_type #endif #if _NM_CC_SUPPORT_GENERIC #define _NM_CONSTCAST_FULL_1(type, obj_expr, obj) \ (_Generic ((obj_expr), \ 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) \ (_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 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) \ (_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 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__)) #else #define NM_CONSTCAST_FULL( type, obj_expr, obj, ...) ((type *) (obj)) #endif #define NM_CONSTCAST(type, obj, ...) \ NM_CONSTCAST_FULL(type, (obj), (obj), ##__VA_ARGS__) #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 #define NM_GOBJECT_CAST(type, obj, is_check, ...) \ ({ \ const void *_obj = (obj); \ \ nm_assert (_obj || (is_check (_obj))); \ NM_CONSTCAST_FULL (type, (obj), _obj, GObject, ##__VA_ARGS__); \ }) #define NM_GOBJECT_CAST_NON_NULL(type, obj, is_check, ...) \ ({ \ const void *_obj = (obj); \ \ nm_assert (is_check (_obj)); \ NM_CONSTCAST_FULL (type, (obj), _obj, GObject, ##__VA_ARGS__); \ }) #define NM_ENSURE_NOT_NULL(ptr) \ ({ \ typeof (ptr) _ptr = (ptr); \ \ nm_assert (_ptr != NULL); \ _ptr; \ }) #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))) #define _NM_ENSURE_TYPE_CONST(type, value) (_Generic ((value), \ const type : ((const type) (value)), \ const type const: ((const type) (value)), \ type : ((const type) (value)), \ type const: ((const type) (value)))) #else #define _NM_ENSURE_TYPE(type, value) (value) #define _NM_ENSURE_TYPE_CONST(type, value) ((const type) (value)) #endif #if _NM_CC_SUPPORT_GENERIC && ( !defined (__clang__) || __clang_major__ > 3 ) #define NM_STRUCT_OFFSET_ENSURE_TYPE(type, container, field) (_Generic ( (&(((container *) NULL)->field))[0] , \ type: G_STRUCT_OFFSET (container, field))) #else #define NM_STRUCT_OFFSET_ENSURE_TYPE(type, container, field) G_STRUCT_OFFSET (container, field) #endif #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, * every time you want to call it with a const argument, you need to * 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 #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 /* 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. */ #define NM_MAKE_STRV(...) \ ((const char *const[(sizeof (((const char *const[]) { __VA_ARGS__ })) / sizeof (const char *)) + 1]) { __VA_ARGS__ }) /*****************************************************************************/ #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_17(op, _x, y, ...) (_x == (y)) op _NM_IN_SET_EVAL_16 (op, _x, __VA_ARGS__) #define _NM_IN_SET_EVAL_18(op, _x, y, ...) (_x == (y)) op _NM_IN_SET_EVAL_17 (op, _x, __VA_ARGS__) #define _NM_IN_SET_EVAL_19(op, _x, y, ...) (_x == (y)) op _NM_IN_SET_EVAL_18 (op, _x, __VA_ARGS__) #define _NM_IN_SET_EVAL_20(op, _x, y, ...) (_x == (y)) op _NM_IN_SET_EVAL_19 (op, _x, __VA_ARGS__) #define _NM_IN_SET_EVAL_N2(op, _x, n, ...) (_NM_IN_SET_EVAL_##n(op, _x, __VA_ARGS__)) #define _NM_IN_SET_EVAL_N(op, type, x, n, ...) \ ({ \ type _x = (x); \ \ /* trigger a -Wenum-compare warning */ \ nm_assert (TRUE || _x == (x)); \ \ !!_NM_IN_SET_EVAL_N2(op, _x, n, __VA_ARGS__); \ }) #define _NM_IN_SET(op, type, x, ...) _NM_IN_SET_EVAL_N(op, type, x, NM_NARG (__VA_ARGS__), __VA_ARGS__) /* Beware that this does short-circuit evaluation (use "||" instead of "|") * which has a possibly unexpected non-function-like behavior. * Use NM_IN_SET_SE if you need all arguments to be evaluated. */ #define NM_IN_SET(x, ...) _NM_IN_SET(||, typeof (x), x, __VA_ARGS__) /* "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. */ #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__) /*****************************************************************************/ #define NM_SWAP(a, b) \ G_STMT_START { \ typeof (a) _tmp; \ \ _tmp = (a); \ (a) = (b); \ (b) = _tmp; \ } G_STMT_END /*****************************************************************************/ static inline gboolean _NM_IN_STRSET_streq (const char *x, const char *s) { return s && strcmp (x, s) == 0; } #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_17(op, _x, y, ...) _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_16 (op, _x, __VA_ARGS__) #define _NM_IN_STRSET_EVAL_18(op, _x, y, ...) _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_17 (op, _x, __VA_ARGS__) #define _NM_IN_STRSET_EVAL_19(op, _x, y, ...) _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_18 (op, _x, __VA_ARGS__) #define _NM_IN_STRSET_EVAL_20(op, _x, y, ...) _NM_IN_STRSET_streq (_x, y) op _NM_IN_STRSET_EVAL_19 (op, _x, __VA_ARGS__) #define _NM_IN_STRSET_EVAL_N2(op, _x, n, ...) (_NM_IN_STRSET_EVAL_##n(op, _x, __VA_ARGS__)) #define _NM_IN_STRSET_EVAL_N(op, x, n, ...) \ ({ \ const char *_x = (x); \ ( ((_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__)) \ ); \ }) /* Beware that this does short-circuit evaluation (use "||" instead of "|") * which has a possibly unexpected non-function-like behavior. * Use NM_IN_STRSET_SE if you need all arguments to be evaluated. */ #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__) #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; \ }) /*****************************************************************************/ /* 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: * - @string must be a quoted string-literal * - @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); \ } /*****************************************************************************/ static inline int nm_strcmp0 (const char *s1, const char *s2) { int c; /* like g_strcmp0(), but this is inlinable. * * Also, it is guaranteed to return either -1, 0, or 1. */ if (s1 == s2) return 0; if (!s1) return -1; if (!s2) return 1; c = strcmp (s1, s2); if (c < 0) return -1; if (c > 0) return 1; return 0; } 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); } #define NM_STR_HAS_PREFIX(str, prefix) \ ({ \ const char *const _str_has_prefix = (str); \ \ nm_assert (strlen (prefix) == NM_STRLEN (prefix)); \ \ _str_has_prefix \ && (strncmp (_str_has_prefix, ""prefix"", NM_STRLEN (prefix)) == 0); \ }) #define NM_STR_HAS_SUFFIX(str, suffix) \ ({ \ const char *const _str_has_suffix = (str); \ gsize _l; \ \ nm_assert (strlen (suffix) == NM_STRLEN (suffix)); \ \ ( _str_has_suffix \ && ((_l = strlen (_str_has_suffix)) >= NM_STRLEN (suffix)) \ && (memcmp (&_str_has_suffix[_l - NM_STRLEN (suffix)], \ ""suffix"", \ NM_STRLEN (suffix)) == 0)); \ }) /* whether @str starts with the string literal @prefix and is followed by * some other text. It is like NM_STR_HAS_PREFIX() && !nm_streq() together. */ #define NM_STR_HAS_PREFIX_WITH_MORE(str, prefix) \ ({ \ const char *const _str_has_prefix_with_more = (str); \ \ NM_STR_HAS_PREFIX (_str_has_prefix_with_more, ""prefix"") \ && _str_has_prefix_with_more[NM_STRLEN (prefix)] != '\0'; \ }) /*****************************************************************************/ 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; } static inline GString * nm_gstring_add_space_delimiter (GString *str) { if (str->len > 0) g_string_append_c (str, ' '); return str; } static inline gboolean nm_str_is_empty (const char *str) { /* %NULL is also accepted, and also "empty". */ return !str || !str[0]; } static inline const char * nm_str_not_empty (const char *str) { return !nm_str_is_empty (str) ? str : NULL; } static inline char * nm_strdup_not_empty (const char *str) { return !nm_str_is_empty (str) ? g_strdup (str) : NULL; } 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); } /*****************************************************************************/ #define NM_PRINT_FMT_QUOTED(cond, prefix, str, suffix, str_else) \ (cond) ? (prefix) : "", \ (cond) ? (str) : (str_else), \ (cond) ? (suffix) : "" #define NM_PRINT_FMT_QUOTE_STRING(arg) NM_PRINT_FMT_QUOTED((arg), "\"", (arg), "\"", "(null)") #define NM_PRINT_FMT_QUOTE_REF_STRING(arg) NM_PRINT_FMT_QUOTED((arg), "\"", (arg)->str, "\"", "(null)") /*****************************************************************************/ /* 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 #if NM_MORE_ASSERTS #define nm_assert(cond) G_STMT_START { g_assert (cond); } G_STMT_END #define nm_assert_se(cond) G_STMT_START { if (G_LIKELY (cond)) { ; } else { g_assert (FALSE && (cond)); } } G_STMT_END #define nm_assert_not_reached() G_STMT_START { g_assert_not_reached (); } G_STMT_END #else #define nm_assert(cond) G_STMT_START { if (FALSE) { if (cond) { } } } G_STMT_END #define nm_assert_se(cond) G_STMT_START { if (G_LIKELY (cond)) { ; } } G_STMT_END #define nm_assert_not_reached() G_STMT_START { ; } G_STMT_END #endif /* Usage: * * if (NM_MORE_ASSERT_ONCE (5)) { extra_check (); } * * This will only run the check once, and only if NM_MORE_ASSERT is >= than * more_assert_level. */ #define NM_MORE_ASSERT_ONCE(more_assert_level) \ ( (NM_MORE_ASSERTS >= (more_assert_level)) \ && ({ \ static volatile int _assert_once = 0; \ \ G_STATIC_ASSERT_EXPR ((more_assert_level) > 0); \ \ G_UNLIKELY ( _assert_once == 0 \ && g_atomic_int_compare_and_exchange (&_assert_once, 0, 1)); \ })) /*****************************************************************************/ #define NM_GOBJECT_PROPERTIES_DEFINE_BASE_FULL(suffix, ...) \ typedef enum { \ PROP_0##suffix, \ __VA_ARGS__ \ _PROPERTY_ENUMS_LAST##suffix, \ } _PropertyEnums##suffix; \ static GParamSpec *obj_properties##suffix[_PROPERTY_ENUMS_LAST##suffix] = { NULL, } #define NM_GOBJECT_PROPERTIES_DEFINE_NOTIFY(suffix, obj_type) \ static inline void \ _nm_gobject_notify_together_impl##suffix (obj_type *obj, guint n, const _PropertyEnums##suffix *props) \ { \ const gboolean freeze_thaw = (n > 1); \ \ nm_assert (G_IS_OBJECT (obj)); \ nm_assert (n > 0); \ \ if (freeze_thaw) \ g_object_freeze_notify ((GObject *) obj); \ while (n-- > 0) { \ const _PropertyEnums##suffix prop = *props++; \ \ if (prop != PROP_0##suffix) { \ nm_assert ((gsize) prop < G_N_ELEMENTS (obj_properties##suffix)); \ nm_assert (obj_properties##suffix[prop]); \ g_object_notify_by_pspec ((GObject *) obj, obj_properties##suffix[prop]); \ } \ } \ if (freeze_thaw) \ g_object_thaw_notify ((GObject *) obj); \ } \ \ _nm_unused static inline void \ _notify##suffix (obj_type *obj, _PropertyEnums##suffix prop) \ { \ _nm_gobject_notify_together_impl##suffix (obj, 1, &prop); \ } \ #define NM_GOBJECT_PROPERTIES_DEFINE_BASE(...) \ NM_GOBJECT_PROPERTIES_DEFINE_BASE_FULL (, __VA_ARGS__); \ #define NM_GOBJECT_PROPERTIES_DEFINE_FULL(suffix, obj_type, ...) \ NM_GOBJECT_PROPERTIES_DEFINE_BASE_FULL (suffix, __VA_ARGS__); \ NM_GOBJECT_PROPERTIES_DEFINE_NOTIFY (suffix, obj_type) #define NM_GOBJECT_PROPERTIES_DEFINE(obj_type, ...) \ NM_GOBJECT_PROPERTIES_DEFINE_FULL (, obj_type, __VA_ARGS__) /* 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_full(suffix, obj, ...) \ _nm_gobject_notify_together_impl##suffix (obj, NM_NARG (__VA_ARGS__), (const _PropertyEnums##suffix[]) { __VA_ARGS__ }) #define nm_gobject_notify_together(obj, ...) \ nm_gobject_notify_together_full (, obj, __VA_ARGS__) /*****************************************************************************/ #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_get_private = NM_GOBJECT_CAST_NON_NULL (type, (self), is_check, ##__VA_ARGS__); \ \ NM_PROPAGATE_CONST (_self_get_private, _self_get_private->_priv); \ }) #else #define _NM_GET_PRIVATE_PTR(self, type, is_check, ...) (NM_GOBJECT_CAST_NON_NULL (type, (self), is_check, ##__VA_ARGS__)->_priv) #endif /*****************************************************************************/ static inline gpointer nm_g_object_ref (gpointer obj) { /* g_object_ref() doesn't accept NULL. */ if (obj) g_object_ref (obj); return obj; } #define nm_g_object_ref(obj) ((typeof (obj)) nm_g_object_ref (obj)) static inline void nm_g_object_unref (gpointer obj) { /* g_object_unref() doesn't accept NULL. Usully, we workaround that * by using g_clear_object(), but sometimes that is not convenient * (for example as as destroy function for a hash table that can contain * NULL values). */ if (obj) g_object_unref (obj); } /* Assigns GObject @obj to destination @pp, and takes an additional ref. * The previous value of @pp is unrefed. * * 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); \ typeof (*_pp) const _obj = (obj); \ typeof (*_pp) _p; \ gboolean _changed = FALSE; \ \ nm_assert (!_pp || !*_pp || G_IS_OBJECT (*_pp)); \ nm_assert (!_obj || G_IS_OBJECT (_obj)); \ \ if ( _pp \ && ((_p = *_pp) != _obj)) { \ nm_g_object_ref (_obj); \ *_pp = _obj; \ nm_g_object_unref (_p); \ _changed = TRUE; \ } \ _changed; \ }) #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; \ }) /* 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) \ nm_clear_pointer (pp, g_free) #define nm_clear_g_object(pp) \ nm_clear_pointer (pp, g_object_unref) /** * nm_clear_error: * @err: a pointer to pointer to a #GError. * * This is like g_clear_error(). The only difference is * that this is an inline function. */ static inline void nm_clear_error (GError **err) { if (err && *err) { g_error_free (*err); *err = NULL; } } /* Patch g_clear_error() to use nm_clear_error(), which is inlineable * and visible to the compiler. For example gs_free_error attribute only * frees the error after checking that it's not %NULL. So, in many cases * the compiler knows that gs_free_error has no effect and can optimize * the call away. By making g_clear_error() inlineable, we give the compiler * more chance to detect that the function actually has no effect. */ #define g_clear_error(ptr) nm_clear_error(ptr) static inline gboolean nm_clear_g_source (guint *id) { guint v; if ( id && (v = *id)) { *id = 0; g_source_remove (v); return TRUE; } return FALSE; } static inline gboolean nm_clear_g_signal_handler (gpointer self, gulong *id) { gulong v; if ( id && (v = *id)) { *id = 0; g_signal_handler_disconnect (self, v); return TRUE; } return FALSE; } static inline gboolean nm_clear_g_variant (GVariant **variant) { GVariant *v; if ( variant && (v = *variant)) { *variant = NULL; g_variant_unref (v); return TRUE; } return FALSE; } static inline gboolean nm_clear_g_cancellable (GCancellable **cancellable) { GCancellable *v; if ( cancellable && (v = *cancellable)) { *cancellable = NULL; g_cancellable_cancel (v); g_object_unref (v); return TRUE; } return FALSE; } /* 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; } /*****************************************************************************/ static inline const char * nm_dbus_path_not_empty (const char *str) { nm_assert (!str || str[0] == '/'); return !str || (str[0] == '/' && str[1] == '\0') ? NULL : str; } /*****************************************************************************/ /* GVariantType is basically a C string. But G_VARIANT_TYPE() is not suitable * to initialize a static variable (because it evaluates a function check that * the string is valid). Add an alternative macro that does the plain cast. * * Here you loose the assertion check that G_VARIANT_TYPE() to ensure the * string is valid. */ #define NM_G_VARIANT_TYPE(fmt) ((const GVariantType *) (""fmt"")) static inline GVariant * nm_g_variant_ref (GVariant *v) { if (v) g_variant_ref (v); return v; } static inline GVariant * nm_g_variant_ref_sink (GVariant *v) { if (v) g_variant_ref_sink (v); return v; } static inline void nm_g_variant_unref (GVariant *v) { if (v) g_variant_unref (v); } static inline GVariant * nm_g_variant_take_ref (GVariant *v) { if (v) g_variant_take_ref (v); return v; } /*****************************************************************************/ /* Determine whether @x is a power of two (@x being an integer type). * Basically, this returns TRUE, if @x has exactly one bit set. * For negative values and zero, this always returns FALSE. */ #define nm_utils_is_power_of_two(x) ({ \ typeof(x) __x = (x); \ \ ( (__x > ((typeof(__x)) 0)) \ && ((__x & (__x - (((typeof(__x)) 1)))) == ((typeof(__x)) 0))); \ }) #define NM_DIV_ROUND_UP(x, y) \ ({ \ const typeof(x) _x = (x); \ const typeof(y) _y = (y); \ \ (_x / _y + !!(_x % _y)); \ }) /*****************************************************************************/ #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(fcn_name, lookup_type, result_type, unknown_val, ...) \ 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__) /* 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(). */ #define NM_UTILS_LOOKUP_STR_A(fcn_name, idx) \ ({ \ 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; \ }) /*****************************************************************************/ /* 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) \ ( G_STATIC_ASSERT_EXPR ((check) > 0 && ((check) & ((check) - 1)) == 0), NM_FLAGS_ANY ((flags), (check)) ) #define NM_FLAGS_ANY(flags, check) ( ( ((flags) & (check)) != 0 ) ? TRUE : FALSE ) #define NM_FLAGS_ALL(flags, check) ( ( ((flags) & (check)) == (check) ) ? TRUE : FALSE ) #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); \ }) #define NM_FLAGS_ASSIGN_MASK(flags, mask, val) ({ \ const typeof(flags) _flags = (flags); \ const typeof(flags) _mask = (mask); \ const typeof(flags) _val = (val); \ \ ((_flags & ~_mask) | (_mask & _val)); \ }) /*****************************************************************************/ #define _NM_BACKPORT_SYMBOL_IMPL(version, return_type, orig_func, versioned_func, args_typed, args) \ return_type versioned_func args_typed; \ _nm_externally_visible return_type versioned_func args_typed \ { \ return orig_func args; \ } \ return_type orig_func args_typed; \ __asm__(".symver "G_STRINGIFY(versioned_func)", "G_STRINGIFY(orig_func)"@"G_STRINGIFY(version)) #define NM_BACKPORT_SYMBOL(version, return_type, func, args_typed, args) \ _NM_BACKPORT_SYMBOL_IMPL(version, return_type, func, _##func##_##version, args_typed, args) /*****************************************************************************/ /* mirrors g_ascii_isspace() and what we consider spaces in general. */ #define NM_ASCII_SPACES " \n\t\r\f" /* Like NM_ASCII_SPACES, but without "\f" (0x0c, Formfeed Page Break). * This is what for example systemd calls WHITESPACE and what it uses to tokenize * the kernel command line. */ #define NM_ASCII_WHITESPACES " \n\t\r" #define nm_str_skip_leading_spaces(str) \ ({ \ typeof (*(str)) *_str_sls = (str); \ _nm_unused const char *const _str_type_check = _str_sls; \ \ if (_str_sls) { \ while (g_ascii_isspace (_str_sls[0])) \ _str_sls++; \ } \ _str_sls; \ }) static inline char * nm_strstrip (char *str) { /* g_strstrip doesn't like NULL. */ return str ? g_strstrip (str) : NULL; } 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; } #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; \ }) static inline gboolean nm_str_is_stripped (const char *str) { if (str && str[0]) { if ( g_ascii_isspace (str[0]) || g_ascii_isspace (str[strlen (str) - 1])) return FALSE; } return TRUE; } /* 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); } /*****************************************************************************/ /* 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)); \ }) #define NM_MAX_WITH_CMP(cmp, a, b) \ ({ \ typeof (a) _a = (a); \ typeof (b) _b = (b); \ \ ( ((cmp (_a, _b)) >= 0) \ ? _a \ : _b); \ }) /* 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))) /*****************************************************************************/ #define nm_g_slice_free(ptr) \ g_slice_free (typeof (*(ptr)), ptr) /*****************************************************************************/ /* 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; } #define nm_malloc_maybe_a(alloca_maxlen, bytes, to_free) \ ({ \ const gsize _bytes = (bytes); \ typeof (to_free) _to_free = (to_free); \ typeof (*_to_free) _ptr; \ \ G_STATIC_ASSERT_EXPR ((alloca_maxlen) <= 500); \ nm_assert (_to_free && !*_to_free); \ \ if (_bytes <= (alloca_maxlen)) { \ _ptr = g_alloca (_bytes); \ } else { \ _ptr = g_malloc (_bytes); \ *_to_free = _ptr; \ }; \ \ _ptr; \ }) #define nm_malloc0_maybe_a(alloca_maxlen, bytes, to_free) \ ({ \ const gsize _bytes = (bytes); \ typeof (to_free) _to_free = (to_free); \ typeof (*_to_free) _ptr; \ \ G_STATIC_ASSERT_EXPR ((alloca_maxlen) <= 500); \ nm_assert (_to_free && !*_to_free); \ \ if (_bytes <= (alloca_maxlen)) { \ _ptr = g_alloca (_bytes); \ memset (_ptr, 0, _bytes); \ } else { \ _ptr = g_malloc0 (_bytes); \ *_to_free = _ptr; \ }; \ \ _ptr; \ }) #define nm_memdup_maybe_a(alloca_maxlen, data, size, to_free) \ ({ \ const gsize _size = (size); \ typeof (to_free) _to_free_md = (to_free); \ typeof (*_to_free_md) _ptr_md = NULL; \ \ nm_assert (_to_free_md && !*_to_free_md); \ \ if (_size > 0u) { \ _ptr_md = nm_malloc_maybe_a ((alloca_maxlen), _size, _to_free_md); \ memcpy (_ptr_md, (data), _size); \ } \ \ _ptr_md; \ }) static inline char * _nm_strndup_a_step (char *s, const char *str, gsize len) { NM_PRAGMA_WARNING_DISABLE ("-Wstringop-truncation"); NM_PRAGMA_WARNING_DISABLE ("-Wstringop-overflow"); if (len > 0) strncpy (s, str, len); s[len] = '\0'; return s; NM_PRAGMA_WARNING_REENABLE; 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 /*****************************************************************************/ static inline guint nm_encode_version (guint major, guint minor, guint micro) { /* analog to the preprocessor macro NM_ENCODE_VERSION(). */ return (major << 16) | (minor << 8) | micro; } static inline void nm_decode_version (guint version, guint *major, guint *minor, guint *micro) { *major = (version & 0xFFFF0000u) >> 16; *minor = (version & 0x0000FF00u) >> 8; *micro = (version & 0x000000FFu); } /*****************************************************************************/ /* 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)]))) /*****************************************************************************/ /* if @str is NULL, return "(null)". Otherwise, allocate a buffer using * 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. * * Thus, the maximum stack allocated buffer will be @trunc_at+3. The maximum * buffer size must be a constant and not larger than 300. */ #define nm_strquote_a(trunc_at, str) \ ({ \ const char *const _str = (str); \ \ (_str \ ? ({ \ const gsize _trunc_at = (trunc_at); \ const gsize _strlen_trunc = NM_MIN (strlen (_str), _trunc_at); \ char *_buf; \ \ G_STATIC_ASSERT_EXPR ((trunc_at) <= 300); \ \ _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)"); \ }) #define nm_sprintf_buf(buf, format, ...) \ ({ \ char * _buf = (buf); \ int _buf_len; \ \ /* 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 *)); \ _buf_len = g_snprintf (_buf, sizeof (buf), \ ""format"", ##__VA_ARGS__); \ nm_assert (_buf_len < sizeof (buf)); \ _buf; \ }) /* it is "unsafe" because @bufsize must not be a constant expression and * there is no check at compiletime. Regardless of that, the buffer size * must not be larger than 300 bytes, as this gets stack allocated. */ #define nm_sprintf_buf_unsafe_a(bufsize, format, ...) \ ({ \ char *_buf; \ int _buf_len; \ typeof (bufsize) _bufsize = (bufsize); \ \ nm_assert (_bufsize <= 300); \ \ _buf = g_alloca (_bufsize); \ _buf_len = g_snprintf (_buf, _bufsize, \ ""format"", ##__VA_ARGS__); \ nm_assert (_buf_len >= 0 && _buf_len < _bufsize); \ _buf; \ }) #define nm_sprintf_bufa(bufsize, format, ...) \ ({ \ G_STATIC_ASSERT_EXPR ((bufsize) <= 300); \ nm_sprintf_buf_unsafe_a ((bufsize), format, ##__VA_ARGS__); \ }) /* aims to alloca() a buffer and fill it with printf(format, name). * Note that format must not contain any format specifier except * "%s". * If the resulting string would be too large for stack allocation, * it allocates a buffer with g_malloc() and assigns it to *p_val_to_free. */ #define nm_construct_name_a(format, name, p_val_to_free) \ ({ \ const char *const _name = (name); \ char **const _p_val_to_free = (p_val_to_free); \ const gsize _name_len = strlen (_name); \ char *_buf2; \ \ nm_assert (_p_val_to_free && !*_p_val_to_free); \ if ( NM_STRLEN (format) <= 290 \ && _name_len < (gsize) (290 - NM_STRLEN (format))) \ _buf2 = nm_sprintf_buf_unsafe_a (NM_STRLEN (format) + _name_len, format, _name); \ else { \ _buf2 = g_strdup_printf (format, _name); \ *_p_val_to_free = _buf2; \ } \ (const char *) _buf2; \ }) /*****************************************************************************/ /** * The boolean type _Bool is C99 while we mostly stick to C89. However, _Bool is too * convenient to miss and is effectively available in gcc and clang. So, just use it. * * Usually, one would include "stdbool.h" to get the "bool" define which aliases * _Bool. We provide this define here, because we want to make use of it anywhere. * (also, stdbool.h is again C99). * * Using _Bool has advantages over gboolean: * * - commonly _Bool is one byte large, instead of gboolean's 4 bytes (because gboolean * is a typedef for int). Especially when having boolean fields in a struct, we can * thereby easily save some space. * * - _Bool type guarantees that two "true" expressions compare equal. E.g. the following * will not work: * gboolean v1 = 1; * gboolean v2 = 2; * g_assert_cmpint (v1, ==, v2); // will fail * For that, we often to use !! to coerce gboolean values to 0 or 1: * g_assert_cmpint (!!v2, ==, TRUE); * With _Bool type, this will be handled properly by the compiler. * * - For structs, we might want to safe even more space and use bitfields: * struct s1 { * gboolean v1:1; * }; * But the problem here is that gboolean is signed, so that * v1 will be either 0 or -1 (not 1, TRUE). Thus, the following * fails: * struct s1 s = { .v1 = TRUE, }; * g_assert_cmpint (s1.v1, ==, TRUE); * It will however work just fine with bool/_Bool while retaining the * notion of having a boolean value. * * Also, add the defines for "true" and "false". Those are nicely highlighted by the editor * as special types, contrary to glib's "TRUE"/"FALSE". */ #ifndef bool #define bool _Bool #define true 1 #define false 0 #endif #ifdef _G_BOOLEAN_EXPR /* g_assert() uses G_LIKELY(), which in turn uses _G_BOOLEAN_EXPR(). * As glib's implementation uses a local variable _g_boolean_var_, * we cannot do * g_assert (some_macro ()); * where some_macro() itself expands to ({g_assert(); ...}). * In other words, you cannot have a g_assert() inside a g_assert() * without getting a -Werror=shadow failure. * * Workaround that by re-defining _G_BOOLEAN_EXPR() **/ #undef _G_BOOLEAN_EXPR #define __NM_G_BOOLEAN_EXPR_IMPL(v, expr) \ ({ \ int NM_UNIQ_T(V, v); \ \ if (expr) \ NM_UNIQ_T(V, v) = 1; \ else \ NM_UNIQ_T(V, v) = 0; \ NM_UNIQ_T(V, v); \ }) #define _G_BOOLEAN_EXPR(expr) __NM_G_BOOLEAN_EXPR_IMPL (NM_UNIQ, expr) #endif /*****************************************************************************/ /** * nm_steal_int: * @p_val: pointer to an int type. * * Returns: *p_val and sets *p_val to zero the same time. * Accepts %NULL, in which case also numeric 0 will be returned. */ #define nm_steal_int(p_val) \ ({ \ typeof (p_val) const _p_val = (p_val); \ typeof (*_p_val) _val = 0; \ \ if ( _p_val \ && (_val = *_p_val)) { \ *_p_val = 0; \ } \ _val; \ }) static inline int nm_steal_fd (int *p_fd) { int fd; if ( p_fd && ((fd = *p_fd) >= 0)) { *p_fd = -1; return fd; } return -1; } /** * nm_close: * * Like close() but throws an assertion if the input fd is * invalid. Closing an invalid fd is a programming error, so * it's better to catch it early. */ static inline int nm_close (int fd) { int r; r = close (fd); nm_assert (r != -1 || fd < 0 || errno != EBADF); return r; } #define NM_PID_T_INVAL ((pid_t) -1) /*****************************************************************************/ NM_AUTO_DEFINE_FCN_VOID0 (GMutex *, _nm_auto_unlock_g_mutex, g_mutex_unlock) #define nm_auto_unlock_g_mutex nm_auto (_nm_auto_unlock_g_mutex) #define _NM_G_MUTEX_LOCKED(lock, uniq) \ nm_auto_unlock_g_mutex GMutex *NM_UNIQ_T(nm_lock, uniq) = (lock) #define NM_G_MUTEX_LOCKED(lock) \ _NM_G_MUTEX_LOCKED (lock, NM_UNIQ) /*****************************************************************************/ #endif /* __NM_MACROS_INTERNAL_H__ */