diff options
Diffstat (limited to 'shared/nm-glib-aux/nm-enum-utils.c')
| -rw-r--r-- | shared/nm-glib-aux/nm-enum-utils.c | 604 |
1 files changed, 298 insertions, 306 deletions
diff --git a/shared/nm-glib-aux/nm-enum-utils.c b/shared/nm-glib-aux/nm-enum-utils.c index 854eda6e..5292755d 100644 --- a/shared/nm-glib-aux/nm-enum-utils.c +++ b/shared/nm-glib-aux/nm-enum-utils.c @@ -1,4 +1,4 @@ -// SPDX-License-Identifier: LGPL-2.1+ +/* SPDX-License-Identifier: LGPL-2.1+ */ /* * Copyright (C) 2017 Red Hat, Inc. */ @@ -10,349 +10,341 @@ /*****************************************************************************/ -#define IS_FLAGS_SEPARATOR(ch) (NM_IN_SET ((ch), ' ', '\t', ',', '\n', '\r')) +#define IS_FLAGS_SEPARATOR(ch) (NM_IN_SET((ch), ' ', '\t', ',', '\n', '\r')) static void -_ASSERT_enum_values_info (GType type, - const NMUtilsEnumValueInfo *value_infos) +_ASSERT_enum_values_info(GType type, const NMUtilsEnumValueInfo *value_infos) { #if NM_MORE_ASSERTS > 5 - nm_auto_unref_gtypeclass GTypeClass *klass = NULL; - gs_unref_hashtable GHashTable *ht = NULL; - - klass = g_type_class_ref (type); - - g_assert (G_IS_ENUM_CLASS (klass) || G_IS_FLAGS_CLASS (klass)); - - if (!value_infos) - return; - - ht = g_hash_table_new (g_str_hash, g_str_equal); - - for (; value_infos->nick; value_infos++) { - - g_assert (value_infos->nick[0]); - - /* duplicate nicks make no sense!! */ - g_assert (!g_hash_table_contains (ht, value_infos->nick)); - g_hash_table_add (ht, (gpointer) value_infos->nick); - - if (G_IS_ENUM_CLASS (klass)) { - GEnumValue *enum_value; - - enum_value = g_enum_get_value_by_nick (G_ENUM_CLASS (klass), value_infos->nick); - if (enum_value) { - /* we do allow specifying the same name via @value_infos and @type. - * That might make sense, if @type comes from a library where older versions - * of the library don't yet support the value. In this case, the caller can - * provide the nick via @value_infos, to support the older library version. - * And then, when actually running against a newer library version where - * @type knows the nick, we have this situation. - * - * Another reason for specifying a nick both in @value_infos and @type, - * is to specify an alias which is not used with highest preference. For - * example, if you add an alias "disabled" for "none" (both numerically - * equal), then the first alias in @value_infos will be preferred over - * the name from @type. So, to still use "none" as preferred name, you may - * explicitly specify the "none" alias in @value_infos before "disabled". - * - * However, what never is allowed, is to use a name (nick) to re-number - * the value. That is, if both @value_infos and @type contain a particular - * nick, their numeric values must agree as well. - * Allowing this, would be very confusing, because the name would have a different - * value from the regular GLib GEnum API. - */ - g_assert (enum_value->value == value_infos->value); - } - } else { - GFlagsValue *flags_value; - - flags_value = g_flags_get_value_by_nick (G_FLAGS_CLASS (klass), value_infos->nick); - if (flags_value) { - /* see ENUM case above. */ - g_assert (flags_value->value == (guint) value_infos->value); - } - } - } + nm_auto_unref_gtypeclass GTypeClass *klass = NULL; + gs_unref_hashtable GHashTable *ht = NULL; + + klass = g_type_class_ref(type); + + g_assert(G_IS_ENUM_CLASS(klass) || G_IS_FLAGS_CLASS(klass)); + + if (!value_infos) + return; + + ht = g_hash_table_new(g_str_hash, g_str_equal); + + for (; value_infos->nick; value_infos++) { + g_assert(value_infos->nick[0]); + + /* duplicate nicks make no sense!! */ + g_assert(!g_hash_table_contains(ht, value_infos->nick)); + g_hash_table_add(ht, (gpointer) value_infos->nick); + + if (G_IS_ENUM_CLASS(klass)) { + GEnumValue *enum_value; + + enum_value = g_enum_get_value_by_nick(G_ENUM_CLASS(klass), value_infos->nick); + if (enum_value) { + /* we do allow specifying the same name via @value_infos and @type. + * That might make sense, if @type comes from a library where older versions + * of the library don't yet support the value. In this case, the caller can + * provide the nick via @value_infos, to support the older library version. + * And then, when actually running against a newer library version where + * @type knows the nick, we have this situation. + * + * Another reason for specifying a nick both in @value_infos and @type, + * is to specify an alias which is not used with highest preference. For + * example, if you add an alias "disabled" for "none" (both numerically + * equal), then the first alias in @value_infos will be preferred over + * the name from @type. So, to still use "none" as preferred name, you may + * explicitly specify the "none" alias in @value_infos before "disabled". + * + * However, what never is allowed, is to use a name (nick) to re-number + * the value. That is, if both @value_infos and @type contain a particular + * nick, their numeric values must agree as well. + * Allowing this, would be very confusing, because the name would have a different + * value from the regular GLib GEnum API. + */ + g_assert(enum_value->value == value_infos->value); + } + } else { + GFlagsValue *flags_value; + + flags_value = g_flags_get_value_by_nick(G_FLAGS_CLASS(klass), value_infos->nick); + if (flags_value) { + /* see ENUM case above. */ + g_assert(flags_value->value == (guint) value_infos->value); + } + } + } #endif } static gboolean -_is_hex_string (const char *str) +_is_hex_string(const char *str) { - return str[0] == '0' - && str[1] == 'x' - && str[2] - && NM_STRCHAR_ALL (&str[2], ch, g_ascii_isxdigit (ch)); + return str[0] == '0' && str[1] == 'x' && str[2] + && NM_STRCHAR_ALL(&str[2], ch, g_ascii_isxdigit(ch)); } static gboolean -_is_dec_string (const char *str) +_is_dec_string(const char *str) { - return str[0] - && NM_STRCHAR_ALL (&str[0], ch, g_ascii_isdigit (ch)); + return str[0] && NM_STRCHAR_ALL(&str[0], ch, g_ascii_isdigit(ch)); } static gboolean -_enum_is_valid_enum_nick (const char *str) +_enum_is_valid_enum_nick(const char *str) { - return str[0] - && !NM_STRCHAR_ANY (str, ch, g_ascii_isspace (ch)) - && !_is_dec_string (str) - && !_is_hex_string (str); + return str[0] && !NM_STRCHAR_ANY(str, ch, g_ascii_isspace(ch)) && !_is_dec_string(str) + && !_is_hex_string(str); } static gboolean -_enum_is_valid_flags_nick (const char *str) +_enum_is_valid_flags_nick(const char *str) { - return str[0] - && !NM_STRCHAR_ANY (str, ch, IS_FLAGS_SEPARATOR (ch)) - && !_is_dec_string (str) - && !_is_hex_string (str); + return str[0] && !NM_STRCHAR_ANY(str, ch, IS_FLAGS_SEPARATOR(ch)) && !_is_dec_string(str) + && !_is_hex_string(str); } char * -_nm_utils_enum_to_str_full (GType type, - int value, - const char *flags_separator, - const NMUtilsEnumValueInfo *value_infos) +_nm_utils_enum_to_str_full(GType type, + int value, + const char * flags_separator, + const NMUtilsEnumValueInfo *value_infos) { - nm_auto_unref_gtypeclass GTypeClass *klass = NULL; - - _ASSERT_enum_values_info (type, value_infos); - - if ( flags_separator - && ( !flags_separator[0] - || NM_STRCHAR_ANY (flags_separator, ch, !IS_FLAGS_SEPARATOR (ch)))) - g_return_val_if_reached (NULL); - - klass = g_type_class_ref (type); - - if (G_IS_ENUM_CLASS (klass)) { - GEnumValue *enum_value; - - for ( ; value_infos && value_infos->nick; value_infos++) { - if (value_infos->value == value) - return g_strdup (value_infos->nick); - } - - enum_value = g_enum_get_value (G_ENUM_CLASS (klass), value); - if ( !enum_value - || !_enum_is_valid_enum_nick (enum_value->value_nick)) - return g_strdup_printf ("%d", value); - else - return g_strdup (enum_value->value_nick); - } else if (G_IS_FLAGS_CLASS (klass)) { - unsigned uvalue = (unsigned) value; - GFlagsValue *flags_value; - NMStrBuf strbuf; - - flags_separator = flags_separator ?: " "; - - nm_str_buf_init (&strbuf, 16, FALSE); - - for ( ; value_infos && value_infos->nick; value_infos++) { - - nm_assert (_enum_is_valid_flags_nick (value_infos->nick)); - - if (uvalue == 0) { - if (value_infos->value != 0) - continue; - } else { - if (!NM_FLAGS_ALL (uvalue, (unsigned) value_infos->value)) - continue; - } - - if (strbuf.len) - nm_str_buf_append (&strbuf, flags_separator); - nm_str_buf_append (&strbuf, value_infos->nick); - uvalue &= ~((unsigned) value_infos->value); - if (uvalue == 0) { - /* we printed all flags. Done. */ - goto flags_done; - } - } - - do { - flags_value = g_flags_get_first_value (G_FLAGS_CLASS (klass), uvalue); - if (strbuf.len) - nm_str_buf_append (&strbuf, flags_separator); - if ( !flags_value - || !_enum_is_valid_flags_nick (flags_value->value_nick)) { - if (uvalue) - nm_str_buf_append_printf (&strbuf, "0x%x", uvalue); - break; - } - nm_str_buf_append (&strbuf, flags_value->value_nick); - uvalue &= ~flags_value->value; - } while (uvalue); + nm_auto_unref_gtypeclass GTypeClass *klass = NULL; + + _ASSERT_enum_values_info(type, value_infos); + + if (flags_separator + && (!flags_separator[0] || NM_STRCHAR_ANY(flags_separator, ch, !IS_FLAGS_SEPARATOR(ch)))) + g_return_val_if_reached(NULL); + + klass = g_type_class_ref(type); + + if (G_IS_ENUM_CLASS(klass)) { + GEnumValue *enum_value; + + for (; value_infos && value_infos->nick; value_infos++) { + if (value_infos->value == value) + return g_strdup(value_infos->nick); + } + + enum_value = g_enum_get_value(G_ENUM_CLASS(klass), value); + if (!enum_value || !_enum_is_valid_enum_nick(enum_value->value_nick)) + return g_strdup_printf("%d", value); + else + return g_strdup(enum_value->value_nick); + } else if (G_IS_FLAGS_CLASS(klass)) { + unsigned uvalue = (unsigned) value; + GFlagsValue *flags_value; + NMStrBuf strbuf; + + flags_separator = flags_separator ?: " "; + + nm_str_buf_init(&strbuf, 16, FALSE); + + for (; value_infos && value_infos->nick; value_infos++) { + nm_assert(_enum_is_valid_flags_nick(value_infos->nick)); + + if (uvalue == 0) { + if (value_infos->value != 0) + continue; + } else { + if (!NM_FLAGS_ALL(uvalue, (unsigned) value_infos->value)) + continue; + } + + if (strbuf.len) + nm_str_buf_append(&strbuf, flags_separator); + nm_str_buf_append(&strbuf, value_infos->nick); + uvalue &= ~((unsigned) value_infos->value); + if (uvalue == 0) { + /* we printed all flags. Done. */ + goto flags_done; + } + } + + do { + flags_value = g_flags_get_first_value(G_FLAGS_CLASS(klass), uvalue); + if (strbuf.len) + nm_str_buf_append(&strbuf, flags_separator); + if (!flags_value || !_enum_is_valid_flags_nick(flags_value->value_nick)) { + if (uvalue) + nm_str_buf_append_printf(&strbuf, "0x%x", uvalue); + break; + } + nm_str_buf_append(&strbuf, flags_value->value_nick); + uvalue &= ~flags_value->value; + } while (uvalue); flags_done: - return nm_str_buf_finalize (&strbuf, NULL); - } + return nm_str_buf_finalize(&strbuf, NULL); + } - g_return_val_if_reached (NULL); + g_return_val_if_reached(NULL); } static const NMUtilsEnumValueInfo * -_find_value_info (const NMUtilsEnumValueInfo *value_infos, const char *needle) +_find_value_info(const NMUtilsEnumValueInfo *value_infos, const char *needle) { - if (value_infos) { - for (; value_infos->nick; value_infos++) { - if (nm_streq (needle, value_infos->nick)) - return value_infos; - } - } - return NULL; + if (value_infos) { + for (; value_infos->nick; value_infos++) { + if (nm_streq(needle, value_infos->nick)) + return value_infos; + } + } + return NULL; } gboolean -_nm_utils_enum_from_str_full (GType type, - const char *str, - int *out_value, - char **err_token, - const NMUtilsEnumValueInfo *value_infos) +_nm_utils_enum_from_str_full(GType type, + const char * str, + int * out_value, + char ** err_token, + const NMUtilsEnumValueInfo *value_infos) { - nm_auto_unref_gtypeclass GTypeClass *klass = NULL; - gboolean ret = FALSE; - int value = 0; - gs_free char *str_clone = NULL; - char *s; - gint64 v64; - const NMUtilsEnumValueInfo *nick; - - g_return_val_if_fail (str, FALSE); - - _ASSERT_enum_values_info (type, value_infos); - - str_clone = strdup (str); - s = nm_str_skip_leading_spaces (str_clone); - g_strchomp (s); - - klass = g_type_class_ref (type); - - if (G_IS_ENUM_CLASS (klass)) { - GEnumValue *enum_value; - - if (s[0]) { - if (_is_hex_string (s)) { - v64 = _nm_utils_ascii_str_to_int64 (s, 16, 0, G_MAXUINT, -1); - if (v64 != -1) { - value = (int) v64; - ret = TRUE; - } - } else if (_is_dec_string (s)) { - v64 = _nm_utils_ascii_str_to_int64 (s, 10, 0, G_MAXUINT, -1); - if (v64 != -1) { - value = (int) v64; - ret = TRUE; - } - } else if ((nick = _find_value_info (value_infos, s))) { - value = nick->value; - ret = TRUE; - } else if ((enum_value = g_enum_get_value_by_nick (G_ENUM_CLASS (klass), s))) { - value = enum_value->value; - ret = TRUE; - } - } - } else if (G_IS_FLAGS_CLASS (klass)) { - GFlagsValue *flags_value; - unsigned uvalue = 0; - - ret = TRUE; - while (s[0]) { - char *s_end; - - for (s_end = s; s_end[0]; s_end++) { - if (IS_FLAGS_SEPARATOR (s_end[0])) { - s_end[0] = '\0'; - s_end++; - break; - } - } - - if (s[0]) { - if (_is_hex_string (s)) { - v64 = _nm_utils_ascii_str_to_int64 (&s[2], 16, 0, G_MAXUINT, -1); - if (v64 == -1) { - ret = FALSE; - break; - } - uvalue |= (unsigned) v64; - } else if (_is_dec_string (s)) { - v64 = _nm_utils_ascii_str_to_int64 (s, 10, 0, G_MAXUINT, -1); - if (v64 == -1) { - ret = FALSE; - break; - } - uvalue |= (unsigned) v64; - } else if ((nick = _find_value_info (value_infos, s))) - uvalue |= (unsigned) nick->value; - else if ((flags_value = g_flags_get_value_by_nick (G_FLAGS_CLASS (klass), s))) - uvalue |= flags_value->value; - else { - ret = FALSE; - break; - } - } - - s = s_end; - } - - value = (int) uvalue; - } else - g_return_val_if_reached (FALSE); - - NM_SET_OUT (err_token, !ret && s[0] ? g_strdup (s) : NULL); - NM_SET_OUT (out_value, ret ? value : 0); - return ret; + nm_auto_unref_gtypeclass GTypeClass *klass = NULL; + gboolean ret = FALSE; + int value = 0; + gs_free char * str_clone = NULL; + char * s; + gint64 v64; + const NMUtilsEnumValueInfo * nick; + + g_return_val_if_fail(str, FALSE); + + _ASSERT_enum_values_info(type, value_infos); + + str_clone = strdup(str); + s = nm_str_skip_leading_spaces(str_clone); + g_strchomp(s); + + klass = g_type_class_ref(type); + + if (G_IS_ENUM_CLASS(klass)) { + GEnumValue *enum_value; + + if (s[0]) { + if (_is_hex_string(s)) { + v64 = _nm_utils_ascii_str_to_int64(s, 16, 0, G_MAXUINT, -1); + if (v64 != -1) { + value = (int) v64; + ret = TRUE; + } + } else if (_is_dec_string(s)) { + v64 = _nm_utils_ascii_str_to_int64(s, 10, 0, G_MAXUINT, -1); + if (v64 != -1) { + value = (int) v64; + ret = TRUE; + } + } else if ((nick = _find_value_info(value_infos, s))) { + value = nick->value; + ret = TRUE; + } else if ((enum_value = g_enum_get_value_by_nick(G_ENUM_CLASS(klass), s))) { + value = enum_value->value; + ret = TRUE; + } + } + } else if (G_IS_FLAGS_CLASS(klass)) { + GFlagsValue *flags_value; + unsigned uvalue = 0; + + ret = TRUE; + while (s[0]) { + char *s_end; + + for (s_end = s; s_end[0]; s_end++) { + if (IS_FLAGS_SEPARATOR(s_end[0])) { + s_end[0] = '\0'; + s_end++; + break; + } + } + + if (s[0]) { + if (_is_hex_string(s)) { + v64 = _nm_utils_ascii_str_to_int64(&s[2], 16, 0, G_MAXUINT, -1); + if (v64 == -1) { + ret = FALSE; + break; + } + uvalue |= (unsigned) v64; + } else if (_is_dec_string(s)) { + v64 = _nm_utils_ascii_str_to_int64(s, 10, 0, G_MAXUINT, -1); + if (v64 == -1) { + ret = FALSE; + break; + } + uvalue |= (unsigned) v64; + } else if ((nick = _find_value_info(value_infos, s))) + uvalue |= (unsigned) nick->value; + else if ((flags_value = g_flags_get_value_by_nick(G_FLAGS_CLASS(klass), s))) + uvalue |= flags_value->value; + else { + ret = FALSE; + break; + } + } + + s = s_end; + } + + value = (int) uvalue; + } else + g_return_val_if_reached(FALSE); + + NM_SET_OUT(err_token, !ret && s[0] ? g_strdup(s) : NULL); + NM_SET_OUT(out_value, ret ? value : 0); + return ret; } const char ** -_nm_utils_enum_get_values (GType type, int from, int to) +_nm_utils_enum_get_values(GType type, int from, int to) { - GTypeClass *klass; - GPtrArray *array; - int i; - char sbuf[64]; - - klass = g_type_class_ref (type); - array = g_ptr_array_new (); - - if (G_IS_ENUM_CLASS (klass)) { - GEnumClass *enum_class = G_ENUM_CLASS (klass); - GEnumValue *enum_value; - - for (i = 0; i < enum_class->n_values; i++) { - enum_value = &enum_class->values[i]; - if (enum_value->value >= from && enum_value->value <= to) { - if (_enum_is_valid_enum_nick (enum_value->value_nick)) - g_ptr_array_add (array, (gpointer) enum_value->value_nick); - else - g_ptr_array_add (array, (gpointer) g_intern_string (nm_sprintf_buf (sbuf, "%d", enum_value->value))); - } - } - } else if (G_IS_FLAGS_CLASS (klass)) { - GFlagsClass *flags_class = G_FLAGS_CLASS (klass); - GFlagsValue *flags_value; - - for (i = 0; i < flags_class->n_values; i++) { - flags_value = &flags_class->values[i]; - if (flags_value->value >= (guint) from && flags_value->value <= (guint) to) { - if (_enum_is_valid_flags_nick (flags_value->value_nick)) - g_ptr_array_add (array, (gpointer) flags_value->value_nick); - else - g_ptr_array_add (array, (gpointer) g_intern_string (nm_sprintf_buf (sbuf, "0x%x", (unsigned) flags_value->value))); - } - } - } else { - g_type_class_unref (klass); - g_ptr_array_free (array, TRUE); - g_return_val_if_reached (NULL); - } - - g_type_class_unref (klass); - g_ptr_array_add (array, NULL); - - return (const char **) g_ptr_array_free (array, FALSE); + GTypeClass *klass; + GPtrArray * array; + int i; + char sbuf[64]; + + klass = g_type_class_ref(type); + array = g_ptr_array_new(); + + if (G_IS_ENUM_CLASS(klass)) { + GEnumClass *enum_class = G_ENUM_CLASS(klass); + GEnumValue *enum_value; + + for (i = 0; i < enum_class->n_values; i++) { + enum_value = &enum_class->values[i]; + if (enum_value->value >= from && enum_value->value <= to) { + if (_enum_is_valid_enum_nick(enum_value->value_nick)) + g_ptr_array_add(array, (gpointer) enum_value->value_nick); + else + g_ptr_array_add( + array, + (gpointer) g_intern_string(nm_sprintf_buf(sbuf, "%d", enum_value->value))); + } + } + } else if (G_IS_FLAGS_CLASS(klass)) { + GFlagsClass *flags_class = G_FLAGS_CLASS(klass); + GFlagsValue *flags_value; + + for (i = 0; i < flags_class->n_values; i++) { + flags_value = &flags_class->values[i]; + if (flags_value->value >= (guint) from && flags_value->value <= (guint) to) { + if (_enum_is_valid_flags_nick(flags_value->value_nick)) + g_ptr_array_add(array, (gpointer) flags_value->value_nick); + else + g_ptr_array_add( + array, + (gpointer) g_intern_string( + nm_sprintf_buf(sbuf, "0x%x", (unsigned) flags_value->value))); + } + } + } else { + g_type_class_unref(klass); + g_ptr_array_free(array, TRUE); + g_return_val_if_reached(NULL); + } + + g_type_class_unref(klass); + g_ptr_array_add(array, NULL); + + return (const char **) g_ptr_array_free(array, FALSE); } |