GNOME.org
 

[gnome-vfs] Update to latest xdgmime updates so we get support

commit 614c30125ab8dad803ca403cc07670ca90475715
Author: Alexander Larsson <alexl redhat com>
Date:   Thu Oct 8 16:11:43 2009 +0200

    Update to latest xdgmime updates so we get support
    for the new mime.cache format

 ChangeLog                  |    9 ++
 libgnomevfs/xdgmime.c      |   13 +---
 libgnomevfs/xdgmimecache.c |  121 ++++++++++++++++++++----------
 libgnomevfs/xdgmimeglob.c  |  180 ++++++++++++++++++++++++++++++++-----------
 libgnomevfs/xdgmimeglob.h  |    6 +-
 5 files changed, 232 insertions(+), 97 deletions(-)
---
diff --git a/ChangeLog b/ChangeLog
index d9198ba..ce57fc5 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,12 @@
+2009-10-08  Alexander Larsson  <alexl redhat com>
+
+	* libgnomevfs/xdgmime.c:
+	* libgnomevfs/xdgmimecache.c:
+	* libgnomevfs/xdgmimeglob.c:
+	* libgnomevfs/xdgmimeglob.h:
+	Update to latest xdgmime updates so we get support
+	for the new mime.cache format
+
 2009-04-16  Alexander Larsson  <alexl redhat com>
 
 	Bug 500307 â?? uninitialized GnomeVFSFileInfo struct in do_seek()
diff --git a/libgnomevfs/xdgmime.c b/libgnomevfs/xdgmime.c
index 2be0f5f..d504f4f 100644
--- a/libgnomevfs/xdgmime.c
+++ b/libgnomevfs/xdgmime.c
@@ -162,7 +162,7 @@ xdg_mime_init_from_directory (const char *directory)
   strcpy (file_name, directory); strcat (file_name, "/mime/globs2");
   if (stat (file_name, &st) == 0)
     {
-      _xdg_mime_glob_read_from_file (global_hash, file_name);
+      _xdg_mime_glob_read_from_file (global_hash, file_name, TRUE);
       xdg_dir_time_list_add (file_name, st.st_mtime);
     }
   else
@@ -172,7 +172,7 @@ xdg_mime_init_from_directory (const char *directory)
       strcpy (file_name, directory); strcat (file_name, "/mime/globs");
       if (stat (file_name, &st) == 0)
         {
-          _xdg_mime_glob_read_from_file (global_hash, file_name);
+          _xdg_mime_glob_read_from_file (global_hash, file_name, FALSE);
           xdg_dir_time_list_add (file_name, st.st_mtime);
         }
       else
@@ -903,19 +903,12 @@ xdg_mime_remove_callback (int callback_id)
 const char *
 xdg_mime_get_icon (const char *mime)
 {
-  const char *icon;
-
   xdg_mime_init ();
   
   if (_caches)
     return _xdg_mime_cache_get_icon (mime);
 
-  icon = _xdg_mime_icon_list_lookup (icon_list, mime);
-
-  if (!icon)
-    icon = xdg_mime_get_generic_icon (mime);
-
-  return icon;
+  return _xdg_mime_icon_list_lookup (icon_list, mime);
 }
 
 const char *
diff --git a/libgnomevfs/xdgmimecache.c b/libgnomevfs/xdgmimecache.c
index dcc1834..6765787 100644
--- a/libgnomevfs/xdgmimecache.c
+++ b/libgnomevfs/xdgmimecache.c
@@ -72,11 +72,13 @@
 #endif
 
 #define MAJOR_VERSION 1
-#define MINOR_VERSION 1
+#define MINOR_VERSION_MIN 1
+#define MINOR_VERSION_MAX 2
 
 struct _XdgMimeCache
 {
   int ref_count;
+  int minor;
 
   size_t  size;
   char   *buffer;
@@ -115,6 +117,7 @@ _xdg_mime_cache_new_from_file (const char *file_name)
   int fd = -1;
   struct stat st;
   char *buffer = NULL;
+  int minor;
 
   /* Open the file and map it into memory */
   fd = open (file_name, O_RDONLY|_O_BINARY, 0);
@@ -130,9 +133,11 @@ _xdg_mime_cache_new_from_file (const char *file_name)
   if (buffer == MAP_FAILED)
     goto done;
 
+  minor = GET_UINT16 (buffer, 2);
   /* Verify version */
   if (GET_UINT16 (buffer, 0) != MAJOR_VERSION ||
-      GET_UINT16 (buffer, 2) != MINOR_VERSION)
+      (minor < MINOR_VERSION_MIN ||
+       minor > MINOR_VERSION_MAX))
     {
       munmap (buffer, st.st_size);
 
@@ -140,6 +145,7 @@ _xdg_mime_cache_new_from_file (const char *file_name)
     }
   
   cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
+  cache->minor = minor;
   cache->ref_count = 1;
   cache->buffer = buffer;
   cache->size = st.st_size;
@@ -167,7 +173,7 @@ cache_magic_matchlet_compare_to_data (XdgMimeCache *cache,
   
   int i, j;
 
-  for (i = range_start; i <= range_start + range_length; i++)
+  for (i = range_start; i < range_start + range_length; i++)
     {
       int valid_matchlet = TRUE;
       
@@ -354,7 +360,8 @@ typedef struct {
 static int
 cache_glob_lookup_literal (const char *file_name,
 			   const char *mime_types[],
-			   int         n_mime_types)
+			   int         n_mime_types,
+			   int         case_sensitive_check)
 {
   const char *ptr;
   int i, min, max, mid, cmp;
@@ -375,17 +382,25 @@ cache_glob_lookup_literal (const char *file_name,
 	  offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid);
 	  ptr = cache->buffer + offset;
 	  cmp = strcmp (ptr, file_name);
-	  
+
 	  if (cmp < 0)
 	    min = mid + 1;
 	  else if (cmp > 0)
 	    max = mid - 1;
 	  else
 	    {
-	      offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid + 4);
-	      mime_types[0] = (const char *)(cache->buffer + offset);
-	      
-	      return 1;
+	      int weight = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid + 8);
+	      int case_sensitive = weight & 0x100;
+	      weight = weight & 0xff;
+
+	      if (case_sensitive_check || !case_sensitive)
+		{
+		  offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * mid + 4);
+		  mime_types[0] = (const char *)(cache->buffer + offset);
+
+		  return 1;
+		}
+	      return 0;
 	    }
 	}
     }
@@ -416,6 +431,7 @@ cache_glob_lookup_fnmatch (const char *file_name,
 	  xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j);
 	  xdg_uint32_t mimetype_offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j + 4);
 	  int weight = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j + 8);
+	  weight = weight & 0xff;
 	  ptr = cache->buffer + offset;
 	  mime_type = cache->buffer + mimetype_offset;
 
@@ -439,9 +455,9 @@ static int
 cache_glob_node_lookup_suffix (XdgMimeCache  *cache,
 			       xdg_uint32_t   n_entries,
 			       xdg_uint32_t   offset,
-			       xdg_unichar_t *file_name,
+			       const char    *file_name,
 			       int            len,
-			       int            ignore_case,
+			       int            case_sensitive_check,
 			       MimeWeight     mime_types[],
 			       int            n_mime_types)
 {
@@ -451,12 +467,11 @@ cache_glob_node_lookup_suffix (XdgMimeCache  *cache,
   xdg_uint32_t n_children;
   xdg_uint32_t child_offset; 
   int weight;
+  int case_sensitive;
 
   int min, max, mid, n, i;
 
   character = file_name[len - 1];
-  if (ignore_case)
-    character = _xdg_ucs4_to_lower (character);
 
   assert (character != 0);
 
@@ -482,7 +497,7 @@ cache_glob_node_lookup_suffix (XdgMimeCache  *cache,
               n = cache_glob_node_lookup_suffix (cache, 
                                                  n_children, child_offset,
                                                  file_name, len, 
-                                                 ignore_case,
+                                                 case_sensitive_check,
                                                  mime_types,
                                                  n_mime_types);
             }
@@ -497,10 +512,15 @@ cache_glob_node_lookup_suffix (XdgMimeCache  *cache,
 
 		  mimetype_offset = GET_UINT32 (cache->buffer, child_offset + 12 * i + 4);
 		  weight = GET_UINT32 (cache->buffer, child_offset + 12 * i + 8);
+		  case_sensitive = weight & 0x100;
+		  weight = weight & 0xff;
 
-		  mime_types[n].mime = cache->buffer + mimetype_offset;
-		  mime_types[n].weight = weight;
-		  n++;
+		  if (case_sensitive_check || !case_sensitive)
+		    {
+		      mime_types[n].mime = cache->buffer + mimetype_offset;
+		      mime_types[n].weight = weight;
+		      n++;
+		    }
 		  i++;
 		}
 	    }
@@ -511,11 +531,11 @@ cache_glob_node_lookup_suffix (XdgMimeCache  *cache,
 }
 
 static int
-cache_glob_lookup_suffix (xdg_unichar_t *file_name,
-			  int            len,
-			  int            ignore_case,
-			  MimeWeight     mime_types[],
-			  int            n_mime_types)
+cache_glob_lookup_suffix (const char *file_name,
+			  int         len,
+			  int         ignore_case,
+			  MimeWeight  mime_types[],
+			  int         n_mime_types)
 {
   int i, n;
 
@@ -548,6 +568,22 @@ static int compare_mime_weight (const void *a, const void *b)
   return aa->weight - bb->weight;
 }
 
+#define ISUPPER(c)		((c) >= 'A' && (c) <= 'Z')
+static char *
+ascii_tolower (const char *str)
+{
+  char *p, *lower;
+
+  lower = strdup (str);
+  p = lower;
+  while (*p != 0)
+    {
+      char c = *p;
+      *p++ = ISUPPER (c) ? c - 'A' + 'a' : c;
+    }
+  return lower;
+}
+
 static int
 cache_glob_lookup_file_name (const char *file_name, 
 			     const char *mime_types[],
@@ -557,23 +593,37 @@ cache_glob_lookup_file_name (const char *file_name,
   MimeWeight mimes[10];
   int n_mimes = 10;
   int i;
-  xdg_unichar_t *ucs4;
   int len;
-  
+  char *lower_case;
+  int try_lower_case;
+
   assert (file_name != NULL && n_mime_types > 0);
 
   /* First, check the literals */
-  n = cache_glob_lookup_literal (file_name, mime_types, n_mime_types);
+
+  lower_case = ascii_tolower (file_name);
+
+  n = cache_glob_lookup_literal (lower_case, mime_types, n_mime_types, FALSE);
   if (n > 0)
-    return n;
+    {
+      free (lower_case);
+      return n;
+    }
 
-  ucs4 = _xdg_convert_to_ucs4 (file_name, &len);
-  n = cache_glob_lookup_suffix (ucs4, len, FALSE, mimes, n_mimes);
+  n = cache_glob_lookup_literal (file_name, mime_types, n_mime_types, TRUE);
+  if (n > 0)
+    {
+      free (lower_case);
+      return n;
+    }
 
+  len = strlen (file_name);
+  n = cache_glob_lookup_suffix (lower_case, len, FALSE, mimes, n_mimes);
   if (n == 0)
-    n = cache_glob_lookup_suffix (ucs4, len, TRUE, mimes, n_mimes);
-  free(ucs4);
-  
+    n = cache_glob_lookup_suffix (file_name, len, TRUE, mimes, n_mimes);
+
+  free (lower_case);
+
   /* Last, try fnmatch */
   if (n == 0)
     n = cache_glob_lookup_fnmatch (file_name, mimes, n_mimes);
@@ -953,14 +1003,7 @@ _xdg_mime_cache_get_generic_icon (const char *mime)
 const char *
 _xdg_mime_cache_get_icon (const char *mime)
 {
-  const char *icon;
- 
-  icon = cache_lookup_icon (mime, 32);
- 
-  if (icon == NULL)
-    icon = _xdg_mime_cache_get_generic_icon (mime);
-
-  return icon;
+  return cache_lookup_icon (mime, 32);
 }
 
 static void
diff --git a/libgnomevfs/xdgmimeglob.c b/libgnomevfs/xdgmimeglob.c
index 9aa9ad9..2a0c777 100644
--- a/libgnomevfs/xdgmimeglob.c
+++ b/libgnomevfs/xdgmimeglob.c
@@ -53,6 +53,7 @@ struct XdgGlobHashNode
   xdg_unichar_t character;
   const char *mime_type;
   int weight;
+  int case_sensitive;
   XdgGlobHashNode *next;
   XdgGlobHashNode *child;
 };
@@ -61,6 +62,7 @@ struct XdgGlobList
   const char *data;
   const char *mime_type;
   int weight;
+  int case_sensitive;
   XdgGlobList *next;
 };
 
@@ -110,15 +112,27 @@ static XdgGlobList *
 _xdg_glob_list_append (XdgGlobList *glob_list,
 		       void        *data,
 		       const char  *mime_type,
-		       int          weight)
+		       int          weight,
+		       int          case_sensitive)
 {
   XdgGlobList *new_element;
   XdgGlobList *tmp_element;
 
+  tmp_element = glob_list;
+  while (tmp_element != NULL)
+    {
+      if (strcmp (tmp_element->data, data) == 0 &&
+	  strcmp (tmp_element->mime_type, mime_type) == 0)
+	return glob_list;
+
+      tmp_element = tmp_element->next;
+    }
+
   new_element = _xdg_glob_list_new ();
   new_element->data = data;
   new_element->mime_type = mime_type;
   new_element->weight = weight;
+  new_element->case_sensitive = case_sensitive;
   if (glob_list == NULL)
     return new_element;
 
@@ -167,7 +181,8 @@ static XdgGlobHashNode *
 _xdg_glob_hash_insert_ucs4 (XdgGlobHashNode *glob_hash_node,
 			    xdg_unichar_t   *text,
 			    const char      *mime_type,
-			    int              weight)
+			    int              weight,
+			    int              case_sensitive)
 {
   XdgGlobHashNode *node;
   xdg_unichar_t character;
@@ -231,11 +246,11 @@ _xdg_glob_hash_insert_ucs4 (XdgGlobHashNode *glob_hash_node,
     {
       if (node->mime_type)
 	{
-	  if (strcmp (node->mime_type, mime_type))
+	  if (strcmp (node->mime_type, mime_type) != 0)
 	    {
 	      XdgGlobHashNode *child;
 	      int found_node = FALSE;
-	      
+
 	      child = node->child;
 	      while (child && child->character == 0)
 		{
@@ -253,6 +268,7 @@ _xdg_glob_hash_insert_ucs4 (XdgGlobHashNode *glob_hash_node,
 		  child->character = 0;
 		  child->mime_type = strdup (mime_type);
 		  child->weight = weight;
+		  child->case_sensitive = case_sensitive;
 		  child->child = NULL;
 		  child->next = node->child;
 		  node->child = child;
@@ -263,11 +279,12 @@ _xdg_glob_hash_insert_ucs4 (XdgGlobHashNode *glob_hash_node,
 	{
 	  node->mime_type = strdup (mime_type);
 	  node->weight = weight;
+	  node->case_sensitive = case_sensitive;
 	}
     }
   else
     {
-      node->child = _xdg_glob_hash_insert_ucs4 (node->child, text, mime_type, weight);
+      node->child = _xdg_glob_hash_insert_ucs4 (node->child, text, mime_type, weight, case_sensitive);
     }
   return glob_hash_node;
 }
@@ -277,7 +294,8 @@ static XdgGlobHashNode *
 _xdg_glob_hash_insert_text (XdgGlobHashNode *glob_hash_node,
 			    const char      *text,
 			    const char      *mime_type,
-			    int              weight)
+			    int              weight,
+			    int              case_sensitive)
 {
   XdgGlobHashNode *node;
   xdg_unichar_t *unitext;
@@ -285,7 +303,7 @@ _xdg_glob_hash_insert_text (XdgGlobHashNode *glob_hash_node,
 
   unitext = _xdg_convert_to_ucs4 (text, &len);
   _xdg_reverse_ucs4 (unitext, len);
-  node = _xdg_glob_hash_insert_ucs4 (glob_hash_node, unitext, mime_type, weight);
+  node = _xdg_glob_hash_insert_ucs4 (glob_hash_node, unitext, mime_type, weight, case_sensitive);
   free (unitext);
   return node;
 }
@@ -297,9 +315,9 @@ typedef struct {
 
 static int
 _xdg_glob_hash_node_lookup_file_name (XdgGlobHashNode *glob_hash_node,
-				      xdg_unichar_t   *file_name,
+				      const char      *file_name,
 				      int              len,
-				      int              ignore_case,
+				      int              case_sensitive_check,
 				      MimeWeight       mime_types[],
 				      int              n_mime_types)
 {
@@ -311,8 +329,6 @@ _xdg_glob_hash_node_lookup_file_name (XdgGlobHashNode *glob_hash_node,
     return 0;
 
   character = file_name[len - 1];
-  if (ignore_case)
-    character = _xdg_ucs4_to_lower(character);
 
   for (node = glob_hash_node; node && character >= node->character; node = node->next)
     {
@@ -325,13 +341,15 @@ _xdg_glob_hash_node_lookup_file_name (XdgGlobHashNode *glob_hash_node,
 	      n = _xdg_glob_hash_node_lookup_file_name (node->child,
 							file_name,
 							len,
-							ignore_case,
+							case_sensitive_check,
 							mime_types,
 							n_mime_types);
 	    }
 	  if (n == 0)
 	    {
-              if (node->mime_type)
+              if (node->mime_type &&
+		  (case_sensitive_check ||
+		   !node->case_sensitive))
                 {
 	          mime_types[n].mime = node->mime_type;
 		  mime_types[n].weight = node->weight;
@@ -340,7 +358,9 @@ _xdg_glob_hash_node_lookup_file_name (XdgGlobHashNode *glob_hash_node,
 	      node = node->child;
 	      while (n < n_mime_types && node && node->character == 0)
 		{
-                  if (node->mime_type)
+                  if (node->mime_type &&
+		      (case_sensitive_check ||
+		       !node->case_sensitive))
 		    {
 		      mime_types[n].mime = node->mime_type;
 		      mime_types[n].weight = node->weight;
@@ -364,6 +384,22 @@ static int compare_mime_weight (const void *a, const void *b)
   return aa->weight - bb->weight;
 }
 
+#define ISUPPER(c)		((c) >= 'A' && (c) <= 'Z')
+static char *
+ascii_tolower (const char *str)
+{
+  char *p, *lower;
+
+  lower = strdup (str);
+  p = lower;
+  while (*p != 0)
+    {
+      char c = *p;
+      *p++ = ISUPPER (c) ? c - 'A' + 'a' : c;
+    }
+  return lower;
+}
+
 int
 _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
 				 const char  *file_name,
@@ -374,8 +410,9 @@ _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
   int i, n;
   MimeWeight mimes[10];
   int n_mimes = 10;
-  xdg_unichar_t *ucs4;
   int len;
+  char *lower_case;
+  int try_lower_case;
 
   /* First, check the literals */
 
@@ -383,24 +420,37 @@ _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
 
   n = 0;
 
+  lower_case = ascii_tolower (file_name);
+
   for (list = glob_hash->literal_list; list; list = list->next)
     {
       if (strcmp ((const char *)list->data, file_name) == 0)
 	{
 	  mime_types[0] = list->mime_type;
+	  free (lower_case);
+	  return 1;
+	}
+    }
+
+  for (list = glob_hash->literal_list; list; list = list->next)
+    {
+      if (!list->case_sensitive &&
+	  strcmp ((const char *)list->data, lower_case) == 0)
+	{
+	  mime_types[0] = list->mime_type;
+	  free (lower_case);
 	  return 1;
 	}
     }
 
-  ucs4 = _xdg_convert_to_ucs4 (file_name, &len);
-  n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, ucs4, len, FALSE,
+
+  len = strlen (file_name);
+  n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, lower_case, len, FALSE,
 					    mimes, n_mimes);
   if (n == 0)
-    n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, ucs4, len, TRUE,
+    n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, file_name, len, TRUE,
 					      mimes, n_mimes);
-  free(ucs4);
 
-  /* FIXME: Not UTF-8 safe */
   if (n == 0)
     {
       for (list = glob_hash->full_list; list && n < n_mime_types; list = list->next)
@@ -413,6 +463,7 @@ _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
 	    }
         }
     }
+  free (lower_case);
 
   qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight);
 
@@ -495,7 +546,8 @@ void
 _xdg_glob_hash_append_glob (XdgGlobHash *glob_hash,
 			    const char  *glob,
 			    const char  *mime_type,
-			    int          weight)
+			    int          weight,
+			    int          case_sensitive)
 {
   XdgGlobType type;
 
@@ -507,13 +559,13 @@ _xdg_glob_hash_append_glob (XdgGlobHash *glob_hash,
   switch (type)
     {
     case XDG_GLOB_LITERAL:
-      glob_hash->literal_list = _xdg_glob_list_append (glob_hash->literal_list, strdup (glob), strdup (mime_type), weight);
+      glob_hash->literal_list = _xdg_glob_list_append (glob_hash->literal_list, strdup (glob), strdup (mime_type), weight, case_sensitive);
       break;
     case XDG_GLOB_SIMPLE:
-      glob_hash->simple_node = _xdg_glob_hash_insert_text (glob_hash->simple_node, glob + 1, mime_type, weight);
+      glob_hash->simple_node = _xdg_glob_hash_insert_text (glob_hash->simple_node, glob + 1, mime_type, weight, case_sensitive);
       break;
     case XDG_GLOB_FULL:
-      glob_hash->full_list = _xdg_glob_list_append (glob_hash->full_list, strdup (glob), strdup (mime_type), weight);
+      glob_hash->full_list = _xdg_glob_list_append (glob_hash->full_list, strdup (glob), strdup (mime_type), weight, case_sensitive);
       break;
     }
 }
@@ -557,10 +609,12 @@ _xdg_glob_hash_dump (XdgGlobHash *glob_hash)
 
 void
 _xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash,
-			       const char  *file_name)
+			       const char  *file_name,
+			       int          version_two)
 {
   FILE *glob_file;
   char line[255];
+  char *p;
 
   glob_file = fopen (file_name, "r");
 
@@ -571,33 +625,67 @@ _xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash,
    * Blah */
   while (fgets (line, 255, glob_file) != NULL)
     {
-      char *colon, *colon2;
-      char *mimetype, *glob;
+      char *colon;
+      char *mimetype, *glob, *end;
       int weight;
+      int case_sensitive;
 
-      if (line[0] == '#')
+      if (line[0] == '#' || line[0] == 0)
 	continue;
 
-      colon = strchr (line, ':');
+      end = line + strlen(line) - 1;
+      if (*end == '\n')
+	*end = 0;
+
+      p = line;
+      if (version_two)
+	{
+	  colon = strchr (p, ':');
+	  if (colon == NULL)
+	    continue;
+	  *colon = 0;
+          weight = atoi (p);
+	  p = colon + 1;
+	}
+      else
+	weight = 50;
+
+      colon = strchr (p, ':');
       if (colon == NULL)
 	continue;
-      *(colon++) = '\0';
-      colon[strlen (colon) -1] = '\0';
-      colon2 = strchr (colon, ':');
-      if (colon2) 
-        {
-          *(colon2++) = '\000';
-          weight = atoi (line);
-          mimetype = colon;
-          glob = colon2;
-        }
-      else 
-        {
-          weight = 50;
-          mimetype = line;
-          glob = colon;
-        }
-      _xdg_glob_hash_append_glob (glob_hash, glob, mimetype, weight);
+      *colon = 0;
+
+      mimetype = p;
+      p = colon + 1;
+      glob = p;
+      case_sensitive = FALSE;
+
+      colon = strchr (p, ':');
+      if (version_two && colon != NULL)
+	{
+	  char *flag;
+
+	  /* We got flags */
+	  *colon = 0;
+	  p = colon + 1;
+
+	  /* Flags end at next colon */
+	  colon = strchr (p, ':');
+	  if (colon != NULL)
+	    *colon = 0;
+
+	  flag = strstr (p, "cs");
+	  if (flag != NULL &&
+	      /* Start or after comma */
+	      (flag == p ||
+	       flag[-1] == ',') &&
+	      /* ends with comma or end of string */
+	      (flag[2] == 0 ||
+	       flag[2] == ','))
+	    case_sensitive = TRUE;
+	}
+
+      _xdg_glob_hash_append_glob (glob_hash, glob, mimetype, weight, case_sensitive);
     }
 
   fclose (glob_file);
diff --git a/libgnomevfs/xdgmimeglob.h b/libgnomevfs/xdgmimeglob.h
index df8dc79..0018292 100644
--- a/libgnomevfs/xdgmimeglob.h
+++ b/libgnomevfs/xdgmimeglob.h
@@ -51,7 +51,8 @@ typedef enum
 #endif
 
 void         _xdg_mime_glob_read_from_file   (XdgGlobHash *glob_hash,
-					      const char  *file_name);
+					      const char  *file_name,
+					      int          version_two);
 XdgGlobHash *_xdg_glob_hash_new              (void);
 void         _xdg_glob_hash_free             (XdgGlobHash *glob_hash);
 int          _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
@@ -61,7 +62,8 @@ int          _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
 void         _xdg_glob_hash_append_glob      (XdgGlobHash *glob_hash,
 					      const char  *glob,
 					      const char  *mime_type,
-					      int          weight);
+					      int          weight,
+					      int          case_sensitive);
 XdgGlobType  _xdg_glob_determine_type        (const char  *glob);
 void         _xdg_glob_hash_dump             (XdgGlobHash *glob_hash);
[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]