glib-compat.h

Go to the documentation of this file.

#ifndef GLIB_COMPAT_H
#define GLIB_COMPAT_H
 
#include "ws_symbol_export.h"
#include "ws_attributes.h"
 
#include <glib.h>
#include <string.h>
 
#ifdef __cplusplus
extern "C" {
#endif /* __cplusplus */
 
#if !GLIB_CHECK_VERSION(2, 57, 1)

static inline gboolean
g_hash_table_steal_extended (GHashTable    *hash_table,
                             gconstpointer  lookup_key,
                             gpointer      *stolen_key,
                             gpointer      *stolen_value)
{
  gpointer key, value;
  if (g_hash_table_lookup_extended (hash_table, lookup_key, &key, &value))
  {
    stolen_key = &key;
    stolen_value = &value;
 
    g_hash_table_steal (hash_table, key);
 
    return TRUE;
  } else {
    if (stolen_key != NULL)
        *stolen_key = NULL;
    if (stolen_value != NULL)
      *stolen_value = NULL;
  }
 
  return FALSE;
}

static inline gchar *
g_canonicalize_filename (const gchar *filename,
                         const gchar *relative_to)
{
  gchar *canon, *input, *output, *after_root, *output_start;
 
  g_return_val_if_fail (relative_to == NULL || g_path_is_absolute (relative_to), NULL);
 
  if (!g_path_is_absolute (filename))
    {
      gchar *cwd_allocated = NULL;
      const gchar  *cwd;
 
      if (relative_to != NULL)
        cwd = relative_to;
      else
        cwd = cwd_allocated = g_get_current_dir ();
 
      canon = g_build_filename (cwd, filename, NULL);
      g_free (cwd_allocated);
    }
  else
    {
      canon = g_strdup (filename);
    }
 
  after_root = (char *)g_path_skip_root (canon);
 
  if (after_root == NULL)
    {
      /* This shouldn't really happen, as g_get_current_dir() should
         return an absolute pathname, but bug 573843 shows this is
         not always happening */
      g_free (canon);
      return g_build_filename (G_DIR_SEPARATOR_S, filename, NULL);
    }
 
  /* Find the first dir separator and use the canonical dir separator. */
  for (output = after_root - 1;
       (output >= canon) && G_IS_DIR_SEPARATOR (*output);
       output--)
    *output = G_DIR_SEPARATOR;
 
  /* 1 to re-increment after the final decrement above (so that output >= canon),
   * and 1 to skip the first `/`. There might not be a first `/` if
   * the @canon is a Windows `//server/share` style path with no
   * trailing directories. @after_root will be '\0' in that case. */
  output++;
  if (*output == G_DIR_SEPARATOR)
    output++;
 
  /* POSIX allows double slashes at the start to mean something special
   * (as does windows too). So, "//" != "/", but more than two slashes
   * is treated as "/".
   */
  if (after_root - output == 1)
    output++;
 
  input = after_root;
  output_start = output;
  while (*input)
    {
      /* input points to the next non-separator to be processed. */
      /* output points to the next location to write to. */
      g_assert (input > canon && G_IS_DIR_SEPARATOR (input[-1]));
      g_assert (output > canon && G_IS_DIR_SEPARATOR (output[-1]));
      g_assert (input >= output);
 
      /* Ignore repeated dir separators. */
      while (G_IS_DIR_SEPARATOR (input[0]))
       input++;
 
      /* Ignore single dot directory components. */
      if (input[0] == '.' && (input[1] == 0 || G_IS_DIR_SEPARATOR (input[1])))
        {
           if (input[1] == 0)
             break;
           input += 2;
        }
      /* Remove double-dot directory components along with the preceding
       * path component. */
      else if (input[0] == '.' && input[1] == '.' &&
               (input[2] == 0 || G_IS_DIR_SEPARATOR (input[2])))
        {
          if (output > output_start)
            {
              do
                {
                  output--;
                }
              while (!G_IS_DIR_SEPARATOR (output[-1]) && output > output_start);
            }
          if (input[2] == 0)
            break;
          input += 3;
        }
      /* Copy the input to the output until the next separator,
       * while converting it to canonical separator */
      else
        {
          while (*input && !G_IS_DIR_SEPARATOR (*input))
            *output++ = *input++;
          if (input[0] == 0)
            break;
          input++;
          *output++ = G_DIR_SEPARATOR;
        }
 
    }
 
  /* Remove a potentially trailing dir separator */
  if (output > output_start && G_IS_DIR_SEPARATOR (output[-1]))
    output--;
 
  *output = '\0';
 
  return canon;
}
 
#endif
 
#if !GLIB_CHECK_VERSION(2, 60, 0)
 
#define g_queue_clear_full queue_clear_full

static inline void
queue_clear_full (GQueue * queue, GDestroyNotify free_func)
{
  gpointer data;
 
  while ((data = g_queue_pop_head (queue)) != NULL)
    free_func (data);
}
 
#endif
 
#if !GLIB_CHECK_VERSION(2, 61, 2)
 
typedef volatile gint   gatomicrefcount;
 
typedef struct _GRealArray GRealArray;
struct _GRealArray {
    guint8         *data;             
    guint           len;              
    guint           alloc;            
    guint           elt_size;         
    guint           zero_terminated;  
    guint           clear;            
    gatomicrefcount ref_count;        
    GDestroyNotify  clear_func;       
};

static inline gboolean
g_array_binary_search (GArray        *array,
                       const void *   target,
                       GCompareFunc   compare_func,
                       guint         *out_match_index)
{
  gboolean result = FALSE;
  GRealArray *_array = (GRealArray *) array;
  guint left, middle, right;
  gint val;
 
  g_return_val_if_fail (_array != NULL, FALSE);
  g_return_val_if_fail (compare_func != NULL, FALSE);
 
  if (G_LIKELY(_array->len))
    {
      left = 0;
      right = _array->len - 1;
 
      while (left <= right)
        {
          middle = left + (right - left) / 2;
 
          val = compare_func (_array->data + (_array->elt_size * middle), target);
          if (val == 0)
            {
              result = TRUE;
              break;
            }
          else if (val < 0)
            left = middle + 1;
          else if (/* val > 0 && */ middle > 0)
            right = middle - 1;
          else
            break;  /* element not found */
        }
    }
 
  if (result && out_match_index != NULL)
    *out_match_index = middle;
 
  return result;
}
#endif
 
#if !GLIB_CHECK_VERSION(2, 64, 0)
typedef struct _GRealPtrArray GRealPtrArray;
 

struct _GRealPtrArray {
    gpointer       *pdata;              
    guint           len;                
    guint           alloc;              
    gatomicrefcount ref_count;          
    guint8          null_terminated:1;  
    GDestroyNotify  element_free_func;  
};

static inline gpointer
g_array_steal (GArray *array,
               gsize *len)
{
  GRealArray *rarray;
  gpointer segment;
 
  g_return_val_if_fail (array != NULL, NULL);
 
  rarray = (GRealArray *) array;
  segment = (gpointer) rarray->data;
 
  if (len != NULL)
    *len = rarray->len;
 
  rarray->data  = NULL;
  rarray->len   = 0;
  rarray->alloc = 0;
  return segment;
}

static inline gpointer *
g_ptr_array_steal (GPtrArray *array,
                   gsize *len)
{
  GRealPtrArray *rarray;
  gpointer *segment;
 
  g_return_val_if_fail (array != NULL, NULL);
 
  rarray = (GRealPtrArray *) array;
  segment = (gpointer *) rarray->pdata;
 
  if (len != NULL)
    *len = rarray->len;
 
  rarray->pdata = NULL;
  rarray->len   = 0;
  rarray->alloc = 0;
  return segment;
}

static inline guint8 *g_byte_array_steal (GByteArray *array,
                    gsize *len)
{
  return (guint8 *) g_array_steal ((GArray *) array, len);
}
#endif
 
#if !GLIB_CHECK_VERSION(2, 68, 0)

static inline void *
g_memdup2(const void *mem, size_t byte_size)
{
  void * new_mem;
 
  if (mem && byte_size != 0) {
      new_mem = g_malloc(byte_size);
      memcpy(new_mem, mem, byte_size);
  }
  else
    new_mem = NULL;
 
  return new_mem;
}
#endif
 
#if !GLIB_CHECK_VERSION(2, 74, 0)
#ifndef G_REGEX_DEFAULT
#define G_REGEX_DEFAULT ((GRegexCompileFlags)0)
#endif
#endif
 
#if !GLIB_CHECK_VERSION(2, 74, 0)
#ifndef G_REGEX_MATCH_DEFAULT
#define G_REGEX_MATCH_DEFAULT ((GRegexMatchFlags)0)
#endif
#endif
 
#if !GLIB_CHECK_VERSION(2, 88, 0)
#ifndef G_NSEC_PER_SEC
#define G_NSEC_PER_SEC 1000000000
#endif
#endif
 
#ifdef __cplusplus
}
#endif /* __cplusplus */
 
#endif /* GLIB_COMPAT_H */