xdgmimeglob.c File Reference

Go to the source code of this file.

Data Structures
struct	XdgGlobHashNode
struct	XdgGlobList
struct	XdgGlobHash
struct	MimeWeight

Typedefs
typedef struct XdgGlobHashNode	XdgGlobHashNode
typedef struct XdgGlobList	XdgGlobList

Functions
int	_xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash, const char *file_name, const char *mime_types[], int n_mime_types)
XdgGlobHash *	_xdg_glob_hash_new (void)
void	_xdg_glob_hash_free (XdgGlobHash *glob_hash)
XdgGlobType	_xdg_glob_determine_type (const char *glob)
void	_xdg_glob_hash_append_glob (XdgGlobHash *glob_hash, const char *glob, const char *mime_type, int weight, int case_sensitive)
void	_xdg_glob_hash_dump (XdgGlobHash *glob_hash)
void	_xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash, const char *file_name, int version_two)

Typedef Documentation

XdgGlobHashNode

typedef struct XdgGlobHashNode XdgGlobHashNode

Definition at line 48 of file xdgmimeglob.c.

XdgGlobList

typedef struct XdgGlobList XdgGlobList

Definition at line 49 of file xdgmimeglob.c.

Function Documentation

_xdg_glob_determine_type()

XdgGlobType _xdg_glob_determine_type

(

const char *

glob

)

Definition at line 519 of file xdgmimeglob.c.

{
  const char *ptr;
  int maybe_in_simple_glob = FALSE;
  int first_char = TRUE;
 
  ptr = glob;
 
  while (*ptr != '\0')
    {
      if (*ptr == '*' && first_char)
    maybe_in_simple_glob = TRUE;
      else if (*ptr == '\\' || *ptr == '[' || *ptr == '?' || *ptr == '*')
      return XDG_GLOB_FULL;
 
      first_char = FALSE;
      ptr = _xdg_utf8_next_char (ptr);
    }
  if (maybe_in_simple_glob)
    return XDG_GLOB_SIMPLE;
  else
    return XDG_GLOB_LITERAL;
}

References XDG_GLOB_FULL, XDG_GLOB_LITERAL, and XDG_GLOB_SIMPLE.

Referenced by _xdg_glob_hash_append_glob().

_xdg_glob_hash_append_glob()

void _xdg_glob_hash_append_glob	(	XdgGlobHash *	glob_hash,
		const char *	glob,
		const char *	mime_type,
		int	weight,
		int	case_sensitive
	)

Definition at line 545 of file xdgmimeglob.c.

{
  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, 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, 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, case_sensitive);
      break;
    }
}

References _xdg_glob_determine_type(), XdgGlobHash::full_list, XdgGlobHash::literal_list, XdgGlobHash::simple_node, XDG_GLOB_FULL, XDG_GLOB_LITERAL, and XDG_GLOB_SIMPLE.

Referenced by _xdg_mime_glob_read_from_file().

_xdg_glob_hash_dump()

void _xdg_glob_hash_dump

(

XdgGlobHash *

glob_hash

)

Definition at line 573 of file xdgmimeglob.c.

{
  XdgGlobList *list;
  printf ("LITERAL STRINGS\n");
  if (!glob_hash || glob_hash->literal_list == NULL)
    {
      printf ("    None\n");
    }
  else
    {
      for (list = glob_hash->literal_list; list; list = list->next)
    printf ("    %s - %s %d\n", (char *)list->data, list->mime_type, list->weight);
    }
  printf ("\nSIMPLE GLOBS\n");
  if (!glob_hash || glob_hash->simple_node == NULL)
    {
      printf ("    None\n");
    }
  else
    {
      _xdg_glob_hash_node_dump (glob_hash->simple_node, 4);
    }
 
  printf ("\nFULL GLOBS\n");
  if (!glob_hash || glob_hash->full_list == NULL)
    {
      printf ("    None\n");
    }
  else
    {
      for (list = glob_hash->full_list; list; list = list->next)
    printf ("    %s - %s %d\n", (char *)list->data, list->mime_type, list->weight);
    }
}

References XdgGlobList::data, XdgGlobHash::full_list, XdgGlobHash::literal_list, XdgGlobList::mime_type, XdgGlobList::next, XdgGlobHash::simple_node, and XdgGlobList::weight.

Referenced by xdg_mime_dump().

_xdg_glob_hash_free()

void _xdg_glob_hash_free

(

XdgGlobHash *

glob_hash

)

Definition at line 510 of file xdgmimeglob.c.

{
  _xdg_glob_list_free (glob_hash->literal_list);
  _xdg_glob_list_free (glob_hash->full_list);
  _xdg_glob_hash_free_nodes (glob_hash->simple_node);
  free (glob_hash);
}

References XdgGlobHash::full_list, XdgGlobHash::literal_list, and XdgGlobHash::simple_node.

Referenced by xdg_mime_shutdown().

_xdg_glob_hash_lookup_file_name()

int _xdg_glob_hash_lookup_file_name	(	XdgGlobHash *	glob_hash,
		const char *	file_name,
		const char *	mime_types[],
		int	n_mime_types
	)

Definition at line 404 of file xdgmimeglob.c.

{
  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, 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;
}

References XdgGlobList::case_sensitive, XdgGlobList::data, XdgGlobHash::full_list, XdgGlobHash::literal_list, MimeWeight::mime, XdgGlobList::mime_type, XdgGlobList::next, XdgGlobHash::simple_node, MimeWeight::weight, and XdgGlobList::weight.

Referenced by xdg_mime_get_mime_type_for_file(), xdg_mime_get_mime_type_from_file_name(), and xdg_mime_get_mime_types_from_file_name().

_xdg_glob_hash_new()

XdgGlobHash * _xdg_glob_hash_new

(

void

)

Definition at line 484 of file xdgmimeglob.c.

{
  XdgGlobHash *glob_hash;
 
  glob_hash = calloc (1, sizeof (XdgGlobHash));
 
  return glob_hash;
}

_xdg_mime_glob_read_from_file()

void _xdg_mime_glob_read_from_file	(	XdgGlobHash *	glob_hash,
		const char *	file_name,
		int	version_two
	)

Definition at line 610 of file xdgmimeglob.c.

{
  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;
      char *mimetype, *glob, *end;
      int weight;
      int case_sensitive;
 
      if (line[0] == '#' || line[0] == 0)
    continue;
 
      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;
 
      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);
}

References _xdg_glob_hash_append_glob().