xdgmimeglob.h File Reference

Go to the source code of this file.

Typedefs
typedef struct XdgGlobHash	XdgGlobHash

Enumerations
enum	XdgGlobType { XDG_GLOB_LITERAL , XDG_GLOB_SIMPLE , XDG_GLOB_FULL }

Functions
void	_xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash, 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, const char *text, const char *mime_types[], int n_mime_types)
void	_xdg_glob_hash_append_glob (XdgGlobHash *glob_hash, const char *glob, const char *mime_type, int weight, int case_sensitive)
XdgGlobType	_xdg_glob_determine_type (const char *glob)
void	_xdg_glob_hash_dump (XdgGlobHash *glob_hash)

Typedef Documentation

XdgGlobHash

typedef struct XdgGlobHash XdgGlobHash

Definition at line 33 of file xdgmimeglob.h.

Enumeration Type Documentation

XdgGlobType

enum XdgGlobType

Enumerator
XDG_GLOB_LITERAL
XDG_GLOB_SIMPLE
XDG_GLOB_FULL

Definition at line 35 of file xdgmimeglob.h.

{
  XDG_GLOB_LITERAL, /* Makefile */
  XDG_GLOB_SIMPLE,  /* *.gif */
  XDG_GLOB_FULL     /* x*.[ch] */
} XdgGlobType;

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 *	text,
		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().