gio/xdgmime/xdgmimeparent.c

   1 /* -*- mode: C; c-file-style: "gnu" -*- */
   2 /* xdgmimealias.c: Private file.  Datastructure for storing the hierarchy.
   3  *
   4  * More info can be found at http://www.freedesktop.org/standards/
   5  *
   6  * Copyright (C) 2004  Red Hat, Inc.
   7  * Copyright (C) 2004  Matthias Clasen <mclasen@redhat.com>
   8  *
   9  * SPDX-License-Identifier: LGPL-2.1-or-later or AFL-2.0
  10  */
  11
  12 #ifdef HAVE_CONFIG_H
  13 #include <config.h>
  14 #endif
  15
  16 #include "xdgmimeparent.h"
  17 #include "xdgmimeint.h"
  18 #include <stdlib.h>
  19 #include <stdio.h>
  20 #include <assert.h>
  21 #include <string.h>
  22 #include <fnmatch.h>
  23
  24 #ifndef FALSE
  25 #define FALSE   (0)
  26 #endif
  27
  28 #ifndef TRUE
  29 #define TRUE    (!FALSE)
  30 #endif
  31
  32 typedef struct XdgMimeParents XdgMimeParents;
  33
  34 struct XdgMimeParents
  35 {
  36   char *mime;
  37   char **parents;
  38   int n_parents;
  39 };
  40
  41 struct XdgParentList
  42 {
  43   struct XdgMimeParents *parents;
  44   int n_mimes;
  45 };
  46
  47 XdgParentList *
  48 _xdg_mime_parent_list_new (void)
  49 {
  50   XdgParentList *list;
  51
  52   list = malloc (sizeof (XdgParentList));
  53
  54   list->parents = NULL;
  55   list->n_mimes = 0;
  56
  57   return list;
  58 }
  59
  60 void
  61 _xdg_mime_parent_list_free (XdgParentList *list)
  62 {
  63   int i;
  64   char **p;
  65
  66   if (list->parents)
  67     {
  68       for (i = 0; i < list->n_mimes; i++)
  69         {
  70           for (p = list->parents[i].parents; *p; p++)
  71             free (*p);
  72
  73           free (list->parents[i].parents);
  74           free (list->parents[i].mime);
  75         }
  76       free (list->parents);
  77     }
  78   free (list);
  79 }
  80
  81 static int
  82 parent_entry_cmp (const void *v1, const void *v2)
  83 {
  84   return strcmp (((XdgMimeParents *)v1)->mime, ((XdgMimeParents *)v2)->mime);
  85 }
  86
  87 const char **
  88 _xdg_mime_parent_list_lookup (XdgParentList *list,
  89                               const char    *mime)
  90 {
  91   XdgMimeParents *entry;
  92   XdgMimeParents key;
  93
  94   if (list->n_mimes > 0)
  95     {
  96       key.mime = (char *)mime;
  97       key.parents = NULL;
  98       key.n_parents = 0;
  99
 100       entry = bsearch (&key, list->parents, list->n_mimes,
 101                        sizeof (XdgMimeParents), &parent_entry_cmp);
 102       if (entry)
 103         return (const char **)entry->parents;
 104     }
 105
 106   return NULL;
 107 }
 108
 109 void
 110 _xdg_mime_parent_read_from_file (XdgParentList *list,
 111                                  const char    *file_name)
 112 {
 113   FILE *file;
 114   char line[255];
 115   int i, alloc;
 116   XdgMimeParents *entry;
 117
 118   file = fopen (file_name, "r");
 119
 120   if (file == NULL)
 121     return;
 122
 123   /* FIXME: Not UTF-8 safe.  Doesn't work if lines are greater than 255 chars.
 124    * Blah */
 125   alloc = list->n_mimes + 16;
 126   list->parents = realloc (list->parents, alloc * sizeof (XdgMimeParents));
 127   while (fgets (line, 255, file) != NULL)
 128     {
 129       char *sep;
 130       if (line[0] == '#')
 131         continue;
 132
 133       sep = strchr (line, ' ');
 134       if (sep == NULL)
 135         continue;
 136       *(sep++) = '\000';
 137       sep[strlen (sep) -1] = '\000';
 138       entry = NULL;
 139       for (i = 0; i < list->n_mimes; i++)
 140         {
 141           if (strcmp (list->parents[i].mime, line) == 0)
 142             {
 143               entry = &(list->parents[i]);
 144               break;
 145             }
 146         }
 147
 148       if (!entry)
 149         {
 150           if (list->n_mimes == alloc)
 151             {
 152               alloc <<= 1;
 153               list->parents = realloc (list->parents,
 154                                        alloc * sizeof (XdgMimeParents));
 155             }
 156           list->parents[list->n_mimes].mime = strdup (line);
 157           list->parents[list->n_mimes].parents = NULL;
 158           entry = &(list->parents[list->n_mimes]);
 159           list->n_mimes++;
 160         }
 161
 162       if (!entry->parents)
 163         {
 164           entry->n_parents = 1;
 165           entry->parents = malloc ((entry->n_parents + 1) * sizeof (char *));
 166         }
 167       else
 168         {
 169           entry->n_parents += 1;
 170           entry->parents = realloc (entry->parents,
 171                                     (entry->n_parents + 2) * sizeof (char *));
 172         }
 173       entry->parents[entry->n_parents - 1] = strdup (sep);
 174       entry->parents[entry->n_parents] = NULL;
 175     }
 176
 177   list->parents = realloc (list->parents,
 178                            list->n_mimes * sizeof (XdgMimeParents));
 179
 180   fclose (file);
 181
 182   if (list->n_mimes > 1)
 183     qsort (list->parents, list->n_mimes,
 184            sizeof (XdgMimeParents), &parent_entry_cmp);
 185 }
 186
 187
 188 void
 189 _xdg_mime_parent_list_dump (XdgParentList *list)
 190 {
 191   int i;
 192   char **p;
 193
 194   if (list->parents)
 195     {
 196       for (i = 0; i < list->n_mimes; i++)
 197         {
 198           for (p = list->parents[i].parents; *p; p++)
 199             printf ("%s %s\n", list->parents[i].mime, *p);
 200         }
 201     }
 202 }
 203
 204