luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-01-27 14:36:16 +01:00
Code Issues Packages Projects Releases Wiki Activity

Update gio/xdgmime with commit 722325f of xdgmime project

Browse Source
This commit is contained in:
Emmanuel Fleury 2021-04-05 15:46:22 +02:00
parent 1176835ce3
commit 3d2ac608de
16 changed files with 269 additions and 475 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
gio/xdgmime/xdgmime.c
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,10 +20,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#include "config.h" #ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "xdgmime.h" #include "xdgmime.h"
#include "xdgmimeint.h" #include "xdgmimeint.h"
@ -56,8 +60,6 @@ static XdgCallbackList *callback_list = NULL;
static XdgIconList *icon_list = NULL; static XdgIconList *icon_list = NULL;
static XdgIconList *generic_icon_list = NULL; static XdgIconList *generic_icon_list = NULL;
static char **xdg_dirs = NULL; /* NULL terminated */
XdgMimeCache **_caches = NULL; XdgMimeCache **_caches = NULL;
static int n_caches = 0; static int n_caches = 0;
@ -141,8 +143,8 @@ xdg_mime_init_from_directory (const char *directory)
assert (directory != NULL); assert (directory != NULL);
file_name = malloc (strlen (directory) + strlen ("/mime.cache") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/mime.cache") + 1);
strcpy (file_name, directory); strcat (file_name, "/mime.cache"); strcpy (file_name, directory); strcat (file_name, "/mime/mime.cache");
if (stat (file_name, &st) == 0) if (stat (file_name, &st) == 0)
{ {
XdgMimeCache *cache = _xdg_mime_cache_new_from_file (file_name); XdgMimeCache *cache = _xdg_mime_cache_new_from_file (file_name);
@ -161,8 +163,8 @@ xdg_mime_init_from_directory (const char *directory)
} }
free (file_name); free (file_name);
file_name = malloc (strlen (directory) + strlen ("/globs2") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/globs2") + 1);
strcpy (file_name, directory); strcat (file_name, "/globs2"); strcpy (file_name, directory); strcat (file_name, "/mime/globs2");
if (stat (file_name, &st) == 0) if (stat (file_name, &st) == 0)
{ {
_xdg_mime_glob_read_from_file (global_hash, file_name, TRUE); _xdg_mime_glob_read_from_file (global_hash, file_name, TRUE);
@ -171,8 +173,8 @@ xdg_mime_init_from_directory (const char *directory)
else else
{ {
free (file_name); free (file_name);
file_name = malloc (strlen (directory) + strlen ("/globs") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/globs") + 1);
strcpy (file_name, directory); strcat (file_name, "/globs"); strcpy (file_name, directory); strcat (file_name, "/mime/globs");
if (stat (file_name, &st) == 0) if (stat (file_name, &st) == 0)
{ {
_xdg_mime_glob_read_from_file (global_hash, file_name, FALSE); _xdg_mime_glob_read_from_file (global_hash, file_name, FALSE);
@ -184,8 +186,8 @@ xdg_mime_init_from_directory (const char *directory)
} }
} }
file_name = malloc (strlen (directory) + strlen ("/magic") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/magic") + 1);
strcpy (file_name, directory); strcat (file_name, "/magic"); strcpy (file_name, directory); strcat (file_name, "/mime/magic");
if (stat (file_name, &st) == 0) if (stat (file_name, &st) == 0)
{ {
_xdg_mime_magic_read_from_file (global_magic, file_name); _xdg_mime_magic_read_from_file (global_magic, file_name);
@ -196,81 +198,69 @@ xdg_mime_init_from_directory (const char *directory)
free (file_name); free (file_name);
} }
file_name = malloc (strlen (directory) + strlen ("/aliases") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/aliases") + 1);
strcpy (file_name, directory); strcat (file_name, "/aliases"); strcpy (file_name, directory); strcat (file_name, "/mime/aliases");
_xdg_mime_alias_read_from_file (alias_list, file_name); _xdg_mime_alias_read_from_file (alias_list, file_name);
free (file_name); free (file_name);
file_name = malloc (strlen (directory) + strlen ("/subclasses") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/subclasses") + 1);
strcpy (file_name, directory); strcat (file_name, "/subclasses"); strcpy (file_name, directory); strcat (file_name, "/mime/subclasses");
_xdg_mime_parent_read_from_file (parent_list, file_name); _xdg_mime_parent_read_from_file (parent_list, file_name);
free (file_name); free (file_name);
file_name = malloc (strlen (directory) + strlen ("/icons") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/icons") + 1);
strcpy (file_name, directory); strcat (file_name, "/icons"); strcpy (file_name, directory); strcat (file_name, "/mime/icons");
_xdg_mime_icon_read_from_file (icon_list, file_name); _xdg_mime_icon_read_from_file (icon_list, file_name);
free (file_name); free (file_name);
file_name = malloc (strlen (directory) + strlen ("/generic-icons") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/generic-icons") + 1);
strcpy (file_name, directory); strcat (file_name, "/generic-icons"); strcpy (file_name, directory); strcat (file_name, "/mime/generic-icons");
_xdg_mime_icon_read_from_file (generic_icon_list, file_name); _xdg_mime_icon_read_from_file (generic_icon_list, file_name);
free (file_name); free (file_name);
return FALSE; /* Keep processing */ return FALSE; /* Keep processing */
} }
/* Set @xdg_dirs from the environment. It must not have been set already. */ /* Runs a command on all the directories in the search path */
static void static void
xdg_init_dirs (void) xdg_run_command_on_dirs (XdgDirectoryFunc func,
void *user_data)
{ {
const char *xdg_data_home, *home, *xdg_data_dirs; const char *xdg_data_home;
const char *xdg_data_dirs;
const char *ptr; const char *ptr;
size_t n_dirs = 0;
size_t i, current_dir;
assert (xdg_dirs == NULL);
xdg_data_home = getenv ("XDG_DATA_HOME"); xdg_data_home = getenv ("XDG_DATA_HOME");
home = getenv ("HOME"); if (xdg_data_home)
xdg_data_dirs = getenv ("XDG_DATA_DIRS"); {
if ((func) (xdg_data_home, user_data))
return;
}
else
{
const char *home;
home = getenv ("HOME");
if (home != NULL)
{
char *guessed_xdg_home;
int stop_processing;
guessed_xdg_home = malloc (strlen (home) + strlen ("/.local/share/") + 1);
strcpy (guessed_xdg_home, home);
strcat (guessed_xdg_home, "/.local/share/");
stop_processing = (func) (guessed_xdg_home, user_data);
free (guessed_xdg_home);
if (stop_processing)
return;
}
}
xdg_data_dirs = getenv ("XDG_DATA_DIRS");
if (xdg_data_dirs == NULL) if (xdg_data_dirs == NULL)
xdg_data_dirs = "/usr/local/share/:/usr/share/"; xdg_data_dirs = "/usr/local/share/:/usr/share/";
/* Work out how many dirs we’re dealing with. */
if (xdg_data_home != NULL || home != NULL)
n_dirs++;
n_dirs++; /* initial entry in @xdg_data_dirs */
for (i = 0; xdg_data_dirs[i] != '\0'; i++)
if (xdg_data_dirs[i] == ':')
n_dirs++;
xdg_dirs = calloc (n_dirs + 1 /* NULL terminator */, sizeof (char *));
current_dir = 0;
/* $XDG_DATA_HOME */
if (xdg_data_home != NULL)
{
char *mime_subdir;
mime_subdir = malloc (strlen (xdg_data_home) + strlen ("/mime/") + 1);
strcpy (mime_subdir, xdg_data_home);
strcat (mime_subdir, "/mime/");
xdg_dirs[current_dir++] = mime_subdir;
}
else if (home != NULL)
{
char *guessed_xdg_home;
guessed_xdg_home = malloc (strlen (home) + strlen ("/.local/share/mime/") + 1);
strcpy (guessed_xdg_home, home);
strcat (guessed_xdg_home, "/.local/share/mime/");
xdg_dirs[current_dir++] = guessed_xdg_home;
}
/* $XDG_DATA_DIRS */
ptr = xdg_data_dirs; ptr = xdg_data_dirs;
while (*ptr != '\000') while (*ptr != '\000')
@ -278,6 +268,7 @@ xdg_init_dirs (void)
const char *end_ptr; const char *end_ptr;
char *dir; char *dir;
int len; int len;
int stop_processing;
end_ptr = ptr; end_ptr = ptr;
while (*end_ptr != ':' && *end_ptr != '\000') while (*end_ptr != ':' && *end_ptr != '\000')
@ -293,68 +284,17 @@ xdg_init_dirs (void)
len = end_ptr - ptr; len = end_ptr - ptr;
else else
len = end_ptr - ptr + 1; len = end_ptr - ptr + 1;
dir = malloc (len + strlen ("/mime/") + 1); dir = malloc (len + 1);
strncpy (dir, ptr, len); strncpy (dir, ptr, len);
dir[len] = '\0'; dir[len] = '\0';
strcat (dir, "/mime/"); stop_processing = (func) (dir, user_data);
free (dir);
xdg_dirs[current_dir++] = dir; if (stop_processing)
return;
ptr = end_ptr; ptr = end_ptr;
} }
/* NULL terminator */
xdg_dirs[current_dir] = NULL;
need_reread = TRUE;
}
/* Runs a command on all the directories in the search path (@xdg_dirs). */
static void
xdg_run_command_on_dirs (XdgDirectoryFunc func,
void *user_data)
{
size_t i;
if (xdg_dirs == NULL)
xdg_init_dirs ();
for (i = 0; xdg_dirs[i] != NULL; i++)
{
if ((func) (xdg_dirs[i], user_data))
return;
}
}
/* Allows the calling code to override the directories used by xdgmime, without
* having to change environment variables in a running process (which is not
* thread safe). This is intended to be used by tests. The changes will be
* picked up by xdg_mime_init() next time public API is called.
*
* This will set @xdg_dirs. Directories in @dirs must be complete, including
* the conventional `/mime` subdirectory. This is to allow tests to override
* them without the need to create a subdirectory. */
void
xdg_mime_set_dirs (const char * const *dirs)
{
size_t i;
for (i = 0; xdg_dirs != NULL && xdg_dirs[i] != NULL; i++)
free (xdg_dirs[i]);
if (xdg_dirs != NULL)
free (xdg_dirs[i]);
xdg_dirs = NULL;
if (dirs != NULL)
{
for (i = 0; dirs[i] != NULL; i++);
xdg_dirs = calloc (i + 1 /* NULL terminator */, sizeof (char*));
for (i = 0; dirs[i] != NULL; i++)
xdg_dirs[i] = strdup (dirs[i]);
xdg_dirs[i] = NULL;
}
need_reread = TRUE;
} }
/* Checks file_path to make sure it has the same mtime as last time it was /* Checks file_path to make sure it has the same mtime as last time it was
@ -408,8 +348,8 @@ xdg_check_dir (const char *directory,
assert (directory != NULL); assert (directory != NULL);
/* Check the mime.cache file */ /* Check the mime.cache file */
file_name = malloc (strlen (directory) + strlen ("/mime.cache") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/mime.cache") + 1);
strcpy (file_name, directory); strcat (file_name, "/mime.cache"); strcpy (file_name, directory); strcat (file_name, "/mime/mime.cache");
invalid = xdg_check_file (file_name, &exists); invalid = xdg_check_file (file_name, &exists);
free (file_name); free (file_name);
if (invalid) if (invalid)
@ -423,8 +363,8 @@ xdg_check_dir (const char *directory,
} }
/* Check the globs file */ /* Check the globs file */
file_name = malloc (strlen (directory) + strlen ("/globs") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/globs") + 1);
strcpy (file_name, directory); strcat (file_name, "/globs"); strcpy (file_name, directory); strcat (file_name, "/mime/globs");
invalid = xdg_check_file (file_name, NULL); invalid = xdg_check_file (file_name, NULL);
free (file_name); free (file_name);
if (invalid) if (invalid)
@ -434,8 +374,8 @@ xdg_check_dir (const char *directory,
} }
/* Check the magic file */ /* Check the magic file */
file_name = malloc (strlen (directory) + strlen ("/magic") + 1); file_name = malloc (strlen (directory) + strlen ("/mime/magic") + 1);
strcpy (file_name, directory); strcat (file_name, "/magic"); strcpy (file_name, directory); strcat (file_name, "/mime/magic");
invalid = xdg_check_file (file_name, NULL); invalid = xdg_check_file (file_name, NULL);
free (file_name); free (file_name);
if (invalid) if (invalid)
@ -549,8 +489,6 @@ xdg_mime_get_mime_type_for_data (const void *data,
return _xdg_binary_or_text_fallback(data, len); return _xdg_binary_or_text_fallback(data, len);
} }
#ifdef NOT_USED_IN_GIO
const char * const char *
xdg_mime_get_mime_type_for_file (const char *file_name, xdg_mime_get_mime_type_for_file (const char *file_name,
struct stat *statbuf) struct stat *statbuf)
@ -621,13 +559,13 @@ xdg_mime_get_mime_type_for_file (const char *file_name,
mime_type = _xdg_mime_magic_lookup_data (global_magic, data, bytes_read, NULL, mime_type = _xdg_mime_magic_lookup_data (global_magic, data, bytes_read, NULL,
mime_types, n); mime_types, n);
if (!mime_type)
mime_type = _xdg_binary_or_text_fallback (data, bytes_read);
free (data); free (data);
fclose (file); fclose (file);
if (mime_type)
return mime_type; return mime_type;
return _xdg_binary_or_text_fallback(data, bytes_read);
} }
const char * const char *
@ -646,8 +584,6 @@ xdg_mime_get_mime_type_from_file_name (const char *file_name)
return XDG_MIME_TYPE_UNKNOWN; return XDG_MIME_TYPE_UNKNOWN;
} }
#endif
int int
xdg_mime_get_mime_types_from_file_name (const char *file_name, xdg_mime_get_mime_types_from_file_name (const char *file_name,
const char *mime_types[], const char *mime_types[],
@ -661,8 +597,6 @@ xdg_mime_get_mime_types_from_file_name (const char *file_name,
return _xdg_glob_hash_lookup_file_name (global_hash, file_name, mime_types, n_mime_types); return _xdg_glob_hash_lookup_file_name (global_hash, file_name, mime_types, n_mime_types);
} }
#ifdef NOT_USED_IN_GIO
int int
xdg_mime_is_valid_mime_type (const char *mime_type) xdg_mime_is_valid_mime_type (const char *mime_type)
{ {
@ -671,8 +605,6 @@ xdg_mime_is_valid_mime_type (const char *mime_type)
return _xdg_utf8_validate (mime_type); return _xdg_utf8_validate (mime_type);
} }
#endif
void void
xdg_mime_shutdown (void) xdg_mime_shutdown (void)
{ {
@ -888,19 +820,14 @@ xdg_mime_mime_type_subclass (const char *mime,
char ** char **
xdg_mime_list_mime_parents (const char *mime) xdg_mime_list_mime_parents (const char *mime)
{ {
const char *umime;
const char **parents; const char **parents;
char **result; char **result;
int i, n; int i, n;
xdg_mime_init ();
if (_caches) if (_caches)
return _xdg_mime_cache_list_mime_parents (mime); return _xdg_mime_cache_list_mime_parents (mime);
umime = _xdg_mime_unalias_mime_type (mime); parents = xdg_mime_get_mime_parents (mime);
parents = _xdg_mime_parent_list_lookup (parent_list, umime);
if (!parents) if (!parents)
return NULL; return NULL;
@ -914,8 +841,6 @@ xdg_mime_list_mime_parents (const char *mime)
return result; return result;
} }
#ifdef NOT_USED_IN_GIO
const char ** const char **
xdg_mime_get_mime_parents (const char *mime) xdg_mime_get_mime_parents (const char *mime)
{ {
@ -945,7 +870,6 @@ xdg_mime_dump (void)
_xdg_mime_cache_glob_dump (); _xdg_mime_cache_glob_dump ();
} }
#endif
/* Registers a function to be called every time the mime database reloads its files /* Registers a function to be called every time the mime database reloads its files
*/ */
@ -973,8 +897,6 @@ xdg_mime_register_reload_callback (XdgMimeCallback callback,
return callback_id - 1; return callback_id - 1;
} }
#ifdef NOT_USED_IN_GIO
void void
xdg_mime_remove_callback (int callback_id) xdg_mime_remove_callback (int callback_id)
{ {
@ -1000,8 +922,6 @@ xdg_mime_remove_callback (int callback_id)
} }
} }
#endif
const char * const char *
xdg_mime_get_icon (const char *mime) xdg_mime_get_icon (const char *mime)
{ {

20
gio/xdgmime/xdgmime.h
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,7 +20,9 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
@ -71,8 +73,8 @@ typedef void (*XdgMimeDestroy) (void *user_data);
#define xdg_mime_get_icon XDG_ENTRY(get_icon) #define xdg_mime_get_icon XDG_ENTRY(get_icon)
#define xdg_mime_get_generic_icon XDG_ENTRY(get_generic_icon) #define xdg_mime_get_generic_icon XDG_ENTRY(get_generic_icon)
#define _xdg_mime_mime_type_subclass XDG_RESERVED_ENTRY(mime_type_subclass)
#define _xdg_mime_mime_type_equal XDG_RESERVED_ENTRY(mime_type_equal) #define _xdg_mime_mime_type_equal XDG_RESERVED_ENTRY(mime_type_equal)
#define _xdg_mime_mime_type_subclass XDG_RESERVED_ENTRY(mime_type_subclass)
#define _xdg_mime_unalias_mime_type XDG_RESERVED_ENTRY(unalias_mime_type) #define _xdg_mime_unalias_mime_type XDG_RESERVED_ENTRY(unalias_mime_type)
#endif #endif
@ -86,17 +88,13 @@ extern const char xdg_mime_type_textplain[];
const char *xdg_mime_get_mime_type_for_data (const void *data, const char *xdg_mime_get_mime_type_for_data (const void *data,
size_t len, size_t len,
int *result_prio); int *result_prio);
#ifdef NOT_USED_IN_GIO
const char *xdg_mime_get_mime_type_for_file (const char *file_name, const char *xdg_mime_get_mime_type_for_file (const char *file_name,
struct stat *statbuf); struct stat *statbuf);
const char *xdg_mime_get_mime_type_from_file_name (const char *file_name); const char *xdg_mime_get_mime_type_from_file_name (const char *file_name);
#endif
int xdg_mime_get_mime_types_from_file_name(const char *file_name, int xdg_mime_get_mime_types_from_file_name(const char *file_name,
const char *mime_types[], const char *mime_types[],
int n_mime_types); int n_mime_types);
#ifdef NOT_USED_IN_GIO
int xdg_mime_is_valid_mime_type (const char *mime_type); int xdg_mime_is_valid_mime_type (const char *mime_type);
#endif
int xdg_mime_mime_type_equal (const char *mime_a, int xdg_mime_mime_type_equal (const char *mime_a,
const char *mime_b); const char *mime_b);
int xdg_mime_media_type_equal (const char *mime_a, int xdg_mime_media_type_equal (const char *mime_a,
@ -108,26 +106,18 @@ int xdg_mime_mime_type_subclass (const char *mime_a,
* instead, but notice that that function expects you to free * instead, but notice that that function expects you to free
* the array it returns. * the array it returns.
*/ */
#ifdef NOT_USED_IN_GIO
const char **xdg_mime_get_mime_parents (const char *mime); const char **xdg_mime_get_mime_parents (const char *mime);
#endif
char ** xdg_mime_list_mime_parents (const char *mime); char ** xdg_mime_list_mime_parents (const char *mime);
const char *xdg_mime_unalias_mime_type (const char *mime); const char *xdg_mime_unalias_mime_type (const char *mime);
const char *xdg_mime_get_icon (const char *mime); const char *xdg_mime_get_icon (const char *mime);
const char *xdg_mime_get_generic_icon (const char *mime); const char *xdg_mime_get_generic_icon (const char *mime);
int xdg_mime_get_max_buffer_extents (void); int xdg_mime_get_max_buffer_extents (void);
void xdg_mime_shutdown (void); void xdg_mime_shutdown (void);
#ifdef NOT_USED_IN_GIO
void xdg_mime_dump (void); void xdg_mime_dump (void);
#endif
int xdg_mime_register_reload_callback (XdgMimeCallback callback, int xdg_mime_register_reload_callback (XdgMimeCallback callback,
void *data, void *data,
XdgMimeDestroy destroy); XdgMimeDestroy destroy);
#ifdef NOT_USED_IN_GIO
void xdg_mime_remove_callback (int callback_id); void xdg_mime_remove_callback (int callback_id);
#endif
void xdg_mime_set_dirs (const char * const *dirs);
/* Private versions of functions that don't call xdg_mime_init () */ /* Private versions of functions that don't call xdg_mime_init () */
int _xdg_mime_mime_type_equal (const char *mime_a, int _xdg_mime_mime_type_equal (const char *mime_a,

14
gio/xdgmime/xdgmimealias.c
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,10 +20,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#include "config.h" #ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "xdgmimealias.h" #include "xdgmimealias.h"
#include "xdgmimeint.h" #include "xdgmimeint.h"
@ -161,8 +165,6 @@ _xdg_mime_alias_read_from_file (XdgAliasList *list,
} }
#ifdef NOT_USED_IN_GIO
void void
_xdg_mime_alias_list_dump (XdgAliasList *list) _xdg_mime_alias_list_dump (XdgAliasList *list)
{ {
@ -179,4 +181,4 @@ _xdg_mime_alias_list_dump (XdgAliasList *list)
} }
} }
#endif

9
gio/xdgmime/xdgmimealias.h
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,7 +20,9 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#ifndef __XDG_MIME_ALIAS_H__ #ifndef __XDG_MIME_ALIAS_H__
@ -44,7 +46,6 @@ XdgAliasList *_xdg_mime_alias_list_new (void);
void _xdg_mime_alias_list_free (XdgAliasList *list); void _xdg_mime_alias_list_free (XdgAliasList *list);
const char *_xdg_mime_alias_list_lookup (XdgAliasList *list, const char *_xdg_mime_alias_list_lookup (XdgAliasList *list,
const char *alias); const char *alias);
#ifdef NOT_USED_IN_GIO
void _xdg_mime_alias_list_dump (XdgAliasList *list); void _xdg_mime_alias_list_dump (XdgAliasList *list);
#endif
#endif /* __XDG_MIME_ALIAS_H__ */ #endif /* __XDG_MIME_ALIAS_H__ */

259
gio/xdgmime/xdgmimecache.c
View File

@ -11,7 +11,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -19,10 +19,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#include "config.h" #ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
@ -39,7 +43,7 @@
#ifdef HAVE_MMAP #ifdef HAVE_MMAP
#include <sys/mman.h> #include <sys/mman.h>
#else #else
#warning Building xdgmime without MMAP support. Binary "mime.info" cache files will not be used. #warning Building xdgmime without MMAP support. Binary "mime.cache" files will not be used.
#endif #endif
#include <sys/stat.h> #include <sys/stat.h>
@ -117,9 +121,9 @@ _xdg_mime_cache_new_from_file (const char *file_name)
int minor; int minor;
/* Open the file and map it into memory */ /* Open the file and map it into memory */
do do {
fd = open (file_name, O_RDONLY|_O_BINARY, 0); fd = open (file_name, O_RDONLY|_O_BINARY, 0);
while (fd == -1 && errno == EINTR); } while (fd == -1 && errno == EINTR);
if (fd < 0) if (fd < 0)
return NULL; return NULL;
@ -153,12 +157,6 @@ _xdg_mime_cache_new_from_file (const char *file_name)
if (fd != -1) if (fd != -1)
close (fd); close (fd);
#else /* HAVE_MMAP */
cache = (XdgMimeCache *) malloc (sizeof (XdgMimeCache));
cache->minor = 0;
cache->ref_count = 1;
cache->buffer = NULL;
cache->size = 0;
#endif /* HAVE_MMAP */ #endif /* HAVE_MMAP */
return cache; return cache;
@ -176,7 +174,7 @@ cache_magic_matchlet_compare_to_data (XdgMimeCache *cache,
xdg_uint32_t data_offset = GET_UINT32 (cache->buffer, offset + 16); xdg_uint32_t data_offset = GET_UINT32 (cache->buffer, offset + 16);
xdg_uint32_t mask_offset = GET_UINT32 (cache->buffer, offset + 20); xdg_uint32_t mask_offset = GET_UINT32 (cache->buffer, offset + 20);
int i, j; xdg_uint32_t i, j;
for (i = range_start; i < range_start + range_length; i++) for (i = range_start; i < range_start + range_length; i++)
{ {
@ -199,14 +197,7 @@ cache_magic_matchlet_compare_to_data (XdgMimeCache *cache,
} }
else else
{ {
for (j = 0; j < data_length; j++) valid_matchlet = memcmp(cache->buffer + data_offset, (unsigned char *)data + i, data_length) == 0;
{
if (((unsigned char *)cache->buffer)[data_offset + j] != ((unsigned char *) data)[j + i])
{
valid_matchlet = FALSE;
break;
}
}
} }
if (valid_matchlet) if (valid_matchlet)
@ -225,7 +216,7 @@ cache_magic_matchlet_compare (XdgMimeCache *cache,
xdg_uint32_t n_children = GET_UINT32 (cache->buffer, offset + 24); xdg_uint32_t n_children = GET_UINT32 (cache->buffer, offset + 24);
xdg_uint32_t child_offset = GET_UINT32 (cache->buffer, offset + 28); xdg_uint32_t child_offset = GET_UINT32 (cache->buffer, offset + 28);
int i; xdg_uint32_t i;
if (cache_magic_matchlet_compare_to_data (cache, offset, data, len)) if (cache_magic_matchlet_compare_to_data (cache, offset, data, len))
{ {
@ -255,7 +246,7 @@ cache_magic_compare_to_data (XdgMimeCache *cache,
xdg_uint32_t n_matchlets = GET_UINT32 (cache->buffer, offset + 8); xdg_uint32_t n_matchlets = GET_UINT32 (cache->buffer, offset + 8);
xdg_uint32_t matchlet_offset = GET_UINT32 (cache->buffer, offset + 12); xdg_uint32_t matchlet_offset = GET_UINT32 (cache->buffer, offset + 12);
int i; xdg_uint32_t i;
for (i = 0; i < n_matchlets; i++) for (i = 0; i < n_matchlets; i++)
{ {
@ -275,15 +266,13 @@ static const char *
cache_magic_lookup_data (XdgMimeCache *cache, cache_magic_lookup_data (XdgMimeCache *cache,
const void *data, const void *data,
size_t len, size_t len,
int *prio, int *prio)
const char *mime_types[],
int n_mime_types)
{ {
xdg_uint32_t list_offset; xdg_uint32_t list_offset;
xdg_uint32_t n_entries; xdg_uint32_t n_entries;
xdg_uint32_t offset; xdg_uint32_t offset;
int j, n; xdg_uint32_t j;
*prio = 0; *prio = 0;
@ -299,21 +288,6 @@ cache_magic_lookup_data (XdgMimeCache *cache,
data, len, prio); data, len, prio);
if (match) if (match)
return match; return match;
else
{
xdg_uint32_t mimetype_offset;
const char *non_match;
mimetype_offset = GET_UINT32 (cache->buffer, offset + 16 * j + 4);
non_match = cache->buffer + mimetype_offset;
for (n = 0; n < n_mime_types; n++)
{
if (mime_types[n] &&
_xdg_mime_mime_type_equal (mime_types[n], non_match))
mime_types[n] = NULL;
}
}
} }
return NULL; return NULL;
@ -328,16 +302,10 @@ cache_alias_lookup (const char *alias)
for (i = 0; _caches[i]; i++) for (i = 0; _caches[i]; i++)
{ {
XdgMimeCache *cache = _caches[i]; XdgMimeCache *cache = _caches[i];
xdg_uint32_t list_offset; xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 4);
xdg_uint32_t n_entries; xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
xdg_uint32_t offset; xdg_uint32_t offset;
if (cache->buffer == NULL)
continue;
list_offset = GET_UINT32 (cache->buffer, 4);
n_entries = GET_UINT32 (cache->buffer, list_offset);
min = 0; min = 0;
max = n_entries - 1; max = n_entries - 1;
while (max >= min) while (max >= min)
@ -380,16 +348,10 @@ cache_glob_lookup_literal (const char *file_name,
for (i = 0; _caches[i]; i++) for (i = 0; _caches[i]; i++)
{ {
XdgMimeCache *cache = _caches[i]; XdgMimeCache *cache = _caches[i];
xdg_uint32_t list_offset; xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 12);
xdg_uint32_t n_entries; xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
xdg_uint32_t offset; xdg_uint32_t offset;
if (cache->buffer == NULL)
continue;
list_offset = GET_UINT32 (cache->buffer, 12);
n_entries = GET_UINT32 (cache->buffer, list_offset);
min = 0; min = 0;
max = n_entries - 1; max = n_entries - 1;
while (max >= min) while (max >= min)
@ -428,36 +390,34 @@ cache_glob_lookup_literal (const char *file_name,
static int static int
cache_glob_lookup_fnmatch (const char *file_name, cache_glob_lookup_fnmatch (const char *file_name,
MimeWeight mime_types[], MimeWeight mime_types[],
int n_mime_types) int n_mime_types,
int case_sensitive_check)
{ {
const char *mime_type; const char *mime_type;
const char *ptr; const char *ptr;
int i, j, n; int i, n;
xdg_uint32_t j;
n = 0; n = 0;
for (i = 0; _caches[i]; i++) for (i = 0; _caches[i]; i++)
{ {
XdgMimeCache *cache = _caches[i]; XdgMimeCache *cache = _caches[i];
xdg_uint32_t list_offset; xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 20);
xdg_uint32_t n_entries; xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
if (cache->buffer == NULL)
continue;
list_offset = GET_UINT32 (cache->buffer, 20);
n_entries = GET_UINT32 (cache->buffer, list_offset);
for (j = 0; j < n_entries && n < n_mime_types; j++) for (j = 0; j < n_entries && n < n_mime_types; j++)
{ {
xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j); 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); 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); int weight = GET_UINT32 (cache->buffer, list_offset + 4 + 12 * j + 8);
int case_sensitive = weight & 0x100;
weight = weight & 0xff; weight = weight & 0xff;
ptr = cache->buffer + offset; ptr = cache->buffer + offset;
mime_type = cache->buffer + mimetype_offset; mime_type = cache->buffer + mimetype_offset;
if (case_sensitive_check || !case_sensitive)
{
/* FIXME: Not UTF-8 safe */ /* FIXME: Not UTF-8 safe */
if (fnmatch (ptr, file_name, 0) == 0) if (fnmatch (ptr, file_name, 0) == 0)
{ {
@ -466,12 +426,13 @@ cache_glob_lookup_fnmatch (const char *file_name,
n++; n++;
} }
} }
if (n == n_mime_types)
break;
} }
if (n > 0)
return n; return n;
}
return 0;
} }
static int static int
@ -492,7 +453,8 @@ cache_glob_node_lookup_suffix (XdgMimeCache *cache,
int weight; int weight;
int case_sensitive; int case_sensitive;
int min, max, mid, n, i; xdg_uint32_t i;
int min, max, mid, n;
character = file_name[len - 1]; character = file_name[len - 1];
@ -562,33 +524,25 @@ cache_glob_lookup_suffix (const char *file_name,
{ {
int i, n; int i, n;
n = 0;
for (i = 0; _caches[i]; i++) for (i = 0; _caches[i]; i++)
{ {
XdgMimeCache *cache = _caches[i]; XdgMimeCache *cache = _caches[i];
xdg_uint32_t list_offset; xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 16);
xdg_uint32_t n_entries; xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
xdg_uint32_t offset; xdg_uint32_t offset = GET_UINT32 (cache->buffer, list_offset + 4);
if (cache->buffer == NULL) n = cache_glob_node_lookup_suffix (cache,
continue;
list_offset = GET_UINT32 (cache->buffer, 16);
n_entries = GET_UINT32 (cache->buffer, list_offset);
offset = GET_UINT32 (cache->buffer, list_offset + 4);
n += cache_glob_node_lookup_suffix (cache,
n_entries, offset, n_entries, offset,
file_name, len, file_name, len,
ignore_case, ignore_case,
mime_types + n, mime_types,
n_mime_types - n); n_mime_types);
if (n == n_mime_types) if (n > 0)
break; return n;
} }
return n; return 0;
} }
static int compare_mime_weight (const void *a, const void *b) static int compare_mime_weight (const void *a, const void *b)
@ -615,34 +569,6 @@ ascii_tolower (const char *str)
return lower; return lower;
} }
static int
filter_out_dupes (MimeWeight mimes[], int n_mimes)
{
int last;
int i, j;
last = n_mimes;
for (i = 0; i < last; i++)
{
j = i + 1;
while (j < last)
{
if (strcmp (mimes[i].mime, mimes[j].mime) == 0)
{
mimes[i].weight = MAX (mimes[i].weight, mimes[j].weight);
last--;
mimes[j].mime = mimes[last].mime;
mimes[j].weight = mimes[last].weight;
}
else
j++;
}
}
return last;
}
static int static int
cache_glob_lookup_file_name (const char *file_name, cache_glob_lookup_file_name (const char *file_name,
const char *mime_types[], const char *mime_types[],
@ -677,16 +603,16 @@ cache_glob_lookup_file_name (const char *file_name,
len = strlen (file_name); len = strlen (file_name);
n = cache_glob_lookup_suffix (lower_case, len, FALSE, mimes, n_mimes); n = cache_glob_lookup_suffix (lower_case, len, FALSE, mimes, n_mimes);
if (n < 2) if (n == 0)
n += cache_glob_lookup_suffix (file_name, len, TRUE, mimes + n, n_mimes - n); n = cache_glob_lookup_suffix (file_name, len, TRUE, mimes, n_mimes);
free (lower_case);
/* Last, try fnmatch */ /* Last, try fnmatch */
if (n < 2) if (n == 0)
n += cache_glob_lookup_fnmatch (file_name, mimes + n, n_mimes - n); n = cache_glob_lookup_fnmatch (lower_case, mimes, n_mimes, FALSE);
if (n == 0)
n = cache_glob_lookup_fnmatch (file_name, mimes, n_mimes, TRUE);
n = filter_out_dupes (mimes, n); free (lower_case);
qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight); qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight);
@ -711,9 +637,6 @@ _xdg_mime_cache_get_max_buffer_extents (void)
{ {
XdgMimeCache *cache = _caches[i]; XdgMimeCache *cache = _caches[i];
if (cache->buffer == NULL)
continue;
offset = GET_UINT32 (cache->buffer, 24); offset = GET_UINT32 (cache->buffer, 24);
max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4)); max_extent = MAX (max_extent, GET_UINT32 (cache->buffer, offset + 4));
} }
@ -740,11 +663,7 @@ cache_get_mime_type_for_data (const void *data,
int prio; int prio;
const char *match; const char *match;
if (cache->buffer == NULL) match = cache_magic_lookup_data (cache, data, len, &prio);
continue;
match = cache_magic_lookup_data (cache, data, len, &prio,
mime_types, n_mime_types);
if (prio > priority) if (prio > priority)
{ {
priority = prio; priority = prio;
@ -756,8 +675,21 @@ cache_get_mime_type_for_data (const void *data,
*result_prio = priority; *result_prio = priority;
if (priority > 0) if (priority > 0)
{
/* Pick glob-result R where mime_type inherits from R */
for (n = 0; n < n_mime_types; n++)
{
if (mime_types[n] && _xdg_mime_cache_mime_type_subclass(mime_types[n], mime_type))
return mime_types[n];
}
if (n == 0)
{
/* No globs: return magic match */
return mime_type; return mime_type;
}
}
/* Pick first glob result, as fallback */
for (n = 0; n < n_mime_types; n++) for (n = 0; n < n_mime_types; n++)
{ {
if (mime_types[n]) if (mime_types[n])
@ -775,8 +707,6 @@ _xdg_mime_cache_get_mime_type_for_data (const void *data,
return cache_get_mime_type_for_data (data, len, result_prio, NULL, 0); return cache_get_mime_type_for_data (data, len, result_prio, NULL, 0);
} }
#ifdef NOT_USED_IN_GIO
const char * const char *
_xdg_mime_cache_get_mime_type_for_file (const char *file_name, _xdg_mime_cache_get_mime_type_for_file (const char *file_name,
struct stat *statbuf) struct stat *statbuf)
@ -844,7 +774,7 @@ _xdg_mime_cache_get_mime_type_for_file (const char *file_name,
mime_types, n); mime_types, n);
if (!mime_type) if (!mime_type)
mime_type = _xdg_binary_or_text_fallback(data, bytes_read); mime_type = _xdg_binary_or_text_fallback (data, bytes_read);
free (data); free (data);
fclose (file); fclose (file);
@ -863,8 +793,6 @@ _xdg_mime_cache_get_mime_type_from_file_name (const char *file_name)
return XDG_MIME_TYPE_UNKNOWN; return XDG_MIME_TYPE_UNKNOWN;
} }
#endif
int int
_xdg_mime_cache_get_mime_types_from_file_name (const char *file_name, _xdg_mime_cache_get_mime_types_from_file_name (const char *file_name,
const char *mime_types[], const char *mime_types[],
@ -905,7 +833,8 @@ _xdg_mime_cache_mime_type_subclass (const char *mime,
{ {
const char *umime, *ubase; const char *umime, *ubase;
int i, j, min, max, med, cmp; xdg_uint32_t j;
int i, min, max, med, cmp;
umime = _xdg_mime_cache_unalias_mime_type (mime); umime = _xdg_mime_cache_unalias_mime_type (mime);
ubase = _xdg_mime_cache_unalias_mime_type (base); ubase = _xdg_mime_cache_unalias_mime_type (base);
@ -935,16 +864,11 @@ _xdg_mime_cache_mime_type_subclass (const char *mime,
for (i = 0; _caches[i]; i++) for (i = 0; _caches[i]; i++)
{ {
XdgMimeCache *cache = _caches[i]; XdgMimeCache *cache = _caches[i];
xdg_uint32_t list_offset;
xdg_uint32_t n_entries; xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
xdg_uint32_t offset, n_parents, parent_offset; xdg_uint32_t offset, n_parents, parent_offset;
if (cache->buffer == NULL)
continue;
list_offset = GET_UINT32 (cache->buffer, 8);
n_entries = GET_UINT32 (cache->buffer, list_offset);
min = 0; min = 0;
max = n_entries - 1; max = n_entries - 1;
while (max >= min) while (max >= min)
@ -965,9 +889,7 @@ _xdg_mime_cache_mime_type_subclass (const char *mime,
for (j = 0; j < n_parents; j++) for (j = 0; j < n_parents; j++)
{ {
parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j); parent_offset = GET_UINT32 (cache->buffer, offset + 4 + 4 * j);
if (strcmp (cache->buffer + parent_offset, mime) != 0 && if (_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
strcmp (cache->buffer + parent_offset, umime) != 0 &&
_xdg_mime_cache_mime_type_subclass (cache->buffer + parent_offset, ubase))
return 1; return 1;
} }
@ -995,7 +917,8 @@ _xdg_mime_cache_unalias_mime_type (const char *mime)
char ** char **
_xdg_mime_cache_list_mime_parents (const char *mime) _xdg_mime_cache_list_mime_parents (const char *mime)
{ {
int i, j, k, l, p; int i, l, p;
xdg_uint32_t j, k;
char *all_parents[128]; /* we'll stop at 128 */ char *all_parents[128]; /* we'll stop at 128 */
char **result; char **result;
@ -1005,14 +928,9 @@ _xdg_mime_cache_list_mime_parents (const char *mime)
for (i = 0; _caches[i]; i++) for (i = 0; _caches[i]; i++)
{ {
XdgMimeCache *cache = _caches[i]; XdgMimeCache *cache = _caches[i];
xdg_uint32_t list_offset;
xdg_uint32_t n_entries;
if (cache->buffer == NULL) xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, 8);
continue; xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
list_offset = GET_UINT32 (cache->buffer, 8);
n_entries = GET_UINT32 (cache->buffer, list_offset);
for (j = 0; j < n_entries; j++) for (j = 0; j < n_entries; j++)
{ {
@ -1062,16 +980,10 @@ cache_lookup_icon (const char *mime, int header)
for (i = 0; _caches[i]; i++) for (i = 0; _caches[i]; i++)
{ {
XdgMimeCache *cache = _caches[i]; XdgMimeCache *cache = _caches[i];
xdg_uint32_t list_offset; xdg_uint32_t list_offset = GET_UINT32 (cache->buffer, header);
xdg_uint32_t n_entries; xdg_uint32_t n_entries = GET_UINT32 (cache->buffer, list_offset);
xdg_uint32_t offset; xdg_uint32_t offset;
if (cache->buffer == NULL)
continue;
list_offset = GET_UINT32 (cache->buffer, header);
n_entries = GET_UINT32 (cache->buffer, list_offset);
min = 0; min = 0;
max = n_entries - 1; max = n_entries - 1;
while (max >= min) while (max >= min)
@ -1109,8 +1021,6 @@ _xdg_mime_cache_get_icon (const char *mime)
return cache_lookup_icon (mime, 32); return cache_lookup_icon (mime, 32);
} }
#ifdef NOT_USED_IN_GIO
static void static void
dump_glob_node (XdgMimeCache *cache, dump_glob_node (XdgMimeCache *cache,
xdg_uint32_t offset, xdg_uint32_t offset,
@ -1120,6 +1030,7 @@ dump_glob_node (XdgMimeCache *cache,
xdg_uint32_t mime_offset; xdg_uint32_t mime_offset;
xdg_uint32_t n_children; xdg_uint32_t n_children;
xdg_uint32_t child_offset; xdg_uint32_t child_offset;
xdg_uint32_t k;
int i; int i;
character = GET_UINT32 (cache->buffer, offset); character = GET_UINT32 (cache->buffer, offset);
@ -1134,25 +1045,21 @@ dump_glob_node (XdgMimeCache *cache,
printf ("\n"); printf ("\n");
if (child_offset) if (child_offset)
{ {
for (i = 0; i < n_children; i++) for (k = 0; k < n_children; k++)
dump_glob_node (cache, child_offset + 20 * i, depth + 1); dump_glob_node (cache, child_offset + 20 * k, depth + 1);
} }
} }
void void
_xdg_mime_cache_glob_dump (void) _xdg_mime_cache_glob_dump (void)
{ {
int i, j; xdg_uint32_t i, j;
for (i = 0; _caches[i]; i++) for (i = 0; _caches[i]; i++)
{ {
XdgMimeCache *cache = _caches[i]; XdgMimeCache *cache = _caches[i];
xdg_uint32_t list_offset; xdg_uint32_t list_offset;
xdg_uint32_t n_entries; xdg_uint32_t n_entries;
xdg_uint32_t offset; xdg_uint32_t offset;
if (cache->buffer == NULL)
continue;
list_offset = GET_UINT32 (cache->buffer, 16); list_offset = GET_UINT32 (cache->buffer, 16);
n_entries = GET_UINT32 (cache->buffer, list_offset); n_entries = GET_UINT32 (cache->buffer, list_offset);
offset = GET_UINT32 (cache->buffer, list_offset + 4); offset = GET_UINT32 (cache->buffer, list_offset + 4);
@ -1161,4 +1068,4 @@ _xdg_mime_cache_glob_dump (void)
} }
} }
#endif

12
gio/xdgmime/xdgmimecache.h
View File

@ -11,7 +11,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -19,7 +19,9 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#ifndef __XDG_MIME_CACHE_H__ #ifndef __XDG_MIME_CACHE_H__
@ -56,16 +58,12 @@ void _xdg_mime_cache_unref (XdgMimeCache *cache);
const char *_xdg_mime_cache_get_mime_type_for_data (const void *data, const char *_xdg_mime_cache_get_mime_type_for_data (const void *data,
size_t len, size_t len,
int *result_prio); int *result_prio);
#ifdef NOT_USED_IN_GIO
const char *_xdg_mime_cache_get_mime_type_for_file (const char *file_name, const char *_xdg_mime_cache_get_mime_type_for_file (const char *file_name,
struct stat *statbuf); struct stat *statbuf);
#endif
int _xdg_mime_cache_get_mime_types_from_file_name (const char *file_name, int _xdg_mime_cache_get_mime_types_from_file_name (const char *file_name,
const char *mime_types[], const char *mime_types[],
int n_mime_types); int n_mime_types);
#ifdef NOT_USED_IN_GIO
const char *_xdg_mime_cache_get_mime_type_from_file_name (const char *file_name); const char *_xdg_mime_cache_get_mime_type_from_file_name (const char *file_name);
#endif
int _xdg_mime_cache_is_valid_mime_type (const char *mime_type); int _xdg_mime_cache_is_valid_mime_type (const char *mime_type);
int _xdg_mime_cache_mime_type_equal (const char *mime_a, int _xdg_mime_cache_mime_type_equal (const char *mime_a,
const char *mime_b); const char *mime_b);
@ -78,8 +76,6 @@ const char *_xdg_mime_cache_unalias_mime_type (const char *mime);
int _xdg_mime_cache_get_max_buffer_extents (void); int _xdg_mime_cache_get_max_buffer_extents (void);
const char *_xdg_mime_cache_get_icon (const char *mime); const char *_xdg_mime_cache_get_icon (const char *mime);
const char *_xdg_mime_cache_get_generic_icon (const char *mime); const char *_xdg_mime_cache_get_generic_icon (const char *mime);
#ifdef NOT_USED_IN_GIO
void _xdg_mime_cache_glob_dump (void); void _xdg_mime_cache_glob_dump (void);
#endif
#endif /* __XDG_MIME_CACHE_H__ */ #endif /* __XDG_MIME_CACHE_H__ */

61
gio/xdgmime/xdgmimeglob.c
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,10 +20,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#include "config.h" #ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "xdgmimeglob.h" #include "xdgmimeglob.h"
#include "xdgmimeint.h" #include "xdgmimeint.h"
@ -33,10 +37,6 @@
#include <string.h> #include <string.h>
#include <fnmatch.h> #include <fnmatch.h>
#ifndef MAX
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif
#ifndef FALSE #ifndef FALSE
#define FALSE (0) #define FALSE (0)
#endif #endif
@ -86,7 +86,7 @@ _xdg_glob_list_new (void)
return new_element; return new_element;
} }
/* Frees glob_list and all of it's children */ /* Frees glob_list and all of its children */
static void static void
_xdg_glob_list_free (XdgGlobList *glob_list) _xdg_glob_list_free (XdgGlobList *glob_list)
{ {
@ -158,8 +158,6 @@ _xdg_glob_hash_node_new (void)
return glob_hash_node; return glob_hash_node;
} }
#ifdef NOT_USED_IN_GIO
static void static void
_xdg_glob_hash_node_dump (XdgGlobHashNode *glob_hash_node, _xdg_glob_hash_node_dump (XdgGlobHashNode *glob_hash_node,
int depth) int depth)
@ -179,8 +177,6 @@ _xdg_glob_hash_node_dump (XdgGlobHashNode *glob_hash_node,
_xdg_glob_hash_node_dump (glob_hash_node->next, depth); _xdg_glob_hash_node_dump (glob_hash_node->next, depth);
} }
#endif
static XdgGlobHashNode * static XdgGlobHashNode *
_xdg_glob_hash_insert_ucs4 (XdgGlobHashNode *glob_hash_node, _xdg_glob_hash_insert_ucs4 (XdgGlobHashNode *glob_hash_node,
xdg_unichar_t *text, xdg_unichar_t *text,
@ -404,34 +400,6 @@ ascii_tolower (const char *str)
return lower; return lower;
} }
static int
filter_out_dupes (MimeWeight mimes[], int n_mimes)
{
int last;
int i, j;
last = n_mimes;
for (i = 0; i < last; i++)
{
j = i + 1;
while (j < last)
{
if (strcmp (mimes[i].mime, mimes[j].mime) == 0)
{
mimes[i].weight = MAX (mimes[i].weight, mimes[j].weight);
last--;
mimes[j].mime = mimes[last].mime;
mimes[j].weight = mimes[last].weight;
}
else
j++;
}
}
return last;
}
int int
_xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash, _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
const char *file_name, const char *file_name,
@ -478,11 +446,11 @@ _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
len = strlen (file_name); len = strlen (file_name);
n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, lower_case, len, FALSE, n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, lower_case, len, FALSE,
mimes, n_mimes); mimes, n_mimes);
if (n < 2) if (n == 0)
n += _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, file_name, len, TRUE, n = _xdg_glob_hash_node_lookup_file_name (glob_hash->simple_node, file_name, len, TRUE,
mimes + n, n_mimes - n); mimes, n_mimes);
if (n < 2) if (n == 0)
{ {
for (list = glob_hash->full_list; list && n < n_mime_types; list = list->next) for (list = glob_hash->full_list; list && n < n_mime_types; list = list->next)
{ {
@ -496,8 +464,6 @@ _xdg_glob_hash_lookup_file_name (XdgGlobHash *glob_hash,
} }
free (lower_case); free (lower_case);
n = filter_out_dupes (mimes, n);
qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight); qsort (mimes, n, sizeof (MimeWeight), compare_mime_weight);
if (n_mime_types < n) if (n_mime_types < n)
@ -603,8 +569,6 @@ _xdg_glob_hash_append_glob (XdgGlobHash *glob_hash,
} }
} }
#ifdef NOT_USED_IN_GIO
void void
_xdg_glob_hash_dump (XdgGlobHash *glob_hash) _xdg_glob_hash_dump (XdgGlobHash *glob_hash)
{ {
@ -641,7 +605,6 @@ _xdg_glob_hash_dump (XdgGlobHash *glob_hash)
} }
} }
#endif
void void
_xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash, _xdg_mime_glob_read_from_file (XdgGlobHash *glob_hash,

8
gio/xdgmime/xdgmimeglob.h
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,7 +20,9 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#ifndef __XDG_MIME_GLOB_H__ #ifndef __XDG_MIME_GLOB_H__
@ -63,8 +65,6 @@ void _xdg_glob_hash_append_glob (XdgGlobHash *glob_hash,
int weight, int weight,
int case_sensitive); int case_sensitive);
XdgGlobType _xdg_glob_determine_type (const char *glob); XdgGlobType _xdg_glob_determine_type (const char *glob);
#ifdef NOT_USED_IN_GIO
void _xdg_glob_hash_dump (XdgGlobHash *glob_hash); void _xdg_glob_hash_dump (XdgGlobHash *glob_hash);
#endif
#endif /* __XDG_MIME_GLOB_H__ */ #endif /* __XDG_MIME_GLOB_H__ */

13
gio/xdgmime/xdgmimeicon.c
View File

@ -11,7 +11,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -19,10 +19,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#include "config.h" #ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "xdgmimeicon.h" #include "xdgmimeicon.h"
#include "xdgmimeint.h" #include "xdgmimeint.h"
@ -159,7 +163,6 @@ _xdg_mime_icon_read_from_file (XdgIconList *list,
sizeof (XdgIcon), icon_entry_cmp); sizeof (XdgIcon), icon_entry_cmp);
} }
#ifdef NOT_USED_IN_GIO
void void
_xdg_mime_icon_list_dump (XdgIconList *list) _xdg_mime_icon_list_dump (XdgIconList *list)
@ -177,4 +180,4 @@ _xdg_mime_icon_list_dump (XdgIconList *list)
} }
} }
#endif

8
gio/xdgmime/xdgmimeicon.h
View File

@ -11,7 +11,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -19,7 +19,9 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#ifndef __XDG_MIME_ICON_H__ #ifndef __XDG_MIME_ICON_H__
@ -43,8 +45,6 @@ XdgIconList *_xdg_mime_icon_list_new (void);
void _xdg_mime_icon_list_free (XdgIconList *list); void _xdg_mime_icon_list_free (XdgIconList *list);
const char *_xdg_mime_icon_list_lookup (XdgIconList *list, const char *_xdg_mime_icon_list_lookup (XdgIconList *list,
const char *mime); const char *mime);
#ifdef NOT_USED_IN_GIO
void _xdg_mime_icon_list_dump (XdgIconList *list); void _xdg_mime_icon_list_dump (XdgIconList *list);
#endif
#endif /* __XDG_MIME_ICON_H__ */ #endif /* __XDG_MIME_ICON_H__ */

12
gio/xdgmime/xdgmimeint.c
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,10 +20,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#include "config.h" #ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "xdgmimeint.h" #include "xdgmimeint.h"
#include <ctype.h> #include <ctype.h>
@ -189,7 +193,7 @@ const char *
_xdg_binary_or_text_fallback(const void *data, size_t len) _xdg_binary_or_text_fallback(const void *data, size_t len)
{ {
unsigned char *chardata; unsigned char *chardata;
int i; size_t i;
chardata = (unsigned char *) data; chardata = (unsigned char *) data;
for (i = 0; i < 128 && i < len; ++i) for (i = 0; i < 128 && i < len; ++i)

6
gio/xdgmime/xdgmimeint.h
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,7 +20,9 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#ifndef __XDG_MIME_INT_H__ #ifndef __XDG_MIME_INT_H__

24
gio/xdgmime/xdgmimemagic.c
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,10 +20,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#include "config.h" #ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <assert.h> #include <assert.h>
#include "xdgmimemagic.h" #include "xdgmimemagic.h"
@ -316,7 +320,7 @@ _xdg_mime_magic_parse_magic_line (FILE *magic_file,
int c; int c;
int end_of_file; int end_of_file;
int indent = 0; int indent = 0;
int bytes_read; size_t bytes_read;
assert (magic_file != NULL); assert (magic_file != NULL);
@ -403,7 +407,7 @@ _xdg_mime_magic_parse_magic_line (FILE *magic_file,
return XDG_MIME_MAGIC_ERROR; return XDG_MIME_MAGIC_ERROR;
} }
bytes_read = fread (matchlet->value, 1, matchlet->value_length, magic_file); bytes_read = fread (matchlet->value, 1, matchlet->value_length, magic_file);
if (bytes_read != matchlet->value_length) if (bytes_read != (size_t) matchlet->value_length)
{ {
_xdg_mime_magic_matchlet_free (matchlet); _xdg_mime_magic_matchlet_free (matchlet);
if (feof (magic_file)) if (feof (magic_file))
@ -423,7 +427,7 @@ _xdg_mime_magic_parse_magic_line (FILE *magic_file,
return XDG_MIME_MAGIC_ERROR; return XDG_MIME_MAGIC_ERROR;
} }
bytes_read = fread (matchlet->mask, 1, matchlet->value_length, magic_file); bytes_read = fread (matchlet->mask, 1, matchlet->value_length, magic_file);
if (bytes_read != matchlet->value_length) if (bytes_read != (size_t) matchlet->value_length)
{ {
_xdg_mime_magic_matchlet_free (matchlet); _xdg_mime_magic_matchlet_free (matchlet);
if (feof (magic_file)) if (feof (magic_file))
@ -461,7 +465,7 @@ _xdg_mime_magic_parse_magic_line (FILE *magic_file,
_xdg_mime_magic_matchlet_free (matchlet); _xdg_mime_magic_matchlet_free (matchlet);
return XDG_MIME_MAGIC_EOF; return XDG_MIME_MAGIC_EOF;
} }
if (matchlet->range_length == -1) if (matchlet->range_length == (unsigned int) -1)
{ {
_xdg_mime_magic_matchlet_free (matchlet); _xdg_mime_magic_matchlet_free (matchlet);
return XDG_MIME_MAGIC_ERROR; return XDG_MIME_MAGIC_ERROR;
@ -475,9 +479,7 @@ _xdg_mime_magic_parse_magic_line (FILE *magic_file,
/* We clean up the matchlet, byte swapping if needed */ /* We clean up the matchlet, byte swapping if needed */
if (matchlet->word_size > 1) if (matchlet->word_size > 1)
{ {
#if LITTLE_ENDIAN unsigned int i;
int i;
#endif
if (matchlet->value_length % matchlet->word_size != 0) if (matchlet->value_length % matchlet->word_size != 0)
{ {
_xdg_mime_magic_matchlet_free (matchlet); _xdg_mime_magic_matchlet_free (matchlet);
@ -522,7 +524,7 @@ _xdg_mime_magic_matchlet_compare_to_data (XdgMimeMagicMatchlet *matchlet,
const void *data, const void *data,
size_t len) size_t len)
{ {
int i, j; unsigned int i, j;
for (i = matchlet->offset; i < matchlet->offset + matchlet->range_length; i++) for (i = matchlet->offset; i < matchlet->offset + matchlet->range_length; i++)
{ {
int valid_matchlet = TRUE; int valid_matchlet = TRUE;

6
gio/xdgmime/xdgmimemagic.h
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,7 +20,9 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#ifndef __XDG_MIME_MAGIC_H__ #ifndef __XDG_MIME_MAGIC_H__

14
gio/xdgmime/xdgmimeparent.c
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,10 +20,14 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#include "config.h" #ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include "xdgmimeparent.h" #include "xdgmimeparent.h"
#include "xdgmimeint.h" #include "xdgmimeint.h"
@ -107,7 +111,6 @@ _xdg_mime_parent_list_lookup (XdgParentList *list,
{ {
key.mime = (char *)mime; key.mime = (char *)mime;
key.parents = NULL; key.parents = NULL;
key.n_parents = 0;
entry = bsearch (&key, list->parents, list->n_mimes, entry = bsearch (&key, list->parents, list->n_mimes,
sizeof (XdgMimeParents), &parent_entry_cmp); sizeof (XdgMimeParents), &parent_entry_cmp);
@ -196,7 +199,6 @@ _xdg_mime_parent_read_from_file (XdgParentList *list,
sizeof (XdgMimeParents), &parent_entry_cmp); sizeof (XdgMimeParents), &parent_entry_cmp);
} }
#ifdef NOT_USED_IN_GIO
void void
_xdg_mime_parent_list_dump (XdgParentList *list) _xdg_mime_parent_list_dump (XdgParentList *list)
@ -214,4 +216,4 @@ _xdg_mime_parent_list_dump (XdgParentList *list)
} }
} }
#endif

8
gio/xdgmime/xdgmimeparent.h
View File

@ -12,7 +12,7 @@
* This library is free software; you can redistribute it and/or * This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public * modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either * License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version. * version 2 of the License, or (at your option) any later version.
* *
* This library is distributed in the hope that it will be useful, * This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
@ -20,7 +20,9 @@
* Lesser General Public License for more details. * Lesser General Public License for more details.
* *
* You should have received a copy of the GNU Lesser General Public * You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>. * License along with this library; if not, write to the
* Free Software Foundation, Inc., 59 Temple Place - Suite 330,
* Boston, MA 02111-1307, USA.
*/ */
#ifndef __XDG_MIME_PARENT_H__ #ifndef __XDG_MIME_PARENT_H__
@ -44,8 +46,6 @@ XdgParentList *_xdg_mime_parent_list_new (void);
void _xdg_mime_parent_list_free (XdgParentList *list); void _xdg_mime_parent_list_free (XdgParentList *list);
const char **_xdg_mime_parent_list_lookup (XdgParentList *list, const char **_xdg_mime_parent_list_lookup (XdgParentList *list,
const char *mime); const char *mime);
#ifdef NOT_USED_IN_GIO
void _xdg_mime_parent_list_dump (XdgParentList *list); void _xdg_mime_parent_list_dump (XdgParentList *list);
#endif
#endif /* __XDG_MIME_PARENT_H__ */ #endif /* __XDG_MIME_PARENT_H__ */