Linux: update base/third_party/xdg_mime from upstream.

base/third_party/xdg_mime/xdgmimeglob.c

 /* -*- mode: C; c-file-style: "gnu" -*- */
 /* xdgmimeglob.c: Private file.  Datastructure for storing the globs.
  *
  * More info can be found at http://www.freedesktop.org/standards/
  *
  * Copyright (C) 2003  Red Hat, Inc.
  * Copyright (C) 2003  Jonathan Blandford <jrb@alum.mit.edu>
  *
  * Licensed under the Academic Free License version 2.0
  * Or under the following terms:
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the
  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  * Boston, MA 02111-1307, USA.
  */
 
 #ifdef HAVE_CONFIG_H
-#include "config.h"
+#include <config.h>
 #endif
 
 #include "xdgmimeglob.h"
 #include "xdgmimeint.h"
 #include <stdlib.h>
 #include <stdio.h>
 #include <assert.h>
 #include <string.h>
 #include <fnmatch.h>
-#include <ctype.h>
 
 #ifndef FALSE
 #define FALSE   (0)
 #endif
 
 #ifndef TRUE
 #define TRUE    (!FALSE)
 #endif
 
 typedef struct XdgGlobHashNode XdgGlobHashNode;
 typedef struct XdgGlobList XdgGlobList;
 
 struct XdgGlobHashNode
 {
   xdg_unichar_t character;
   const char *mime_type;
   int weight;
+  int case_sensitive;
   XdgGlobHashNode *next;
   XdgGlobHashNode *child;
 };
 struct XdgGlobList
 {
   const char *data;
   const char *mime_type;
   int weight;
+  int case_sensitive;
   XdgGlobList *next;
 };
 
 struct XdgGlobHash
 {
   XdgGlobList *literal_list;
   XdgGlobHashNode *simple_node;
   XdgGlobList *full_list;
 };
 
@@ skipping 29 matching lines @@
       free (ptr);
 
       ptr = next;
     }
 }
 
 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;
 
   tmp_element = glob_list;
   while (tmp_element->next != NULL)
     tmp_element = tmp_element->next;
 
   tmp_element->next = new_element;
 
   return glob_list;
@@ skipping 28 matching lines @@
   if (glob_hash_node->child)
     _xdg_glob_hash_node_dump (glob_hash_node->child, depth + 1);
   if (glob_hash_node->next)
     _xdg_glob_hash_node_dump (glob_hash_node->next, depth);
 }
 
 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;
 
   character = text[0];
 
   if ((glob_hash_node == NULL) ||
       (character < glob_hash_node->character))
     {
       node = _xdg_glob_hash_node_new ();
@@ skipping 43 matching lines @@
           node->next = prev_node->next;
           prev_node->next = node;
         }
     }
 
   text++;
   if (*text == 0)
     {
       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)
                 {
                   if (strcmp (child->mime_type, mime_type) == 0)
                     {
                       found_node = TRUE;
                       break;
                     }
                   child = child->next;
                 }
 
               if (!found_node)
                 {
                   child = _xdg_glob_hash_node_new ();
                   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;
                 }
             }
         }
       else
         {
           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;
 }
 
 /* glob must be valid UTF-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;
   int len;
 
   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;
 }
 
 typedef struct {
   const char *mime;
   int weight;
 } MimeWeight;
 
 static int
 _xdg_glob_hash_node_lookup_file_name (XdgGlobHashNode *glob_hash_node,
                                       const char      *file_name,
                                       int              len,
-                                      int              ignore_case,
+                                      int              case_sensitive_check,
                                       MimeWeight       mime_types[],
                                       int              n_mime_types)
 {
   int n;
   XdgGlobHashNode *node;
   xdg_unichar_t character;
 
   if (glob_hash_node == NULL)
     return 0;
 
   character = file_name[len - 1];
-  if (ignore_case)
-    character = tolower(character);
 
   for (node = glob_hash_node; node && character >= node->character; node = node->next)
     {
       if (character == node->character)
         {
           len--;
           n = 0;
           if (len > 0) 
             {
               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;
                   n++; 
                 }
               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;
                       n++;
                     }
                   node = node->next;
                 }
             }
           return n;
         }
     }
 
   return 0;
 }
 
 static int compare_mime_weight (const void *a, const void *b)
 {
   const MimeWeight *aa = (const MimeWeight *)a;
   const MimeWeight *bb = (const MimeWeight *)b;
 
-  return aa->weight - bb->weight;
+  return bb->weight - aa->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,
                                  const char  *mime_types[],
                                  int          n_mime_types)
 {
   XdgGlobList *list;
   int i, n;
   MimeWeight mimes[10];
   int n_mimes = 10;
   int len;
+  char *lower_case;
 
   /* First, check the literals */
 
   assert (file_name != NULL && n_mime_types > 0);
 
   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;
+        }
+    }
+
+
   len = strlen (file_name);
-  n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, file_name, len, FALSE,
+  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, file_name, len, TRUE,
                                               mimes, n_mimes);
 
   if (n == 0)
     {
       for (list = glob_hash->full_list; list && n < n_mime_types; list = list->next)
         {
           if (fnmatch ((const char *)list->data, file_name, 0) == 0)
             {
               mimes[n].mime = list->mime_type;
               mimes[n].weight = list->weight;
               n++;
             }
         }
     }
+  free (lower_case);
 
   qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight);
 
   if (n_mime_types < n)
     n = n_mime_types;
 
   for (i = 0; i < n; i++)
     mime_types[i] = mimes[i].mime;
 
   return n;
@@ skipping 62 matching lines @@
     return XDG_GLOB_SIMPLE;
   else
     return XDG_GLOB_LITERAL;
 }
 
 /* glob must be valid UTF-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;
 
   assert (glob_hash != NULL);
   assert (glob != NULL);
 
   type = _xdg_glob_determine_type (glob);
 
   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;
     }
 }
 
 void
 _xdg_glob_hash_dump (XdgGlobHash *glob_hash)
 {
   XdgGlobList *list;
   printf ("LITERAL STRINGS\n");
   if (!glob_hash || glob_hash->literal_list == NULL)
@@ skipping 23 matching lines @@
   else
     {
       for (list = glob_hash->full_list; list; list = list->next)
         printf ("    %s - %s %d\n", (char *)list->data, list->mime_type, list->weight);
     }
 }
 
 
 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");
 
   if (glob_file == NULL)
     return;
 
   /* FIXME: Not UTF-8 safe.  Doesn't work if lines are greater than 255 chars.
    * 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);
 }