1 /* 2 GLIB - Library of useful routines for C programming 3 4 Copyright (C) 2009-2024 5 Free Software Foundation, Inc. 6 7 Written by: 8 Slava Zanko <slavazanko@gmail.com>, 2009, 2013. 9 10 This file is part of the Midnight Commander. 11 12 The Midnight Commander is free software: you can redistribute it 13 and/or modify it under the terms of the GNU General Public License as 14 published by the Free Software Foundation, either version 3 of the License, 15 or (at your option) any later version. 16 17 The Midnight Commander is distributed in the hope that it will be useful, 18 but WITHOUT ANY WARRANTY; without even the implied warranty of 19 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 20 GNU General Public License for more details. 21 22 You should have received a copy of the GNU General Public License 23 along with this program. If not, see <http://www.gnu.org/licenses/>. 24 */ 25 26 /** \file glibcompat.c 27 * \brief Source: compatibility with older versions of glib 28 * 29 * Following code was copied from glib to GNU Midnight Commander to 30 * provide compatibility with older versions of glib. 31 */ 32 33 #include <config.h> 34 #include <string.h> 35 36 #include "global.h" 37 #include "glibcompat.h" 38 39 /*** global variables ****************************************************************************/ 40 41 /*** file scope macro definitions ****************************************************************/ 42 43 /*** file scope type declarations ****************************************************************/ 44 45 /*** file scope variables ************************************************************************/ 46 47 /*** file scope functions ************************************************************************/ 48 49 /* --------------------------------------------------------------------------------------------- */ 50 /*** public functions ****************************************************************************/ 51 /* --------------------------------------------------------------------------------------------- */ 52 53 #if ! GLIB_CHECK_VERSION (2, 63, 3) 54 /** 55 * g_clear_slist: (skip) 56 * @slist_ptr: (not nullable): a #GSList return location 57 * @destroy: (nullable): the function to pass to g_slist_free_full() or NULL to not free elements 58 * 59 * Clears a pointer to a #GSList, freeing it and, optionally, freeing its elements using @destroy. 60 * 61 * @slist_ptr must be a valid pointer. If @slist_ptr points to a null #GSList, this does nothing. 62 * 63 * Since: 2.64 64 */ 65 void 66 g_clear_slist (GSList ** slist_ptr, GDestroyNotify destroy) /* */ 67 { 68 GSList *slist; 69 70 slist = *slist_ptr; 71 72 if (slist != NULL) 73 { 74 *slist_ptr = NULL; 75 76 if (destroy != NULL) 77 g_slist_free_full (slist, destroy); 78 else 79 g_slist_free (slist); 80 } 81 } 82 83 /* --------------------------------------------------------------------------------------------- */ 84 85 /** 86 * g_clear_list: 87 * @list_ptr: (not nullable): a #GList return location 88 * @destroy: (nullable): the function to pass to g_list_free_full() or NULL to not free elements 89 * 90 * Clears a pointer to a #GList, freeing it and, optionally, freeing its elements using @destroy. 91 * 92 * @list_ptr must be a valid pointer. If @list_ptr points to a null #GList, this does nothing. 93 * 94 * Since: 2.64 95 */ 96 void 97 g_clear_list (GList ** list_ptr, GDestroyNotify destroy) /* */ 98 { 99 GList *list; 100 101 list = *list_ptr; 102 103 if (list != NULL) 104 { 105 *list_ptr = NULL; 106 107 if (destroy != NULL) 108 g_list_free_full (list, destroy); 109 else 110 g_list_free (list); 111 } 112 } 113 114 #endif /* ! GLIB_CHECK_VERSION (2, 63, 3) */ 115 116 /* --------------------------------------------------------------------------------------------- */ 117 118 #if ! GLIB_CHECK_VERSION (2, 60, 0) 119 /** 120 * g_queue_clear_full: 121 * @queue: a pointer to a #GQueue 122 * @free_func: (nullable): the function to be called to free memory allocated 123 * 124 * Convenience method, which frees all the memory used by a #GQueue, 125 * and calls the provided @free_func on each item in the #GQueue. 126 * 127 * Since: 2.60 128 */ 129 void 130 g_queue_clear_full (GQueue * queue, GDestroyNotify free_func) /* */ 131 { 132 g_return_if_fail (queue != NULL); 133 134 if (free_func != NULL) 135 g_queue_foreach (queue, (GFunc) free_func, NULL); 136 137 g_queue_clear (queue); 138 } 139 #endif /* ! GLIB_CHECK_VERSION (2, 60, 0) */ 140 141 /* --------------------------------------------------------------------------------------------- */ 142 143 #if ! GLIB_CHECK_VERSION (2, 77, 0) 144 /** 145 * g_string_new_take: 146 * @init: (nullable): initial text used as the string. 147 * Ownership of the string is transferred to the #GString. 148 * Passing NULL creates an empty string. 149 * 150 * Creates a new #GString, initialized with the given string. 151 * 152 * After this call, @init belongs to the #GString and may no longer be 153 * modified by the caller. The memory of @data has to be dynamically 154 * allocated and will eventually be freed with g_free(). 155 * 156 * Returns: the new #GString 157 */ 158 GString * 159 g_string_new_take (char *init) /* */ 160 { 161 GString *string; 162 163 if (init == NULL) 164 return g_string_new (NULL); 165 166 string = g_slice_new (GString); 167 168 string->str = init; 169 string->len = strlen (string->str); 170 string->allocated_len = string->len + 1; 171 172 return string; 173 } 174 #endif /* ! GLIB_CHECK_VERSION (2, 77, 0) */ 175 176 /* --------------------------------------------------------------------------------------------- */ 177 178 /** 179 * mc_g_string_copy: 180 * @dest: (not nullable): the destination #GString. Its current contents are destroyed 181 * @src: (not nullable): the source #GString 182 * @return: @dest 183 * 184 * Copies the bytes from a #GString into a #GString, destroying any previous contents. 185 * It is rather like the standard strcpy() function, except that you do not have to worry about 186 * having enough space to copy the string. 187 * 188 * There is no such API in GLib2. 189 */ 190 GString * 191 mc_g_string_copy (GString * dest, const GString * src) /* */ 192 { 193 g_return_val_if_fail (src != NULL, NULL); 194 g_return_val_if_fail (dest != NULL, NULL); 195 196 g_string_set_size (dest, 0); 197 g_string_append_len (dest, src->str, src->len); 198 199 return dest; 200 } 201 202 /* --------------------------------------------------------------------------------------------- */ 203 204 /** 205 * mc_g_string_dup: 206 * @s: (nullable): the source #GString 207 * @return: @copy of @s 208 * 209 * Copies the bytes from one #GString to another. 210 * 211 * There is no such API in GLib2. 212 */ 213 GString * 214 mc_g_string_dup (const GString * s) /* */ 215 { 216 GString *ret = NULL; 217 218 if (s != NULL) 219 ret = g_string_new_len (s->str, s->len); 220 221 return ret; 222 } 223 224 /* --------------------------------------------------------------------------------------------- */