Move libvlc module stuff to their own subdirectory
authorRémi Denis-Courmont <rem@videolan.org>
Sat, 14 Apr 2007 15:19:03 +0000 (15:19 +0000)
committerRémi Denis-Courmont <rem@videolan.org>
Sat, 14 Apr 2007 15:19:03 +0000 (15:19 +0000)
17 files changed:
po/POTFILES.in
src/Makefile.am
src/libvlc-common.c
src/misc/configuration.c [deleted file]
src/misc/configuration.h [deleted file]
src/misc/configuration_chain.c [deleted file]
src/misc/modules.c [deleted file]
src/misc/modules.h [deleted file]
src/misc/modules_builtin.h.in [deleted file]
src/modules/builtin.h.in [new file with mode: 0644]
src/modules/configuration.c [new file with mode: 0644]
src/modules/configuration.h [new file with mode: 0644]
src/modules/configuration_chain.c [new file with mode: 0644]
src/modules/modules.c [new file with mode: 0644]
src/modules/modules.h [new file with mode: 0644]
src/playlist/loadsave.c
toolbox

index 2016634..882b953 100644 (file)
@@ -111,9 +111,9 @@ src/libvlc.c
 src/libvlc.h
 src/misc/beos_specific.cpp
 src/misc/block.c
-src/misc/configuration.c
-src/misc/configuration.h
-src/misc/configuration_chain.c
+src/modules/configuration.c
+src/modules/configuration.h
+src/modules/configuration_chain.c
 src/misc/cpu.c
 src/misc/darwin_specific.c
 src/misc/devices.c
@@ -121,8 +121,8 @@ src/misc/error.c
 src/misc/image.c
 src/misc/md5.c
 src/misc/messages.c
-src/misc/modules.c
-src/misc/modules.h
+src/modules/modules.c
+src/modules/modules.h
 src/misc/mtime.c
 src/misc/objects.c
 src/misc/stats.c
index d1c17f0..1974c68 100644 (file)
@@ -7,10 +7,10 @@ AUTOMAKE_OPTIONS = subdir-objects
 NULL =
 SUBDIRS =
 
-EXTRA_DIST = extras/COPYING misc/modules_builtin.h.in libvlc.sym
+EXTRA_DIST = extras/COPYING modules/builtin.h.in libvlc.sym
 
 BUILT_SOURCES = $(CLEANFILES)
-CLEANFILES = misc/modules_builtin.h
+CLEANFILES = modules/builtin.h
 MOSTLYCLEANFILES = $(DATA_noinst_libvlc)
 
 TOOLBOX = srcdir=$(top_srcdir) builddir=$(top_builddir) $(top_srcdir)/toolbox
@@ -90,11 +90,11 @@ HEADERS_include = \
        ../include/vlc_vout_synchro.h \
        $(NULL)
 
-misc/modules_builtin.h: misc/modules_builtin.h.in
+modules/builtin.h: modules/builtin.h.in
        $(TOOLBOX) --update-includes
        touch $@
 
-misc/modules.c: misc/modules_builtin.h
+modules/modules.c: modules/builtin.h
 
 ###############################################################################
 # Building libvlc
@@ -286,14 +286,14 @@ SOURCES_libvlc_common = \
        misc/md5.c \
        misc/mtime.c \
        misc/block.c \
-       misc/modules.h \
-       misc/modules.c \
+       modules/modules.h \
+       modules/modules.c \
        misc/threads.c \
        misc/stats.c \
        misc/cpu.c \
-       misc/configuration.h \
-       misc/configuration.c \
-       misc/configuration_chain.c \
+       modules/configuration.h \
+       modules/configuration.c \
+       modules/configuration_chain.c \
        misc/image.c \
        misc/messages.c \
        misc/objects.c \
index 79a0c5a..2c03b2c 100644 (file)
@@ -36,8 +36,8 @@
 #include "control/libvlc_internal.h"
 #include <vlc_input.h>
 
-#include "misc/modules.h"
-#include "misc/configuration.h"
+#include "modules/modules.h"
+#include "modules/configuration.h"
 
 #include <errno.h>                                                 /* ENOMEM */
 #include <stdio.h>                                              /* sprintf() */
diff --git a/src/misc/configuration.c b/src/misc/configuration.c
deleted file mode 100644 (file)
index 9f54778..0000000
+++ /dev/null
@@ -1,1845 +0,0 @@
-/*****************************************************************************
- * configuration.c management of the modules configuration
- *****************************************************************************
- * Copyright (C) 2001-2007 the VideoLAN team
- * $Id$
- *
- * Authors: Gildas Bazin <gbazin@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-#include <vlc/vlc.h>
-#include "vlc_keys.h"
-#include "vlc_charset.h"
-
-#include <stdio.h>                                              /* sprintf() */
-#include <stdlib.h>                                      /* free(), strtol() */
-#include <string.h>                                              /* strdup() */
-#include <errno.h>                                                  /* errno */
-
-#ifdef HAVE_LIMITS_H
-#   include <limits.h>
-#endif
-
-#ifdef HAVE_UNISTD_H
-#    include <unistd.h>                                          /* getuid() */
-#endif
-
-#ifdef HAVE_GETOPT_LONG
-#   ifdef HAVE_GETOPT_H
-#       include <getopt.h>                                       /* getopt() */
-#   endif
-#else
-#   include "../extras/getopt.h"
-#endif
-
-#if defined(HAVE_GETPWUID)
-#   include <pwd.h>                                            /* getpwuid() */
-#endif
-
-#if defined( HAVE_SYS_STAT_H )
-#   include <sys/stat.h>
-#endif
-#if defined( HAVE_SYS_TYPES_H )
-#   include <sys/types.h>
-#endif
-#if defined( WIN32 )
-#   if !defined( UNDER_CE )
-#       include <direct.h>
-#   endif
-#include <tchar.h>
-#endif
-
-#include "configuration.h"
-
-static int ConfigStringToKey( const char * );
-static char *ConfigKeyToString( int );
-
-static inline void freenull (const void *p)
-{
-    if (p != NULL)
-        free ((void *)p);
-}
-
-static inline char *strdupnull (const char *src)
-{
-    if (src == NULL)
-        return NULL;
-    return strdup (src);
-}
-
-static inline char *_strdupnull (const char *src)
-{
-    if (src == NULL)
-        return NULL;
-    return strdup (_(src));
-}
-
-
-/*****************************************************************************
- * config_GetType: get the type of a variable (bool, int, float, string)
- *****************************************************************************
- * This function is used to get the type of a variable from its name.
- * Beware, this is quite slow.
- *****************************************************************************/
-int __config_GetType( vlc_object_t *p_this, const char *psz_name )
-{
-    module_config_t *p_config;
-    int i_type;
-
-    p_config = config_FindConfig( p_this, psz_name );
-
-    /* sanity checks */
-    if( !p_config )
-    {
-        return 0;
-    }
-
-    switch( p_config->i_type )
-    {
-    case CONFIG_ITEM_BOOL:
-        i_type = VLC_VAR_BOOL;
-        break;
-
-    case CONFIG_ITEM_INTEGER:
-        i_type = VLC_VAR_INTEGER;
-        break;
-
-    case CONFIG_ITEM_FLOAT:
-        i_type = VLC_VAR_FLOAT;
-        break;
-
-    case CONFIG_ITEM_MODULE:
-    case CONFIG_ITEM_MODULE_CAT:
-    case CONFIG_ITEM_MODULE_LIST:
-    case CONFIG_ITEM_MODULE_LIST_CAT:
-        i_type = VLC_VAR_MODULE;
-        break;
-
-    case CONFIG_ITEM_STRING:
-        i_type = VLC_VAR_STRING;
-        break;
-
-    case CONFIG_ITEM_FILE:
-        i_type = VLC_VAR_FILE;
-        break;
-
-    case CONFIG_ITEM_DIRECTORY:
-        i_type = VLC_VAR_DIRECTORY;
-        break;
-
-    default:
-        i_type = 0;
-        break;
-    }
-
-    return i_type;
-}
-
-/*****************************************************************************
- * config_GetInt: get the value of an int variable
- *****************************************************************************
- * This function is used to get the value of variables which are internally
- * represented by an integer (CONFIG_ITEM_INTEGER and
- * CONFIG_ITEM_BOOL).
- *****************************************************************************/
-int __config_GetInt( vlc_object_t *p_this, const char *psz_name )
-{
-    module_config_t *p_config;
-
-    p_config = config_FindConfig( p_this, psz_name );
-
-    /* sanity checks */
-    if( !p_config )
-    {
-        msg_Err( p_this, "option %s does not exist", psz_name );
-        return -1;
-    }
-
-    if (!IsConfigIntegerType (p_config->i_type))
-    {
-        msg_Err( p_this, "option %s does not refer to an int", psz_name );
-        return -1;
-    }
-
-    return p_config->value.i;
-}
-
-/*****************************************************************************
- * config_GetFloat: get the value of a float variable
- *****************************************************************************
- * This function is used to get the value of variables which are internally
- * represented by a float (CONFIG_ITEM_FLOAT).
- *****************************************************************************/
-float __config_GetFloat( vlc_object_t *p_this, const char *psz_name )
-{
-    module_config_t *p_config;
-
-    p_config = config_FindConfig( p_this, psz_name );
-
-    /* sanity checks */
-    if( !p_config )
-    {
-        msg_Err( p_this, "option %s does not exist", psz_name );
-        return -1;
-    }
-
-    if (!IsConfigFloatType (p_config->i_type))
-    {
-        msg_Err( p_this, "option %s does not refer to a float", psz_name );
-        return -1;
-    }
-
-    return p_config->value.f;
-}
-
-/*****************************************************************************
- * config_GetPsz: get the string value of a string variable
- *****************************************************************************
- * This function is used to get the value of variables which are internally
- * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_FILE,
- * CONFIG_ITEM_DIRECTORY, and CONFIG_ITEM_MODULE).
- *
- * Important note: remember to free() the returned char* because it's a
- *   duplicate of the actual value. It isn't safe to return a pointer to the
- *   actual value as it can be modified at any time.
- *****************************************************************************/
-char * __config_GetPsz( vlc_object_t *p_this, const char *psz_name )
-{
-    module_config_t *p_config;
-
-    p_config = config_FindConfig( p_this, psz_name );
-
-    /* sanity checks */
-    if( !p_config )
-    {
-        msg_Err( p_this, "option %s does not exist", psz_name );
-        return NULL;
-    }
-
-    if (!IsConfigStringType (p_config->i_type))
-    {
-        msg_Err( p_this, "option %s does not refer to a string", psz_name );
-        return NULL;
-    }
-
-    /* return a copy of the string */
-    vlc_mutex_lock( p_config->p_lock );
-    char *psz_value = strdupnull (p_config->value.psz);
-    vlc_mutex_unlock( p_config->p_lock );
-
-    return psz_value;
-}
-
-/*****************************************************************************
- * config_PutPsz: set the string value of a string variable
- *****************************************************************************
- * This function is used to set the value of variables which are internally
- * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_FILE,
- * CONFIG_ITEM_DIRECTORY, and CONFIG_ITEM_MODULE).
- *****************************************************************************/
-void __config_PutPsz( vlc_object_t *p_this,
-                      const char *psz_name, const char *psz_value )
-{
-    module_config_t *p_config;
-    vlc_value_t oldval, val;
-
-    p_config = config_FindConfig( p_this, psz_name );
-
-
-    /* sanity checks */
-    if( !p_config )
-    {
-        msg_Warn( p_this, "option %s does not exist", psz_name );
-        return;
-    }
-
-    if (!IsConfigStringType (p_config->i_type))
-    {
-        msg_Err( p_this, "option %s does not refer to a string", psz_name );
-        return;
-    }
-
-    vlc_mutex_lock( p_config->p_lock );
-
-    /* backup old value */
-    oldval.psz_string = (char *)p_config->value.psz;
-
-    if ((psz_value != NULL) && *psz_value)
-        p_config->value.psz = strdup (psz_value);
-    else
-        p_config->value.psz = NULL;
-
-    p_config->b_dirty = VLC_TRUE;
-
-    val.psz_string = (char *)p_config->value.psz;
-
-    vlc_mutex_unlock( p_config->p_lock );
-
-    if( p_config->pf_callback )
-    {
-        p_config->pf_callback( p_this, psz_name, oldval, val,
-                               p_config->p_callback_data );
-    }
-
-    /* free old string */
-    if( oldval.psz_string ) free( oldval.psz_string );
-}
-
-/*****************************************************************************
- * config_PutInt: set the integer value of an int variable
- *****************************************************************************
- * This function is used to set the value of variables which are internally
- * represented by an integer (CONFIG_ITEM_INTEGER and
- * CONFIG_ITEM_BOOL).
- *****************************************************************************/
-void __config_PutInt( vlc_object_t *p_this, const char *psz_name, int i_value )
-{
-    module_config_t *p_config;
-    vlc_value_t oldval, val;
-
-    p_config = config_FindConfig( p_this, psz_name );
-
-    /* sanity checks */
-    if( !p_config )
-    {
-        msg_Warn( p_this, "option %s does not exist", psz_name );
-        return;
-    }
-
-    if (!IsConfigIntegerType (p_config->i_type))
-    {
-        msg_Err( p_this, "option %s does not refer to an int", psz_name );
-        return;
-    }
-
-    /* backup old value */
-    oldval.i_int = p_config->value.i;
-
-    /* if i_min == i_max == 0, then do not use them */
-    if ((p_config->min.i == 0) && (p_config->max.i == 0))
-    {
-        p_config->value.i = i_value;
-    }
-    else if (i_value < p_config->min.i)
-    {
-        p_config->value.i = p_config->min.i;
-    }
-    else if (i_value > p_config->max.i)
-    {
-        p_config->value.i = p_config->max.i;
-    }
-    else
-    {
-        p_config->value.i = i_value;
-    }
-
-    p_config->b_dirty = VLC_TRUE;
-
-    val.i_int = p_config->value.i;
-
-    if( p_config->pf_callback )
-    {
-        p_config->pf_callback( p_this, psz_name, oldval, val,
-                               p_config->p_callback_data );
-    }
-}
-
-/*****************************************************************************
- * config_PutFloat: set the value of a float variable
- *****************************************************************************
- * This function is used to set the value of variables which are internally
- * represented by a float (CONFIG_ITEM_FLOAT).
- *****************************************************************************/
-void __config_PutFloat( vlc_object_t *p_this,
-                        const char *psz_name, float f_value )
-{
-    module_config_t *p_config;
-    vlc_value_t oldval, val;
-
-    p_config = config_FindConfig( p_this, psz_name );
-
-    /* sanity checks */
-    if( !p_config )
-    {
-        msg_Warn( p_this, "option %s does not exist", psz_name );
-        return;
-    }
-
-    if (!IsConfigFloatType (p_config->i_type))
-    {
-        msg_Err( p_this, "option %s does not refer to a float", psz_name );
-        return;
-    }
-
-    /* backup old value */
-    oldval.f_float = p_config->value.f;
-
-    /* if f_min == f_max == 0, then do not use them */
-    if ((p_config->min.f == 0) && (p_config->max.f == 0))
-    {
-        p_config->value.f = f_value;
-    }
-    else if (f_value < p_config->min.f)
-    {
-        p_config->value.f = p_config->min.f;
-    }
-    else if (f_value > p_config->max.f)
-    {
-        p_config->value.f = p_config->max.f;
-    }
-    else
-    {
-        p_config->value.f = f_value;
-    }
-
-    p_config->b_dirty = VLC_TRUE;
-
-    val.f_float = p_config->value.f;
-
-    if( p_config->pf_callback )
-    {
-        p_config->pf_callback( p_this, psz_name, oldval, val,
-                               p_config->p_callback_data );
-    }
-}
-
-/*****************************************************************************
- * config_FindConfig: find the config structure associated with an option.
- *****************************************************************************
- * FIXME: This function really needs to be optimized.
- * FIXME: And now even more.
- *****************************************************************************/
-module_config_t *config_FindConfig( vlc_object_t *p_this, const char *psz_name )
-{
-    vlc_list_t *p_list;
-    int i_index;
-
-    if( !psz_name ) return NULL;
-
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-
-    for( i_index = 0; i_index < p_list->i_count; i_index++ )
-    {
-        module_config_t *p_item, *p_end;
-        module_t *p_parser = (module_t *)p_list->p_values[i_index].p_object;
-
-        if( !p_parser->i_config_items )
-            continue;
-
-        for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
-             p_item < p_end;
-             p_item++ )
-        {
-            if( p_item->i_type & CONFIG_HINT )
-                /* ignore hints */
-                continue;
-            if( !strcmp( psz_name, p_item->psz_name ) )
-            {
-                vlc_list_release( p_list );
-                return p_item;
-            }
-        }
-    }
-
-    vlc_list_release( p_list );
-
-    return NULL;
-}
-
-/*****************************************************************************
- * config_FindModule: find a specific module structure.
- *****************************************************************************/
-module_t *config_FindModule( vlc_object_t *p_this, const char *psz_name )
-{
-    vlc_list_t *p_list;
-    module_t *p_module, *p_result = NULL;
-    int i_index;
-
-    if( !psz_name ) return NULL;
-
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-
-    for( i_index = 0; i_index < p_list->i_count; i_index++ )
-    {
-        p_module = (module_t *)p_list->p_values[i_index].p_object;
-        if( !strcmp( p_module->psz_object_name, psz_name ) )
-        {
-             p_result = p_module;
-             break;
-        }
-    }
-
-    vlc_list_release( p_list );
-
-    return p_result;
-}
-
-/*****************************************************************************
- * config_Duplicate: creates a duplicate of a module's configuration data.
- *****************************************************************************
- * Unfortunatly we cannot work directly with the module's config data as
- * this module might be unloaded from memory at any time (remember HideModule).
- * This is why we need to create an exact copy of the config data.
- *****************************************************************************/
-int config_Duplicate( module_t *p_module, const module_config_t *p_orig,
-                      size_t n )
-{
-    int j;
-    const module_config_t *p_item, *p_end = p_orig + n;
-
-    /* Calculate the structure length */
-    p_module->i_config_items = 0;
-    p_module->i_bool_items = 0;
-
-    for( p_item = p_orig; p_item < p_end; p_item++ )
-    {
-        if( p_item->i_type & CONFIG_ITEM )
-        {
-            p_module->i_config_items++;
-        }
-
-        if( p_item->i_type == CONFIG_ITEM_BOOL )
-        {
-            p_module->i_bool_items++;
-        }
-    }
-
-    /* Allocate memory */
-    p_module->p_config = (module_config_t *)calloc( n, sizeof(*p_orig) );
-    if( p_module->p_config == NULL )
-    {
-        msg_Err( p_module, "config error: can't duplicate p_config" );
-        return VLC_ENOMEM;
-    }
-    p_module->confsize = n;
-
-    /* Do the duplication job */
-    for( size_t i = 0; i < n ; i++ )
-    {
-        p_module->p_config[i] = p_orig[i];
-
-        if (IsConfigIntegerType (p_module->p_config[i].i_type))
-        {
-            p_module->p_config[i].orig.i = p_orig[i].value.i;
-            p_module->p_config[i].saved.i = p_orig[i].value.i;
-        }
-        else
-        if (IsConfigFloatType (p_module->p_config[i].i_type))
-        {
-            p_module->p_config[i].orig.f = p_orig[i].value.f;
-            p_module->p_config[i].saved.f = p_orig[i].value.f;
-        }
-        else
-        if (IsConfigStringType (p_module->p_config[i].i_type))
-        {
-            p_module->p_config[i].value.psz = strdupnull (p_orig[i].value.psz);
-            p_module->p_config[i].orig.psz = strdupnull (p_orig[i].value.psz);
-            p_module->p_config[i].saved.psz = NULL;
-        }
-
-        p_module->p_config[i].psz_type = strdupnull (p_orig[i].psz_type);
-        p_module->p_config[i].psz_name = strdupnull (p_orig[i].psz_name);
-        p_module->p_config[i].psz_current = strdupnull (p_orig[i].psz_current);
-        p_module->p_config[i].psz_text = _strdupnull (p_orig[i].psz_text);
-        p_module->p_config[i].psz_longtext = _strdupnull (p_orig[i].psz_longtext);
-
-        p_module->p_config[i].p_lock = &p_module->object_lock;
-
-        /* duplicate the string list */
-        if( p_orig[i].i_list )
-        {
-            if( p_orig[i].ppsz_list )
-            {
-                p_module->p_config[i].ppsz_list =
-                    malloc( (p_orig[i].i_list + 1) * sizeof(char *) );
-                if( p_module->p_config[i].ppsz_list )
-                {
-                    for( j = 0; j < p_orig[i].i_list; j++ )
-                        p_module->p_config[i].ppsz_list[j] =
-                                strdupnull (p_orig[i].ppsz_list[j]);
-                    p_module->p_config[i].ppsz_list[j] = NULL;
-                }
-            }
-            if( p_orig[i].ppsz_list_text )
-            {
-                p_module->p_config[i].ppsz_list_text =
-                    calloc( (p_orig[i].i_list + 1), sizeof(char *) );
-                if( p_module->p_config[i].ppsz_list_text )
-                {
-                    for( j = 0; j < p_orig[i].i_list; j++ )
-                        p_module->p_config[i].ppsz_list_text[j] =
-                                strdupnull (_(p_orig[i].ppsz_list_text[j]));
-                    p_module->p_config[i].ppsz_list_text[j] = NULL;
-                }
-            }
-            if( p_orig[i].pi_list )
-            {
-                p_module->p_config[i].pi_list =
-                    malloc( (p_orig[i].i_list + 1) * sizeof(int) );
-                if( p_module->p_config[i].pi_list )
-                {
-                    for( j = 0; j < p_orig[i].i_list; j++ )
-                        p_module->p_config[i].pi_list[j] =
-                            p_orig[i].pi_list[j];
-                }
-            }
-        }
-
-        /* duplicate the actions list */
-        if( p_orig[i].i_action )
-        {
-            int j;
-
-            p_module->p_config[i].ppf_action =
-                malloc( p_orig[i].i_action * sizeof(void *) );
-            p_module->p_config[i].ppsz_action_text =
-                malloc( p_orig[i].i_action * sizeof(char *) );
-
-            for( j = 0; j < p_orig[i].i_action; j++ )
-            {
-                p_module->p_config[i].ppf_action[j] =
-                    p_orig[i].ppf_action[j];
-                p_module->p_config[i].ppsz_action_text[j] =
-                    strdupnull (p_orig[i].ppsz_action_text[j]);
-            }
-        }
-
-        p_module->p_config[i].pf_callback = p_orig[i].pf_callback;
-    }
-    return VLC_SUCCESS;
-}
-
-
-/*****************************************************************************
- * config_Free: frees a duplicated module's configuration data.
- *****************************************************************************
- * This function frees all the data duplicated by config_Duplicate.
- *****************************************************************************/
-void config_Free( module_t *p_module )
-{
-    int i;
-
-    for (size_t j = 0; j < p_module->confsize; j++)
-    {
-        module_config_t *p_item = p_module->p_config + j;
-
-        free( (char*) p_item->psz_type );
-        free( (char*) p_item->psz_name );
-        free( (char*) p_item->psz_current );
-        free( (char*) p_item->psz_text );
-        free( (char*) p_item->psz_longtext );
-
-        if (IsConfigStringType (p_item->i_type))
-        {
-            freenull (p_item->value.psz);
-            freenull (p_item->orig.psz);
-            freenull (p_item->saved.psz);
-        }
-
-        if( p_item->i_list )
-        {
-            for( i = 0; i < p_item->i_list; i++ )
-            {
-                if( p_item->ppsz_list && p_item->ppsz_list[i] )
-                    free( (char*) p_item->ppsz_list[i] );
-                if( p_item->ppsz_list_text && p_item->ppsz_list_text[i] )
-                    free( (char*) p_item->ppsz_list_text[i] );
-            }
-            if( p_item->ppsz_list ) free( p_item->ppsz_list );
-            if( p_item->ppsz_list_text ) free( p_item->ppsz_list_text );
-            if( p_item->pi_list ) free( p_item->pi_list );
-        }
-
-        if( p_item->i_action )
-        {
-            for( i = 0; i < p_item->i_action; i++ )
-            {
-                free( (char*) p_item->ppsz_action_text[i] );
-            }
-            if( p_item->ppf_action ) free( p_item->ppf_action );
-            if( p_item->ppsz_action_text ) free( p_item->ppsz_action_text );
-        }
-    }
-
-    if (p_module->p_config != NULL)
-    {
-        free (p_module->p_config);
-        p_module->p_config = NULL;
-    }
-}
-
-/*****************************************************************************
- * config_SetCallbacks: sets callback functions in the duplicate p_config.
- *****************************************************************************
- * Unfortunatly we cannot work directly with the module's config data as
- * this module might be unloaded from memory at any time (remember HideModule).
- * This is why we need to duplicate callbacks each time we reload the module.
- *****************************************************************************/
-void config_SetCallbacks( module_config_t *p_new, module_config_t *p_orig,
-                          size_t n )
-{
-    for (size_t i = 0; i < n; i++)
-    {
-        p_new->pf_callback = p_orig->pf_callback;
-        p_new++;
-        p_orig++;
-    }
-}
-
-/*****************************************************************************
- * config_UnsetCallbacks: unsets callback functions in the duplicate p_config.
- *****************************************************************************
- * We simply undo what we did in config_SetCallbacks.
- *****************************************************************************/
-void config_UnsetCallbacks( module_config_t *p_new, size_t n )
-{
-    for (size_t i = 0; i < n; i++)
-    {
-        p_new->pf_callback = NULL;
-        p_new++;
-    }
-}
-
-/*****************************************************************************
- * config_ResetAll: reset the configuration data for all the modules.
- *****************************************************************************/
-void __config_ResetAll( vlc_object_t *p_this )
-{
-    int i_index;
-    vlc_list_t *p_list;
-    module_t *p_module;
-
-    /* Acquire config file lock */
-    vlc_mutex_lock( &p_this->p_libvlc->config_lock );
-
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-
-    for( i_index = 0; i_index < p_list->i_count; i_index++ )
-    {
-        p_module = (module_t *)p_list->p_values[i_index].p_object ;
-        if( p_module->b_submodule ) continue;
-
-        for (size_t i = 0; i < p_module->confsize; i++ )
-        {
-            if (IsConfigIntegerType (p_module->p_config[i].i_type))
-                p_module->p_config[i].value.i = p_module->p_config[i].orig.i;
-            else
-            if (IsConfigFloatType (p_module->p_config[i].i_type))
-                p_module->p_config[i].value.f = p_module->p_config[i].orig.f;
-            else
-            if (IsConfigStringType (p_module->p_config[i].i_type))
-            {
-                freenull (p_module->p_config[i].value.psz);
-                p_module->p_config[i].value.psz =
-                        strdupnull (p_module->p_config[i].orig.psz);
-            }
-        }
-    }
-
-    vlc_list_release( p_list );
-    vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
-}
-
-
-static FILE *config_OpenConfigFile( vlc_object_t *p_obj, const char *mode )
-{
-    static const char psz_subpath[] = DIR_SEP CONFIG_DIR DIR_SEP CONFIG_FILE;
-    const char *psz_filename = p_obj->p_libvlc->psz_configfile;
-    const char *psz_homedir;
-    size_t i_buflen = 0;
-    FILE *p_stream;
-
-    if( psz_filename == NULL )
-    {
-        psz_homedir = p_obj->p_libvlc->psz_homedir;
-        if( psz_homedir == NULL )
-        {
-            msg_Err( p_obj, "no home directory defined" );
-            return NULL;
-        }
-
-        i_buflen = strlen(psz_homedir) + sizeof(psz_subpath) + 1;
-    }
-
-    char buf[i_buflen];
-    if( psz_filename == NULL )
-    {
-        sprintf( buf, "%s%s", psz_homedir, psz_subpath );
-        psz_filename = buf;
-    }
-
-    msg_Dbg( p_obj, "opening config file (%s)", psz_filename );
-    p_stream = utf8_fopen( psz_filename, mode );
-    if( p_stream == NULL && errno != ENOENT )
-        msg_Err( p_obj, "cannot open config file (%s): %s", psz_filename, strerror(errno) );
-
-    return p_stream;
-}
-
-
-/*****************************************************************************
- * config_LoadConfigFile: loads the configuration file.
- *****************************************************************************
- * This function is called to load the config options stored in the config
- * file.
- *****************************************************************************/
-int __config_LoadConfigFile( vlc_object_t *p_this, const char *psz_module_name )
-{
-    vlc_list_t *p_list;
-    FILE *file;
-
-    file = config_OpenConfigFile (p_this, "rt");
-    if (file == NULL)
-        return VLC_EGENERIC;
-
-    /* Acquire config file lock */
-    vlc_mutex_lock( &p_this->p_libvlc->config_lock );
-
-    /* Look for the selected module, if NULL then save everything */
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-
-    /* Look for UTF-8 Byte Order Mark */
-    char * (*convert) (const char *) = strdupnull;
-    char bom[3];
-
-    if ((fread (bom, 1, 3, file) != 3)
-     || memcmp (bom, "\xEF\xBB\xBF", 3))
-    {
-        convert = FromLocaleDup;
-        rewind (file); /* no BOM, rewind */
-    }
-
-    module_t *module = NULL;
-    char line[1024], section[1022];
-    section[0] = '\0';
-
-    while (fgets (line, 1024, file) != NULL)
-    {
-        /* Ignore comments and empty lines */
-        switch (line[0])
-        {
-            case '#':
-            case '\n':
-            case '\0':
-                continue;
-        }
-
-        if (line[0] == '[')
-        {
-            char *ptr = strchr (line, ']');
-            if (ptr == NULL)
-                continue; /* syntax error; */
-            *ptr = '\0';
-
-            /* New section ( = a given module) */
-            strcpy (section, line + 1);
-            module = NULL;
-
-            if ((psz_module_name == NULL)
-             || (strcmp (psz_module_name, section) == 0))
-            {
-                for (int i = 0; i < p_list->i_count; i++)
-                {
-                    module_t *m = (module_t *)p_list->p_values[i].p_object;
-
-                    if ((strcmp (section, m->psz_object_name) == 0)
-                     && (m->i_config_items > 0)) /* ignore config-less modules */
-                    {
-                        module = m;
-                        if (psz_module_name != NULL)
-                            msg_Dbg (p_this,
-                                     "loading config for module \"%s\"",
-                                     section);
-                        break;
-                    }
-                }
-            }
-
-            continue;
-        }
-
-        if (module == NULL)
-            continue; /* no need to parse if there is no matching module */
-
-        char *ptr = strchr (line, '\n');
-        if (ptr != NULL)
-            *ptr = '\0';
-
-        /* look for option name */
-        const char *psz_option_name = line;
-
-        ptr = strchr (line, '=');
-        if (ptr == NULL)
-            continue; /* syntax error */
-
-        *ptr = '\0';
-        const char *psz_option_value = ptr + 1;
-
-        /* try to match this option with one of the module's options */
-        for (size_t i = 0; i < module->confsize; i++)
-        {
-            module_config_t *p_item = module->p_config + i;
-
-            if ((p_item->i_type & CONFIG_HINT)
-             || strcmp (p_item->psz_name, psz_option_name))
-                continue;
-
-            /* We found it */
-            switch( p_item->i_type )
-            {
-                case CONFIG_ITEM_BOOL:
-                case CONFIG_ITEM_INTEGER:
-                    if( !*psz_option_value )
-                        break;                    /* ignore empty option */
-                    p_item->value.i = strtol( psz_option_value, 0, 0 );
-                    p_item->saved.i = p_item->value.i;
-
-                    /*msg_Dbg (p_this, "option \"%s\", value %i",
-                             psz_option_name, p_item->value.i);*/
-                    break;
-
-                case CONFIG_ITEM_FLOAT:
-                    if( !*psz_option_value )
-                        break;                    /* ignore empty option */
-                    p_item->value.f = (float)i18n_atof( psz_option_value);
-                    p_item->saved.f = p_item->value.f;
-
-                    /*msg_Dbg (p_this, "option \"%s\", value %f",
-                             psz_option_name, (double)p_item->value.f);*/
-                    break;
-
-                case CONFIG_ITEM_KEY:
-                    if( !*psz_option_value )
-                        break;                    /* ignore empty option */
-                    p_item->value.i = ConfigStringToKey(psz_option_value);
-                    p_item->saved.i = p_item->value.i;
-                    break;
-
-                default:
-                    vlc_mutex_lock( p_item->p_lock );
-
-                    /* free old string */
-                    free( (char*) p_item->value.psz );
-                    free( (char*) p_item->saved.psz );
-
-                    p_item->value.psz = convert (psz_option_value);
-                    p_item->saved.psz = strdupnull (p_item->value.psz);
-
-                    vlc_mutex_unlock( p_item->p_lock );
-
-                    /*msg_Dbg (p_this, "option \"%s\", value \"%s\"",
-                             psz_option_name, psz_option_value ?: "");*/
-                    break;
-            }
-
-            break;
-        }
-    }
-
-    vlc_list_release( p_list );
-
-    fclose( file );
-
-    vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
-    return 0;
-}
-
-/*****************************************************************************
- * config_CreateDir: Create configuration directory if it doesn't exist.
- *****************************************************************************/
-int config_CreateDir( vlc_object_t *p_this, const char *psz_dirname )
-{
-    if( !psz_dirname && !*psz_dirname ) return -1;
-
-    if( utf8_mkdir( psz_dirname ) && ( errno != EEXIST ) )
-    {
-        msg_Err( p_this, "could not create %s (%s)",
-                 psz_dirname, strerror(errno) );
-        return -1;
-    }
-
-    return 0;
-}
-
-/*****************************************************************************
- * config_SaveConfigFile: Save a module's config options.
- *****************************************************************************
- * This will save the specified module's config options to the config file.
- * If psz_module_name is NULL then we save all the modules config options.
- * It's no use to save the config options that kept their default values, so
- * we'll try to be a bit clever here.
- *
- * When we save we mustn't delete the config options of the modules that
- * haven't been loaded. So we cannot just create a new config file with the
- * config structures we've got in memory.
- * I don't really know how to deal with this nicely, so I will use a completly
- * dumb method ;-)
- * I will load the config file in memory, but skipping all the sections of the
- * modules we want to save. Then I will create a brand new file, dump the file
- * loaded in memory and then append the sections of the modules we want to
- * save.
- * Really stupid no ?
- *****************************************************************************/
-static int SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name,
-                           vlc_bool_t b_autosave )
-{
-    module_t *p_parser;
-    vlc_list_t *p_list;
-    FILE *file;
-    char p_line[1024], *p_index2;
-    int i_sizebuf = 0;
-    char *p_bigbuffer, *p_index;
-    vlc_bool_t b_backup;
-    int i_index;
-
-    /* Acquire config file lock */
-    vlc_mutex_lock( &p_this->p_libvlc->config_lock );
-
-    if (p_this->p_libvlc->psz_configfile == NULL)
-    {
-        const char *psz_homedir = p_this->p_libvlc->psz_homedir;
-        if( !psz_homedir )
-        {
-            msg_Err( p_this, "no home directory defined" );
-            vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
-            return -1;
-        }
-
-        char dirname[strlen (psz_homedir) + sizeof (DIR_SEP CONFIG_DIR)];
-        sprintf (dirname, "%s" DIR_SEP CONFIG_DIR, psz_homedir);
-        config_CreateDir (p_this, dirname);
-    }
-
-    file = config_OpenConfigFile (p_this, "rt");
-    if (file != NULL)
-    {
-        /* look for file size */
-        fseek( file, 0L, SEEK_END );
-        i_sizebuf = ftell( file );
-        fseek( file, 0L, SEEK_SET );
-    }
-
-    p_bigbuffer = p_index = malloc( i_sizebuf+1 );
-    if( !p_bigbuffer )
-    {
-        msg_Err( p_this, "out of memory" );
-        if( file ) fclose( file );
-        vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
-        return -1;
-    }
-    p_bigbuffer[0] = 0;
-
-    /* List all available modules */
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-
-    /* backup file into memory, we only need to backup the sections we won't
-     * save later on */
-    b_backup = 0;
-    while( file && fgets( p_line, 1024, file ) )
-    {
-        if( (p_line[0] == '[') && (p_index2 = strchr(p_line,']')))
-        {
-
-            /* we found a section, check if we need to do a backup */
-            for( i_index = 0; i_index < p_list->i_count; i_index++ )
-            {
-                p_parser = (module_t *)p_list->p_values[i_index].p_object ;
-
-                if( ((p_index2 - &p_line[1])
-                       == (int)strlen(p_parser->psz_object_name) )
-                    && !memcmp( &p_line[1], p_parser->psz_object_name,
-                                strlen(p_parser->psz_object_name) ) )
-                {
-                    if( !psz_module_name )
-                        break;
-                    else if( !strcmp( psz_module_name,
-                                      p_parser->psz_object_name ) )
-                        break;
-                }
-            }
-
-            if( i_index == p_list->i_count )
-            {
-                /* we don't have this section in our list so we need to back
-                 * it up */
-                *p_index2 = 0;
-#if 0
-                msg_Dbg( p_this, "backing up config for unknown module \"%s\"",
-                                 &p_line[1] );
-#endif
-                *p_index2 = ']';
-
-                b_backup = 1;
-            }
-            else
-            {
-                b_backup = 0;
-            }
-        }
-
-        /* save line if requested and line is valid (doesn't begin with a
-         * space, tab, or eol) */
-        if( b_backup && (p_line[0] != '\n') && (p_line[0] != ' ')
-            && (p_line[0] != '\t') )
-        {
-            strcpy( p_index, p_line );
-            p_index += strlen( p_line );
-        }
-    }
-    if( file ) fclose( file );
-
-
-    /*
-     * Save module config in file
-     */
-
-    file = config_OpenConfigFile (p_this, "wt");
-    if( !file )
-    {
-        vlc_list_release( p_list );
-        free( p_bigbuffer );
-        vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
-        return -1;
-    }
-
-    fprintf( file, "\xEF\xBB\xBF###\n###  " COPYRIGHT_MESSAGE "\n###\n\n"
-       "###\n### lines begining with a '#' character are comments\n###\n\n" );
-
-    /* Look for the selected module, if NULL then save everything */
-    for( i_index = 0; i_index < p_list->i_count; i_index++ )
-    {
-        module_config_t *p_item, *p_end;
-        p_parser = (module_t *)p_list->p_values[i_index].p_object ;
-
-        if( psz_module_name && strcmp( psz_module_name,
-                                       p_parser->psz_object_name ) )
-            continue;
-
-        if( !p_parser->i_config_items )
-            continue;
-
-        if( psz_module_name )
-            msg_Dbg( p_this, "saving config for module \"%s\"",
-                     p_parser->psz_object_name );
-
-        fprintf( file, "[%s]", p_parser->psz_object_name );
-        if( p_parser->psz_longname )
-            fprintf( file, " # %s\n\n", p_parser->psz_longname );
-        else
-            fprintf( file, "\n\n" );
-
-        for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
-             p_item < p_end;
-             p_item++ )
-        {
-            char  *psz_key;
-            int   i_value = p_item->value.i;
-            float f_value = p_item->value.f;
-            const char  *psz_value = p_item->value.psz;
-
-            if( p_item->i_type & CONFIG_HINT )
-                /* ignore hints */
-                continue;
-            /* Ignore deprecated options */
-            if( p_item->psz_current )
-                continue;
-            if( p_item->b_unsaveable )
-                /*obvious*/
-                continue;
-
-            if( b_autosave && !p_item->b_autosave )
-            {
-                i_value = p_item->saved.i;
-                f_value = p_item->saved.f;
-                psz_value = p_item->saved.psz;
-                if( !psz_value ) psz_value = p_item->orig.psz;
-            }
-            else
-            {
-                p_item->b_dirty = VLC_FALSE;
-            }
-
-            switch( p_item->i_type )
-            {
-            case CONFIG_ITEM_BOOL:
-            case CONFIG_ITEM_INTEGER:
-                if( p_item->psz_text )
-                    fprintf( file, "# %s (%s)\n", p_item->psz_text,
-                             (p_item->i_type == CONFIG_ITEM_BOOL) ?
-                             _("boolean") : _("integer") );
-                if( i_value == p_item->orig.i )
-                    fputc ('#', file);
-                fprintf( file, "%s=%i\n", p_item->psz_name, i_value );
-
-                p_item->saved.i = i_value;
-                break;
-
-            case CONFIG_ITEM_KEY:
-                if( p_item->psz_text )
-                    fprintf( file, "# %s (%s)\n", p_item->psz_text,
-                             _("key") );
-                if( i_value == p_item->orig.i )
-                    fputc ('#', file);
-                psz_key = ConfigKeyToString( i_value );
-                fprintf( file, "%s=%s\n", p_item->psz_name,
-                         psz_key ? psz_key : "" );
-                freenull (psz_key);
-
-                p_item->saved.i = i_value;
-                break;
-
-            case CONFIG_ITEM_FLOAT:
-                if( p_item->psz_text )
-                    fprintf( file, "# %s (%s)\n", p_item->psz_text,
-                             _("float") );
-                if( f_value == p_item->orig.f )
-                    fputc ('#', file);
-                fprintf( file, "%s=%f\n", p_item->psz_name, (double)f_value );
-
-                p_item->saved.f = f_value;
-                break;
-
-            default:
-                if( p_item->psz_text )
-                    fprintf( file, "# %s (%s)\n", p_item->psz_text,
-                             _("string") );
-                if( (!psz_value && !p_item->orig.psz) ||
-                    (psz_value && p_item->orig.psz &&
-                     !strcmp( psz_value, p_item->orig.psz )) )
-                    fputc ('#', file);
-                fprintf( file, "%s=%s\n", p_item->psz_name,
-                         psz_value ?: "" );
-
-                if( b_autosave && !p_item->b_autosave ) break;
-
-                freenull (p_item->saved.psz);
-                if( (psz_value && p_item->orig.psz &&
-                     strcmp( psz_value, p_item->orig.psz )) ||
-                    !psz_value || !p_item->orig.psz)
-                    p_item->saved.psz = strdupnull (psz_value);
-                else
-                    p_item->saved.psz = NULL;
-            }
-        }
-
-        fputc ('\n', file);
-    }
-
-    vlc_list_release( p_list );
-
-    /*
-     * Restore old settings from the config in file
-     */
-    fputs( p_bigbuffer, file );
-    free( p_bigbuffer );
-
-    fclose( file );
-    vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
-
-    return 0;
-}
-
-int config_AutoSaveConfigFile( vlc_object_t *p_this )
-{
-    vlc_list_t *p_list;
-    int i_index, i_count;
-
-    if( !p_this ) return -1;
-
-    /* Check if there's anything to save */
-    vlc_mutex_lock( &p_this->p_libvlc->config_lock );
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-    i_count = p_list->i_count;
-    for( i_index = 0; i_index < i_count; i_index++ )
-    {
-        module_t *p_parser = (module_t *)p_list->p_values[i_index].p_object ;
-        module_config_t *p_item, *p_end;
-
-        if( !p_parser->i_config_items ) continue;
-
-        for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
-             p_item < p_end;
-             p_item++ )
-        {
-            if( p_item->b_autosave && p_item->b_dirty ) break;
-        }
-        break;
-    }
-    vlc_list_release( p_list );
-    vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
-
-    if( i_index == i_count ) return VLC_SUCCESS;
-    return SaveConfigFile( p_this, 0, VLC_TRUE );
-}
-
-int __config_SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name )
-{
-    return SaveConfigFile( p_this, psz_module_name, VLC_FALSE );
-}
-
-/*****************************************************************************
- * config_LoadCmdLine: parse command line
- *****************************************************************************
- * Parse command line for configuration options.
- * Now that the module_bank has been initialized, we can dynamically
- * generate the longopts structure used by getops. We have to do it this way
- * because we don't know (and don't want to know) in advance the configuration
- * options used (ie. exported) by each module.
- *****************************************************************************/
-int __config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, char *ppsz_argv[],
-                          vlc_bool_t b_ignore_errors )
-{
-    int i_cmd, i_index, i_opts, i_shortopts, flag, i_verbose = 0;
-    module_t *p_parser;
-    vlc_list_t *p_list;
-    struct option *p_longopts;
-    int i_modules_index;
-
-    /* Short options */
-    module_config_t *pp_shortopts[256];
-    char *psz_shortopts;
-
-    /* Set default configuration and copy arguments */
-    p_this->p_libvlc->i_argc    = *pi_argc;
-    p_this->p_libvlc->ppsz_argv = ppsz_argv;
-
-#ifdef __APPLE__
-    /* When VLC.app is run by double clicking in Mac OS X, the 2nd arg
-     * is the PSN - process serial number (a unique PID-ish thingie)
-     * still ok for real Darwin & when run from command line */
-    if ( (*pi_argc > 1) && (strncmp( ppsz_argv[ 1 ] , "-psn" , 4 ) == 0) )
-                                        /* for example -psn_0_9306113 */
-    {
-        /* GDMF!... I can't do this or else the MacOSX window server will
-         * not pick up the PSN and not register the app and we crash...
-         * hence the following kludge otherwise we'll get confused w/ argv[1]
-         * being an input file name */
-#if 0
-        ppsz_argv[ 1 ] = NULL;
-#endif
-        *pi_argc = *pi_argc - 1;
-        pi_argc--;
-        return 0;
-    }
-#endif
-
-    /* List all modules */
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-
-    /*
-     * Generate the longopts and shortopts structures used by getopt_long
-     */
-
-    i_opts = 0;
-    for( i_modules_index = 0; i_modules_index < p_list->i_count;
-         i_modules_index++ )
-    {
-        p_parser = (module_t *)p_list->p_values[i_modules_index].p_object ;
-
-        /* count the number of exported configuration options (to allocate
-         * longopts). We also need to allocate space for two options when
-         * dealing with boolean to allow for --foo and --no-foo */
-        i_opts += p_parser->i_config_items
-                     + 2 * p_parser->i_bool_items;
-    }
-
-    p_longopts = malloc( sizeof(struct option) * (i_opts + 1) );
-    if( p_longopts == NULL )
-    {
-        msg_Err( p_this, "out of memory" );
-        vlc_list_release( p_list );
-        return -1;
-    }
-
-    psz_shortopts = malloc( sizeof( char ) * (2 * i_opts + 1) );
-    if( psz_shortopts == NULL )
-    {
-        msg_Err( p_this, "out of memory" );
-        free( p_longopts );
-        vlc_list_release( p_list );
-        return -1;
-    }
-
-    /* If we are requested to ignore errors, then we must work on a copy
-     * of the ppsz_argv array, otherwise getopt_long will reorder it for
-     * us, ignoring the arity of the options */
-    if( b_ignore_errors )
-    {
-        ppsz_argv = (char**)malloc( *pi_argc * sizeof(char *) );
-        if( ppsz_argv == NULL )
-        {
-            msg_Err( p_this, "out of memory" );
-            free( psz_shortopts );
-            free( p_longopts );
-            vlc_list_release( p_list );
-            return -1;
-        }
-        memcpy( ppsz_argv, p_this->p_libvlc->ppsz_argv,
-                *pi_argc * sizeof(char *) );
-    }
-
-    i_shortopts = 0;
-    for( i_index = 0; i_index < 256; i_index++ )
-    {
-        pp_shortopts[i_index] = NULL;
-    }
-
-    /* Fill the p_longopts and psz_shortopts structures */
-    i_index = 0;
-    for( i_modules_index = 0; i_modules_index < p_list->i_count;
-         i_modules_index++ )
-    {
-        module_config_t *p_item, *p_end;
-        p_parser = (module_t *)p_list->p_values[i_modules_index].p_object ;
-
-        if( !p_parser->i_config_items )
-            continue;
-
-        for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
-             p_item < p_end;
-             p_item++ )
-        {
-            /* Ignore hints */
-            if( p_item->i_type & CONFIG_HINT )
-                continue;
-
-            /* Add item to long options */
-            p_longopts[i_index].name = strdup( p_item->psz_name );
-            if( p_longopts[i_index].name == NULL ) continue;
-            p_longopts[i_index].has_arg =
-                (p_item->i_type == CONFIG_ITEM_BOOL)?
-                                               no_argument : required_argument;
-            p_longopts[i_index].flag = &flag;
-            p_longopts[i_index].val = 0;
-            i_index++;
-
-            /* When dealing with bools we also need to add the --no-foo
-             * option */
-            if( p_item->i_type == CONFIG_ITEM_BOOL )
-            {
-                char *psz_name = malloc( strlen(p_item->psz_name) + 3 );
-                if( psz_name == NULL ) continue;
-                strcpy( psz_name, "no" );
-                strcat( psz_name, p_item->psz_name );
-
-                p_longopts[i_index].name = psz_name;
-                p_longopts[i_index].has_arg = no_argument;
-                p_longopts[i_index].flag = &flag;
-                p_longopts[i_index].val = 1;
-                i_index++;
-
-                psz_name = malloc( strlen(p_item->psz_name) + 4 );
-                if( psz_name == NULL ) continue;
-                strcpy( psz_name, "no-" );
-                strcat( psz_name, p_item->psz_name );
-
-                p_longopts[i_index].name = psz_name;
-                p_longopts[i_index].has_arg = no_argument;
-                p_longopts[i_index].flag = &flag;
-                p_longopts[i_index].val = 1;
-                i_index++;
-            }
-
-            /* If item also has a short option, add it */
-            if( p_item->i_short )
-            {
-                pp_shortopts[(int)p_item->i_short] = p_item;
-                psz_shortopts[i_shortopts] = p_item->i_short;
-                i_shortopts++;
-                if( p_item->i_type != CONFIG_ITEM_BOOL )
-                {
-                    psz_shortopts[i_shortopts] = ':';
-                    i_shortopts++;
-
-                    if( p_item->i_short == 'v' )
-                    {
-                        psz_shortopts[i_shortopts] = ':';
-                        i_shortopts++;
-                    }
-                }
-            }
-        }
-    }
-
-    /* We don't need the module list anymore */
-    vlc_list_release( p_list );
-
-    /* Close the longopts and shortopts structures */
-    memset( &p_longopts[i_index], 0, sizeof(struct option) );
-    psz_shortopts[i_shortopts] = '\0';
-
-    /*
-     * Parse the command line options
-     */
-    opterr = 0;
-    optind = 0; /* set to 0 to tell GNU getopt to reinitialize */
-    while( ( i_cmd = getopt_long( *pi_argc, ppsz_argv, psz_shortopts,
-                                  p_longopts, &i_index ) ) != -1 )
-    {
-        /* A long option has been recognized */
-        if( i_cmd == 0 )
-        {
-            module_config_t *p_conf;
-            char *psz_name = (char *)p_longopts[i_index].name;
-
-            /* Check if we deal with a --nofoo or --no-foo long option */
-            if( flag ) psz_name += psz_name[2] == '-' ? 3 : 2;
-
-            /* Store the configuration option */
-            p_conf = config_FindConfig( p_this, psz_name );
-            if( p_conf )
-            {
-                /* Check if the option is deprecated */
-                if( p_conf->psz_current )
-                {
-                    if( !strcmp(p_conf->psz_current,"SUPPRESSED") )
-                    {
-                        if( !b_ignore_errors )
-                        {
-                            fprintf(stderr,
-                                    "Warning: option --%s is no longer used.\n",
-                                    p_conf->psz_name);
-                        }
-                       continue;
-                    }
-                    if( !b_ignore_errors )
-                    {
-                        if( p_conf->b_strict )
-                        {
-                            fprintf( stderr,
-                                     "Error: option --%s is deprecated. "
-                                     "Use --%s instead.\n",
-                                     p_conf->psz_name, p_conf->psz_current);
-                            /*free */
-                            for( i_index = 0; p_longopts[i_index].name; i_index++ )
-                                free( (char *)p_longopts[i_index].name );
-
-                            free( p_longopts );
-                            free( psz_shortopts );
-                            return -1;
-                        }
-                        fprintf(stderr,
-                                "Warning: option --%s is deprecated. "
-                                "You should use --%s instead.\n",
-                                p_conf->psz_name, p_conf->psz_current);
-                    }
-                    psz_name = (char *)p_conf->psz_current;
-                    p_conf = config_FindConfig( p_this, psz_name );
-                }
-
-                switch( p_conf->i_type )
-                {
-                    case CONFIG_ITEM_STRING:
-                    case CONFIG_ITEM_FILE:
-                    case CONFIG_ITEM_DIRECTORY:
-                    case CONFIG_ITEM_MODULE:
-                    case CONFIG_ITEM_MODULE_LIST:
-                    case CONFIG_ITEM_MODULE_LIST_CAT:
-                    case CONFIG_ITEM_MODULE_CAT:
-                        config_PutPsz( p_this, psz_name, optarg );
-                        break;
-                    case CONFIG_ITEM_INTEGER:
-                        config_PutInt( p_this, psz_name, strtol(optarg, 0, 0));
-                        break;
-                    case CONFIG_ITEM_FLOAT:
-                        config_PutFloat( p_this, psz_name, (float)atof(optarg) );
-                        break;
-                    case CONFIG_ITEM_KEY:
-                        config_PutInt( p_this, psz_name, ConfigStringToKey( optarg ) );
-                        break;
-                    case CONFIG_ITEM_BOOL:
-                        config_PutInt( p_this, psz_name, !flag );
-                        break;
-                }
-                continue;
-            }
-        }
-
-        /* A short option has been recognized */
-        if( pp_shortopts[i_cmd] != NULL )
-        {
-            switch( pp_shortopts[i_cmd]->i_type )
-            {
-                case CONFIG_ITEM_STRING:
-                case CONFIG_ITEM_FILE:
-                case CONFIG_ITEM_DIRECTORY:
-                case CONFIG_ITEM_MODULE:
-                case CONFIG_ITEM_MODULE_CAT:
-                case CONFIG_ITEM_MODULE_LIST:
-                case CONFIG_ITEM_MODULE_LIST_CAT:
-                    config_PutPsz( p_this, pp_shortopts[i_cmd]->psz_name, optarg );
-                    break;
-                case CONFIG_ITEM_INTEGER:
-                    if( i_cmd == 'v' )
-                    {
-                        if( optarg )
-                        {
-                            if( *optarg == 'v' ) /* eg. -vvv */
-                            {
-                                i_verbose++;
-                                while( *optarg == 'v' )
-                                {
-                                    i_verbose++;
-                                    optarg++;
-                                }
-                            }
-                            else
-                            {
-                                i_verbose += atoi( optarg ); /* eg. -v2 */
-                            }
-                        }
-                        else
-                        {
-                            i_verbose++; /* -v */
-                        }
-                        config_PutInt( p_this, pp_shortopts[i_cmd]->psz_name,
-                                               i_verbose );
-                    }
-                    else
-                    {
-                        config_PutInt( p_this, pp_shortopts[i_cmd]->psz_name,
-                                               strtol(optarg, 0, 0) );
-                    }
-                    break;
-                case CONFIG_ITEM_BOOL:
-                    config_PutInt( p_this, pp_shortopts[i_cmd]->psz_name, 1 );
-                    break;
-            }
-
-            continue;
-        }
-
-        /* Internal error: unknown option */
-        if( !b_ignore_errors )
-        {
-            fprintf( stderr, "%s: unknown option"
-                     " or missing mandatory argument ",
-                     p_this->p_libvlc->psz_object_name );
-            if( optopt )
-            {
-                fprintf( stderr, "`-%c'\n", optopt );
-            }
-            else
-            {
-                fprintf( stderr, "`%s'\n", ppsz_argv[optind-1] );
-            }
-            fprintf( stderr, "Try `%s --help' for more information.\n",
-                             p_this->p_libvlc->psz_object_name );
-
-            for( i_index = 0; p_longopts[i_index].name; i_index++ )
-                free( (char *)p_longopts[i_index].name );
-            free( p_longopts );
-            free( psz_shortopts );
-            return -1;
-        }
-    }
-
-    /* Free allocated resources */
-    for( i_index = 0; p_longopts[i_index].name; i_index++ )
-        free( (char *)p_longopts[i_index].name );
-    free( p_longopts );
-    free( psz_shortopts );
-    if( b_ignore_errors ) free( ppsz_argv );
-
-    return 0;
-}
-
-/**
- * config_GetDataDir: find directory where shared data is installed
- *
- * @return a string (always succeeds).
- */
-const char *config_GetDataDir( const vlc_object_t *p_this )
-{
-#if defined (WIN32) || defined (UNDER_CE)
-    return p_this->p_libvlc_global->psz_vlcpath;
-#elif defined(__APPLE__) || defined (SYS_BEOS)
-    static char path[PATH_MAX] = "";
-
-    if( *path == '\0' )
-    {
-        snprintf( path, sizeof( path ), "%s/share",
-                  p_this->p_libvlc_global->psz_vlcpath );
-        path[sizeof( path ) - 1] = '\0';
-    }
-    return path;
-#else
-    (void)p_this;
-    return DATA_PATH;
-#endif
-}
-
-/*****************************************************************************
- * config_GetHomeDir, config_GetUserDir: find the user's home directory.
- *****************************************************************************
- * This function will try by different ways to find the user's home path.
- * Note that this function is not reentrant, it should be called only once
- * at the beginning of main where the result will be stored for later use.
- *****************************************************************************/
-static char *GetDir( vlc_bool_t b_appdata )
-{
-    const char *psz_localhome = NULL;
-
-#if defined(WIN32) && !defined(UNDER_CE)
-    typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD,
-                                               LPWSTR );
-#ifndef CSIDL_FLAG_CREATE
-#   define CSIDL_FLAG_CREATE 0x8000
-#endif
-#ifndef CSIDL_APPDATA
-#   define CSIDL_APPDATA 0x1A
-#endif
-#ifndef CSIDL_PROFILE
-#   define CSIDL_PROFILE 0x28
-#endif
-#ifndef SHGFP_TYPE_CURRENT
-#   define SHGFP_TYPE_CURRENT 0
-#endif
-
-    HINSTANCE shfolder_dll;
-    SHGETFOLDERPATH SHGetFolderPath ;
-
-    /* load the shfolder dll to retrieve SHGetFolderPath */
-    if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL )
-    {
-        SHGetFolderPath = (void *)GetProcAddress( shfolder_dll,
-                                                  _T("SHGetFolderPathW") );
-        if ( SHGetFolderPath != NULL )
-        {
-            wchar_t whomedir[MAX_PATH];
-
-            /* get the "Application Data" folder for the current user */
-            if( S_OK == SHGetFolderPath( NULL,
-                                         (b_appdata ? CSIDL_APPDATA :
-                                           CSIDL_PROFILE) | CSIDL_FLAG_CREATE,
-                                         NULL, SHGFP_TYPE_CURRENT,
-                                         whomedir ) )
-            {
-                FreeLibrary( shfolder_dll );
-                return FromWide( whomedir );
-            }
-        }
-        FreeLibrary( shfolder_dll );
-    }
-
-#elif defined(UNDER_CE)
-
-#ifndef CSIDL_APPDATA
-#   define CSIDL_APPDATA 0x1A
-#endif
-
-    wchar_t whomedir[MAX_PATH];
-
-    /* get the "Application Data" folder for the current user */
-    if( SHGetSpecialFolderPath( NULL, whomedir, CSIDL_APPDATA, 1 ) )
-        return FromWide( whomedir );
-#endif
-
-#if defined(HAVE_GETPWUID)
-    struct passwd *p_pw;
-    (void)b_appdata;
-
-    if( ( p_pw = getpwuid( getuid() ) ) == NULL )
-#endif
-    {
-        psz_localhome = getenv( "HOME" );
-        if( psz_localhome == NULL )
-        {
-            psz_localhome = getenv( "TMP" );
-            if( psz_localhome == NULL )
-                psz_localhome = "/tmp";
-        }
-    }
-#if defined(HAVE_GETPWUID)
-    else
-        psz_localhome = p_pw->pw_dir;
-#endif
-
-    return FromLocaleDup( psz_localhome );
-}
-
-char *config_GetHomeDir( void )
-{
-    return GetDir( VLC_TRUE );
-}
-
-char *config_GetUserDir( void )
-{
-    return GetDir( VLC_FALSE );
-}
-
-
-static int ConfigStringToKey( const char *psz_key )
-{
-    int i_key = 0;
-    unsigned int i;
-    const char *psz_parser = strchr( psz_key, '-' );
-    while( psz_parser && psz_parser != psz_key )
-    {
-        for( i = 0; i < sizeof(vlc_modifiers) / sizeof(key_descriptor_t); i++ )
-        {
-            if( !strncasecmp( vlc_modifiers[i].psz_key_string, psz_key,
-                              strlen( vlc_modifiers[i].psz_key_string ) ) )
-            {
-                i_key |= vlc_modifiers[i].i_key_code;
-            }
-        }
-        psz_key = psz_parser + 1;
-        psz_parser = strchr( psz_key, '-' );
-    }
-    for( i = 0; i < sizeof(vlc_keys) / sizeof( key_descriptor_t ); i++ )
-    {
-        if( !strcasecmp( vlc_keys[i].psz_key_string, psz_key ) )
-        {
-            i_key |= vlc_keys[i].i_key_code;
-            break;
-        }
-    }
-    return i_key;
-}
-
-static char *ConfigKeyToString( int i_key )
-{
-    char *psz_key = malloc( 100 );
-    char *p;
-    size_t index;
-
-    if ( !psz_key )
-    {
-        return NULL;
-    }
-    *psz_key = '\0';
-    p = psz_key;
-    for( index = 0; index < (sizeof(vlc_modifiers) / sizeof(key_descriptor_t));
-         index++ )
-    {
-        if( i_key & vlc_modifiers[index].i_key_code )
-        {
-            p += sprintf( p, "%s-", vlc_modifiers[index].psz_key_string );
-        }
-    }
-    for( index = 0; index < (sizeof(vlc_keys) / sizeof( key_descriptor_t));
-         index++)
-    {
-        if( (int)( i_key & ~KEY_MODIFIER ) == vlc_keys[index].i_key_code )
-        {
-            p += sprintf( p, "%s", vlc_keys[index].psz_key_string );
-            break;
-        }
-    }
-    return psz_key;
-}
diff --git a/src/misc/configuration.h b/src/misc/configuration.h
deleted file mode 100644 (file)
index 2a14693..0000000
+++ /dev/null
@@ -1,49 +0,0 @@
-/*****************************************************************************
- * configuration.h management of the modules configuration
- *****************************************************************************
- * Copyright (C) 2007 the VideoLAN team
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-#ifndef LIBVLC_CONFIGURATION_H
-# define LIBVLC_CONFIGURATION_H 1
-
-# ifdef __cplusplus
-extern "C" {
-# endif
-
-/* Internal configuration prototypes and structures */
-
-int  config_CreateDir( vlc_object_t *, const char * );
-int  config_AutoSaveConfigFile( vlc_object_t * );
-
-void config_Free( module_t * );
-
-void config_SetCallbacks( module_config_t *, module_config_t *, size_t );
-void config_UnsetCallbacks ( module_config_t *, size_t );
-
-#define config_LoadCmdLine(a,b,c,d) __config_LoadCmdLine(VLC_OBJECT(a),b,c,d)
-#define config_LoadConfigFile(a,b) __config_LoadConfigFile(VLC_OBJECT(a),b)
-
-int   __config_LoadCmdLine  ( vlc_object_t *, int *, char *[], vlc_bool_t );
-char *   config_GetHomeDir     ( void );
-char *   config_GetUserDir     ( void );
-int    __config_LoadConfigFile ( vlc_object_t *, const char * );
-
-# ifdef __cplusplus
-}
-# endif
-#endif
diff --git a/src/misc/configuration_chain.c b/src/misc/configuration_chain.c
deleted file mode 100644 (file)
index 03ebf2d..0000000
+++ /dev/null
@@ -1,390 +0,0 @@
-/*****************************************************************************
- * configuration_chain.c : configuration module chain parsing stuff
- *****************************************************************************
- * Copyright (C) 2002-2006 the VideoLAN team
- * $Id$
- *
- * Authors: Christophe Massiot <massiot@via.ecp.fr>
- *          Laurent Aimar <fenrir@via.ecp.fr>
- *          Eric Petit <titer@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/*****************************************************************************
- * Preamble
- *****************************************************************************/
-
-#include <vlc/vlc.h>
-
-#include <stdlib.h>                                                /* free() */
-#include <stdio.h>                                              /* sprintf() */
-#include <string.h>                                            /* strerror() */
-
-/*****************************************************************************
- * Local prototypes
- *****************************************************************************/
-
-/* chain format:
-    module{option=*:option=*}[:module{option=*:...}]
- */
-#define SKIPSPACE( p ) { while( *p && ( *p == ' ' || *p == '\t' ) ) p++; }
-#define SKIPTRAILINGSPACE( p, e ) \
-    { while( e > p && ( *(e-1) == ' ' || *(e-1) == '\t' ) ) e--; }
-
-/* go accross " " and { } */
-static const char *_get_chain_end( const char *str )
-{
-    char c;
-    const char *p = str;
-
-    SKIPSPACE( p );
-
-    for( ;; )
-    {
-        if( !*p || *p == ',' || *p == '}' ) return p;
-
-        if( *p != '{' && *p != '"' && *p != '\'' )
-        {
-            p++;
-            continue;
-        }
-
-        if( *p == '{' ) c = '}';
-        else c = *p;
-        p++;
-
-        for( ;; )
-        {
-            if( !*p ) return p;
-
-            if( *p == c ) return ++p;
-            else if( *p == '{' && c == '}' ) p = _get_chain_end( p );
-            else p++;
-        }
-    }
-}
-
-char *config_ChainCreate( char **ppsz_name, config_chain_t **pp_cfg, const char *psz_chain )
-{
-    config_chain_t *p_cfg = NULL;
-    const char *p = psz_chain;
-
-    *ppsz_name = NULL;
-    *pp_cfg    = NULL;
-
-    if( !p ) return NULL;
-
-    SKIPSPACE( p );
-
-    while( *p && *p != '{' && *p != ':' && *p != ' ' && *p != '\t' ) p++;
-
-    if( p == psz_chain ) return NULL;
-
-    *ppsz_name = strndup( psz_chain, p - psz_chain );
-
-    SKIPSPACE( p );
-
-    if( *p == '{' )
-    {
-        const char *psz_name;
-
-        p++;
-
-        for( ;; )
-        {
-            config_chain_t cfg;
-
-            SKIPSPACE( p );
-
-            psz_name = p;
-
-            while( *p && *p != '=' && *p != ',' && *p != '{' && *p != '}' &&
-                   *p != ' ' && *p != '\t' ) p++;
-
-            /* fprintf( stderr, "name=%s - rest=%s\n", psz_name, p ); */
-            if( p == psz_name )
-            {
-                fprintf( stderr, "invalid options (empty)" );
-                break;
-            }
-
-            cfg.psz_name = strndup( psz_name, p - psz_name );
-
-            SKIPSPACE( p );
-
-            if( *p == '=' || *p == '{' )
-            {
-                const char *end;
-                vlc_bool_t b_keep_brackets = (*p == '{');
-
-                if( *p == '=' ) p++;
-
-                end = _get_chain_end( p );
-                if( end <= p )
-                {
-                    cfg.psz_value = NULL;
-                }
-                else
-                {
-                    /* Skip heading and trailing spaces.
-                     * This ain't necessary but will avoid simple
-                     * user mistakes. */
-                    SKIPSPACE( p );
-                }
-
-                if( end <= p )
-                {
-                    cfg.psz_value = NULL;
-                }
-                else
-                {
-                    if( *p == '\'' || *p == '"' ||
-                        ( !b_keep_brackets && *p == '{' ) )
-                    {
-                        p++;
-
-                        if( *(end-1) != '\'' && *(end-1) == '"' )
-                            SKIPTRAILINGSPACE( p, end );
-
-                        if( end - 1 <= p ) cfg.psz_value = NULL;
-                        else cfg.psz_value = strndup( p, end -1 - p );
-                    }
-                    else
-                    {
-                        SKIPTRAILINGSPACE( p, end );
-                        if( end <= p ) cfg.psz_value = NULL;
-                        else cfg.psz_value = strndup( p, end - p );
-                    }
-                }
-
-                p = end;
-                SKIPSPACE( p );
-            }
-            else
-            {
-                cfg.psz_value = NULL;
-            }
-
-            cfg.p_next = NULL;
-            if( p_cfg )
-            {
-                p_cfg->p_next = malloc( sizeof( config_chain_t ) );
-                memcpy( p_cfg->p_next, &cfg, sizeof( config_chain_t ) );
-
-                p_cfg = p_cfg->p_next;
-            }
-            else
-            {
-                p_cfg = malloc( sizeof( config_chain_t ) );
-                memcpy( p_cfg, &cfg, sizeof( config_chain_t ) );
-
-                *pp_cfg = p_cfg;
-            }
-
-            if( *p == ',' ) p++;
-
-            if( *p == '}' )
-            {
-                p++;
-                break;
-            }
-        }
-    }
-
-    if( *p == ':' ) return( strdup( p + 1 ) );
-
-    return NULL;
-}
-
-void config_ChainDestroy( config_chain_t *p_cfg )
-{
-    while( p_cfg != NULL )
-    {
-        config_chain_t *p_next;
-
-        p_next = p_cfg->p_next;
-
-        FREENULL( p_cfg->psz_name );
-        FREENULL( p_cfg->psz_value );
-        free( p_cfg );
-
-        p_cfg = p_next;
-    }
-}
-
-void __config_ChainParse( vlc_object_t *p_this, const char *psz_prefix,
-                          const char **ppsz_options, config_chain_t *cfg )
-{
-    char *psz_name;
-    int  i_type;
-    int  i;
-
-    /* First, var_Create all variables */
-    for( i = 0; ppsz_options[i] != NULL; i++ )
-    {
-        asprintf( &psz_name, "%s%s", psz_prefix,
-                  *ppsz_options[i] == '*' ? &ppsz_options[i][1] : ppsz_options[i] );
-
-        i_type = config_GetType( p_this, psz_name );
-
-        var_Create( p_this, psz_name, i_type | VLC_VAR_DOINHERIT );
-        free( psz_name );
-    }
-
-    /* Now parse options and set value */
-    if( psz_prefix == NULL ) psz_prefix = "";
-
-    while( cfg )
-    {
-        vlc_value_t val;
-        vlc_bool_t b_yes = VLC_TRUE;
-        vlc_bool_t b_once = VLC_FALSE;
-        module_config_t *p_conf;
-
-        if( cfg->psz_name == NULL || *cfg->psz_name == '\0' )
-        {
-            cfg = cfg->p_next;
-            continue;
-        }
-        for( i = 0; ppsz_options[i] != NULL; i++ )
-        {
-            if( !strcmp( ppsz_options[i], cfg->psz_name ) )
-            {
-                break;
-            }
-            if( ( !strncmp( cfg->psz_name, "no-", 3 ) &&
-                  !strcmp( ppsz_options[i], cfg->psz_name + 3 ) ) ||
-                ( !strncmp( cfg->psz_name, "no", 2 ) &&
-                  !strcmp( ppsz_options[i], cfg->psz_name + 2 ) ) )
-            {
-                b_yes = VLC_FALSE;
-                break;
-            }
-
-            if( *ppsz_options[i] == '*' &&
-                !strcmp( &ppsz_options[i][1], cfg->psz_name ) )
-            {
-                b_once = VLC_TRUE;
-                break;
-            }
-
-        }
-        if( ppsz_options[i] == NULL )
-        {
-            msg_Warn( p_this, "option %s is unknown", cfg->psz_name );
-            cfg = cfg->p_next;
-            continue;
-        }
-
-        /* create name */
-        asprintf( &psz_name, "%s%s", psz_prefix, b_once ? &ppsz_options[i][1] : ppsz_options[i] );
-
-        /* Check if the option is deprecated */
-        p_conf = config_FindConfig( p_this, psz_name );
-
-        /* This is basically cut and paste from src/misc/configuration.c
-         * with slight changes */
-        if( p_conf && p_conf->psz_current )
-        {
-            if( !strcmp( p_conf->psz_current, "SUPPRESSED" ) )
-            {
-                msg_Err( p_this, "Option %s is no longer used.",
-                         p_conf->psz_name );
-                goto next;
-            }
-            else if( p_conf->b_strict )
-            {
-                msg_Err( p_this, "Option %s is deprecated. Use %s instead.",
-                         p_conf->psz_name, p_conf->psz_current );
-                /* TODO: this should return an error and end option parsing
-                 * ... but doing this would change the VLC API and all the
-                 * modules so i'll do it later */
-                goto next;
-            }
-            else
-            {
-                msg_Warn( p_this, "Option %s is deprecated. You should use "
-                        "%s instead.", p_conf->psz_name, p_conf->psz_current );
-                free( psz_name );
-                psz_name = strdup( p_conf->psz_current );
-            }
-        }
-        /* </Check if the option is deprecated> */
-
-        /* get the type of the variable */
-        i_type = config_GetType( p_this, psz_name );
-        if( !i_type )
-        {
-            msg_Warn( p_this, "unknown option %s (value=%s)",
-                      cfg->psz_name, cfg->psz_value );
-            goto next;
-        }
-
-        i_type &= 0x00f0;
-
-        if( i_type != VLC_VAR_BOOL && cfg->psz_value == NULL )
-        {
-            msg_Warn( p_this, "missing value for option %s", cfg->psz_name );
-            goto next;
-        }
-        if( i_type != VLC_VAR_STRING && b_once )
-        {
-            msg_Warn( p_this, "*option_name need to be a string option" );
-            goto next;
-        }
-
-        switch( i_type )
-        {
-            case VLC_VAR_BOOL:
-                val.b_bool = b_yes;
-                break;
-            case VLC_VAR_INTEGER:
-                val.i_int = strtol( cfg->psz_value ? cfg->psz_value : "0",
-                                    NULL, 0 );
-                break;
-            case VLC_VAR_FLOAT:
-                val.f_float = atof( cfg->psz_value ? cfg->psz_value : "0" );
-                break;
-            case VLC_VAR_STRING:
-            case VLC_VAR_MODULE:
-                val.psz_string = cfg->psz_value;
-                break;
-            default:
-                msg_Warn( p_this, "unhandled config var type (%d)", i_type );
-                memset( &val, 0, sizeof( vlc_value_t ) );
-                break;
-        }
-        if( b_once )
-        {
-            vlc_value_t val2;
-
-            var_Get( p_this, psz_name, &val2 );
-            if( *val2.psz_string )
-            {
-                free( val2.psz_string );
-                msg_Dbg( p_this, "ignoring option %s (not first occurrence)", psz_name );
-                goto next;
-            }
-            free( val2.psz_string );
-        }
-        var_Set( p_this, psz_name, val );
-        msg_Dbg( p_this, "set config option: %s to %s", psz_name, cfg->psz_value );
-
-    next:
-        free( psz_name );
-        cfg = cfg->p_next;
-    }
-}
diff --git a/src/misc/modules.c b/src/misc/modules.c
deleted file mode 100644 (file)
index 8abbac1..0000000
+++ /dev/null
@@ -1,2256 +0,0 @@
-/*****************************************************************************
- * modules.c : Builtin and plugin modules management functions
- *****************************************************************************
- * Copyright (C) 2001-2007 the VideoLAN team
- * $Id$
- *
- * Authors: Sam Hocevar <sam@zoy.org>
- *          Ethan C. Baldridge <BaldridgeE@cadmus.com>
- *          Hans-Peter Jansen <hpj@urpla.net>
- *          Gildas Bazin <gbazin@videolan.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-#include <vlc/vlc.h>
-
-/* Some faulty libcs have a broken struct dirent when _FILE_OFFSET_BITS
- * is set to 64. Don't try to be cleverer. */
-#ifdef _FILE_OFFSET_BITS
-#undef _FILE_OFFSET_BITS
-#endif
-
-#include <stdlib.h>                                      /* free(), strtol() */
-#include <stdio.h>                                              /* sprintf() */
-#include <string.h>                                              /* strdup() */
-
-#ifdef HAVE_DIRENT_H
-#   include <dirent.h>
-#endif
-
-#ifdef HAVE_SYS_TYPES_H
-#   include <sys/types.h>
-#endif
-#ifdef HAVE_SYS_STAT_H
-#   include <sys/stat.h>
-#endif
-#ifdef HAVE_UNISTD_H
-#   include <unistd.h>
-#endif
-
-#if !defined(HAVE_DYNAMIC_PLUGINS)
-    /* no support for plugins */
-#elif defined(HAVE_DL_DYLD)
-#   if defined(HAVE_MACH_O_DYLD_H)
-#       include <mach-o/dyld.h>
-#   endif
-#elif defined(HAVE_DL_BEOS)
-#   if defined(HAVE_IMAGE_H)
-#       include <image.h>
-#   endif
-#elif defined(HAVE_DL_WINDOWS)
-#   include <windows.h>
-#elif defined(HAVE_DL_DLOPEN)
-#   if defined(HAVE_DLFCN_H) /* Linux, BSD, Hurd */
-#       include <dlfcn.h>
-#   endif
-#   if defined(HAVE_SYS_DL_H)
-#       include <sys/dl.h>
-#   endif
-#elif defined(HAVE_DL_SHL_LOAD)
-#   if defined(HAVE_DL_H)
-#       include <dl.h>
-#   endif
-#endif
-
-#include "misc/configuration.h"
-
-#include "vlc_interface.h"
-#include "vlc_playlist.h"
-
-#include "vlc_stream.h"
-#include "vlc_access.h"
-#include "vlc_demux.h"
-
-#include "vlc_vout.h"
-#include "vlc_vout_synchro.h"
-
-#include "vlc_aout.h"
-
-#include "vlc_sout.h"
-#include "vlc_httpd.h"
-#include "vlc_acl.h"
-#include "vlc_tls.h"
-#include "vlc_md5.h"
-#include "vlc_xml.h"
-#include "vlc_url.h"
-
-#include "iso_lang.h"
-#include "vlc_charset.h"
-
-#include "vlc_block.h"
-
-#include "vlc_vlm.h"
-
-#include "vlc_image.h"
-#include "vlc_osd.h"
-
-#include "vlc_update.h"
-#include "vlc_strings.h"
-#include "vlc_streaming.h"
-
-#include "modules.h"
-
-#if defined( _MSC_VER ) && defined( UNDER_CE )
-#    include "modules_builtin_evc.h"
-#elif defined( _MSC_VER )
-#    include "modules_builtin_msvc.h"
-#else
-#    include "modules_builtin.h"
-#endif
-#include "vlc_network.h"
-
-#if defined( WIN32 ) || defined( UNDER_CE )
-    /* Avoid name collisions */
-#   define LoadModule(a,b,c) LoadVlcModule(a,b,c)
-#endif
-
-/*****************************************************************************
- * Local prototypes
- *****************************************************************************/
-#ifdef HAVE_DYNAMIC_PLUGINS
-static void AllocateAllPlugins  ( vlc_object_t * );
-static void AllocatePluginDir   ( vlc_object_t *, const char *, int );
-static int  AllocatePluginFile  ( vlc_object_t *, char *, int64_t, int64_t );
-static module_t * AllocatePlugin( vlc_object_t *, char * );
-#endif
-static int  AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) );
-static int  DeleteModule ( module_t *, vlc_bool_t );
-#ifdef HAVE_DYNAMIC_PLUGINS
-static void   DupModule        ( module_t * );
-static void   UndupModule      ( module_t * );
-static int    CallEntry        ( module_t * );
-static int    LoadModule       ( vlc_object_t *, char *, module_handle_t * );
-static void   CloseModule      ( module_handle_t );
-static void * GetSymbol        ( module_handle_t, const char * );
-static void   CacheLoad        ( vlc_object_t * );
-static int    CacheLoadConfig  ( module_t *, FILE * );
-static void   CacheSave        ( vlc_object_t * );
-static void   CacheSaveConfig  ( module_t *, FILE * );
-static char * CacheName        ( void );
-static void   CacheMerge       ( vlc_object_t *, module_t *, module_t * );
-static module_cache_t * CacheFind( vlc_object_t *, char *, int64_t, int64_t );
-
-#if defined(HAVE_DL_WINDOWS)
-static char * GetWindowsError  ( void );
-#endif
-#endif
-
-static void module_LoadMain( vlc_object_t *p_this );
-
-
-/* Sub-version number
- * (only used to avoid breakage in dev version when cache structure changes) */
-#define CACHE_SUBVERSION_NUM 2
-
-/*****************************************************************************
- * module_InitBank: create the module bank.
- *****************************************************************************
- * This function creates a module bank structure which will be filled later
- * on with all the modules found.
- *****************************************************************************/
-void __module_InitBank( vlc_object_t *p_this )
-{
-    module_bank_t *p_bank = NULL;
-    vlc_value_t  lockval;
-
-    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( p_this->p_libvlc_global->p_module_bank )
-    {
-        p_this->p_libvlc_global->p_module_bank->i_usage++;
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_this->p_libvlc_global, "libvlc" );
-        return;
-    }
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_this->p_libvlc_global, "libvlc" );
-
-    p_bank = vlc_object_create( p_this, sizeof(module_bank_t) );
-    if( !p_bank )
-        return;
-    p_bank->psz_object_name = "module bank";
-    p_bank->i_usage = 1;
-    p_bank->i_cache = p_bank->i_loaded_cache = 0;
-    p_bank->pp_cache = p_bank->pp_loaded_cache = NULL;
-    p_bank->b_cache = p_bank->b_cache_dirty =
-        p_bank->b_cache_delete = VLC_FALSE;
-
-    /*
-     * Store the symbols to be exported
-     */
-#if defined (HAVE_DYNAMIC_PLUGINS) && !defined (HAVE_SHARED_LIBVLC)
-    STORE_SYMBOLS( &p_bank->symbols );
-#endif
-
-    /* Everything worked, attach the object */
-    p_this->p_libvlc_global->p_module_bank = p_bank;
-    vlc_object_attach( p_bank, p_this->p_libvlc_global );
-
-    module_LoadMain( p_this );
-}
-
-/*****************************************************************************
- * module_ResetBank: reset the module bank.
- *****************************************************************************
- * This function resets the module bank by unloading all unused plugin
- * modules.
- *****************************************************************************/
-void __module_ResetBank( vlc_object_t *p_this )
-{
-    msg_Err( p_this, "FIXME: module_ResetBank unimplemented" );
-    return;
-}
-
-/*****************************************************************************
- * module_EndBank: empty the module bank.
- *****************************************************************************
- * This function unloads all unused plugin modules and empties the module
- * bank in case of success.
- *****************************************************************************/
-void __module_EndBank( vlc_object_t *p_this )
-{
-    module_t * p_next = NULL;
-    vlc_value_t lockval;
-
-    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( !p_this->p_libvlc_global->p_module_bank )
-    {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_this->p_libvlc_global, "libvlc" );
-        return;
-    }
-    if( --p_this->p_libvlc_global->p_module_bank->i_usage )
-    {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_this->p_libvlc_global, "libvlc" );
-        return;
-    }
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_this->p_libvlc_global, "libvlc" );
-
-    config_AutoSaveConfigFile( p_this );
-
-#ifdef HAVE_DYNAMIC_PLUGINS
-#define p_bank p_this->p_libvlc_global->p_module_bank
-    if( p_bank->b_cache ) CacheSave( p_this );
-    while( p_bank->i_loaded_cache-- )
-    {
-        if( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] )
-        {
-            DeleteModule( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->p_module, p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->b_used );
-            free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->psz_file );
-            free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] );
-            p_bank->pp_loaded_cache[p_bank->i_loaded_cache] = NULL;
-        }
-    }
-    if( p_bank->pp_loaded_cache )
-    {
-        free( p_bank->pp_loaded_cache );
-        p_bank->pp_loaded_cache = NULL;
-    }
-    while( p_bank->i_cache-- )
-    {
-        free( p_bank->pp_cache[p_bank->i_cache]->psz_file );
-        free( p_bank->pp_cache[p_bank->i_cache] );
-        p_bank->pp_cache[p_bank->i_cache] = NULL;
-    }
-    if( p_bank->pp_cache )
-    {
-        free( p_bank->pp_cache );
-        p_bank->pp_cache = NULL;
-    }
-#undef p_bank
-#endif
-
-    vlc_object_detach( p_this->p_libvlc_global->p_module_bank );
-
-    while( p_this->p_libvlc_global->p_module_bank->i_children )
-    {
-        p_next = (module_t *)p_this->p_libvlc_global->p_module_bank->pp_children[0];
-
-        if( DeleteModule( p_next, VLC_TRUE ) )
-        {
-            /* Module deletion failed */
-            msg_Err( p_this, "module \"%s\" can't be removed, trying harder",
-                     p_next->psz_object_name );
-
-            /* We just free the module by hand. Niahahahahaha. */
-            vlc_object_detach( p_next );
-            vlc_object_destroy( p_next );
-        }
-    }
-
-    vlc_object_destroy( p_this->p_libvlc_global->p_module_bank );
-    p_this->p_libvlc_global->p_module_bank = NULL;
-
-    return;
-}
-
-/*****************************************************************************
- * module_LoadMain: load the main program info into the module bank.
- *****************************************************************************
- * This function fills the module bank structure with the main module infos.
- * This is very useful as it will allow us to consider the main program just
- * as another module, and for instance the configuration options of main will
- * be available in the module bank structure just as for every other module.
- *****************************************************************************/
-static void module_LoadMain( vlc_object_t *p_this )
-{
-    vlc_value_t lockval;
-
-    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( p_this->p_libvlc_global->p_module_bank->b_main )
-    {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_this->p_libvlc_global, "libvlc" );
-        return;
-    }
-    p_this->p_libvlc_global->p_module_bank->b_main = VLC_TRUE;
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_this->p_libvlc_global, "libvlc" );
-
-    AllocateBuiltinModule( p_this, vlc_entry__main );
-}
-
-/*****************************************************************************
- * module_LoadBuiltins: load all modules which we built with.
- *****************************************************************************
- * This function fills the module bank structure with the builtin modules.
- *****************************************************************************/
-void __module_LoadBuiltins( vlc_object_t * p_this )
-{
-    vlc_value_t lockval;
-
-    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( p_this->p_libvlc_global->p_module_bank->b_builtins )
-    {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_this->p_libvlc_global, "libvlc" );
-        return;
-    }
-    p_this->p_libvlc_global->p_module_bank->b_builtins = VLC_TRUE;
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_this->p_libvlc_global, "libvlc" );
-
-    msg_Dbg( p_this, "checking builtin modules" );
-    ALLOCATE_ALL_BUILTINS();
-}
-
-/*****************************************************************************
- * module_LoadPlugins: load all plugin modules we can find.
- *****************************************************************************
- * This function fills the module bank structure with the plugin modules.
- *****************************************************************************/
-void __module_LoadPlugins( vlc_object_t * p_this )
-{
-#ifdef HAVE_DYNAMIC_PLUGINS
-    vlc_value_t lockval;
-
-    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
-    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
-    vlc_mutex_lock( lockval.p_address );
-    if( p_this->p_libvlc_global->p_module_bank->b_plugins )
-    {
-        vlc_mutex_unlock( lockval.p_address );
-        var_Destroy( p_this->p_libvlc_global, "libvlc" );
-        return;
-    }
-    p_this->p_libvlc_global->p_module_bank->b_plugins = VLC_TRUE;
-    vlc_mutex_unlock( lockval.p_address );
-    var_Destroy( p_this->p_libvlc_global, "libvlc" );
-
-    msg_Dbg( p_this, "checking plugin modules" );
-
-    if( config_GetInt( p_this, "plugins-cache" ) )
-        p_this->p_libvlc_global->p_module_bank->b_cache = VLC_TRUE;
-
-    if( p_this->p_libvlc_global->p_module_bank->b_cache ||
-        p_this->p_libvlc_global->p_module_bank->b_cache_delete ) CacheLoad( p_this );
-
-    AllocateAllPlugins( p_this );
-#endif
-}
-
-/*****************************************************************************
- * module_Need: return the best module function, given a capability list.
- *****************************************************************************
- * This function returns the module that best fits the asked capabilities.
- *****************************************************************************/
-module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability,
-                          const char *psz_name, vlc_bool_t b_strict )
-{
-    typedef struct module_list_t module_list_t;
-
-    struct module_list_t
-    {
-        module_t *p_module;
-        int i_score;
-        vlc_bool_t b_force;
-        module_list_t *p_next;
-    };
-
-    module_list_t *p_list, *p_first, *p_tmp;
-    vlc_list_t *p_all;
-
-    int i_which_module, i_index = 0;
-    vlc_bool_t b_intf = VLC_FALSE;
-
-    module_t *p_module;
-
-    int   i_shortcuts = 0;
-    char *psz_shortcuts = NULL, *psz_var = NULL, *psz_alias = NULL;
-    vlc_bool_t b_force_backup = p_this->b_force;
-
-
-    /* Deal with variables */
-    if( psz_name && psz_name[0] == '$' )
-    {
-        vlc_value_t val;
-        var_Create( p_this, psz_name + 1, VLC_VAR_MODULE | VLC_VAR_DOINHERIT );
-        var_Get( p_this, psz_name + 1, &val );
-        psz_var = val.psz_string;
-        psz_name = psz_var;
-    }
-
-    /* Count how many different shortcuts were asked for */
-    if( psz_name && *psz_name )
-    {
-        char *psz_parser, *psz_last_shortcut;
-
-        /* If the user wants none, give him none. */
-        if( !strcmp( psz_name, "none" ) )
-        {
-            free( psz_var );
-            return NULL;
-        }
-
-        i_shortcuts++;
-        psz_shortcuts = psz_last_shortcut = strdup( psz_name );
-
-        for( psz_parser = psz_shortcuts; *psz_parser; psz_parser++ )
-        {
-            if( *psz_parser == ',' )
-            {
-                 *psz_parser = '\0';
-                 i_shortcuts++;
-                 psz_last_shortcut = psz_parser + 1;
-            }
-        }
-
-        /* Check if the user wants to override the "strict" mode */
-        if( psz_last_shortcut )
-        {
-            if( !strcmp(psz_last_shortcut, "none") )
-            {
-                b_strict = VLC_TRUE;
-                i_shortcuts--;
-            }
-            else if( !strcmp(psz_last_shortcut, "any") )
-            {
-                b_strict = VLC_FALSE;
-                i_shortcuts--;
-            }
-        }
-    }
-
-    /* Sort the modules and test them */
-    p_all = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-    p_list = malloc( p_all->i_count * sizeof( module_list_t ) );
-    p_first = NULL;
-
-    /* Parse the module list for capabilities and probe each of them */
-    for( i_which_module = 0; i_which_module < p_all->i_count; i_which_module++ )
-    {
-        int i_shortcut_bonus = 0;
-
-        p_module = (module_t *)p_all->p_values[i_which_module].p_object;
-
-        /* Test that this module can do what we need */
-        if( strcmp( p_module->psz_capability, psz_capability ) )
-        {
-            /* Don't recurse through the sub-modules because vlc_list_find()
-             * will list them anyway. */
-            continue;
-        }
-
-        /* Test if we have the required CPU */
-        if( (p_module->i_cpu & p_this->p_libvlc_global->i_cpu) != p_module->i_cpu )
-        {
-            continue;
-        }
-
-        /* If we required a shortcut, check this plugin provides it. */
-        if( i_shortcuts > 0 )
-        {
-            vlc_bool_t b_trash;
-            const char *psz_name = psz_shortcuts;
-
-            /* Let's drop modules with a <= 0 score (unless they are
-             * explicitly requested) */
-            b_trash = p_module->i_score <= 0;
-
-            for( unsigned i_short = i_shortcuts; i_short > 0; i_short-- )
-            {
-                for( unsigned i = 0; p_module->pp_shortcuts[i]; i++ )
-                {
-                    char *c;
-                    if( ( c = strchr( psz_name, '@' ) )
-                        ? !strncasecmp( psz_name, p_module->pp_shortcuts[i],
-                                        c-psz_name )
-                        : !strcasecmp( psz_name, p_module->pp_shortcuts[i] ) )
-                    {
-                        /* Found it */
-                        if( c && c[1] )
-                            psz_alias = c+1;
-                        i_shortcut_bonus = i_short * 10000;
-                        goto found_shortcut;
-                    }
-                }
-
-                /* Go to the next shortcut... This is so lame! */
-                psz_name += strlen( psz_name ) + 1;
-            }
-
-            /* If we are in "strict" mode and we couldn't
-             * find the module in the list of provided shortcuts,
-             * then kick the bastard out of here!!! */
-            if( b_strict )
-                continue;
-        }
-        /* If we didn't require a shortcut, trash <= 0 scored plugins */
-        else if( p_module->i_score <= 0 )
-        {
-            continue;
-        }
-
-found_shortcut:
-
-        /* Special case: test if we requested a particular intf plugin */
-        if( !i_shortcuts && p_module->psz_program
-             && !strcmp( psz_capability, "interface" )
-             && !strcmp( p_module->psz_program,
-                         p_this->p_libvlc->psz_object_name ) )
-        {
-            if( !b_intf )
-            {
-                /* Remove previous non-matching plugins */
-                i_index = 0;
-                b_intf = VLC_TRUE;
-            }
-        }
-        else if( b_intf )
-        {
-            /* This one doesn't match */
-            continue;
-        }
-
-        /* Store this new module */
-        p_list[ i_index ].p_module = p_module;
-        p_list[ i_index ].i_score = p_module->i_score + i_shortcut_bonus;
-        p_list[ i_index ].b_force = i_shortcut_bonus && b_strict;
-
-        /* Add it to the modules-to-probe list */
-        if( i_index == 0 )
-        {
-            p_list[ 0 ].p_next = NULL;
-            p_first = p_list;
-        }
-        else
-        {
-            /* Ok, so at school you learned that quicksort is quick, and
-             * bubble sort sucks raw eggs. But that's when dealing with
-             * thousands of items. Here we have barely 50. */
-            module_list_t *p_newlist = p_first;
-
-            if( p_first->i_score < p_list[ i_index ].i_score )
-            {
-                p_list[ i_index ].p_next = p_first;
-                p_first = &p_list[ i_index ];
-            }
-            else
-            {
-                while( p_newlist->p_next != NULL &&
-                    p_newlist->p_next->i_score >= p_list[ i_index ].i_score )
-                {
-                    p_newlist = p_newlist->p_next;
-                }
-
-                p_list[ i_index ].p_next = p_newlist->p_next;
-                p_newlist->p_next = &p_list[ i_index ];
-            }
-        }
-
-        i_index++;
-    }
-
-    msg_Dbg( p_this, "looking for %s module: %i candidate%s", psz_capability,
-                                            i_index, i_index == 1 ? "" : "s" );
-
-    /* Lock all candidate modules */
-    p_tmp = p_first;
-    while( p_tmp != NULL )
-    {
-        vlc_object_yield( p_tmp->p_module );
-        p_tmp = p_tmp->p_next;
-    }
-
-    /* We can release the list, interesting modules were yielded */
-    vlc_list_release( p_all );
-
-    /* Parse the linked list and use the first successful module */
-    p_tmp = p_first;
-    while( p_tmp != NULL )
-    {
-#ifdef HAVE_DYNAMIC_PLUGINS
-        /* Make sure the module is loaded in mem */
-        module_t *p_module = p_tmp->p_module;
-        if( p_module->b_submodule )
-            p_module = (module_t *)p_module->p_parent;
-
-        if( !p_module->b_builtin && !p_module->b_loaded )
-        {
-            module_t *p_new_module =
-                AllocatePlugin( p_this, p_module->psz_filename );
-            if( p_new_module )
-            {
-                CacheMerge( p_this, p_module, p_new_module );
-                vlc_object_attach( p_new_module, p_module );
-                DeleteModule( p_new_module, VLC_TRUE );
-            }
-        }
-#endif
-
-        p_this->b_force = p_tmp->b_force;
-        if( p_tmp->p_module->pf_activate
-             && p_tmp->p_module->pf_activate( p_this ) == VLC_SUCCESS )
-        {
-            break;
-        }
-
-        vlc_object_release( p_tmp->p_module );
-        p_tmp = p_tmp->p_next;
-    }
-
-    /* Store the locked module value */
-    if( p_tmp != NULL )
-    {
-        p_module = p_tmp->p_module;
-        p_tmp = p_tmp->p_next;
-    }
-    else
-    {
-        p_module = NULL;
-    }
-
-    /* Unlock the remaining modules */
-    while( p_tmp != NULL )
-    {
-        vlc_object_release( p_tmp->p_module );
-        p_tmp = p_tmp->p_next;
-    }
-
-    free( p_list );
-    p_this->b_force = b_force_backup;
-
-    if( p_module != NULL )
-    {
-        msg_Dbg( p_this, "using %s module \"%s\"",
-                 psz_capability, p_module->psz_object_name );
-    }
-    else if( p_first == NULL )
-    {
-        if( !strcmp( psz_capability, "access_demux" ) )
-        {
-            msg_Warn( p_this, "no %s module matched \"%s\"",
-                 psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
-        }
-        else
-        {
-            msg_Err( p_this, "no %s module matched \"%s\"",
-                 psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
-
-            msg_StackSet( VLC_EGENERIC, "no %s module matched \"%s\"",
-                 psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
-        }
-    }
-    else if( psz_name != NULL && *psz_name )
-    {
-        msg_Warn( p_this, "no %s module matching \"%s\" could be loaded",
-                  psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
-    }
-    else
-        msg_StackSet( VLC_EGENERIC, "no suitable %s module", psz_capability );
-
-    if( p_module && !p_this->psz_object_name )
-    {
-        /* This assumes that p_this is the object which will be using the
-         * module. That's not always the case ... but it is in most cases.
-         */
-        if( psz_alias )
-            p_this->psz_object_name = strdup( psz_alias );
-        else
-            p_this->psz_object_name = strdup( p_module->psz_object_name );
-    }
-
-    free( psz_shortcuts );
-    free( psz_var );
-
-    /* Don't forget that the module is still locked */
-    return p_module;
-}
-
-/*****************************************************************************
- * module_Unneed: decrease the usage count of a module.
- *****************************************************************************
- * This function must be called by the thread that called module_Need, to
- * decrease the reference count and allow for hiding of modules.
- *****************************************************************************/
-void __module_Unneed( vlc_object_t * p_this, module_t * p_module )
-{
-    /* Use the close method */
-    if( p_module->pf_deactivate )
-    {
-        p_module->pf_deactivate( p_this );
-    }
-
-    msg_Dbg( p_this, "removing module \"%s\"", p_module->psz_object_name );
-
-    vlc_object_release( p_module );
-
-    return;
-}
-
-/*****************************************************************************
- * module_Exists: tell if a module exists.
- *****************************************************************************
- * This function is a boolean function that tells if a module exist or not.
- *****************************************************************************/
-
-vlc_bool_t __module_Exists(  vlc_object_t *p_this, const char * psz_name )
-{
-    vlc_list_t *p_list;
-    int i;
-    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
-    for( i = 0 ; i < p_list->i_count; i++)
-    {
-        const char *psz_module_name =
-            ((module_t *) p_list->p_values[i].p_object)->psz_shortname;
-        if( psz_module_name && !strcmp( psz_module_name, psz_name ) )
-        {
-            /* We can release the list, and return yes */
-            vlc_list_release( p_list ); return VLC_TRUE;
-        }
-    }
-    vlc_list_release( p_list ); return VLC_FALSE;
-}
-
-
-/*****************************************************************************
- * Following functions are local.
- *****************************************************************************/
-
-/*****************************************************************************
- * AllocateAllPlugins: load all plugin modules we can find.
- *****************************************************************************/
-#ifdef HAVE_DYNAMIC_PLUGINS
-static void AllocateAllPlugins( vlc_object_t *p_this )
-{
-    /* Yes, there are two NULLs because we replace one with "plugin-path". */
-#if defined( WIN32 ) || defined( UNDER_CE )
-    const char *path[] = { "modules", "", "plugins", NULL, NULL };
-#else
-    const char *path[] = { "modules", PLUGIN_PATH, "plugins", NULL, NULL };
-#endif
-
-    const char *const *ppsz_path;
-
-    /* If the user provided a plugin path, we add it to the list */
-    char *userpath = config_GetPsz( p_this, "plugin-path" );
-    path[sizeof(path)/sizeof(path[0]) - 2] = userpath;
-
-    for (ppsz_path = path; *ppsz_path != NULL; ppsz_path++)
-    {
-        char *psz_fullpath;
-
-        if (!**ppsz_path) continue;
-
-#if defined( SYS_BEOS ) || defined( __APPLE__ ) || defined( WIN32 )
-
-        /* Handle relative as well as absolute paths */
-#ifdef WIN32
-        if( (*ppsz_path)[0] != '\\' && (*ppsz_path)[0] != '/' &&
-            (*ppsz_path)[1] != ':' )
-#else
-        if( (*ppsz_path)[0] != '/' )
-#endif
-        {
-            if( 0>= asprintf(&psz_fullpath, "%s"DIR_SEP"%s",
-                          p_this->p_libvlc_global->psz_vlcpath, *ppsz_path) )
-                psz_fullpath = NULL;
-        }
-        else
-#endif
-            psz_fullpath = strdup( *ppsz_path );
-
-        if( psz_fullpath == NULL )
-            continue;
-
-        msg_Dbg( p_this, "recursively browsing `%s'", psz_fullpath );
-
-        /* Don't go deeper than 5 subdirectories */
-        AllocatePluginDir( p_this, psz_fullpath, 5 );
-
-        free( psz_fullpath );
-    }
-
-    /* Free plugin-path */
-    free( userpath );
-}
-
-/*****************************************************************************
- * AllocatePluginDir: recursively parse a directory to look for plugins
- *****************************************************************************/
-static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir,
-                               int i_maxdepth )
-{
-/* FIXME: Needs to be ported to wide char on ALL Windows builds */
-#ifdef WIN32
-# undef opendir
-# undef closedir
-# undef readdir
-#endif
-#if defined( UNDER_CE ) || defined( _MSC_VER )
-#ifdef UNDER_CE
-    wchar_t psz_wpath[MAX_PATH + 256];
-    wchar_t psz_wdir[MAX_PATH];
-#endif
-    char psz_path[MAX_PATH + 256];
-    WIN32_FIND_DATA finddata;
-    HANDLE handle;
-    int rc;
-#else
-    int    i_dirlen;
-    DIR *  dir;
-    struct dirent * file;
-#endif
-    char * psz_file;
-
-    if( p_this->p_libvlc->b_die || i_maxdepth < 0 )
-    {
-        return;
-    }
-
-#if defined( UNDER_CE ) || defined( _MSC_VER )
-#ifdef UNDER_CE
-    MultiByteToWideChar( CP_ACP, 0, psz_dir, -1, psz_wdir, MAX_PATH );
-
-    rc = GetFileAttributes( psz_wdir );
-    if( rc<0 || !(rc&FILE_ATTRIBUTE_DIRECTORY) ) return; /* Not a directory */
-
-    /* Parse all files in the directory */
-    swprintf( psz_wpath, L"%ls\\*", psz_wdir );
-#else
-    rc = GetFileAttributes( psz_dir );
-    if( rc<0 || !(rc&FILE_ATTRIBUTE_DIRECTORY) ) return; /* Not a directory */
-#endif
-
-    /* Parse all files in the directory */
-    sprintf( psz_path, "%s\\*", psz_dir );
-
-#ifdef UNDER_CE
-    handle = FindFirstFile( psz_wpath, &finddata );
-#else
-    handle = FindFirstFile( psz_path, &finddata );
-#endif
-    if( handle == INVALID_HANDLE_VALUE )
-    {
-        /* Empty directory */
-        return;
-    }
-
-    /* Parse the directory and try to load all files it contains. */
-    do
-    {
-#ifdef UNDER_CE
-        unsigned int i_len = wcslen( finddata.cFileName );
-        swprintf( psz_wpath, L"%ls\\%ls", psz_wdir, finddata.cFileName );
-        sprintf( psz_path, "%s\\%ls", psz_dir, finddata.cFileName );
-#else
-        unsigned int i_len = strlen( finddata.cFileName );
-        sprintf( psz_path, "%s\\%s", psz_dir, finddata.cFileName );
-#endif
-
-        /* Skip ".", ".." */
-        if( !*finddata.cFileName || !strcmp( finddata.cFileName, "." )
-         || !strcmp( finddata.cFileName, ".." ) )
-        {
-            if( !FindNextFile( handle, &finddata ) ) break;
-            continue;
-        }
-
-#ifdef UNDER_CE
-        if( GetFileAttributes( psz_wpath ) & FILE_ATTRIBUTE_DIRECTORY )
-#else
-        if( GetFileAttributes( psz_path ) & FILE_ATTRIBUTE_DIRECTORY )
-#endif
-        {
-            AllocatePluginDir( p_this, psz_path, i_maxdepth - 1 );
-        }
-        else if( i_len > strlen( LIBEXT )
-                  /* We only load files ending with LIBEXT */
-                  && !strncasecmp( psz_path + strlen( psz_path)
-                                   - strlen( LIBEXT ),
-                                   LIBEXT, strlen( LIBEXT ) ) )
-        {
-            WIN32_FILE_ATTRIBUTE_DATA attrbuf;
-            int64_t i_time = 0, i_size = 0;
-
-#ifdef UNDER_CE
-            if( GetFileAttributesEx( psz_wpath, GetFileExInfoStandard,
-                                     &attrbuf ) )
-#else
-            if( GetFileAttributesEx( psz_path, GetFileExInfoStandard,
-                                     &attrbuf ) )
-#endif
-            {
-                i_time = attrbuf.ftLastWriteTime.dwHighDateTime;
-                i_time <<= 32;
-                i_time |= attrbuf.ftLastWriteTime.dwLowDateTime;
-                i_size = attrbuf.nFileSizeHigh;
-                i_size <<= 32;
-                i_size |= attrbuf.nFileSizeLow;
-            }
-            psz_file = psz_path;
-
-            AllocatePluginFile( p_this, psz_file, i_time, i_size );
-        }
-    }
-    while( !p_this->p_libvlc->b_die && FindNextFile( handle, &finddata ) );
-
-    /* Close the directory */
-    FindClose( handle );
-
-#else
-    dir = opendir( psz_dir );
-    if( !dir )
-    {
-        return;
-    }
-
-    i_dirlen = strlen( psz_dir );
-
-    /* Parse the directory and try to load all files it contains. */
-    while( !p_this->p_libvlc->b_die && (file = readdir( dir )) )
-    {
-        struct stat statbuf;
-        unsigned int i_len;
-        int i_stat;
-
-        /* Skip ".", ".." */
-        if( !*file->d_name || !strcmp( file->d_name, "." )
-         || !strcmp( file->d_name, ".." ) )
-        {
-            continue;
-        }
-
-        i_len = strlen( file->d_name );
-        psz_file = malloc( i_dirlen + 1 + i_len + 1 );
-#ifdef WIN32
-        sprintf( psz_file, "%s\\%s", psz_dir, file->d_name );
-#else
-        sprintf( psz_file, "%s/%s", psz_dir, file->d_name );
-#endif
-
-        i_stat = stat( psz_file, &statbuf );
-        if( !i_stat && statbuf.st_mode & S_IFDIR )
-        {
-            AllocatePluginDir( p_this, psz_file, i_maxdepth - 1 );
-        }
-        else if( i_len > strlen( LIBEXT )
-                  /* We only load files ending with LIBEXT */
-                  && !strncasecmp( file->d_name + i_len - strlen( LIBEXT ),
-                                   LIBEXT, strlen( LIBEXT ) ) )
-        {
-            int64_t i_time = 0, i_size = 0;
-
-            if( !i_stat )
-            {
-                i_time = statbuf.st_mtime;
-                i_size = statbuf.st_size;
-            }
-
-            AllocatePluginFile( p_this, psz_file, i_time, i_size );
-        }
-
-        free( psz_file );
-    }
-
-    /* Close the directory */
-    closedir( dir );
-
-#endif
-}
-
-/*****************************************************************************
- * AllocatePluginFile: load a module into memory and initialize it.
- *****************************************************************************
- * This function loads a dynamically loadable module and allocates a structure
- * for its information data. The module can then be handled by module_Need
- * and module_Unneed. It can be removed by DeleteModule.
- *****************************************************************************/
-static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file,
-                               int64_t i_file_time, int64_t i_file_size )
-{
-    module_t * p_module = NULL;
-    module_cache_t *p_cache_entry = NULL;
-
-    /*
-     * Check our plugins cache first then load plugin if needed
-     */
-    p_cache_entry =
-        CacheFind( p_this, psz_file, i_file_time, i_file_size );
-
-    if( !p_cache_entry )
-    {
-        p_module = AllocatePlugin( p_this, psz_file );
-    }
-    else
-    {
-        /* If junk dll, don't try to load it */
-        if( p_cache_entry->b_junk )
-        {
-            p_module = NULL;
-        }
-        else
-        {
-            module_config_t *p_item = NULL, *p_end = NULL;
-
-            p_module = p_cache_entry->p_module;
-            p_module->b_loaded = VLC_FALSE;
-
-            /* For now we force loading if the module's config contains
-             * callbacks or actions.
-             * Could be optimized by adding an API call.*/
-            for( p_item = p_module->p_config, p_end = p_item + p_module->confsize;
-                 p_item < p_end; p_item++ )
-            {
-                if( p_item->pf_callback || p_item->i_action )
-                {
-                    p_module = AllocatePlugin( p_this, psz_file );
-                    break;
-                }
-            }
-            if( p_module == p_cache_entry->p_module )
-                p_cache_entry->b_used = VLC_TRUE;
-        }
-    }
-
-    if( p_module )
-    {
-        /* Everything worked fine !
-         * The module is ready to be added to the list. */
-        p_module->b_builtin = VLC_FALSE;
-
-        /* msg_Dbg( p_this, "plugin \"%s\", %s",
-                    p_module->psz_object_name, p_module->psz_longname ); */
-
-        vlc_object_attach( p_module, p_this->p_libvlc_global->p_module_bank );
-
-        if( !p_this->p_libvlc_global->p_module_bank->b_cache )
-            return 0;
-
-        /* Add entry to cache */
-#define p_bank p_this->p_libvlc_global->p_module_bank
-        p_bank->pp_cache =
-            realloc( p_bank->pp_cache, (p_bank->i_cache + 1) * sizeof(void *) );
-        p_bank->pp_cache[p_bank->i_cache] = malloc( sizeof(module_cache_t) );
-        if( !p_bank->pp_cache[p_bank->i_cache] )
-            return -1;
-        p_bank->pp_cache[p_bank->i_cache]->psz_file = strdup( psz_file );
-        p_bank->pp_cache[p_bank->i_cache]->i_time = i_file_time;
-        p_bank->pp_cache[p_bank->i_cache]->i_size = i_file_size;
-        p_bank->pp_cache[p_bank->i_cache]->b_junk = p_module ? 0 : 1;
-        p_bank->pp_cache[p_bank->i_cache]->b_used = VLC_TRUE;
-        p_bank->pp_cache[p_bank->i_cache]->p_module = p_module;
-        p_bank->i_cache++;
-    }
-
-    return p_module ? 0 : -1;
-}
-
-/*****************************************************************************
- * AllocatePlugin: load a module into memory and initialize it.
- *****************************************************************************
- * This function loads a dynamically loadable module and allocates a structure
- * for its information data. The module can then be handled by module_Need
- * and module_Unneed. It can be removed by DeleteModule.
- *****************************************************************************/
-static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file )
-{
-    module_t * p_module = NULL;
-    module_handle_t handle;
-
-    if( LoadModule( p_this, psz_file, &handle ) )
-        return NULL;
-
-    /* Now that we have successfully loaded the module, we can
-     * allocate a structure for it */
-    p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE );
-    if( p_module == NULL )
-    {
-        msg_Err( p_this, "out of memory" );
-        CloseModule( handle );
-        return NULL;
-    }
-
-    /* We need to fill these since they may be needed by CallEntry() */
-    p_module->psz_filename = psz_file;
-    p_module->handle = handle;
-#ifndef HAVE_SHARED_LIBVLC
-    p_module->p_symbols = &p_this->p_libvlc_global->p_module_bank->symbols;
-#endif
-    p_module->b_loaded = VLC_TRUE;
-
-    /* Initialize the module: fill p_module, default config */
-    if( CallEntry( p_module ) != 0 )
-    {
-        /* We couldn't call module_init() */
-        vlc_object_destroy( p_module );
-        CloseModule( handle );
-        return NULL;
-    }
-
-    DupModule( p_module );
-    p_module->psz_filename = strdup( p_module->psz_filename );
-
-    /* Everything worked fine ! The module is ready to be added to the list. */
-    p_module->b_builtin = VLC_FALSE;
-
-    return p_module;
-}
-
-/*****************************************************************************
- * DupModule: make a plugin module standalone.
- *****************************************************************************
- * This function duplicates all strings in the module, so that the dynamic
- * object can be unloaded. It acts recursively on submodules.
- *****************************************************************************/
-static void DupModule( module_t *p_module )
-{
-    const char **pp_shortcut;
-    int i_submodule;
-
-    for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ )
-    {
-        *pp_shortcut = strdup( *pp_shortcut );
-    }
-
-    /* We strdup() these entries so that they are still valid when the
-     * module is unloaded. */
-    p_module->psz_object_name = strdup( p_module->psz_object_name );
-    p_module->psz_capability = strdup( p_module->psz_capability );
-    p_module->psz_shortname = p_module->psz_shortname ?
-                                 strdup( p_module->psz_shortname ) : NULL;
-    p_module->psz_longname = strdup( p_module->psz_longname );
-    p_module->psz_help = p_module->psz_help ? strdup( p_module->psz_help )
-                                            : NULL;
-
-    if( p_module->psz_program != NULL )
-    {
-        p_module->psz_program = strdup( p_module->psz_program );
-    }
-
-    for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ )
-    {
-        DupModule( (module_t*)p_module->pp_children[ i_submodule ] );
-    }
-}
-
-/*****************************************************************************
- * UndupModule: free a duplicated module.
- *****************************************************************************
- * This function frees the allocations done in DupModule().
- *****************************************************************************/
-static void UndupModule( module_t *p_module )
-{
-    const char **pp_shortcut;
-    int i_submodule;
-
-    for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ )
-    {
-        UndupModule( (module_t*)p_module->pp_children[ i_submodule ] );
-    }
-
-    for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ )
-    {
-        free( (void*)*pp_shortcut );
-    }
-
-    free( (void*)p_module->psz_object_name );
-    free( (void*)p_module->psz_capability );
-    free( (void*)p_module->psz_shortname );
-    free( (void*)p_module->psz_longname );
-    free( (void*)p_module->psz_help );
-    free( (void*)p_module->psz_program );
-}
-
-#endif /* HAVE_DYNAMIC_PLUGINS */
-
-/*****************************************************************************
- * AllocateBuiltinModule: initialize a builtin module.
- *****************************************************************************
- * This function registers a builtin module and allocates a structure
- * for its information data. The module can then be handled by module_Need
- * and module_Unneed. It can be removed by DeleteModule.
- *****************************************************************************/
-static int AllocateBuiltinModule( vlc_object_t * p_this,
-                                  int ( *pf_entry ) ( module_t * ) )
-{
-    module_t * p_module;
-
-    /* Now that we have successfully loaded the module, we can
-     * allocate a structure for it */
-    p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE );
-    if( p_module == NULL )
-    {
-        msg_Err( p_this, "out of memory" );
-        return -1;
-    }
-
-    /* Initialize the module : fill p_module->psz_object_name, etc. */
-    if( pf_entry( p_module ) != 0 )
-    {
-        /* With a well-written module we shouldn't have to print an
-         * additional error message here, but just make sure. */
-        msg_Err( p_this, "failed calling entry point in builtin module" );
-        vlc_object_destroy( p_module );
-        return -1;
-    }
-
-    /* Everything worked fine ! The module is ready to be added to the list. */
-    p_module->b_builtin = VLC_TRUE;
-
-    /* msg_Dbg( p_this, "builtin \"%s\", %s",
-                p_module->psz_object_name, p_module->psz_longname ); */
-
-    vlc_object_attach( p_module, p_this->p_libvlc_global->p_module_bank );
-
-    return 0;
-}
-
-/*****************************************************************************
- * DeleteModule: delete a module and its structure.
- *****************************************************************************
- * This function can only be called if the module isn't being used.
- *****************************************************************************/
-static int DeleteModule( module_t * p_module, vlc_bool_t b_detach )
-{
-    if( !p_module ) return VLC_EGENERIC;
-    if( b_detach )
-        vlc_object_detach( p_module );
-
-    /* We free the structures that we strdup()ed in Allocate*Module(). */
-#ifdef HAVE_DYNAMIC_PLUGINS
-    if( !p_module->b_builtin )
-    {
-        if( p_module->b_loaded && p_module->b_unloadable )
-        {
-            CloseModule( p_module->handle );
-        }
-        UndupModule( p_module );
-        free( p_module->psz_filename );
-    }
-#endif
-
-    /* Free and detach the object's children */
-    while( p_module->i_children )
-    {
-        vlc_object_t *p_this = p_module->pp_children[0];
-        vlc_object_detach( p_this );
-        vlc_object_destroy( p_this );
-    }
-
-    config_Free( p_module );
-    vlc_object_destroy( p_module );
-    p_module = NULL;
-    return 0;
-}
-
-#ifdef HAVE_DYNAMIC_PLUGINS
-/*****************************************************************************
- * CallEntry: call an entry point.
- *****************************************************************************
- * This function calls a symbol given its name and a module structure. The
- * symbol MUST refer to a function returning int and taking a module_t* as
- * an argument.
- *****************************************************************************/
-static int CallEntry( module_t * p_module )
-{
-    static const char * const psz_name = "vlc_entry" MODULE_SUFFIX;
-    int (* pf_symbol) ( module_t * p_module );
-
-    /* Try to resolve the symbol */
-    pf_symbol = (int (*)(module_t *)) GetSymbol( p_module->handle, psz_name );
-
-    if( pf_symbol == NULL )
-    {
-#if defined(HAVE_DL_DYLD) || defined(HAVE_DL_BEOS)
-        msg_Warn( p_module, "cannot find symbol \"%s\" in file `%s'",
-                            psz_name, p_module->psz_filename );
-#elif defined(HAVE_DL_WINDOWS)
-        char *psz_error = GetWindowsError();
-        msg_Warn( p_module, "cannot find symbol \"%s\" in file `%s' (%s)",
-                            psz_name, p_module->psz_filename, psz_error );
-        free( psz_error );
-#elif defined(HAVE_DL_DLOPEN)
-        msg_Warn( p_module, "cannot find symbol \"%s\" in file `%s' (%s)",
-                            psz_name, p_module->psz_filename, dlerror() );
-#elif defined(HAVE_DL_SHL_LOAD)
-        msg_Warn( p_module, "cannot find symbol \"%s\" in file `%s' (%s)",
-                            psz_name, p_module->psz_filename, strerror(errno) );
-#else
-#   error "Something is wrong in modules.c"
-#endif
-        return -1;
-    }
-
-    /* We can now try to call the symbol */
-    if( pf_symbol( p_module ) != 0 )
-    {
-        /* With a well-written module we shouldn't have to print an
-         * additional error message here, but just make sure. */
-        msg_Err( p_module, "Failed to call symbol \"%s\" in file `%s'",
-                           psz_name, p_module->psz_filename );
-        return -1;
-    }
-
-    /* Everything worked fine, we can return */
-    return 0;
-}
-
-/*****************************************************************************
- * LoadModule: loads a dynamic library
- *****************************************************************************
- * This function loads a dynamically linked library using a system dependant
- * method. Will return 0 on success as well as the module handle.
- *****************************************************************************/
-static int LoadModule( vlc_object_t *p_this, char *psz_file,
-                       module_handle_t *p_handle )
-{
-    module_handle_t handle;
-
-#if defined(HAVE_DL_DYLD)
-    NSObjectFileImage image;
-    NSObjectFileImageReturnCode ret;
-
-    ret = NSCreateObjectFileImageFromFile( psz_file, &image );
-
-    if( ret != NSObjectFileImageSuccess )
-    {
-        msg_Warn( p_this, "cannot create image from `%s'", psz_file );
-        return -1;
-    }
-
-    /* Open the dynamic module */
-    handle = NSLinkModule( image, psz_file,
-                           NSLINKMODULE_OPTION_RETURN_ON_ERROR );
-
-    if( !handle )
-    {
-        NSLinkEditErrors errors;
-        const char *psz_file, *psz_err;
-        int i_errnum;
-        NSLinkEditError( &errors, &i_errnum, &psz_file, &psz_err );
-        msg_Warn( p_this, "cannot link module `%s' (%s)", psz_file, psz_err );
-        NSDestroyObjectFileImage( image );
-        return -1;
-    }
-
-    /* Destroy our image, we won't need it */
-    NSDestroyObjectFileImage( image );
-
-#elif defined(HAVE_DL_BEOS)
-    handle = load_add_on( psz_file );
-    if( handle < 0 )
-    {
-        msg_Warn( p_this, "cannot load module `%s'", psz_file );
-        return -1;
-    }
-
-#elif defined(HAVE_DL_WINDOWS)
-#ifdef UNDER_CE
-    {
-        wchar_t psz_wfile[MAX_PATH];
-        MultiByteToWideChar( CP_ACP, 0, psz_file, -1, psz_wfile, MAX_PATH );
-        handle = LoadLibrary( psz_wfile );
-    }
-#else
-    handle = LoadLibrary( psz_file );
-#endif
-    if( handle == NULL )
-    {
-        char *psz_err = GetWindowsError();
-        msg_Warn( p_this, "cannot load module `%s' (%s)", psz_file, psz_err );
-        free( psz_err );
-        return -1;
-    }
-
-#elif defined(HAVE_DL_DLOPEN) && defined(RTLD_NOW)
-    /* static is OK, we are called atomically */
-
-#   if defined(SYS_LINUX)
-    /* XXX HACK #1 - we should NOT open modules with RTLD_GLOBAL, or we
-     * are going to get namespace collisions when two modules have common
-     * public symbols, but ALSA is being a pest here. */
-    if( strstr( psz_file, "alsa_plugin" ) )
-    {
-        handle = dlopen( psz_file, RTLD_NOW | RTLD_GLOBAL );
-        if( handle == NULL )
-        {
-            msg_Warn( p_this, "cannot load module `%s' (%s)",
-                              psz_file, dlerror() );
-            return -1;
-        }
-    }
-#   endif
-
-    handle = dlopen( psz_file, RTLD_NOW );
-    if( handle == NULL )
-    {
-        msg_Warn( p_this, "cannot load module `%s' (%s)",
-                          psz_file, dlerror() );
-        return -1;
-    }
-
-#elif defined(HAVE_DL_DLOPEN)
-#   if defined(DL_LAZY)
-    handle = dlopen( psz_file, DL_LAZY );
-#   else
-    handle = dlopen( psz_file, 0 );
-#   endif
-    if( handle == NULL )
-    {
-        msg_Warn( p_this, "cannot load module `%s' (%s)",
-                          psz_file, dlerror() );
-        return -1;
-    }
-
-#elif defined(HAVE_DL_SHL_LOAD)
-    handle = shl_load( psz_file, BIND_IMMEDIATE | BIND_NONFATAL, NULL );
-    if( handle == NULL )
-    {
-        msg_Warn( p_this, "cannot load module `%s' (%s)",
-                          psz_file, strerror(errno) );
-        return -1;
-    }
-
-#else
-#   error "Something is wrong in modules.c"
-
-#endif
-
-    *p_handle = handle;
-    return 0;
-}
-
-/*****************************************************************************
- * CloseModule: unload a dynamic library
- *****************************************************************************
- * This function unloads a previously opened dynamically linked library
- * using a system dependant method. No return value is taken in consideration,
- * since some libraries sometimes refuse to close properly.
- *****************************************************************************/
-static void CloseModule( module_handle_t handle )
-{
-#if defined(HAVE_DL_DYLD)
-    NSUnLinkModule( handle, FALSE );
-
-#elif defined(HAVE_DL_BEOS)
-    unload_add_on( handle );
-
-#elif defined(HAVE_DL_WINDOWS)
-    FreeLibrary( handle );
-
-#elif defined(HAVE_DL_DLOPEN)
-    dlclose( handle );
-
-#elif defined(HAVE_DL_SHL_LOAD)
-    shl_unload( handle );
-
-#endif
-    return;
-}
-
-/*****************************************************************************
- * GetSymbol: get a symbol from a dynamic library
- *****************************************************************************
- * This function queries a loaded library for a symbol specified in a
- * string, and returns a pointer to it. We don't check for dlerror() or
- * similar functions, since we want a non-NULL symbol anyway.
- *****************************************************************************/
-static void * _module_getsymbol( module_handle_t, const char * );
-
-static void * GetSymbol( module_handle_t handle, const char * psz_function )
-{
-    void * p_symbol = _module_getsymbol( handle, psz_function );
-
-    /* MacOS X dl library expects symbols to begin with "_". So do
-     * some other operating systems. That's really lame, but hey, what
-     * can we do ? */
-    if( p_symbol == NULL )
-    {
-        char *psz_call = malloc( strlen( psz_function ) + 2 );
-
-        strcpy( psz_call + 1, psz_function );
-        psz_call[ 0 ] = '_';
-        p_symbol = _module_getsymbol( handle, psz_call );
-        free( psz_call );
-    }
-
-    return p_symbol;
-}
-
-static void * _module_getsymbol( module_handle_t handle,
-                                 const char * psz_function )
-{
-#if defined(HAVE_DL_DYLD)
-    NSSymbol sym = NSLookupSymbolInModule( handle, psz_function );
-    return NSAddressOfSymbol( sym );
-
-#elif defined(HAVE_DL_BEOS)
-    void * p_symbol;
-    if( B_OK == get_image_symbol( handle, psz_function,
-                                  B_SYMBOL_TYPE_TEXT, &p_symbol ) )
-    {
-        return p_symbol;
-    }
-    else
-    {
-        return NULL;
-    }
-
-#elif defined(HAVE_DL_WINDOWS) && defined(UNDER_CE)
-    wchar_t psz_real[256];
-    MultiByteToWideChar( CP_ACP, 0, psz_function, -1, psz_real, 256 );
-
-    return (void *)GetProcAddress( handle, psz_real );
-
-#elif defined(HAVE_DL_WINDOWS) && defined(WIN32)
-    return (void *)GetProcAddress( handle, (char *)psz_function );
-
-#elif defined(HAVE_DL_DLOPEN)
-    return dlsym( handle, psz_function );
-
-#elif defined(HAVE_DL_SHL_LOAD)
-    void *p_sym;
-    shl_findsym( &handle, psz_function, TYPE_UNDEFINED, &p_sym );
-    return p_sym;
-
-#endif
-}
-
-#if defined(HAVE_DL_WINDOWS)
-static char * GetWindowsError( void )
-{
-#if defined(UNDER_CE)
-    wchar_t psz_tmp[MAX_PATH];
-    char * psz_buffer = malloc( MAX_PATH );
-#else
-    char * psz_tmp = malloc( MAX_PATH );
-#endif
-    int i = 0, i_error = GetLastError();
-
-    FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
-                   NULL, i_error, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
-                   (LPTSTR)psz_tmp, MAX_PATH, NULL );
-
-    /* Go to the end of the string */
-    while( psz_tmp[i] && psz_tmp[i] != _T('\r') && psz_tmp[i] != _T('\n') )
-    {
-        i++;
-    }
-
-    if( psz_tmp[i] )
-    {
-#if defined(UNDER_CE)
-        swprintf( psz_tmp + i, L" (error %i)", i_error );
-        psz_tmp[ 255 ] = L'\0';
-#else
-        snprintf( psz_tmp + i, 256 - i, " (error %i)", i_error );
-        psz_tmp[ 255 ] = '\0';
-#endif
-    }
-
-#if defined(UNDER_CE)
-    wcstombs( psz_buffer, psz_tmp, MAX_PATH );
-    return psz_buffer;
-#else
-    return psz_tmp;
-#endif
-}
-#endif /* HAVE_DL_WINDOWS */
-
-/*****************************************************************************
- * LoadPluginsCache: loads the plugins cache file
- *****************************************************************************
- * This function will load the plugin cache if present and valid. This cache
- * will in turn be queried by AllocateAllPlugins() to see if it needs to
- * actually load the dynamically loadable module.
- * This allows us to only fully load plugins when they are actually used.
- *****************************************************************************/
-static void CacheLoad( vlc_object_t *p_this )
-{
-    char *psz_filename, *psz_homedir;
-    FILE *file;
-    int i, j, i_size, i_read;
-    char p_cachestring[sizeof(PLUGINSCACHE_DIR COPYRIGHT_MESSAGE)];
-    char p_cachelang[6], p_lang[6];
-    int i_cache;
-    module_cache_t **pp_cache = 0;
-    int32_t i_file_size, i_marker;
-
-    psz_homedir = p_this->p_libvlc->psz_homedir;
-    if( !psz_homedir )
-    {
-        msg_Err( p_this, "psz_homedir is null" );
-        return;
-    }
-
-    i_size = asprintf( &psz_filename, "%s/%s/%s/%s", psz_homedir, CONFIG_DIR,
-                       PLUGINSCACHE_DIR, CacheName() );
-    if( i_size <= 0 )
-    {
-        msg_Err( p_this, "out of memory" );
-        return;
-    }
-
-    if( p_this->p_libvlc_global->p_module_bank->b_cache_delete )
-    {
-#if !defined( UNDER_CE )
-        unlink( psz_filename );
-#else
-        wchar_t psz_wf[MAX_PATH];
-        MultiByteToWideChar( CP_ACP, 0, psz_filename, -1, psz_wf, MAX_PATH );
-        DeleteFile( psz_wf );
-#endif
-        msg_Dbg( p_this, "removing plugins cache file %s", psz_filename );
-        free( psz_filename );
-        return;
-    }
-
-    msg_Dbg( p_this, "loading plugins cache file %s", psz_filename );
-
-    file = utf8_fopen( psz_filename, "rb" );
-    if( !file )
-    {
-        msg_Warn( p_this, "could not open plugins cache file %s for reading",
-                  psz_filename );
-        free( psz_filename );
-        return;
-    }
-    free( psz_filename );
-
-    /* Check the file size */
-    i_read = fread( &i_file_size, sizeof(char), sizeof(i_file_size), file );
-    if( i_read != sizeof(i_file_size) )
-    {
-        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
-                  "(too short)" );
-        fclose( file );
-        return;
-    }
-
-    fseek( file, 0, SEEK_END );
-    if( ftell( file ) != i_file_size )
-    {
-        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
-                  "(corrupted size)" );
-        fclose( file );
-        return;
-    }
-    fseek( file, sizeof(i_file_size), SEEK_SET );
-
-    /* Check the file is a plugins cache */
-    i_size = sizeof(PLUGINSCACHE_DIR COPYRIGHT_MESSAGE) - 1;
-    i_read = fread( p_cachestring, sizeof(char), i_size, file );
-    if( i_read != i_size ||
-        memcmp( p_cachestring, PLUGINSCACHE_DIR COPYRIGHT_MESSAGE, i_size ) )
-    {
-        msg_Warn( p_this, "This doesn't look like a valid plugins cache" );
-        fclose( file );
-        return;
-    }
-
-    /* Check Sub-version number */
-    i_read = fread( &i_marker, sizeof(char), sizeof(i_marker), file );
-    if( i_read != sizeof(i_marker) || i_marker != CACHE_SUBVERSION_NUM )
-    {
-        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
-                  "(corrupted header)" );
-        fclose( file );
-        return;
-    }
-
-    /* Check the language hasn't changed */
-    sprintf( p_lang, "%5.5s", _("C") ); i_size = 5;
-    i_read = fread( p_cachelang, sizeof(char), i_size, file );
-    if( i_read != i_size || memcmp( p_cachelang, p_lang, i_size ) )
-    {
-        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
-                  "(language changed)" );
-        fclose( file );
-        return;
-    }
-
-    /* Check header marker */
-    i_read = fread( &i_marker, sizeof(char), sizeof(i_marker), file );
-    if( i_read != sizeof(i_marker) ||
-        i_marker != ftell( file ) - (int)sizeof(i_marker) )
-    {
-        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
-                  "(corrupted header)" );
-        fclose( file );
-        return;
-    }
-
-    p_this->p_libvlc_global->p_module_bank->i_loaded_cache = 0;
-    fread( &i_cache, sizeof(char), sizeof(i_cache), file );
-    if( i_cache )
-        pp_cache = p_this->p_libvlc_global->p_module_bank->pp_loaded_cache =
-                   malloc( i_cache * sizeof(void *) );
-
-#define LOAD_IMMEDIATE(a) \
-    if( fread( (void *)&a, sizeof(char), sizeof(a), file ) != sizeof(a) ) goto error
-#define LOAD_STRING(a) \
-{ \
-    a = NULL; \
-    if( ( fread( &i_size, sizeof(i_size), 1, file ) != 1 ) \
-     || ( i_size > 16384 ) ) \
-        goto error; \
-    if( i_size ) { \
-        char *psz = malloc( i_size ); \
-        if( fread( psz, i_size, 1, file ) != 1 ) { \
-            free( psz ); \
-            goto error; \
-        } \
-        if( psz[i_size-1] ) { \
-            free( psz ); \
-            goto error; \
-        } \
-        a = psz; \
-    } \
-}
-
-    for( i = 0; i < i_cache; i++ )
-    {
-        uint16_t i_size;
-        int i_submodules;
-
-        pp_cache[i] = malloc( sizeof(module_cache_t) );
-        p_this->p_libvlc_global->p_module_bank->i_loaded_cache++;
-
-        /* Load common info */
-        LOAD_STRING( pp_cache[i]->psz_file );
-        LOAD_IMMEDIATE( pp_cache[i]->i_time );
-        LOAD_IMMEDIATE( pp_cache[i]->i_size );
-        LOAD_IMMEDIATE( pp_cache[i]->b_junk );
-        pp_cache[i]->b_used = VLC_FALSE;
-
-        if( pp_cache[i]->b_junk ) continue;
-
-        pp_cache[i]->p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE );
-
-        /* Load additional infos */
-        LOAD_STRING( pp_cache[i]->p_module->psz_object_name );
-        LOAD_STRING( pp_cache[i]->p_module->psz_shortname );
-        LOAD_STRING( pp_cache[i]->p_module->psz_longname );
-        LOAD_STRING( pp_cache[i]->p_module->psz_help );
-        LOAD_STRING( pp_cache[i]->p_module->psz_program );
-        for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
-        {
-            LOAD_STRING( pp_cache[i]->p_module->pp_shortcuts[j] ); // FIX
-        }
-        LOAD_STRING( pp_cache[i]->p_module->psz_capability );
-        LOAD_IMMEDIATE( pp_cache[i]->p_module->i_score );
-        LOAD_IMMEDIATE( pp_cache[i]->p_module->i_cpu );
-        LOAD_IMMEDIATE( pp_cache[i]->p_module->b_unloadable );
-        LOAD_IMMEDIATE( pp_cache[i]->p_module->b_reentrant );
-        LOAD_IMMEDIATE( pp_cache[i]->p_module->b_submodule );
-
-        /* Config stuff */
-        if( CacheLoadConfig( pp_cache[i]->p_module, file ) != VLC_SUCCESS )
-            goto error;
-
-        LOAD_STRING( pp_cache[i]->p_module->psz_filename );
-
-        LOAD_IMMEDIATE( i_submodules );
-
-        while( i_submodules-- )
-        {
-            module_t *p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE);
-            vlc_object_attach( p_module, pp_cache[i]->p_module );
-            p_module->b_submodule = VLC_TRUE;
-
-            LOAD_STRING( p_module->psz_object_name );
-            LOAD_STRING( p_module->psz_shortname );
-            LOAD_STRING( p_module->psz_longname );
-            LOAD_STRING( p_module->psz_help );
-            LOAD_STRING( p_module->psz_program );
-            for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
-            {
-                LOAD_STRING( p_module->pp_shortcuts[j] ); // FIX
-            }
-            LOAD_STRING( p_module->psz_capability );
-            LOAD_IMMEDIATE( p_module->i_score );
-            LOAD_IMMEDIATE( p_module->i_cpu );
-            LOAD_IMMEDIATE( p_module->b_unloadable );
-            LOAD_IMMEDIATE( p_module->b_reentrant );
-        }
-    }
-
-    fclose( file );
-    return;
-
- error:
-
-    msg_Warn( p_this, "plugins cache not loaded (corrupted)" );
-
-    /* TODO: cleanup */
-    p_this->p_libvlc_global->p_module_bank->i_loaded_cache = 0;
-
-    fclose( file );
-    return;
-}
-
-
-int CacheLoadConfig( module_t *p_module, FILE *file )
-{
-    uint32_t i_lines;
-    uint16_t i_size;
-
-    /* Calculate the structure length */
-    LOAD_IMMEDIATE( p_module->i_config_items );
-    LOAD_IMMEDIATE( p_module->i_bool_items );
-
-    LOAD_IMMEDIATE( i_lines );
-
-    /* Allocate memory */
-    if (i_lines)
-    {
-        p_module->p_config =
-            (module_config_t *)calloc( i_lines, sizeof(module_config_t) );
-        if( p_module->p_config == NULL )
-        {
-            p_module->confsize = 0;
-            msg_Err( p_module, "config error: can't duplicate p_config" );
-            return VLC_ENOMEM;
-        }
-    }
-    p_module->confsize = i_lines;
-
-    /* Do the duplication job */
-    for (size_t i = 0; i < i_lines; i++ )
-    {
-        LOAD_IMMEDIATE( p_module->p_config[i] );
-
-        LOAD_STRING( p_module->p_config[i].psz_type );
-        LOAD_STRING( p_module->p_config[i].psz_name );
-        LOAD_STRING( p_module->p_config[i].psz_text );
-        LOAD_STRING( p_module->p_config[i].psz_longtext );
-        LOAD_STRING( p_module->p_config[i].psz_current );
-
-        if (IsConfigStringType (p_module->p_config[i].i_type))
-        {
-            LOAD_STRING (p_module->p_config[i].orig.psz);
-            p_module->p_config[i].value.psz =
-                    (p_module->p_config[i].orig.psz != NULL)
-                        ? strdup (p_module->p_config[i].orig.psz) : NULL;
-            p_module->p_config[i].saved.psz = NULL;
-        }
-        else
-        {
-            memcpy (&p_module->p_config[i].value, &p_module->p_config[i].orig,
-                    sizeof (p_module->p_config[i].value));
-            memcpy (&p_module->p_config[i].saved, &p_module->p_config[i].orig,
-                    sizeof (p_module->p_config[i].saved));
-        }
-
-        p_module->p_config[i].b_dirty = VLC_FALSE;
-
-        p_module->p_config[i].p_lock = &p_module->object_lock;
-
-        if( p_module->p_config[i].i_list )
-        {
-            if( p_module->p_config[i].ppsz_list )
-            {
-                int j;
-                p_module->p_config[i].ppsz_list =
-                    malloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
-                if( p_module->p_config[i].ppsz_list )
-                {
-                    for( j = 0; j < p_module->p_config[i].i_list; j++ )
-                        LOAD_STRING( p_module->p_config[i].ppsz_list[j] );
-                    p_module->p_config[i].ppsz_list[j] = NULL;
-                }
-            }
-            if( p_module->p_config[i].ppsz_list_text )
-            {
-                int j;
-                p_module->p_config[i].ppsz_list_text =
-                    malloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
-                if( p_module->p_config[i].ppsz_list_text )
-                {
-                  for( j = 0; j < p_module->p_config[i].i_list; j++ )
-                      LOAD_STRING( p_module->p_config[i].ppsz_list_text[j] );
-                  p_module->p_config[i].ppsz_list_text[j] = NULL;
-                }
-            }
-            if( p_module->p_config[i].pi_list )
-            {
-                p_module->p_config[i].pi_list =
-                    malloc( (p_module->p_config[i].i_list + 1) * sizeof(int) );
-                if( p_module->p_config[i].pi_list )
-                {
-                    for (int j = 0; j < p_module->p_config[i].i_list; j++)
-                        LOAD_IMMEDIATE( p_module->p_config[i].pi_list[j] );
-                }
-            }
-        }
-
-        if( p_module->p_config[i].i_action )
-        {
-            p_module->p_config[i].ppf_action =
-                malloc( p_module->p_config[i].i_action * sizeof(void *) );
-            p_module->p_config[i].ppsz_action_text =
-                malloc( p_module->p_config[i].i_action * sizeof(char *) );
-
-            for (int j = 0; j < p_module->p_config[i].i_action; j++)
-            {
-                p_module->p_config[i].ppf_action[j] = 0;
-                LOAD_STRING( p_module->p_config[i].ppsz_action_text[j] );
-            }
-        }
-
-        LOAD_IMMEDIATE( p_module->p_config[i].pf_callback );
-    }
-
-    return VLC_SUCCESS;
-
- error:
-
-    return VLC_EGENERIC;
-}
-
-/*****************************************************************************
- * SavePluginsCache: saves the plugins cache to a file
- *****************************************************************************/
-static void CacheSave( vlc_object_t *p_this )
-{
-    static char const psz_tag[] =
-        "Signature: 8a477f597d28d172789f06886806bc55\r\n"
-        "# This file is a cache directory tag created by VLC.\r\n"
-        "# For information about cache directory tags, see:\r\n"
-        "#   http://www.brynosaurus.com/cachedir/\r\n";
-
-    char *psz_filename, *psz_homedir;
-    FILE *file;
-    int i, j, i_cache;
-    module_cache_t **pp_cache;
-    int32_t i_file_size = 0;
-
-    psz_homedir = p_this->p_libvlc->psz_homedir;
-    if( !psz_homedir )
-    {
-        msg_Err( p_this, "psz_homedir is null" );
-        return;
-    }
-    psz_filename =
-       (char *)malloc( sizeof("/" CONFIG_DIR "/" PLUGINSCACHE_DIR "/" ) +
-                       strlen(psz_homedir) + strlen(CacheName()) );
-
-    if( !psz_filename )
-    {
-        msg_Err( p_this, "out of memory" );
-        return;
-    }
-
-    sprintf( psz_filename, "%s/%s", psz_homedir, CONFIG_DIR );
-
-    config_CreateDir( p_this, psz_filename );
-
-    strcat( psz_filename, "/" PLUGINSCACHE_DIR );
-
-    config_CreateDir( p_this, psz_filename );
-
-    strcat( psz_filename, "/CACHEDIR.TAG" );
-
-    file = utf8_fopen( psz_filename, "wb" );
-    if( file )
-    {
-        fwrite( psz_tag, 1, strlen(psz_tag), file );
-        fclose( file );
-    }
-
-    sprintf( psz_filename, "%s/%s/%s/%s", psz_homedir, CONFIG_DIR,
-             PLUGINSCACHE_DIR, CacheName() );
-
-    msg_Dbg( p_this, "saving plugins cache file %s", psz_filename );
-
-    file = utf8_fopen( psz_filename, "wb" );
-    if( !file )
-    {
-        msg_Warn( p_this, "could not open plugins cache file %s for writing",
-                  psz_filename );
-        free( psz_filename );
-        return;
-    }
-    free( psz_filename );
-
-    /* Empty space for file size */
-    fwrite( &i_file_size, sizeof(char), sizeof(i_file_size), file );
-
-    /* Contains version number */
-    fprintf( file, "%s", PLUGINSCACHE_DIR COPYRIGHT_MESSAGE );
-
-    /* Sub-version number (to avoid breakage in the dev version when cache
-     * structure changes) */
-    i_file_size = CACHE_SUBVERSION_NUM;
-    fwrite( &i_file_size, sizeof(char), sizeof(i_file_size), file );
-
-    /* Language */
-    fprintf( file, "%5.5s", _("C") );
-
-    /* Header marker */
-    i_file_size = ftell( file );
-    fwrite( &i_file_size, sizeof(char), sizeof(i_file_size), file );
-
-    i_cache = p_this->p_libvlc_global->p_module_bank->i_cache;
-    pp_cache = p_this->p_libvlc_global->p_module_bank->pp_cache;
-
-    fwrite( &i_cache, sizeof(char), sizeof(i_cache), file );
-
-#define SAVE_IMMEDIATE(a) \
-    fwrite( &a, sizeof(char), sizeof(a), file )
-#define SAVE_STRING(a) \
-    { i_size = a ? strlen( a ) + 1 : 0; \
-      fwrite( &i_size, sizeof(char), sizeof(i_size), file ); \
-      if( a ) fwrite( a, sizeof(char), i_size, file ); \
-    } while(0)
-
-    for( i = 0; i < i_cache; i++ )
-    {
-        uint16_t i_size;
-        uint32_t i_submodule;
-
-        /* Save common info */
-        SAVE_STRING( pp_cache[i]->psz_file );
-        SAVE_IMMEDIATE( pp_cache[i]->i_time );
-        SAVE_IMMEDIATE( pp_cache[i]->i_size );
-        SAVE_IMMEDIATE( pp_cache[i]->b_junk );
-
-        if( pp_cache[i]->b_junk ) continue;
-
-        /* Save additional infos */
-        SAVE_STRING( pp_cache[i]->p_module->psz_object_name );
-        SAVE_STRING( pp_cache[i]->p_module->psz_shortname );
-        SAVE_STRING( pp_cache[i]->p_module->psz_longname );
-        SAVE_STRING( pp_cache[i]->p_module->psz_help );
-        SAVE_STRING( pp_cache[i]->p_module->psz_program );
-        for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
-        {
-            SAVE_STRING( pp_cache[i]->p_module->pp_shortcuts[j] ); // FIX
-        }
-        SAVE_STRING( pp_cache[i]->p_module->psz_capability );
-        SAVE_IMMEDIATE( pp_cache[i]->p_module->i_score );
-        SAVE_IMMEDIATE( pp_cache[i]->p_module->i_cpu );
-        SAVE_IMMEDIATE( pp_cache[i]->p_module->b_unloadable );
-        SAVE_IMMEDIATE( pp_cache[i]->p_module->b_reentrant );
-        SAVE_IMMEDIATE( pp_cache[i]->p_module->b_submodule );
-
-        /* Config stuff */
-        CacheSaveConfig( pp_cache[i]->p_module, file );
-
-        SAVE_STRING( pp_cache[i]->p_module->psz_filename );
-
-        i_submodule = pp_cache[i]->p_module->i_children;
-        SAVE_IMMEDIATE( i_submodule );
-        for( i_submodule = 0;
-             i_submodule < (unsigned)pp_cache[i]->p_module->i_children;
-             i_submodule++ )
-        {
-            module_t *p_module =
-                (module_t *)pp_cache[i]->p_module->pp_children[i_submodule];
-
-            SAVE_STRING( p_module->psz_object_name );
-            SAVE_STRING( p_module->psz_shortname );
-            SAVE_STRING( p_module->psz_longname );
-            SAVE_STRING( p_module->psz_help );
-            SAVE_STRING( p_module->psz_program );
-            for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
-            {
-                SAVE_STRING( p_module->pp_shortcuts[j] ); // FIX
-            }
-            SAVE_STRING( p_module->psz_capability );
-            SAVE_IMMEDIATE( p_module->i_score );
-            SAVE_IMMEDIATE( p_module->i_cpu );
-            SAVE_IMMEDIATE( p_module->b_unloadable );
-            SAVE_IMMEDIATE( p_module->b_reentrant );
-        }
-    }
-
-    /* Fill-up file size */
-    i_file_size = ftell( file );
-    fseek( file, 0, SEEK_SET );
-    fwrite( &i_file_size, sizeof(char), sizeof(i_file_size), file );
-
-    fclose( file );
-
-    return;
-}
-
-void CacheSaveConfig( module_t *p_module, FILE *file )
-{
-    uint32_t i_lines = p_module->confsize;
-    uint16_t i_size;
-
-    SAVE_IMMEDIATE( p_module->i_config_items );
-    SAVE_IMMEDIATE( p_module->i_bool_items );
-    SAVE_IMMEDIATE( i_lines );
-
-    for (size_t i = 0; i < i_lines ; i++)
-    {
-        SAVE_IMMEDIATE( p_module->p_config[i] );
-
-        SAVE_STRING( p_module->p_config[i].psz_type );
-        SAVE_STRING( p_module->p_config[i].psz_name );
-        SAVE_STRING( p_module->p_config[i].psz_text );
-        SAVE_STRING( p_module->p_config[i].psz_longtext );
-        SAVE_STRING( p_module->p_config[i].psz_current );
-        if (IsConfigStringType (p_module->p_config[i].i_type))
-            SAVE_STRING( p_module->p_config[i].orig.psz );
-
-        if( p_module->p_config[i].i_list )
-        {
-            if( p_module->p_config[i].ppsz_list )
-            {
-                for (int j = 0; j < p_module->p_config[i].i_list; j++)
-                    SAVE_STRING( p_module->p_config[i].ppsz_list[j] );
-            }
-
-            if( p_module->p_config[i].ppsz_list_text )
-            {
-                for (int j = 0; j < p_module->p_config[i].i_list; j++)
-                    SAVE_STRING( p_module->p_config[i].ppsz_list_text[j] );
-            }
-            if( p_module->p_config[i].pi_list )
-            {
-                for (int j = 0; j < p_module->p_config[i].i_list; j++)
-                    SAVE_IMMEDIATE( p_module->p_config[i].pi_list[j] );
-            }
-        }
-
-        for (int j = 0; j < p_module->p_config[i].i_action; j++)
-            SAVE_STRING( p_module->p_config[i].ppsz_action_text[j] );
-
-        SAVE_IMMEDIATE( p_module->p_config[i].pf_callback );
-    }
-}
-
-/*****************************************************************************
- * CacheName: Return the cache file name for this platform.
- *****************************************************************************/
-static char *CacheName( void )
-{
-    static char psz_cachename[32];
-
-    /* Code int size, pointer size and endianness in the filename */
-    int32_t x = 0xbe00001e;
-    sprintf( psz_cachename, "plugins-%.2x%.2x%.2x.dat", (int)sizeof(int),
-             (int)sizeof(void *), (unsigned int)((unsigned char *)&x)[0] );
-    return psz_cachename;
-}
-
-/*****************************************************************************
- * CacheMerge: Merge a cache module descriptor with a full module descriptor.
- *****************************************************************************/
-static void CacheMerge( vlc_object_t *p_this, module_t *p_cache,
-                        module_t *p_module )
-{
-    int i_submodule;
-    (void)p_this;
-
-    p_cache->pf_activate = p_module->pf_activate;
-    p_cache->pf_deactivate = p_module->pf_deactivate;
-#ifndef HAVE_SHARED_LIBVLC
-    p_cache->p_symbols = p_module->p_symbols;
-#endif
-    p_cache->handle = p_module->handle;
-
-    for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ )
-    {
-        module_t *p_child = (module_t*)p_module->pp_children[i_submodule];
-        module_t *p_cchild = (module_t*)p_cache->pp_children[i_submodule];
-        p_cchild->pf_activate = p_child->pf_activate;
-        p_cchild->pf_deactivate = p_child->pf_deactivate;
-#ifndef HAVE_SHARED_LIBVLC
-        p_cchild->p_symbols = p_child->p_symbols;
-#endif
-    }
-
-    p_cache->b_loaded = VLC_TRUE;
-    p_module->b_loaded = VLC_FALSE;
-}
-
-/*****************************************************************************
- * CacheFind: finds the cache entry corresponding to a file
- *****************************************************************************/
-static module_cache_t *CacheFind( vlc_object_t *p_this, char *psz_file,
-                                  int64_t i_time, int64_t i_size )
-{
-    module_cache_t **pp_cache;
-    int i_cache, i;
-
-    pp_cache = p_this->p_libvlc_global->p_module_bank->pp_loaded_cache;
-    i_cache = p_this->p_libvlc_global->p_module_bank->i_loaded_cache;
-
-    for( i = 0; i < i_cache; i++ )
-    {
-        if( !strcmp( pp_cache[i]->psz_file, psz_file ) &&
-            pp_cache[i]->i_time == i_time &&
-            pp_cache[i]->i_size == i_size ) return pp_cache[i];
-    }
-
-    return NULL;
-}
-
-#endif /* HAVE_DYNAMIC_PLUGINS */
diff --git a/src/misc/modules.h b/src/misc/modules.h
deleted file mode 100644 (file)
index 13be264..0000000
+++ /dev/null
@@ -1,82 +0,0 @@
-/*****************************************************************************
- * modules.h : Module management functions.
- *****************************************************************************
- * Copyright (C) 2001 the VideoLAN team
- * $Id: modules.h 17958 2006-11-22 17:13:24Z courmisch $
- *
- * Authors: Samuel Hocevar <sam@zoy.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-/* Number of tries before we unload an unused module */
-#define MODULE_HIDE_DELAY 50
-
-/*****************************************************************************
- * module_bank_t: the module bank
- *****************************************************************************
- * This variable is accessed by any function using modules.
- *****************************************************************************/
-struct module_bank_t
-{
-    VLC_COMMON_MEMBERS
-
-    int              i_usage;
-#ifndef HAVE_SHARED_LIBVLC
-    module_symbols_t symbols;
-#endif
-
-    vlc_bool_t       b_main;
-    vlc_bool_t       b_builtins;
-    vlc_bool_t       b_plugins;
-
-    /* Plugins cache */
-    vlc_bool_t     b_cache;
-    vlc_bool_t     b_cache_dirty;
-    vlc_bool_t     b_cache_delete;
-
-    int            i_cache;
-    module_cache_t **pp_cache;
-
-    int            i_loaded_cache;
-    module_cache_t **pp_loaded_cache;
-};
-
-/*****************************************************************************
- * Module cache description structure
- *****************************************************************************/
-struct module_cache_t
-{
-    /* Mandatory cache entry header */
-    char       *psz_file;
-    int64_t    i_time;
-    int64_t    i_size;
-    vlc_bool_t b_junk;
-
-    /* Optional extra data */
-    module_t *p_module;
-    vlc_bool_t b_used;
-};
-
-#define module_InitBank(a)     __module_InitBank(VLC_OBJECT(a))
-void  __module_InitBank        ( vlc_object_t * );
-#define module_LoadBuiltins(a) __module_LoadBuiltins(VLC_OBJECT(a))
-void  __module_LoadBuiltins    ( vlc_object_t * );
-#define module_LoadPlugins(a)  __module_LoadPlugins(VLC_OBJECT(a))
-void  __module_LoadPlugins     ( vlc_object_t * );
-#define module_EndBank(a)      __module_EndBank(VLC_OBJECT(a))
-void  __module_EndBank         ( vlc_object_t * );
-#define module_ResetBank(a)    __module_ResetBank(VLC_OBJECT(a))
-void  __module_ResetBank       ( vlc_object_t * );
diff --git a/src/misc/modules_builtin.h.in b/src/misc/modules_builtin.h.in
deleted file mode 100644 (file)
index 333837c..0000000
+++ /dev/null
@@ -1,29 +0,0 @@
-/*****************************************************************************
- * modules_builtin.h: built-in modules list
- *****************************************************************************
- * Copyright (C) 2001 the VideoLAN team
- *
- * Authors: Samuel Hocevar <sam@zoy.org>
- *
- * This program is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version.
- *
- * This program 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 General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
- *****************************************************************************/
-
-#define ALLOCATE_BUILTIN( NAME ) \
-    AllocateBuiltinModule( p_this, vlc_entry__ ## NAME );
-
-/* We also consider the main program as a module (useful for config stuff) */
-int vlc_entry__main( module_t* );
-
-/* Add stuff here */
diff --git a/src/modules/builtin.h.in b/src/modules/builtin.h.in
new file mode 100644 (file)
index 0000000..333837c
--- /dev/null
@@ -0,0 +1,29 @@
+/*****************************************************************************
+ * modules_builtin.h: built-in modules list
+ *****************************************************************************
+ * Copyright (C) 2001 the VideoLAN team
+ *
+ * Authors: Samuel Hocevar <sam@zoy.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#define ALLOCATE_BUILTIN( NAME ) \
+    AllocateBuiltinModule( p_this, vlc_entry__ ## NAME );
+
+/* We also consider the main program as a module (useful for config stuff) */
+int vlc_entry__main( module_t* );
+
+/* Add stuff here */
diff --git a/src/modules/configuration.c b/src/modules/configuration.c
new file mode 100644 (file)
index 0000000..9f54778
--- /dev/null
@@ -0,0 +1,1845 @@
+/*****************************************************************************
+ * configuration.c management of the modules configuration
+ *****************************************************************************
+ * Copyright (C) 2001-2007 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#include <vlc/vlc.h>
+#include "vlc_keys.h"
+#include "vlc_charset.h"
+
+#include <stdio.h>                                              /* sprintf() */
+#include <stdlib.h>                                      /* free(), strtol() */
+#include <string.h>                                              /* strdup() */
+#include <errno.h>                                                  /* errno */
+
+#ifdef HAVE_LIMITS_H
+#   include <limits.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+#    include <unistd.h>                                          /* getuid() */
+#endif
+
+#ifdef HAVE_GETOPT_LONG
+#   ifdef HAVE_GETOPT_H
+#       include <getopt.h>                                       /* getopt() */
+#   endif
+#else
+#   include "../extras/getopt.h"
+#endif
+
+#if defined(HAVE_GETPWUID)
+#   include <pwd.h>                                            /* getpwuid() */
+#endif
+
+#if defined( HAVE_SYS_STAT_H )
+#   include <sys/stat.h>
+#endif
+#if defined( HAVE_SYS_TYPES_H )
+#   include <sys/types.h>
+#endif
+#if defined( WIN32 )
+#   if !defined( UNDER_CE )
+#       include <direct.h>
+#   endif
+#include <tchar.h>
+#endif
+
+#include "configuration.h"
+
+static int ConfigStringToKey( const char * );
+static char *ConfigKeyToString( int );
+
+static inline void freenull (const void *p)
+{
+    if (p != NULL)
+        free ((void *)p);
+}
+
+static inline char *strdupnull (const char *src)
+{
+    if (src == NULL)
+        return NULL;
+    return strdup (src);
+}
+
+static inline char *_strdupnull (const char *src)
+{
+    if (src == NULL)
+        return NULL;
+    return strdup (_(src));
+}
+
+
+/*****************************************************************************
+ * config_GetType: get the type of a variable (bool, int, float, string)
+ *****************************************************************************
+ * This function is used to get the type of a variable from its name.
+ * Beware, this is quite slow.
+ *****************************************************************************/
+int __config_GetType( vlc_object_t *p_this, const char *psz_name )
+{
+    module_config_t *p_config;
+    int i_type;
+
+    p_config = config_FindConfig( p_this, psz_name );
+
+    /* sanity checks */
+    if( !p_config )
+    {
+        return 0;
+    }
+
+    switch( p_config->i_type )
+    {
+    case CONFIG_ITEM_BOOL:
+        i_type = VLC_VAR_BOOL;
+        break;
+
+    case CONFIG_ITEM_INTEGER:
+        i_type = VLC_VAR_INTEGER;
+        break;
+
+    case CONFIG_ITEM_FLOAT:
+        i_type = VLC_VAR_FLOAT;
+        break;
+
+    case CONFIG_ITEM_MODULE:
+    case CONFIG_ITEM_MODULE_CAT:
+    case CONFIG_ITEM_MODULE_LIST:
+    case CONFIG_ITEM_MODULE_LIST_CAT:
+        i_type = VLC_VAR_MODULE;
+        break;
+
+    case CONFIG_ITEM_STRING:
+        i_type = VLC_VAR_STRING;
+        break;
+
+    case CONFIG_ITEM_FILE:
+        i_type = VLC_VAR_FILE;
+        break;
+
+    case CONFIG_ITEM_DIRECTORY:
+        i_type = VLC_VAR_DIRECTORY;
+        break;
+
+    default:
+        i_type = 0;
+        break;
+    }
+
+    return i_type;
+}
+
+/*****************************************************************************
+ * config_GetInt: get the value of an int variable
+ *****************************************************************************
+ * This function is used to get the value of variables which are internally
+ * represented by an integer (CONFIG_ITEM_INTEGER and
+ * CONFIG_ITEM_BOOL).
+ *****************************************************************************/
+int __config_GetInt( vlc_object_t *p_this, const char *psz_name )
+{
+    module_config_t *p_config;
+
+    p_config = config_FindConfig( p_this, psz_name );
+
+    /* sanity checks */
+    if( !p_config )
+    {
+        msg_Err( p_this, "option %s does not exist", psz_name );
+        return -1;
+    }
+
+    if (!IsConfigIntegerType (p_config->i_type))
+    {
+        msg_Err( p_this, "option %s does not refer to an int", psz_name );
+        return -1;
+    }
+
+    return p_config->value.i;
+}
+
+/*****************************************************************************
+ * config_GetFloat: get the value of a float variable
+ *****************************************************************************
+ * This function is used to get the value of variables which are internally
+ * represented by a float (CONFIG_ITEM_FLOAT).
+ *****************************************************************************/
+float __config_GetFloat( vlc_object_t *p_this, const char *psz_name )
+{
+    module_config_t *p_config;
+
+    p_config = config_FindConfig( p_this, psz_name );
+
+    /* sanity checks */
+    if( !p_config )
+    {
+        msg_Err( p_this, "option %s does not exist", psz_name );
+        return -1;
+    }
+
+    if (!IsConfigFloatType (p_config->i_type))
+    {
+        msg_Err( p_this, "option %s does not refer to a float", psz_name );
+        return -1;
+    }
+
+    return p_config->value.f;
+}
+
+/*****************************************************************************
+ * config_GetPsz: get the string value of a string variable
+ *****************************************************************************
+ * This function is used to get the value of variables which are internally
+ * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_FILE,
+ * CONFIG_ITEM_DIRECTORY, and CONFIG_ITEM_MODULE).
+ *
+ * Important note: remember to free() the returned char* because it's a
+ *   duplicate of the actual value. It isn't safe to return a pointer to the
+ *   actual value as it can be modified at any time.
+ *****************************************************************************/
+char * __config_GetPsz( vlc_object_t *p_this, const char *psz_name )
+{
+    module_config_t *p_config;
+
+    p_config = config_FindConfig( p_this, psz_name );
+
+    /* sanity checks */
+    if( !p_config )
+    {
+        msg_Err( p_this, "option %s does not exist", psz_name );
+        return NULL;
+    }
+
+    if (!IsConfigStringType (p_config->i_type))
+    {
+        msg_Err( p_this, "option %s does not refer to a string", psz_name );
+        return NULL;
+    }
+
+    /* return a copy of the string */
+    vlc_mutex_lock( p_config->p_lock );
+    char *psz_value = strdupnull (p_config->value.psz);
+    vlc_mutex_unlock( p_config->p_lock );
+
+    return psz_value;
+}
+
+/*****************************************************************************
+ * config_PutPsz: set the string value of a string variable
+ *****************************************************************************
+ * This function is used to set the value of variables which are internally
+ * represented by a string (CONFIG_ITEM_STRING, CONFIG_ITEM_FILE,
+ * CONFIG_ITEM_DIRECTORY, and CONFIG_ITEM_MODULE).
+ *****************************************************************************/
+void __config_PutPsz( vlc_object_t *p_this,
+                      const char *psz_name, const char *psz_value )
+{
+    module_config_t *p_config;
+    vlc_value_t oldval, val;
+
+    p_config = config_FindConfig( p_this, psz_name );
+
+
+    /* sanity checks */
+    if( !p_config )
+    {
+        msg_Warn( p_this, "option %s does not exist", psz_name );
+        return;
+    }
+
+    if (!IsConfigStringType (p_config->i_type))
+    {
+        msg_Err( p_this, "option %s does not refer to a string", psz_name );
+        return;
+    }
+
+    vlc_mutex_lock( p_config->p_lock );
+
+    /* backup old value */
+    oldval.psz_string = (char *)p_config->value.psz;
+
+    if ((psz_value != NULL) && *psz_value)
+        p_config->value.psz = strdup (psz_value);
+    else
+        p_config->value.psz = NULL;
+
+    p_config->b_dirty = VLC_TRUE;
+
+    val.psz_string = (char *)p_config->value.psz;
+
+    vlc_mutex_unlock( p_config->p_lock );
+
+    if( p_config->pf_callback )
+    {
+        p_config->pf_callback( p_this, psz_name, oldval, val,
+                               p_config->p_callback_data );
+    }
+
+    /* free old string */
+    if( oldval.psz_string ) free( oldval.psz_string );
+}
+
+/*****************************************************************************
+ * config_PutInt: set the integer value of an int variable
+ *****************************************************************************
+ * This function is used to set the value of variables which are internally
+ * represented by an integer (CONFIG_ITEM_INTEGER and
+ * CONFIG_ITEM_BOOL).
+ *****************************************************************************/
+void __config_PutInt( vlc_object_t *p_this, const char *psz_name, int i_value )
+{
+    module_config_t *p_config;
+    vlc_value_t oldval, val;
+
+    p_config = config_FindConfig( p_this, psz_name );
+
+    /* sanity checks */
+    if( !p_config )
+    {
+        msg_Warn( p_this, "option %s does not exist", psz_name );
+        return;
+    }
+
+    if (!IsConfigIntegerType (p_config->i_type))
+    {
+        msg_Err( p_this, "option %s does not refer to an int", psz_name );
+        return;
+    }
+
+    /* backup old value */
+    oldval.i_int = p_config->value.i;
+
+    /* if i_min == i_max == 0, then do not use them */
+    if ((p_config->min.i == 0) && (p_config->max.i == 0))
+    {
+        p_config->value.i = i_value;
+    }
+    else if (i_value < p_config->min.i)
+    {
+        p_config->value.i = p_config->min.i;
+    }
+    else if (i_value > p_config->max.i)
+    {
+        p_config->value.i = p_config->max.i;
+    }
+    else
+    {
+        p_config->value.i = i_value;
+    }
+
+    p_config->b_dirty = VLC_TRUE;
+
+    val.i_int = p_config->value.i;
+
+    if( p_config->pf_callback )
+    {
+        p_config->pf_callback( p_this, psz_name, oldval, val,
+                               p_config->p_callback_data );
+    }
+}
+
+/*****************************************************************************
+ * config_PutFloat: set the value of a float variable
+ *****************************************************************************
+ * This function is used to set the value of variables which are internally
+ * represented by a float (CONFIG_ITEM_FLOAT).
+ *****************************************************************************/
+void __config_PutFloat( vlc_object_t *p_this,
+                        const char *psz_name, float f_value )
+{
+    module_config_t *p_config;
+    vlc_value_t oldval, val;
+
+    p_config = config_FindConfig( p_this, psz_name );
+
+    /* sanity checks */
+    if( !p_config )
+    {
+        msg_Warn( p_this, "option %s does not exist", psz_name );
+        return;
+    }
+
+    if (!IsConfigFloatType (p_config->i_type))
+    {
+        msg_Err( p_this, "option %s does not refer to a float", psz_name );
+        return;
+    }
+
+    /* backup old value */
+    oldval.f_float = p_config->value.f;
+
+    /* if f_min == f_max == 0, then do not use them */
+    if ((p_config->min.f == 0) && (p_config->max.f == 0))
+    {
+        p_config->value.f = f_value;
+    }
+    else if (f_value < p_config->min.f)
+    {
+        p_config->value.f = p_config->min.f;
+    }
+    else if (f_value > p_config->max.f)
+    {
+        p_config->value.f = p_config->max.f;
+    }
+    else
+    {
+        p_config->value.f = f_value;
+    }
+
+    p_config->b_dirty = VLC_TRUE;
+
+    val.f_float = p_config->value.f;
+
+    if( p_config->pf_callback )
+    {
+        p_config->pf_callback( p_this, psz_name, oldval, val,
+                               p_config->p_callback_data );
+    }
+}
+
+/*****************************************************************************
+ * config_FindConfig: find the config structure associated with an option.
+ *****************************************************************************
+ * FIXME: This function really needs to be optimized.
+ * FIXME: And now even more.
+ *****************************************************************************/
+module_config_t *config_FindConfig( vlc_object_t *p_this, const char *psz_name )
+{
+    vlc_list_t *p_list;
+    int i_index;
+
+    if( !psz_name ) return NULL;
+
+    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
+
+    for( i_index = 0; i_index < p_list->i_count; i_index++ )
+    {
+        module_config_t *p_item, *p_end;
+        module_t *p_parser = (module_t *)p_list->p_values[i_index].p_object;
+
+        if( !p_parser->i_config_items )
+            continue;
+
+        for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
+             p_item < p_end;
+             p_item++ )
+        {
+            if( p_item->i_type & CONFIG_HINT )
+                /* ignore hints */
+                continue;
+            if( !strcmp( psz_name, p_item->psz_name ) )
+            {
+                vlc_list_release( p_list );
+                return p_item;
+            }
+        }
+    }
+
+    vlc_list_release( p_list );
+
+    return NULL;
+}
+
+/*****************************************************************************
+ * config_FindModule: find a specific module structure.
+ *****************************************************************************/
+module_t *config_FindModule( vlc_object_t *p_this, const char *psz_name )
+{
+    vlc_list_t *p_list;
+    module_t *p_module, *p_result = NULL;
+    int i_index;
+
+    if( !psz_name ) return NULL;
+
+    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
+
+    for( i_index = 0; i_index < p_list->i_count; i_index++ )
+    {
+        p_module = (module_t *)p_list->p_values[i_index].p_object;
+        if( !strcmp( p_module->psz_object_name, psz_name ) )
+        {
+             p_result = p_module;
+             break;
+        }
+    }
+
+    vlc_list_release( p_list );
+
+    return p_result;
+}
+
+/*****************************************************************************
+ * config_Duplicate: creates a duplicate of a module's configuration data.
+ *****************************************************************************
+ * Unfortunatly we cannot work directly with the module's config data as
+ * this module might be unloaded from memory at any time (remember HideModule).
+ * This is why we need to create an exact copy of the config data.
+ *****************************************************************************/
+int config_Duplicate( module_t *p_module, const module_config_t *p_orig,
+                      size_t n )
+{
+    int j;
+    const module_config_t *p_item, *p_end = p_orig + n;
+
+    /* Calculate the structure length */
+    p_module->i_config_items = 0;
+    p_module->i_bool_items = 0;
+
+    for( p_item = p_orig; p_item < p_end; p_item++ )
+    {
+        if( p_item->i_type & CONFIG_ITEM )
+        {
+            p_module->i_config_items++;
+        }
+
+        if( p_item->i_type == CONFIG_ITEM_BOOL )
+        {
+            p_module->i_bool_items++;
+        }
+    }
+
+    /* Allocate memory */
+    p_module->p_config = (module_config_t *)calloc( n, sizeof(*p_orig) );
+    if( p_module->p_config == NULL )
+    {
+        msg_Err( p_module, "config error: can't duplicate p_config" );
+        return VLC_ENOMEM;
+    }
+    p_module->confsize = n;
+
+    /* Do the duplication job */
+    for( size_t i = 0; i < n ; i++ )
+    {
+        p_module->p_config[i] = p_orig[i];
+
+        if (IsConfigIntegerType (p_module->p_config[i].i_type))
+        {
+            p_module->p_config[i].orig.i = p_orig[i].value.i;
+            p_module->p_config[i].saved.i = p_orig[i].value.i;
+        }
+        else
+        if (IsConfigFloatType (p_module->p_config[i].i_type))
+        {
+            p_module->p_config[i].orig.f = p_orig[i].value.f;
+            p_module->p_config[i].saved.f = p_orig[i].value.f;
+        }
+        else
+        if (IsConfigStringType (p_module->p_config[i].i_type))
+        {
+            p_module->p_config[i].value.psz = strdupnull (p_orig[i].value.psz);
+            p_module->p_config[i].orig.psz = strdupnull (p_orig[i].value.psz);
+            p_module->p_config[i].saved.psz = NULL;
+        }
+
+        p_module->p_config[i].psz_type = strdupnull (p_orig[i].psz_type);
+        p_module->p_config[i].psz_name = strdupnull (p_orig[i].psz_name);
+        p_module->p_config[i].psz_current = strdupnull (p_orig[i].psz_current);
+        p_module->p_config[i].psz_text = _strdupnull (p_orig[i].psz_text);
+        p_module->p_config[i].psz_longtext = _strdupnull (p_orig[i].psz_longtext);
+
+        p_module->p_config[i].p_lock = &p_module->object_lock;
+
+        /* duplicate the string list */
+        if( p_orig[i].i_list )
+        {
+            if( p_orig[i].ppsz_list )
+            {
+                p_module->p_config[i].ppsz_list =
+                    malloc( (p_orig[i].i_list + 1) * sizeof(char *) );
+                if( p_module->p_config[i].ppsz_list )
+                {
+                    for( j = 0; j < p_orig[i].i_list; j++ )
+                        p_module->p_config[i].ppsz_list[j] =
+                                strdupnull (p_orig[i].ppsz_list[j]);
+                    p_module->p_config[i].ppsz_list[j] = NULL;
+                }
+            }
+            if( p_orig[i].ppsz_list_text )
+            {
+                p_module->p_config[i].ppsz_list_text =
+                    calloc( (p_orig[i].i_list + 1), sizeof(char *) );
+                if( p_module->p_config[i].ppsz_list_text )
+                {
+                    for( j = 0; j < p_orig[i].i_list; j++ )
+                        p_module->p_config[i].ppsz_list_text[j] =
+                                strdupnull (_(p_orig[i].ppsz_list_text[j]));
+                    p_module->p_config[i].ppsz_list_text[j] = NULL;
+                }
+            }
+            if( p_orig[i].pi_list )
+            {
+                p_module->p_config[i].pi_list =
+                    malloc( (p_orig[i].i_list + 1) * sizeof(int) );
+                if( p_module->p_config[i].pi_list )
+                {
+                    for( j = 0; j < p_orig[i].i_list; j++ )
+                        p_module->p_config[i].pi_list[j] =
+                            p_orig[i].pi_list[j];
+                }
+            }
+        }
+
+        /* duplicate the actions list */
+        if( p_orig[i].i_action )
+        {
+            int j;
+
+            p_module->p_config[i].ppf_action =
+                malloc( p_orig[i].i_action * sizeof(void *) );
+            p_module->p_config[i].ppsz_action_text =
+                malloc( p_orig[i].i_action * sizeof(char *) );
+
+            for( j = 0; j < p_orig[i].i_action; j++ )
+            {
+                p_module->p_config[i].ppf_action[j] =
+                    p_orig[i].ppf_action[j];
+                p_module->p_config[i].ppsz_action_text[j] =
+                    strdupnull (p_orig[i].ppsz_action_text[j]);
+            }
+        }
+
+        p_module->p_config[i].pf_callback = p_orig[i].pf_callback;
+    }
+    return VLC_SUCCESS;
+}
+
+
+/*****************************************************************************
+ * config_Free: frees a duplicated module's configuration data.
+ *****************************************************************************
+ * This function frees all the data duplicated by config_Duplicate.
+ *****************************************************************************/
+void config_Free( module_t *p_module )
+{
+    int i;
+
+    for (size_t j = 0; j < p_module->confsize; j++)
+    {
+        module_config_t *p_item = p_module->p_config + j;
+
+        free( (char*) p_item->psz_type );
+        free( (char*) p_item->psz_name );
+        free( (char*) p_item->psz_current );
+        free( (char*) p_item->psz_text );
+        free( (char*) p_item->psz_longtext );
+
+        if (IsConfigStringType (p_item->i_type))
+        {
+            freenull (p_item->value.psz);
+            freenull (p_item->orig.psz);
+            freenull (p_item->saved.psz);
+        }
+
+        if( p_item->i_list )
+        {
+            for( i = 0; i < p_item->i_list; i++ )
+            {
+                if( p_item->ppsz_list && p_item->ppsz_list[i] )
+                    free( (char*) p_item->ppsz_list[i] );
+                if( p_item->ppsz_list_text && p_item->ppsz_list_text[i] )
+                    free( (char*) p_item->ppsz_list_text[i] );
+            }
+            if( p_item->ppsz_list ) free( p_item->ppsz_list );
+            if( p_item->ppsz_list_text ) free( p_item->ppsz_list_text );
+            if( p_item->pi_list ) free( p_item->pi_list );
+        }
+
+        if( p_item->i_action )
+        {
+            for( i = 0; i < p_item->i_action; i++ )
+            {
+                free( (char*) p_item->ppsz_action_text[i] );
+            }
+            if( p_item->ppf_action ) free( p_item->ppf_action );
+            if( p_item->ppsz_action_text ) free( p_item->ppsz_action_text );
+        }
+    }
+
+    if (p_module->p_config != NULL)
+    {
+        free (p_module->p_config);
+        p_module->p_config = NULL;
+    }
+}
+
+/*****************************************************************************
+ * config_SetCallbacks: sets callback functions in the duplicate p_config.
+ *****************************************************************************
+ * Unfortunatly we cannot work directly with the module's config data as
+ * this module might be unloaded from memory at any time (remember HideModule).
+ * This is why we need to duplicate callbacks each time we reload the module.
+ *****************************************************************************/
+void config_SetCallbacks( module_config_t *p_new, module_config_t *p_orig,
+                          size_t n )
+{
+    for (size_t i = 0; i < n; i++)
+    {
+        p_new->pf_callback = p_orig->pf_callback;
+        p_new++;
+        p_orig++;
+    }
+}
+
+/*****************************************************************************
+ * config_UnsetCallbacks: unsets callback functions in the duplicate p_config.
+ *****************************************************************************
+ * We simply undo what we did in config_SetCallbacks.
+ *****************************************************************************/
+void config_UnsetCallbacks( module_config_t *p_new, size_t n )
+{
+    for (size_t i = 0; i < n; i++)
+    {
+        p_new->pf_callback = NULL;
+        p_new++;
+    }
+}
+
+/*****************************************************************************
+ * config_ResetAll: reset the configuration data for all the modules.
+ *****************************************************************************/
+void __config_ResetAll( vlc_object_t *p_this )
+{
+    int i_index;
+    vlc_list_t *p_list;
+    module_t *p_module;
+
+    /* Acquire config file lock */
+    vlc_mutex_lock( &p_this->p_libvlc->config_lock );
+
+    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
+
+    for( i_index = 0; i_index < p_list->i_count; i_index++ )
+    {
+        p_module = (module_t *)p_list->p_values[i_index].p_object ;
+        if( p_module->b_submodule ) continue;
+
+        for (size_t i = 0; i < p_module->confsize; i++ )
+        {
+            if (IsConfigIntegerType (p_module->p_config[i].i_type))
+                p_module->p_config[i].value.i = p_module->p_config[i].orig.i;
+            else
+            if (IsConfigFloatType (p_module->p_config[i].i_type))
+                p_module->p_config[i].value.f = p_module->p_config[i].orig.f;
+            else
+            if (IsConfigStringType (p_module->p_config[i].i_type))
+            {
+                freenull (p_module->p_config[i].value.psz);
+                p_module->p_config[i].value.psz =
+                        strdupnull (p_module->p_config[i].orig.psz);
+            }
+        }
+    }
+
+    vlc_list_release( p_list );
+    vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+}
+
+
+static FILE *config_OpenConfigFile( vlc_object_t *p_obj, const char *mode )
+{
+    static const char psz_subpath[] = DIR_SEP CONFIG_DIR DIR_SEP CONFIG_FILE;
+    const char *psz_filename = p_obj->p_libvlc->psz_configfile;
+    const char *psz_homedir;
+    size_t i_buflen = 0;
+    FILE *p_stream;
+
+    if( psz_filename == NULL )
+    {
+        psz_homedir = p_obj->p_libvlc->psz_homedir;
+        if( psz_homedir == NULL )
+        {
+            msg_Err( p_obj, "no home directory defined" );
+            return NULL;
+        }
+
+        i_buflen = strlen(psz_homedir) + sizeof(psz_subpath) + 1;
+    }
+
+    char buf[i_buflen];
+    if( psz_filename == NULL )
+    {
+        sprintf( buf, "%s%s", psz_homedir, psz_subpath );
+        psz_filename = buf;
+    }
+
+    msg_Dbg( p_obj, "opening config file (%s)", psz_filename );
+    p_stream = utf8_fopen( psz_filename, mode );
+    if( p_stream == NULL && errno != ENOENT )
+        msg_Err( p_obj, "cannot open config file (%s): %s", psz_filename, strerror(errno) );
+
+    return p_stream;
+}
+
+
+/*****************************************************************************
+ * config_LoadConfigFile: loads the configuration file.
+ *****************************************************************************
+ * This function is called to load the config options stored in the config
+ * file.
+ *****************************************************************************/
+int __config_LoadConfigFile( vlc_object_t *p_this, const char *psz_module_name )
+{
+    vlc_list_t *p_list;
+    FILE *file;
+
+    file = config_OpenConfigFile (p_this, "rt");
+    if (file == NULL)
+        return VLC_EGENERIC;
+
+    /* Acquire config file lock */
+    vlc_mutex_lock( &p_this->p_libvlc->config_lock );
+
+    /* Look for the selected module, if NULL then save everything */
+    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
+
+    /* Look for UTF-8 Byte Order Mark */
+    char * (*convert) (const char *) = strdupnull;
+    char bom[3];
+
+    if ((fread (bom, 1, 3, file) != 3)
+     || memcmp (bom, "\xEF\xBB\xBF", 3))
+    {
+        convert = FromLocaleDup;
+        rewind (file); /* no BOM, rewind */
+    }
+
+    module_t *module = NULL;
+    char line[1024], section[1022];
+    section[0] = '\0';
+
+    while (fgets (line, 1024, file) != NULL)
+    {
+        /* Ignore comments and empty lines */
+        switch (line[0])
+        {
+            case '#':
+            case '\n':
+            case '\0':
+                continue;
+        }
+
+        if (line[0] == '[')
+        {
+            char *ptr = strchr (line, ']');
+            if (ptr == NULL)
+                continue; /* syntax error; */
+            *ptr = '\0';
+
+            /* New section ( = a given module) */
+            strcpy (section, line + 1);
+            module = NULL;
+
+            if ((psz_module_name == NULL)
+             || (strcmp (psz_module_name, section) == 0))
+            {
+                for (int i = 0; i < p_list->i_count; i++)
+                {
+                    module_t *m = (module_t *)p_list->p_values[i].p_object;
+
+                    if ((strcmp (section, m->psz_object_name) == 0)
+                     && (m->i_config_items > 0)) /* ignore config-less modules */
+                    {
+                        module = m;
+                        if (psz_module_name != NULL)
+                            msg_Dbg (p_this,
+                                     "loading config for module \"%s\"",
+                                     section);
+                        break;
+                    }
+                }
+            }
+
+            continue;
+        }
+
+        if (module == NULL)
+            continue; /* no need to parse if there is no matching module */
+
+        char *ptr = strchr (line, '\n');
+        if (ptr != NULL)
+            *ptr = '\0';
+
+        /* look for option name */
+        const char *psz_option_name = line;
+
+        ptr = strchr (line, '=');
+        if (ptr == NULL)
+            continue; /* syntax error */
+
+        *ptr = '\0';
+        const char *psz_option_value = ptr + 1;
+
+        /* try to match this option with one of the module's options */
+        for (size_t i = 0; i < module->confsize; i++)
+        {
+            module_config_t *p_item = module->p_config + i;
+
+            if ((p_item->i_type & CONFIG_HINT)
+             || strcmp (p_item->psz_name, psz_option_name))
+                continue;
+
+            /* We found it */
+            switch( p_item->i_type )
+            {
+                case CONFIG_ITEM_BOOL:
+                case CONFIG_ITEM_INTEGER:
+                    if( !*psz_option_value )
+                        break;                    /* ignore empty option */
+                    p_item->value.i = strtol( psz_option_value, 0, 0 );
+                    p_item->saved.i = p_item->value.i;
+
+                    /*msg_Dbg (p_this, "option \"%s\", value %i",
+                             psz_option_name, p_item->value.i);*/
+                    break;
+
+                case CONFIG_ITEM_FLOAT:
+                    if( !*psz_option_value )
+                        break;                    /* ignore empty option */
+                    p_item->value.f = (float)i18n_atof( psz_option_value);
+                    p_item->saved.f = p_item->value.f;
+
+                    /*msg_Dbg (p_this, "option \"%s\", value %f",
+                             psz_option_name, (double)p_item->value.f);*/
+                    break;
+
+                case CONFIG_ITEM_KEY:
+                    if( !*psz_option_value )
+                        break;                    /* ignore empty option */
+                    p_item->value.i = ConfigStringToKey(psz_option_value);
+                    p_item->saved.i = p_item->value.i;
+                    break;
+
+                default:
+                    vlc_mutex_lock( p_item->p_lock );
+
+                    /* free old string */
+                    free( (char*) p_item->value.psz );
+                    free( (char*) p_item->saved.psz );
+
+                    p_item->value.psz = convert (psz_option_value);
+                    p_item->saved.psz = strdupnull (p_item->value.psz);
+
+                    vlc_mutex_unlock( p_item->p_lock );
+
+                    /*msg_Dbg (p_this, "option \"%s\", value \"%s\"",
+                             psz_option_name, psz_option_value ?: "");*/
+                    break;
+            }
+
+            break;
+        }
+    }
+
+    vlc_list_release( p_list );
+
+    fclose( file );
+
+    vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+    return 0;
+}
+
+/*****************************************************************************
+ * config_CreateDir: Create configuration directory if it doesn't exist.
+ *****************************************************************************/
+int config_CreateDir( vlc_object_t *p_this, const char *psz_dirname )
+{
+    if( !psz_dirname && !*psz_dirname ) return -1;
+
+    if( utf8_mkdir( psz_dirname ) && ( errno != EEXIST ) )
+    {
+        msg_Err( p_this, "could not create %s (%s)",
+                 psz_dirname, strerror(errno) );
+        return -1;
+    }
+
+    return 0;
+}
+
+/*****************************************************************************
+ * config_SaveConfigFile: Save a module's config options.
+ *****************************************************************************
+ * This will save the specified module's config options to the config file.
+ * If psz_module_name is NULL then we save all the modules config options.
+ * It's no use to save the config options that kept their default values, so
+ * we'll try to be a bit clever here.
+ *
+ * When we save we mustn't delete the config options of the modules that
+ * haven't been loaded. So we cannot just create a new config file with the
+ * config structures we've got in memory.
+ * I don't really know how to deal with this nicely, so I will use a completly
+ * dumb method ;-)
+ * I will load the config file in memory, but skipping all the sections of the
+ * modules we want to save. Then I will create a brand new file, dump the file
+ * loaded in memory and then append the sections of the modules we want to
+ * save.
+ * Really stupid no ?
+ *****************************************************************************/
+static int SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name,
+                           vlc_bool_t b_autosave )
+{
+    module_t *p_parser;
+    vlc_list_t *p_list;
+    FILE *file;
+    char p_line[1024], *p_index2;
+    int i_sizebuf = 0;
+    char *p_bigbuffer, *p_index;
+    vlc_bool_t b_backup;
+    int i_index;
+
+    /* Acquire config file lock */
+    vlc_mutex_lock( &p_this->p_libvlc->config_lock );
+
+    if (p_this->p_libvlc->psz_configfile == NULL)
+    {
+        const char *psz_homedir = p_this->p_libvlc->psz_homedir;
+        if( !psz_homedir )
+        {
+            msg_Err( p_this, "no home directory defined" );
+            vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+            return -1;
+        }
+
+        char dirname[strlen (psz_homedir) + sizeof (DIR_SEP CONFIG_DIR)];
+        sprintf (dirname, "%s" DIR_SEP CONFIG_DIR, psz_homedir);
+        config_CreateDir (p_this, dirname);
+    }
+
+    file = config_OpenConfigFile (p_this, "rt");
+    if (file != NULL)
+    {
+        /* look for file size */
+        fseek( file, 0L, SEEK_END );
+        i_sizebuf = ftell( file );
+        fseek( file, 0L, SEEK_SET );
+    }
+
+    p_bigbuffer = p_index = malloc( i_sizebuf+1 );
+    if( !p_bigbuffer )
+    {
+        msg_Err( p_this, "out of memory" );
+        if( file ) fclose( file );
+        vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+        return -1;
+    }
+    p_bigbuffer[0] = 0;
+
+    /* List all available modules */
+    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
+
+    /* backup file into memory, we only need to backup the sections we won't
+     * save later on */
+    b_backup = 0;
+    while( file && fgets( p_line, 1024, file ) )
+    {
+        if( (p_line[0] == '[') && (p_index2 = strchr(p_line,']')))
+        {
+
+            /* we found a section, check if we need to do a backup */
+            for( i_index = 0; i_index < p_list->i_count; i_index++ )
+            {
+                p_parser = (module_t *)p_list->p_values[i_index].p_object ;
+
+                if( ((p_index2 - &p_line[1])
+                       == (int)strlen(p_parser->psz_object_name) )
+                    && !memcmp( &p_line[1], p_parser->psz_object_name,
+                                strlen(p_parser->psz_object_name) ) )
+                {
+                    if( !psz_module_name )
+                        break;
+                    else if( !strcmp( psz_module_name,
+                                      p_parser->psz_object_name ) )
+                        break;
+                }
+            }
+
+            if( i_index == p_list->i_count )
+            {
+                /* we don't have this section in our list so we need to back
+                 * it up */
+                *p_index2 = 0;
+#if 0
+                msg_Dbg( p_this, "backing up config for unknown module \"%s\"",
+                                 &p_line[1] );
+#endif
+                *p_index2 = ']';
+
+                b_backup = 1;
+            }
+            else
+            {
+                b_backup = 0;
+            }
+        }
+
+        /* save line if requested and line is valid (doesn't begin with a
+         * space, tab, or eol) */
+        if( b_backup && (p_line[0] != '\n') && (p_line[0] != ' ')
+            && (p_line[0] != '\t') )
+        {
+            strcpy( p_index, p_line );
+            p_index += strlen( p_line );
+        }
+    }
+    if( file ) fclose( file );
+
+
+    /*
+     * Save module config in file
+     */
+
+    file = config_OpenConfigFile (p_this, "wt");
+    if( !file )
+    {
+        vlc_list_release( p_list );
+        free( p_bigbuffer );
+        vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+        return -1;
+    }
+
+    fprintf( file, "\xEF\xBB\xBF###\n###  " COPYRIGHT_MESSAGE "\n###\n\n"
+       "###\n### lines begining with a '#' character are comments\n###\n\n" );
+
+    /* Look for the selected module, if NULL then save everything */
+    for( i_index = 0; i_index < p_list->i_count; i_index++ )
+    {
+        module_config_t *p_item, *p_end;
+        p_parser = (module_t *)p_list->p_values[i_index].p_object ;
+
+        if( psz_module_name && strcmp( psz_module_name,
+                                       p_parser->psz_object_name ) )
+            continue;
+
+        if( !p_parser->i_config_items )
+            continue;
+
+        if( psz_module_name )
+            msg_Dbg( p_this, "saving config for module \"%s\"",
+                     p_parser->psz_object_name );
+
+        fprintf( file, "[%s]", p_parser->psz_object_name );
+        if( p_parser->psz_longname )
+            fprintf( file, " # %s\n\n", p_parser->psz_longname );
+        else
+            fprintf( file, "\n\n" );
+
+        for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
+             p_item < p_end;
+             p_item++ )
+        {
+            char  *psz_key;
+            int   i_value = p_item->value.i;
+            float f_value = p_item->value.f;
+            const char  *psz_value = p_item->value.psz;
+
+            if( p_item->i_type & CONFIG_HINT )
+                /* ignore hints */
+                continue;
+            /* Ignore deprecated options */
+            if( p_item->psz_current )
+                continue;
+            if( p_item->b_unsaveable )
+                /*obvious*/
+                continue;
+
+            if( b_autosave && !p_item->b_autosave )
+            {
+                i_value = p_item->saved.i;
+                f_value = p_item->saved.f;
+                psz_value = p_item->saved.psz;
+                if( !psz_value ) psz_value = p_item->orig.psz;
+            }
+            else
+            {
+                p_item->b_dirty = VLC_FALSE;
+            }
+
+            switch( p_item->i_type )
+            {
+            case CONFIG_ITEM_BOOL:
+            case CONFIG_ITEM_INTEGER:
+                if( p_item->psz_text )
+                    fprintf( file, "# %s (%s)\n", p_item->psz_text,
+                             (p_item->i_type == CONFIG_ITEM_BOOL) ?
+                             _("boolean") : _("integer") );
+                if( i_value == p_item->orig.i )
+                    fputc ('#', file);
+                fprintf( file, "%s=%i\n", p_item->psz_name, i_value );
+
+                p_item->saved.i = i_value;
+                break;
+
+            case CONFIG_ITEM_KEY:
+                if( p_item->psz_text )
+                    fprintf( file, "# %s (%s)\n", p_item->psz_text,
+                             _("key") );
+                if( i_value == p_item->orig.i )
+                    fputc ('#', file);
+                psz_key = ConfigKeyToString( i_value );
+                fprintf( file, "%s=%s\n", p_item->psz_name,
+                         psz_key ? psz_key : "" );
+                freenull (psz_key);
+
+                p_item->saved.i = i_value;
+                break;
+
+            case CONFIG_ITEM_FLOAT:
+                if( p_item->psz_text )
+                    fprintf( file, "# %s (%s)\n", p_item->psz_text,
+                             _("float") );
+                if( f_value == p_item->orig.f )
+                    fputc ('#', file);
+                fprintf( file, "%s=%f\n", p_item->psz_name, (double)f_value );
+
+                p_item->saved.f = f_value;
+                break;
+
+            default:
+                if( p_item->psz_text )
+                    fprintf( file, "# %s (%s)\n", p_item->psz_text,
+                             _("string") );
+                if( (!psz_value && !p_item->orig.psz) ||
+                    (psz_value && p_item->orig.psz &&
+                     !strcmp( psz_value, p_item->orig.psz )) )
+                    fputc ('#', file);
+                fprintf( file, "%s=%s\n", p_item->psz_name,
+                         psz_value ?: "" );
+
+                if( b_autosave && !p_item->b_autosave ) break;
+
+                freenull (p_item->saved.psz);
+                if( (psz_value && p_item->orig.psz &&
+                     strcmp( psz_value, p_item->orig.psz )) ||
+                    !psz_value || !p_item->orig.psz)
+                    p_item->saved.psz = strdupnull (psz_value);
+                else
+                    p_item->saved.psz = NULL;
+            }
+        }
+
+        fputc ('\n', file);
+    }
+
+    vlc_list_release( p_list );
+
+    /*
+     * Restore old settings from the config in file
+     */
+    fputs( p_bigbuffer, file );
+    free( p_bigbuffer );
+
+    fclose( file );
+    vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+
+    return 0;
+}
+
+int config_AutoSaveConfigFile( vlc_object_t *p_this )
+{
+    vlc_list_t *p_list;
+    int i_index, i_count;
+
+    if( !p_this ) return -1;
+
+    /* Check if there's anything to save */
+    vlc_mutex_lock( &p_this->p_libvlc->config_lock );
+    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
+    i_count = p_list->i_count;
+    for( i_index = 0; i_index < i_count; i_index++ )
+    {
+        module_t *p_parser = (module_t *)p_list->p_values[i_index].p_object ;
+        module_config_t *p_item, *p_end;
+
+        if( !p_parser->i_config_items ) continue;
+
+        for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
+             p_item < p_end;
+             p_item++ )
+        {
+            if( p_item->b_autosave && p_item->b_dirty ) break;
+        }
+        break;
+    }
+    vlc_list_release( p_list );
+    vlc_mutex_unlock( &p_this->p_libvlc->config_lock );
+
+    if( i_index == i_count ) return VLC_SUCCESS;
+    return SaveConfigFile( p_this, 0, VLC_TRUE );
+}
+
+int __config_SaveConfigFile( vlc_object_t *p_this, const char *psz_module_name )
+{
+    return SaveConfigFile( p_this, psz_module_name, VLC_FALSE );
+}
+
+/*****************************************************************************
+ * config_LoadCmdLine: parse command line
+ *****************************************************************************
+ * Parse command line for configuration options.
+ * Now that the module_bank has been initialized, we can dynamically
+ * generate the longopts structure used by getops. We have to do it this way
+ * because we don't know (and don't want to know) in advance the configuration
+ * options used (ie. exported) by each module.
+ *****************************************************************************/
+int __config_LoadCmdLine( vlc_object_t *p_this, int *pi_argc, char *ppsz_argv[],
+                          vlc_bool_t b_ignore_errors )
+{
+    int i_cmd, i_index, i_opts, i_shortopts, flag, i_verbose = 0;
+    module_t *p_parser;
+    vlc_list_t *p_list;
+    struct option *p_longopts;
+    int i_modules_index;
+
+    /* Short options */
+    module_config_t *pp_shortopts[256];
+    char *psz_shortopts;
+
+    /* Set default configuration and copy arguments */
+    p_this->p_libvlc->i_argc    = *pi_argc;
+    p_this->p_libvlc->ppsz_argv = ppsz_argv;
+
+#ifdef __APPLE__
+    /* When VLC.app is run by double clicking in Mac OS X, the 2nd arg
+     * is the PSN - process serial number (a unique PID-ish thingie)
+     * still ok for real Darwin & when run from command line */
+    if ( (*pi_argc > 1) && (strncmp( ppsz_argv[ 1 ] , "-psn" , 4 ) == 0) )
+                                        /* for example -psn_0_9306113 */
+    {
+        /* GDMF!... I can't do this or else the MacOSX window server will
+         * not pick up the PSN and not register the app and we crash...
+         * hence the following kludge otherwise we'll get confused w/ argv[1]
+         * being an input file name */
+#if 0
+        ppsz_argv[ 1 ] = NULL;
+#endif
+        *pi_argc = *pi_argc - 1;
+        pi_argc--;
+        return 0;
+    }
+#endif
+
+    /* List all modules */
+    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
+
+    /*
+     * Generate the longopts and shortopts structures used by getopt_long
+     */
+
+    i_opts = 0;
+    for( i_modules_index = 0; i_modules_index < p_list->i_count;
+         i_modules_index++ )
+    {
+        p_parser = (module_t *)p_list->p_values[i_modules_index].p_object ;
+
+        /* count the number of exported configuration options (to allocate
+         * longopts). We also need to allocate space for two options when
+         * dealing with boolean to allow for --foo and --no-foo */
+        i_opts += p_parser->i_config_items
+                     + 2 * p_parser->i_bool_items;
+    }
+
+    p_longopts = malloc( sizeof(struct option) * (i_opts + 1) );
+    if( p_longopts == NULL )
+    {
+        msg_Err( p_this, "out of memory" );
+        vlc_list_release( p_list );
+        return -1;
+    }
+
+    psz_shortopts = malloc( sizeof( char ) * (2 * i_opts + 1) );
+    if( psz_shortopts == NULL )
+    {
+        msg_Err( p_this, "out of memory" );
+        free( p_longopts );
+        vlc_list_release( p_list );
+        return -1;
+    }
+
+    /* If we are requested to ignore errors, then we must work on a copy
+     * of the ppsz_argv array, otherwise getopt_long will reorder it for
+     * us, ignoring the arity of the options */
+    if( b_ignore_errors )
+    {
+        ppsz_argv = (char**)malloc( *pi_argc * sizeof(char *) );
+        if( ppsz_argv == NULL )
+        {
+            msg_Err( p_this, "out of memory" );
+            free( psz_shortopts );
+            free( p_longopts );
+            vlc_list_release( p_list );
+            return -1;
+        }
+        memcpy( ppsz_argv, p_this->p_libvlc->ppsz_argv,
+                *pi_argc * sizeof(char *) );
+    }
+
+    i_shortopts = 0;
+    for( i_index = 0; i_index < 256; i_index++ )
+    {
+        pp_shortopts[i_index] = NULL;
+    }
+
+    /* Fill the p_longopts and psz_shortopts structures */
+    i_index = 0;
+    for( i_modules_index = 0; i_modules_index < p_list->i_count;
+         i_modules_index++ )
+    {
+        module_config_t *p_item, *p_end;
+        p_parser = (module_t *)p_list->p_values[i_modules_index].p_object ;
+
+        if( !p_parser->i_config_items )
+            continue;
+
+        for( p_item = p_parser->p_config, p_end = p_item + p_parser->confsize;
+             p_item < p_end;
+             p_item++ )
+        {
+            /* Ignore hints */
+            if( p_item->i_type & CONFIG_HINT )
+                continue;
+
+            /* Add item to long options */
+            p_longopts[i_index].name = strdup( p_item->psz_name );
+            if( p_longopts[i_index].name == NULL ) continue;
+            p_longopts[i_index].has_arg =
+                (p_item->i_type == CONFIG_ITEM_BOOL)?
+                                               no_argument : required_argument;
+            p_longopts[i_index].flag = &flag;
+            p_longopts[i_index].val = 0;
+            i_index++;
+
+            /* When dealing with bools we also need to add the --no-foo
+             * option */
+            if( p_item->i_type == CONFIG_ITEM_BOOL )
+            {
+                char *psz_name = malloc( strlen(p_item->psz_name) + 3 );
+                if( psz_name == NULL ) continue;
+                strcpy( psz_name, "no" );
+                strcat( psz_name, p_item->psz_name );
+
+                p_longopts[i_index].name = psz_name;
+                p_longopts[i_index].has_arg = no_argument;
+                p_longopts[i_index].flag = &flag;
+                p_longopts[i_index].val = 1;
+                i_index++;
+
+                psz_name = malloc( strlen(p_item->psz_name) + 4 );
+                if( psz_name == NULL ) continue;
+                strcpy( psz_name, "no-" );
+                strcat( psz_name, p_item->psz_name );
+
+                p_longopts[i_index].name = psz_name;
+                p_longopts[i_index].has_arg = no_argument;
+                p_longopts[i_index].flag = &flag;
+                p_longopts[i_index].val = 1;
+                i_index++;
+            }
+
+            /* If item also has a short option, add it */
+            if( p_item->i_short )
+            {
+                pp_shortopts[(int)p_item->i_short] = p_item;
+                psz_shortopts[i_shortopts] = p_item->i_short;
+                i_shortopts++;
+                if( p_item->i_type != CONFIG_ITEM_BOOL )
+                {
+                    psz_shortopts[i_shortopts] = ':';
+                    i_shortopts++;
+
+                    if( p_item->i_short == 'v' )
+                    {
+                        psz_shortopts[i_shortopts] = ':';
+                        i_shortopts++;
+                    }
+                }
+            }
+        }
+    }
+
+    /* We don't need the module list anymore */
+    vlc_list_release( p_list );
+
+    /* Close the longopts and shortopts structures */
+    memset( &p_longopts[i_index], 0, sizeof(struct option) );
+    psz_shortopts[i_shortopts] = '\0';
+
+    /*
+     * Parse the command line options
+     */
+    opterr = 0;
+    optind = 0; /* set to 0 to tell GNU getopt to reinitialize */
+    while( ( i_cmd = getopt_long( *pi_argc, ppsz_argv, psz_shortopts,
+                                  p_longopts, &i_index ) ) != -1 )
+    {
+        /* A long option has been recognized */
+        if( i_cmd == 0 )
+        {
+            module_config_t *p_conf;
+            char *psz_name = (char *)p_longopts[i_index].name;
+
+            /* Check if we deal with a --nofoo or --no-foo long option */
+            if( flag ) psz_name += psz_name[2] == '-' ? 3 : 2;
+
+            /* Store the configuration option */
+            p_conf = config_FindConfig( p_this, psz_name );
+            if( p_conf )
+            {
+                /* Check if the option is deprecated */
+                if( p_conf->psz_current )
+                {
+                    if( !strcmp(p_conf->psz_current,"SUPPRESSED") )
+                    {
+                        if( !b_ignore_errors )
+                        {
+                            fprintf(stderr,
+                                    "Warning: option --%s is no longer used.\n",
+                                    p_conf->psz_name);
+                        }
+                       continue;
+                    }
+                    if( !b_ignore_errors )
+                    {
+                        if( p_conf->b_strict )
+                        {
+                            fprintf( stderr,
+                                     "Error: option --%s is deprecated. "
+                                     "Use --%s instead.\n",
+                                     p_conf->psz_name, p_conf->psz_current);
+                            /*free */
+                            for( i_index = 0; p_longopts[i_index].name; i_index++ )
+                                free( (char *)p_longopts[i_index].name );
+
+                            free( p_longopts );
+                            free( psz_shortopts );
+                            return -1;
+                        }
+                        fprintf(stderr,
+                                "Warning: option --%s is deprecated. "
+                                "You should use --%s instead.\n",
+                                p_conf->psz_name, p_conf->psz_current);
+                    }
+                    psz_name = (char *)p_conf->psz_current;
+                    p_conf = config_FindConfig( p_this, psz_name );
+                }
+
+                switch( p_conf->i_type )
+                {
+                    case CONFIG_ITEM_STRING:
+                    case CONFIG_ITEM_FILE:
+                    case CONFIG_ITEM_DIRECTORY:
+                    case CONFIG_ITEM_MODULE:
+                    case CONFIG_ITEM_MODULE_LIST:
+                    case CONFIG_ITEM_MODULE_LIST_CAT:
+                    case CONFIG_ITEM_MODULE_CAT:
+                        config_PutPsz( p_this, psz_name, optarg );
+                        break;
+                    case CONFIG_ITEM_INTEGER:
+                        config_PutInt( p_this, psz_name, strtol(optarg, 0, 0));
+                        break;
+                    case CONFIG_ITEM_FLOAT:
+                        config_PutFloat( p_this, psz_name, (float)atof(optarg) );
+                        break;
+                    case CONFIG_ITEM_KEY:
+                        config_PutInt( p_this, psz_name, ConfigStringToKey( optarg ) );
+                        break;
+                    case CONFIG_ITEM_BOOL:
+                        config_PutInt( p_this, psz_name, !flag );
+                        break;
+                }
+                continue;
+            }
+        }
+
+        /* A short option has been recognized */
+        if( pp_shortopts[i_cmd] != NULL )
+        {
+            switch( pp_shortopts[i_cmd]->i_type )
+            {
+                case CONFIG_ITEM_STRING:
+                case CONFIG_ITEM_FILE:
+                case CONFIG_ITEM_DIRECTORY:
+                case CONFIG_ITEM_MODULE:
+                case CONFIG_ITEM_MODULE_CAT:
+                case CONFIG_ITEM_MODULE_LIST:
+                case CONFIG_ITEM_MODULE_LIST_CAT:
+                    config_PutPsz( p_this, pp_shortopts[i_cmd]->psz_name, optarg );
+                    break;
+                case CONFIG_ITEM_INTEGER:
+                    if( i_cmd == 'v' )
+                    {
+                        if( optarg )
+                        {
+                            if( *optarg == 'v' ) /* eg. -vvv */
+                            {
+                                i_verbose++;
+                                while( *optarg == 'v' )
+                                {
+                                    i_verbose++;
+                                    optarg++;
+                                }
+                            }
+                            else
+                            {
+                                i_verbose += atoi( optarg ); /* eg. -v2 */
+                            }
+                        }
+                        else
+                        {
+                            i_verbose++; /* -v */
+                        }
+                        config_PutInt( p_this, pp_shortopts[i_cmd]->psz_name,
+                                               i_verbose );
+                    }
+                    else
+                    {
+                        config_PutInt( p_this, pp_shortopts[i_cmd]->psz_name,
+                                               strtol(optarg, 0, 0) );
+                    }
+                    break;
+                case CONFIG_ITEM_BOOL:
+                    config_PutInt( p_this, pp_shortopts[i_cmd]->psz_name, 1 );
+                    break;
+            }
+
+            continue;
+        }
+
+        /* Internal error: unknown option */
+        if( !b_ignore_errors )
+        {
+            fprintf( stderr, "%s: unknown option"
+                     " or missing mandatory argument ",
+                     p_this->p_libvlc->psz_object_name );
+            if( optopt )
+            {
+                fprintf( stderr, "`-%c'\n", optopt );
+            }
+            else
+            {
+                fprintf( stderr, "`%s'\n", ppsz_argv[optind-1] );
+            }
+            fprintf( stderr, "Try `%s --help' for more information.\n",
+                             p_this->p_libvlc->psz_object_name );
+
+            for( i_index = 0; p_longopts[i_index].name; i_index++ )
+                free( (char *)p_longopts[i_index].name );
+            free( p_longopts );
+            free( psz_shortopts );
+            return -1;
+        }
+    }
+
+    /* Free allocated resources */
+    for( i_index = 0; p_longopts[i_index].name; i_index++ )
+        free( (char *)p_longopts[i_index].name );
+    free( p_longopts );
+    free( psz_shortopts );
+    if( b_ignore_errors ) free( ppsz_argv );
+
+    return 0;
+}
+
+/**
+ * config_GetDataDir: find directory where shared data is installed
+ *
+ * @return a string (always succeeds).
+ */
+const char *config_GetDataDir( const vlc_object_t *p_this )
+{
+#if defined (WIN32) || defined (UNDER_CE)
+    return p_this->p_libvlc_global->psz_vlcpath;
+#elif defined(__APPLE__) || defined (SYS_BEOS)
+    static char path[PATH_MAX] = "";
+
+    if( *path == '\0' )
+    {
+        snprintf( path, sizeof( path ), "%s/share",
+                  p_this->p_libvlc_global->psz_vlcpath );
+        path[sizeof( path ) - 1] = '\0';
+    }
+    return path;
+#else
+    (void)p_this;
+    return DATA_PATH;
+#endif
+}
+
+/*****************************************************************************
+ * config_GetHomeDir, config_GetUserDir: find the user's home directory.
+ *****************************************************************************
+ * This function will try by different ways to find the user's home path.
+ * Note that this function is not reentrant, it should be called only once
+ * at the beginning of main where the result will be stored for later use.
+ *****************************************************************************/
+static char *GetDir( vlc_bool_t b_appdata )
+{
+    const char *psz_localhome = NULL;
+
+#if defined(WIN32) && !defined(UNDER_CE)
+    typedef HRESULT (WINAPI *SHGETFOLDERPATH)( HWND, int, HANDLE, DWORD,
+                                               LPWSTR );
+#ifndef CSIDL_FLAG_CREATE
+#   define CSIDL_FLAG_CREATE 0x8000
+#endif
+#ifndef CSIDL_APPDATA
+#   define CSIDL_APPDATA 0x1A
+#endif
+#ifndef CSIDL_PROFILE
+#   define CSIDL_PROFILE 0x28
+#endif
+#ifndef SHGFP_TYPE_CURRENT
+#   define SHGFP_TYPE_CURRENT 0
+#endif
+
+    HINSTANCE shfolder_dll;
+    SHGETFOLDERPATH SHGetFolderPath ;
+
+    /* load the shfolder dll to retrieve SHGetFolderPath */
+    if( ( shfolder_dll = LoadLibrary( _T("SHFolder.dll") ) ) != NULL )
+    {
+        SHGetFolderPath = (void *)GetProcAddress( shfolder_dll,
+                                                  _T("SHGetFolderPathW") );
+        if ( SHGetFolderPath != NULL )
+        {
+            wchar_t whomedir[MAX_PATH];
+
+            /* get the "Application Data" folder for the current user */
+            if( S_OK == SHGetFolderPath( NULL,
+                                         (b_appdata ? CSIDL_APPDATA :
+                                           CSIDL_PROFILE) | CSIDL_FLAG_CREATE,
+                                         NULL, SHGFP_TYPE_CURRENT,
+                                         whomedir ) )
+            {
+                FreeLibrary( shfolder_dll );
+                return FromWide( whomedir );
+            }
+        }
+        FreeLibrary( shfolder_dll );
+    }
+
+#elif defined(UNDER_CE)
+
+#ifndef CSIDL_APPDATA
+#   define CSIDL_APPDATA 0x1A
+#endif
+
+    wchar_t whomedir[MAX_PATH];
+
+    /* get the "Application Data" folder for the current user */
+    if( SHGetSpecialFolderPath( NULL, whomedir, CSIDL_APPDATA, 1 ) )
+        return FromWide( whomedir );
+#endif
+
+#if defined(HAVE_GETPWUID)
+    struct passwd *p_pw;
+    (void)b_appdata;
+
+    if( ( p_pw = getpwuid( getuid() ) ) == NULL )
+#endif
+    {
+        psz_localhome = getenv( "HOME" );
+        if( psz_localhome == NULL )
+        {
+            psz_localhome = getenv( "TMP" );
+            if( psz_localhome == NULL )
+                psz_localhome = "/tmp";
+        }
+    }
+#if defined(HAVE_GETPWUID)
+    else
+        psz_localhome = p_pw->pw_dir;
+#endif
+
+    return FromLocaleDup( psz_localhome );
+}
+
+char *config_GetHomeDir( void )
+{
+    return GetDir( VLC_TRUE );
+}
+
+char *config_GetUserDir( void )
+{
+    return GetDir( VLC_FALSE );
+}
+
+
+static int ConfigStringToKey( const char *psz_key )
+{
+    int i_key = 0;
+    unsigned int i;
+    const char *psz_parser = strchr( psz_key, '-' );
+    while( psz_parser && psz_parser != psz_key )
+    {
+        for( i = 0; i < sizeof(vlc_modifiers) / sizeof(key_descriptor_t); i++ )
+        {
+            if( !strncasecmp( vlc_modifiers[i].psz_key_string, psz_key,
+                              strlen( vlc_modifiers[i].psz_key_string ) ) )
+            {
+                i_key |= vlc_modifiers[i].i_key_code;
+            }
+        }
+        psz_key = psz_parser + 1;
+        psz_parser = strchr( psz_key, '-' );
+    }
+    for( i = 0; i < sizeof(vlc_keys) / sizeof( key_descriptor_t ); i++ )
+    {
+        if( !strcasecmp( vlc_keys[i].psz_key_string, psz_key ) )
+        {
+            i_key |= vlc_keys[i].i_key_code;
+            break;
+        }
+    }
+    return i_key;
+}
+
+static char *ConfigKeyToString( int i_key )
+{
+    char *psz_key = malloc( 100 );
+    char *p;
+    size_t index;
+
+    if ( !psz_key )
+    {
+        return NULL;
+    }
+    *psz_key = '\0';
+    p = psz_key;
+    for( index = 0; index < (sizeof(vlc_modifiers) / sizeof(key_descriptor_t));
+         index++ )
+    {
+        if( i_key & vlc_modifiers[index].i_key_code )
+        {
+            p += sprintf( p, "%s-", vlc_modifiers[index].psz_key_string );
+        }
+    }
+    for( index = 0; index < (sizeof(vlc_keys) / sizeof( key_descriptor_t));
+         index++)
+    {
+        if( (int)( i_key & ~KEY_MODIFIER ) == vlc_keys[index].i_key_code )
+        {
+            p += sprintf( p, "%s", vlc_keys[index].psz_key_string );
+            break;
+        }
+    }
+    return psz_key;
+}
diff --git a/src/modules/configuration.h b/src/modules/configuration.h
new file mode 100644 (file)
index 0000000..2a14693
--- /dev/null
@@ -0,0 +1,49 @@
+/*****************************************************************************
+ * configuration.h management of the modules configuration
+ *****************************************************************************
+ * Copyright (C) 2007 the VideoLAN team
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#ifndef LIBVLC_CONFIGURATION_H
+# define LIBVLC_CONFIGURATION_H 1
+
+# ifdef __cplusplus
+extern "C" {
+# endif
+
+/* Internal configuration prototypes and structures */
+
+int  config_CreateDir( vlc_object_t *, const char * );
+int  config_AutoSaveConfigFile( vlc_object_t * );
+
+void config_Free( module_t * );
+
+void config_SetCallbacks( module_config_t *, module_config_t *, size_t );
+void config_UnsetCallbacks ( module_config_t *, size_t );
+
+#define config_LoadCmdLine(a,b,c,d) __config_LoadCmdLine(VLC_OBJECT(a),b,c,d)
+#define config_LoadConfigFile(a,b) __config_LoadConfigFile(VLC_OBJECT(a),b)
+
+int   __config_LoadCmdLine  ( vlc_object_t *, int *, char *[], vlc_bool_t );
+char *   config_GetHomeDir     ( void );
+char *   config_GetUserDir     ( void );
+int    __config_LoadConfigFile ( vlc_object_t *, const char * );
+
+# ifdef __cplusplus
+}
+# endif
+#endif
diff --git a/src/modules/configuration_chain.c b/src/modules/configuration_chain.c
new file mode 100644 (file)
index 0000000..03ebf2d
--- /dev/null
@@ -0,0 +1,390 @@
+/*****************************************************************************
+ * configuration_chain.c : configuration module chain parsing stuff
+ *****************************************************************************
+ * Copyright (C) 2002-2006 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Christophe Massiot <massiot@via.ecp.fr>
+ *          Laurent Aimar <fenrir@via.ecp.fr>
+ *          Eric Petit <titer@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+
+#include <vlc/vlc.h>
+
+#include <stdlib.h>                                                /* free() */
+#include <stdio.h>                                              /* sprintf() */
+#include <string.h>                                            /* strerror() */
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+
+/* chain format:
+    module{option=*:option=*}[:module{option=*:...}]
+ */
+#define SKIPSPACE( p ) { while( *p && ( *p == ' ' || *p == '\t' ) ) p++; }
+#define SKIPTRAILINGSPACE( p, e ) \
+    { while( e > p && ( *(e-1) == ' ' || *(e-1) == '\t' ) ) e--; }
+
+/* go accross " " and { } */
+static const char *_get_chain_end( const char *str )
+{
+    char c;
+    const char *p = str;
+
+    SKIPSPACE( p );
+
+    for( ;; )
+    {
+        if( !*p || *p == ',' || *p == '}' ) return p;
+
+        if( *p != '{' && *p != '"' && *p != '\'' )
+        {
+            p++;
+            continue;
+        }
+
+        if( *p == '{' ) c = '}';
+        else c = *p;
+        p++;
+
+        for( ;; )
+        {
+            if( !*p ) return p;
+
+            if( *p == c ) return ++p;
+            else if( *p == '{' && c == '}' ) p = _get_chain_end( p );
+            else p++;
+        }
+    }
+}
+
+char *config_ChainCreate( char **ppsz_name, config_chain_t **pp_cfg, const char *psz_chain )
+{
+    config_chain_t *p_cfg = NULL;
+    const char *p = psz_chain;
+
+    *ppsz_name = NULL;
+    *pp_cfg    = NULL;
+
+    if( !p ) return NULL;
+
+    SKIPSPACE( p );
+
+    while( *p && *p != '{' && *p != ':' && *p != ' ' && *p != '\t' ) p++;
+
+    if( p == psz_chain ) return NULL;
+
+    *ppsz_name = strndup( psz_chain, p - psz_chain );
+
+    SKIPSPACE( p );
+
+    if( *p == '{' )
+    {
+        const char *psz_name;
+
+        p++;
+
+        for( ;; )
+        {
+            config_chain_t cfg;
+
+            SKIPSPACE( p );
+
+            psz_name = p;
+
+            while( *p && *p != '=' && *p != ',' && *p != '{' && *p != '}' &&
+                   *p != ' ' && *p != '\t' ) p++;
+
+            /* fprintf( stderr, "name=%s - rest=%s\n", psz_name, p ); */
+            if( p == psz_name )
+            {
+                fprintf( stderr, "invalid options (empty)" );
+                break;
+            }
+
+            cfg.psz_name = strndup( psz_name, p - psz_name );
+
+            SKIPSPACE( p );
+
+            if( *p == '=' || *p == '{' )
+            {
+                const char *end;
+                vlc_bool_t b_keep_brackets = (*p == '{');
+
+                if( *p == '=' ) p++;
+
+                end = _get_chain_end( p );
+                if( end <= p )
+                {
+                    cfg.psz_value = NULL;
+                }
+                else
+                {
+                    /* Skip heading and trailing spaces.
+                     * This ain't necessary but will avoid simple
+                     * user mistakes. */
+                    SKIPSPACE( p );
+                }
+
+                if( end <= p )
+                {
+                    cfg.psz_value = NULL;
+                }
+                else
+                {
+                    if( *p == '\'' || *p == '"' ||
+                        ( !b_keep_brackets && *p == '{' ) )
+                    {
+                        p++;
+
+                        if( *(end-1) != '\'' && *(end-1) == '"' )
+                            SKIPTRAILINGSPACE( p, end );
+
+                        if( end - 1 <= p ) cfg.psz_value = NULL;
+                        else cfg.psz_value = strndup( p, end -1 - p );
+                    }
+                    else
+                    {
+                        SKIPTRAILINGSPACE( p, end );
+                        if( end <= p ) cfg.psz_value = NULL;
+                        else cfg.psz_value = strndup( p, end - p );
+                    }
+                }
+
+                p = end;
+                SKIPSPACE( p );
+            }
+            else
+            {
+                cfg.psz_value = NULL;
+            }
+
+            cfg.p_next = NULL;
+            if( p_cfg )
+            {
+                p_cfg->p_next = malloc( sizeof( config_chain_t ) );
+                memcpy( p_cfg->p_next, &cfg, sizeof( config_chain_t ) );
+
+                p_cfg = p_cfg->p_next;
+            }
+            else
+            {
+                p_cfg = malloc( sizeof( config_chain_t ) );
+                memcpy( p_cfg, &cfg, sizeof( config_chain_t ) );
+
+                *pp_cfg = p_cfg;
+            }
+
+            if( *p == ',' ) p++;
+
+            if( *p == '}' )
+            {
+                p++;
+                break;
+            }
+        }
+    }
+
+    if( *p == ':' ) return( strdup( p + 1 ) );
+
+    return NULL;
+}
+
+void config_ChainDestroy( config_chain_t *p_cfg )
+{
+    while( p_cfg != NULL )
+    {
+        config_chain_t *p_next;
+
+        p_next = p_cfg->p_next;
+
+        FREENULL( p_cfg->psz_name );
+        FREENULL( p_cfg->psz_value );
+        free( p_cfg );
+
+        p_cfg = p_next;
+    }
+}
+
+void __config_ChainParse( vlc_object_t *p_this, const char *psz_prefix,
+                          const char **ppsz_options, config_chain_t *cfg )
+{
+    char *psz_name;
+    int  i_type;
+    int  i;
+
+    /* First, var_Create all variables */
+    for( i = 0; ppsz_options[i] != NULL; i++ )
+    {
+        asprintf( &psz_name, "%s%s", psz_prefix,
+                  *ppsz_options[i] == '*' ? &ppsz_options[i][1] : ppsz_options[i] );
+
+        i_type = config_GetType( p_this, psz_name );
+
+        var_Create( p_this, psz_name, i_type | VLC_VAR_DOINHERIT );
+        free( psz_name );
+    }
+
+    /* Now parse options and set value */
+    if( psz_prefix == NULL ) psz_prefix = "";
+
+    while( cfg )
+    {
+        vlc_value_t val;
+        vlc_bool_t b_yes = VLC_TRUE;
+        vlc_bool_t b_once = VLC_FALSE;
+        module_config_t *p_conf;
+
+        if( cfg->psz_name == NULL || *cfg->psz_name == '\0' )
+        {
+            cfg = cfg->p_next;
+            continue;
+        }
+        for( i = 0; ppsz_options[i] != NULL; i++ )
+        {
+            if( !strcmp( ppsz_options[i], cfg->psz_name ) )
+            {
+                break;
+            }
+            if( ( !strncmp( cfg->psz_name, "no-", 3 ) &&
+                  !strcmp( ppsz_options[i], cfg->psz_name + 3 ) ) ||
+                ( !strncmp( cfg->psz_name, "no", 2 ) &&
+                  !strcmp( ppsz_options[i], cfg->psz_name + 2 ) ) )
+            {
+                b_yes = VLC_FALSE;
+                break;
+            }
+
+            if( *ppsz_options[i] == '*' &&
+                !strcmp( &ppsz_options[i][1], cfg->psz_name ) )
+            {
+                b_once = VLC_TRUE;
+                break;
+            }
+
+        }
+        if( ppsz_options[i] == NULL )
+        {
+            msg_Warn( p_this, "option %s is unknown", cfg->psz_name );
+            cfg = cfg->p_next;
+            continue;
+        }
+
+        /* create name */
+        asprintf( &psz_name, "%s%s", psz_prefix, b_once ? &ppsz_options[i][1] : ppsz_options[i] );
+
+        /* Check if the option is deprecated */
+        p_conf = config_FindConfig( p_this, psz_name );
+
+        /* This is basically cut and paste from src/misc/configuration.c
+         * with slight changes */
+        if( p_conf && p_conf->psz_current )
+        {
+            if( !strcmp( p_conf->psz_current, "SUPPRESSED" ) )
+            {
+                msg_Err( p_this, "Option %s is no longer used.",
+                         p_conf->psz_name );
+                goto next;
+            }
+            else if( p_conf->b_strict )
+            {
+                msg_Err( p_this, "Option %s is deprecated. Use %s instead.",
+                         p_conf->psz_name, p_conf->psz_current );
+                /* TODO: this should return an error and end option parsing
+                 * ... but doing this would change the VLC API and all the
+                 * modules so i'll do it later */
+                goto next;
+            }
+            else
+            {
+                msg_Warn( p_this, "Option %s is deprecated. You should use "
+                        "%s instead.", p_conf->psz_name, p_conf->psz_current );
+                free( psz_name );
+                psz_name = strdup( p_conf->psz_current );
+            }
+        }
+        /* </Check if the option is deprecated> */
+
+        /* get the type of the variable */
+        i_type = config_GetType( p_this, psz_name );
+        if( !i_type )
+        {
+            msg_Warn( p_this, "unknown option %s (value=%s)",
+                      cfg->psz_name, cfg->psz_value );
+            goto next;
+        }
+
+        i_type &= 0x00f0;
+
+        if( i_type != VLC_VAR_BOOL && cfg->psz_value == NULL )
+        {
+            msg_Warn( p_this, "missing value for option %s", cfg->psz_name );
+            goto next;
+        }
+        if( i_type != VLC_VAR_STRING && b_once )
+        {
+            msg_Warn( p_this, "*option_name need to be a string option" );
+            goto next;
+        }
+
+        switch( i_type )
+        {
+            case VLC_VAR_BOOL:
+                val.b_bool = b_yes;
+                break;
+            case VLC_VAR_INTEGER:
+                val.i_int = strtol( cfg->psz_value ? cfg->psz_value : "0",
+                                    NULL, 0 );
+                break;
+            case VLC_VAR_FLOAT:
+                val.f_float = atof( cfg->psz_value ? cfg->psz_value : "0" );
+                break;
+            case VLC_VAR_STRING:
+            case VLC_VAR_MODULE:
+                val.psz_string = cfg->psz_value;
+                break;
+            default:
+                msg_Warn( p_this, "unhandled config var type (%d)", i_type );
+                memset( &val, 0, sizeof( vlc_value_t ) );
+                break;
+        }
+        if( b_once )
+        {
+            vlc_value_t val2;
+
+            var_Get( p_this, psz_name, &val2 );
+            if( *val2.psz_string )
+            {
+                free( val2.psz_string );
+                msg_Dbg( p_this, "ignoring option %s (not first occurrence)", psz_name );
+                goto next;
+            }
+            free( val2.psz_string );
+        }
+        var_Set( p_this, psz_name, val );
+        msg_Dbg( p_this, "set config option: %s to %s", psz_name, cfg->psz_value );
+
+    next:
+        free( psz_name );
+        cfg = cfg->p_next;
+    }
+}
diff --git a/src/modules/modules.c b/src/modules/modules.c
new file mode 100644 (file)
index 0000000..4fcf249
--- /dev/null
@@ -0,0 +1,2250 @@
+/*****************************************************************************
+ * modules.c : Builtin and plugin modules management functions
+ *****************************************************************************
+ * Copyright (C) 2001-2007 the VideoLAN team
+ * $Id$
+ *
+ * Authors: Sam Hocevar <sam@zoy.org>
+ *          Ethan C. Baldridge <BaldridgeE@cadmus.com>
+ *          Hans-Peter Jansen <hpj@urpla.net>
+ *          Gildas Bazin <gbazin@videolan.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
+ *****************************************************************************/
+
+#include <vlc/vlc.h>
+
+/* Some faulty libcs have a broken struct dirent when _FILE_OFFSET_BITS
+ * is set to 64. Don't try to be cleverer. */
+#ifdef _FILE_OFFSET_BITS
+#undef _FILE_OFFSET_BITS
+#endif
+
+#include <stdlib.h>                                      /* free(), strtol() */
+#include <stdio.h>                                              /* sprintf() */
+#include <string.h>                                              /* strdup() */
+
+#ifdef HAVE_DIRENT_H
+#   include <dirent.h>
+#endif
+
+#ifdef HAVE_SYS_TYPES_H
+#   include <sys/types.h>
+#endif
+#ifdef HAVE_SYS_STAT_H
+#   include <sys/stat.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#   include <unistd.h>
+#endif
+
+#if !defined(HAVE_DYNAMIC_PLUGINS)
+    /* no support for plugins */
+#elif defined(HAVE_DL_DYLD)
+#   if defined(HAVE_MACH_O_DYLD_H)
+#       include <mach-o/dyld.h>
+#   endif
+#elif defined(HAVE_DL_BEOS)
+#   if defined(HAVE_IMAGE_H)
+#       include <image.h>
+#   endif
+#elif defined(HAVE_DL_WINDOWS)
+#   include <windows.h>
+#elif defined(HAVE_DL_DLOPEN)
+#   if defined(HAVE_DLFCN_H) /* Linux, BSD, Hurd */
+#       include <dlfcn.h>
+#   endif
+#   if defined(HAVE_SYS_DL_H)
+#       include <sys/dl.h>
+#   endif
+#elif defined(HAVE_DL_SHL_LOAD)
+#   if defined(HAVE_DL_H)
+#       include <dl.h>
+#   endif
+#endif
+
+#include "modules/configuration.h"
+
+#include "vlc_interface.h"
+#include "vlc_playlist.h"
+
+#include "vlc_stream.h"
+#include "vlc_access.h"
+#include "vlc_demux.h"
+
+#include "vlc_vout.h"
+#include "vlc_vout_synchro.h"
+
+#include "vlc_aout.h"
+
+#include "vlc_sout.h"
+#include "vlc_httpd.h"
+#include "vlc_acl.h"
+#include "vlc_tls.h"
+#include "vlc_md5.h"
+#include "vlc_xml.h"
+#include "vlc_url.h"
+
+#include "iso_lang.h"
+#include "vlc_charset.h"
+
+#include "vlc_block.h"
+
+#include "vlc_vlm.h"
+
+#include "vlc_image.h"
+#include "vlc_osd.h"
+
+#include "vlc_update.h"
+#include "vlc_strings.h"
+#include "vlc_streaming.h"
+
+#include "modules/modules.h"
+#include "modules/builtin.h"
+
+#include "vlc_network.h"
+
+#if defined( WIN32 ) || defined( UNDER_CE )
+    /* Avoid name collisions */
+#   define LoadModule(a,b,c) LoadVlcModule(a,b,c)
+#endif
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+#ifdef HAVE_DYNAMIC_PLUGINS
+static void AllocateAllPlugins  ( vlc_object_t * );
+static void AllocatePluginDir   ( vlc_object_t *, const char *, int );
+static int  AllocatePluginFile  ( vlc_object_t *, char *, int64_t, int64_t );
+static module_t * AllocatePlugin( vlc_object_t *, char * );
+#endif
+static int  AllocateBuiltinModule( vlc_object_t *, int ( * ) ( module_t * ) );
+static int  DeleteModule ( module_t *, vlc_bool_t );
+#ifdef HAVE_DYNAMIC_PLUGINS
+static void   DupModule        ( module_t * );
+static void   UndupModule      ( module_t * );
+static int    CallEntry        ( module_t * );
+static int    LoadModule       ( vlc_object_t *, char *, module_handle_t * );
+static void   CloseModule      ( module_handle_t );
+static void * GetSymbol        ( module_handle_t, const char * );
+static void   CacheLoad        ( vlc_object_t * );
+static int    CacheLoadConfig  ( module_t *, FILE * );
+static void   CacheSave        ( vlc_object_t * );
+static void   CacheSaveConfig  ( module_t *, FILE * );
+static char * CacheName        ( void );
+static void   CacheMerge       ( vlc_object_t *, module_t *, module_t * );
+static module_cache_t * CacheFind( vlc_object_t *, char *, int64_t, int64_t );
+
+#if defined(HAVE_DL_WINDOWS)
+static char * GetWindowsError  ( void );
+#endif
+#endif
+
+static void module_LoadMain( vlc_object_t *p_this );
+
+
+/* Sub-version number
+ * (only used to avoid breakage in dev version when cache structure changes) */
+#define CACHE_SUBVERSION_NUM 2
+
+/*****************************************************************************
+ * module_InitBank: create the module bank.
+ *****************************************************************************
+ * This function creates a module bank structure which will be filled later
+ * on with all the modules found.
+ *****************************************************************************/
+void __module_InitBank( vlc_object_t *p_this )
+{
+    module_bank_t *p_bank = NULL;
+    vlc_value_t  lockval;
+
+    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
+    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
+    vlc_mutex_lock( lockval.p_address );
+    if( p_this->p_libvlc_global->p_module_bank )
+    {
+        p_this->p_libvlc_global->p_module_bank->i_usage++;
+        vlc_mutex_unlock( lockval.p_address );
+        var_Destroy( p_this->p_libvlc_global, "libvlc" );
+        return;
+    }
+    vlc_mutex_unlock( lockval.p_address );
+    var_Destroy( p_this->p_libvlc_global, "libvlc" );
+
+    p_bank = vlc_object_create( p_this, sizeof(module_bank_t) );
+    if( !p_bank )
+        return;
+    p_bank->psz_object_name = "module bank";
+    p_bank->i_usage = 1;
+    p_bank->i_cache = p_bank->i_loaded_cache = 0;
+    p_bank->pp_cache = p_bank->pp_loaded_cache = NULL;
+    p_bank->b_cache = p_bank->b_cache_dirty =
+        p_bank->b_cache_delete = VLC_FALSE;
+
+    /*
+     * Store the symbols to be exported
+     */
+#if defined (HAVE_DYNAMIC_PLUGINS) && !defined (HAVE_SHARED_LIBVLC)
+    STORE_SYMBOLS( &p_bank->symbols );
+#endif
+
+    /* Everything worked, attach the object */
+    p_this->p_libvlc_global->p_module_bank = p_bank;
+    vlc_object_attach( p_bank, p_this->p_libvlc_global );
+
+    module_LoadMain( p_this );
+}
+
+/*****************************************************************************
+ * module_ResetBank: reset the module bank.
+ *****************************************************************************
+ * This function resets the module bank by unloading all unused plugin
+ * modules.
+ *****************************************************************************/
+void __module_ResetBank( vlc_object_t *p_this )
+{
+    msg_Err( p_this, "FIXME: module_ResetBank unimplemented" );
+    return;
+}
+
+/*****************************************************************************
+ * module_EndBank: empty the module bank.
+ *****************************************************************************
+ * This function unloads all unused plugin modules and empties the module
+ * bank in case of success.
+ *****************************************************************************/
+void __module_EndBank( vlc_object_t *p_this )
+{
+    module_t * p_next = NULL;
+    vlc_value_t lockval;
+
+    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
+    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
+    vlc_mutex_lock( lockval.p_address );
+    if( !p_this->p_libvlc_global->p_module_bank )
+    {
+        vlc_mutex_unlock( lockval.p_address );
+        var_Destroy( p_this->p_libvlc_global, "libvlc" );
+        return;
+    }
+    if( --p_this->p_libvlc_global->p_module_bank->i_usage )
+    {
+        vlc_mutex_unlock( lockval.p_address );
+        var_Destroy( p_this->p_libvlc_global, "libvlc" );
+        return;
+    }
+    vlc_mutex_unlock( lockval.p_address );
+    var_Destroy( p_this->p_libvlc_global, "libvlc" );
+
+    config_AutoSaveConfigFile( p_this );
+
+#ifdef HAVE_DYNAMIC_PLUGINS
+#define p_bank p_this->p_libvlc_global->p_module_bank
+    if( p_bank->b_cache ) CacheSave( p_this );
+    while( p_bank->i_loaded_cache-- )
+    {
+        if( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] )
+        {
+            DeleteModule( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->p_module, p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->b_used );
+            free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache]->psz_file );
+            free( p_bank->pp_loaded_cache[p_bank->i_loaded_cache] );
+            p_bank->pp_loaded_cache[p_bank->i_loaded_cache] = NULL;
+        }
+    }
+    if( p_bank->pp_loaded_cache )
+    {
+        free( p_bank->pp_loaded_cache );
+        p_bank->pp_loaded_cache = NULL;
+    }
+    while( p_bank->i_cache-- )
+    {
+        free( p_bank->pp_cache[p_bank->i_cache]->psz_file );
+        free( p_bank->pp_cache[p_bank->i_cache] );
+        p_bank->pp_cache[p_bank->i_cache] = NULL;
+    }
+    if( p_bank->pp_cache )
+    {
+        free( p_bank->pp_cache );
+        p_bank->pp_cache = NULL;
+    }
+#undef p_bank
+#endif
+
+    vlc_object_detach( p_this->p_libvlc_global->p_module_bank );
+
+    while( p_this->p_libvlc_global->p_module_bank->i_children )
+    {
+        p_next = (module_t *)p_this->p_libvlc_global->p_module_bank->pp_children[0];
+
+        if( DeleteModule( p_next, VLC_TRUE ) )
+        {
+            /* Module deletion failed */
+            msg_Err( p_this, "module \"%s\" can't be removed, trying harder",
+                     p_next->psz_object_name );
+
+            /* We just free the module by hand. Niahahahahaha. */
+            vlc_object_detach( p_next );
+            vlc_object_destroy( p_next );
+        }
+    }
+
+    vlc_object_destroy( p_this->p_libvlc_global->p_module_bank );
+    p_this->p_libvlc_global->p_module_bank = NULL;
+
+    return;
+}
+
+/*****************************************************************************
+ * module_LoadMain: load the main program info into the module bank.
+ *****************************************************************************
+ * This function fills the module bank structure with the main module infos.
+ * This is very useful as it will allow us to consider the main program just
+ * as another module, and for instance the configuration options of main will
+ * be available in the module bank structure just as for every other module.
+ *****************************************************************************/
+static void module_LoadMain( vlc_object_t *p_this )
+{
+    vlc_value_t lockval;
+
+    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
+    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
+    vlc_mutex_lock( lockval.p_address );
+    if( p_this->p_libvlc_global->p_module_bank->b_main )
+    {
+        vlc_mutex_unlock( lockval.p_address );
+        var_Destroy( p_this->p_libvlc_global, "libvlc" );
+        return;
+    }
+    p_this->p_libvlc_global->p_module_bank->b_main = VLC_TRUE;
+    vlc_mutex_unlock( lockval.p_address );
+    var_Destroy( p_this->p_libvlc_global, "libvlc" );
+
+    AllocateBuiltinModule( p_this, vlc_entry__main );
+}
+
+/*****************************************************************************
+ * module_LoadBuiltins: load all modules which we built with.
+ *****************************************************************************
+ * This function fills the module bank structure with the builtin modules.
+ *****************************************************************************/
+void __module_LoadBuiltins( vlc_object_t * p_this )
+{
+    vlc_value_t lockval;
+
+    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
+    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
+    vlc_mutex_lock( lockval.p_address );
+    if( p_this->p_libvlc_global->p_module_bank->b_builtins )
+    {
+        vlc_mutex_unlock( lockval.p_address );
+        var_Destroy( p_this->p_libvlc_global, "libvlc" );
+        return;
+    }
+    p_this->p_libvlc_global->p_module_bank->b_builtins = VLC_TRUE;
+    vlc_mutex_unlock( lockval.p_address );
+    var_Destroy( p_this->p_libvlc_global, "libvlc" );
+
+    msg_Dbg( p_this, "checking builtin modules" );
+    ALLOCATE_ALL_BUILTINS();
+}
+
+/*****************************************************************************
+ * module_LoadPlugins: load all plugin modules we can find.
+ *****************************************************************************
+ * This function fills the module bank structure with the plugin modules.
+ *****************************************************************************/
+void __module_LoadPlugins( vlc_object_t * p_this )
+{
+#ifdef HAVE_DYNAMIC_PLUGINS
+    vlc_value_t lockval;
+
+    var_Create( p_this->p_libvlc_global, "libvlc", VLC_VAR_MUTEX );
+    var_Get( p_this->p_libvlc_global, "libvlc", &lockval );
+    vlc_mutex_lock( lockval.p_address );
+    if( p_this->p_libvlc_global->p_module_bank->b_plugins )
+    {
+        vlc_mutex_unlock( lockval.p_address );
+        var_Destroy( p_this->p_libvlc_global, "libvlc" );
+        return;
+    }
+    p_this->p_libvlc_global->p_module_bank->b_plugins = VLC_TRUE;
+    vlc_mutex_unlock( lockval.p_address );
+    var_Destroy( p_this->p_libvlc_global, "libvlc" );
+
+    msg_Dbg( p_this, "checking plugin modules" );
+
+    if( config_GetInt( p_this, "plugins-cache" ) )
+        p_this->p_libvlc_global->p_module_bank->b_cache = VLC_TRUE;
+
+    if( p_this->p_libvlc_global->p_module_bank->b_cache ||
+        p_this->p_libvlc_global->p_module_bank->b_cache_delete ) CacheLoad( p_this );
+
+    AllocateAllPlugins( p_this );
+#endif
+}
+
+/*****************************************************************************
+ * module_Need: return the best module function, given a capability list.
+ *****************************************************************************
+ * This function returns the module that best fits the asked capabilities.
+ *****************************************************************************/
+module_t * __module_Need( vlc_object_t *p_this, const char *psz_capability,
+                          const char *psz_name, vlc_bool_t b_strict )
+{
+    typedef struct module_list_t module_list_t;
+
+    struct module_list_t
+    {
+        module_t *p_module;
+        int i_score;
+        vlc_bool_t b_force;
+        module_list_t *p_next;
+    };
+
+    module_list_t *p_list, *p_first, *p_tmp;
+    vlc_list_t *p_all;
+
+    int i_which_module, i_index = 0;
+    vlc_bool_t b_intf = VLC_FALSE;
+
+    module_t *p_module;
+
+    int   i_shortcuts = 0;
+    char *psz_shortcuts = NULL, *psz_var = NULL, *psz_alias = NULL;
+    vlc_bool_t b_force_backup = p_this->b_force;
+
+
+    /* Deal with variables */
+    if( psz_name && psz_name[0] == '$' )
+    {
+        vlc_value_t val;
+        var_Create( p_this, psz_name + 1, VLC_VAR_MODULE | VLC_VAR_DOINHERIT );
+        var_Get( p_this, psz_name + 1, &val );
+        psz_var = val.psz_string;
+        psz_name = psz_var;
+    }
+
+    /* Count how many different shortcuts were asked for */
+    if( psz_name && *psz_name )
+    {
+        char *psz_parser, *psz_last_shortcut;
+
+        /* If the user wants none, give him none. */
+        if( !strcmp( psz_name, "none" ) )
+        {
+            free( psz_var );
+            return NULL;
+        }
+
+        i_shortcuts++;
+        psz_shortcuts = psz_last_shortcut = strdup( psz_name );
+
+        for( psz_parser = psz_shortcuts; *psz_parser; psz_parser++ )
+        {
+            if( *psz_parser == ',' )
+            {
+                 *psz_parser = '\0';
+                 i_shortcuts++;
+                 psz_last_shortcut = psz_parser + 1;
+            }
+        }
+
+        /* Check if the user wants to override the "strict" mode */
+        if( psz_last_shortcut )
+        {
+            if( !strcmp(psz_last_shortcut, "none") )
+            {
+                b_strict = VLC_TRUE;
+                i_shortcuts--;
+            }
+            else if( !strcmp(psz_last_shortcut, "any") )
+            {
+                b_strict = VLC_FALSE;
+                i_shortcuts--;
+            }
+        }
+    }
+
+    /* Sort the modules and test them */
+    p_all = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
+    p_list = malloc( p_all->i_count * sizeof( module_list_t ) );
+    p_first = NULL;
+
+    /* Parse the module list for capabilities and probe each of them */
+    for( i_which_module = 0; i_which_module < p_all->i_count; i_which_module++ )
+    {
+        int i_shortcut_bonus = 0;
+
+        p_module = (module_t *)p_all->p_values[i_which_module].p_object;
+
+        /* Test that this module can do what we need */
+        if( strcmp( p_module->psz_capability, psz_capability ) )
+        {
+            /* Don't recurse through the sub-modules because vlc_list_find()
+             * will list them anyway. */
+            continue;
+        }
+
+        /* Test if we have the required CPU */
+        if( (p_module->i_cpu & p_this->p_libvlc_global->i_cpu) != p_module->i_cpu )
+        {
+            continue;
+        }
+
+        /* If we required a shortcut, check this plugin provides it. */
+        if( i_shortcuts > 0 )
+        {
+            vlc_bool_t b_trash;
+            const char *psz_name = psz_shortcuts;
+
+            /* Let's drop modules with a <= 0 score (unless they are
+             * explicitly requested) */
+            b_trash = p_module->i_score <= 0;
+
+            for( unsigned i_short = i_shortcuts; i_short > 0; i_short-- )
+            {
+                for( unsigned i = 0; p_module->pp_shortcuts[i]; i++ )
+                {
+                    char *c;
+                    if( ( c = strchr( psz_name, '@' ) )
+                        ? !strncasecmp( psz_name, p_module->pp_shortcuts[i],
+                                        c-psz_name )
+                        : !strcasecmp( psz_name, p_module->pp_shortcuts[i] ) )
+                    {
+                        /* Found it */
+                        if( c && c[1] )
+                            psz_alias = c+1;
+                        i_shortcut_bonus = i_short * 10000;
+                        goto found_shortcut;
+                    }
+                }
+
+                /* Go to the next shortcut... This is so lame! */
+                psz_name += strlen( psz_name ) + 1;
+            }
+
+            /* If we are in "strict" mode and we couldn't
+             * find the module in the list of provided shortcuts,
+             * then kick the bastard out of here!!! */
+            if( b_strict )
+                continue;
+        }
+        /* If we didn't require a shortcut, trash <= 0 scored plugins */
+        else if( p_module->i_score <= 0 )
+        {
+            continue;
+        }
+
+found_shortcut:
+
+        /* Special case: test if we requested a particular intf plugin */
+        if( !i_shortcuts && p_module->psz_program
+             && !strcmp( psz_capability, "interface" )
+             && !strcmp( p_module->psz_program,
+                         p_this->p_libvlc->psz_object_name ) )
+        {
+            if( !b_intf )
+            {
+                /* Remove previous non-matching plugins */
+                i_index = 0;
+                b_intf = VLC_TRUE;
+            }
+        }
+        else if( b_intf )
+        {
+            /* This one doesn't match */
+            continue;
+        }
+
+        /* Store this new module */
+        p_list[ i_index ].p_module = p_module;
+        p_list[ i_index ].i_score = p_module->i_score + i_shortcut_bonus;
+        p_list[ i_index ].b_force = i_shortcut_bonus && b_strict;
+
+        /* Add it to the modules-to-probe list */
+        if( i_index == 0 )
+        {
+            p_list[ 0 ].p_next = NULL;
+            p_first = p_list;
+        }
+        else
+        {
+            /* Ok, so at school you learned that quicksort is quick, and
+             * bubble sort sucks raw eggs. But that's when dealing with
+             * thousands of items. Here we have barely 50. */
+            module_list_t *p_newlist = p_first;
+
+            if( p_first->i_score < p_list[ i_index ].i_score )
+            {
+                p_list[ i_index ].p_next = p_first;
+                p_first = &p_list[ i_index ];
+            }
+            else
+            {
+                while( p_newlist->p_next != NULL &&
+                    p_newlist->p_next->i_score >= p_list[ i_index ].i_score )
+                {
+                    p_newlist = p_newlist->p_next;
+                }
+
+                p_list[ i_index ].p_next = p_newlist->p_next;
+                p_newlist->p_next = &p_list[ i_index ];
+            }
+        }
+
+        i_index++;
+    }
+
+    msg_Dbg( p_this, "looking for %s module: %i candidate%s", psz_capability,
+                                            i_index, i_index == 1 ? "" : "s" );
+
+    /* Lock all candidate modules */
+    p_tmp = p_first;
+    while( p_tmp != NULL )
+    {
+        vlc_object_yield( p_tmp->p_module );
+        p_tmp = p_tmp->p_next;
+    }
+
+    /* We can release the list, interesting modules were yielded */
+    vlc_list_release( p_all );
+
+    /* Parse the linked list and use the first successful module */
+    p_tmp = p_first;
+    while( p_tmp != NULL )
+    {
+#ifdef HAVE_DYNAMIC_PLUGINS
+        /* Make sure the module is loaded in mem */
+        module_t *p_module = p_tmp->p_module;
+        if( p_module->b_submodule )
+            p_module = (module_t *)p_module->p_parent;
+
+        if( !p_module->b_builtin && !p_module->b_loaded )
+        {
+            module_t *p_new_module =
+                AllocatePlugin( p_this, p_module->psz_filename );
+            if( p_new_module )
+            {
+                CacheMerge( p_this, p_module, p_new_module );
+                vlc_object_attach( p_new_module, p_module );
+                DeleteModule( p_new_module, VLC_TRUE );
+            }
+        }
+#endif
+
+        p_this->b_force = p_tmp->b_force;
+        if( p_tmp->p_module->pf_activate
+             && p_tmp->p_module->pf_activate( p_this ) == VLC_SUCCESS )
+        {
+            break;
+        }
+
+        vlc_object_release( p_tmp->p_module );
+        p_tmp = p_tmp->p_next;
+    }
+
+    /* Store the locked module value */
+    if( p_tmp != NULL )
+    {
+        p_module = p_tmp->p_module;
+        p_tmp = p_tmp->p_next;
+    }
+    else
+    {
+        p_module = NULL;
+    }
+
+    /* Unlock the remaining modules */
+    while( p_tmp != NULL )
+    {
+        vlc_object_release( p_tmp->p_module );
+        p_tmp = p_tmp->p_next;
+    }
+
+    free( p_list );
+    p_this->b_force = b_force_backup;
+
+    if( p_module != NULL )
+    {
+        msg_Dbg( p_this, "using %s module \"%s\"",
+                 psz_capability, p_module->psz_object_name );
+    }
+    else if( p_first == NULL )
+    {
+        if( !strcmp( psz_capability, "access_demux" ) )
+        {
+            msg_Warn( p_this, "no %s module matched \"%s\"",
+                 psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
+        }
+        else
+        {
+            msg_Err( p_this, "no %s module matched \"%s\"",
+                 psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
+
+            msg_StackSet( VLC_EGENERIC, "no %s module matched \"%s\"",
+                 psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
+        }
+    }
+    else if( psz_name != NULL && *psz_name )
+    {
+        msg_Warn( p_this, "no %s module matching \"%s\" could be loaded",
+                  psz_capability, (psz_name && *psz_name) ? psz_name : "any" );
+    }
+    else
+        msg_StackSet( VLC_EGENERIC, "no suitable %s module", psz_capability );
+
+    if( p_module && !p_this->psz_object_name )
+    {
+        /* This assumes that p_this is the object which will be using the
+         * module. That's not always the case ... but it is in most cases.
+         */
+        if( psz_alias )
+            p_this->psz_object_name = strdup( psz_alias );
+        else
+            p_this->psz_object_name = strdup( p_module->psz_object_name );
+    }
+
+    free( psz_shortcuts );
+    free( psz_var );
+
+    /* Don't forget that the module is still locked */
+    return p_module;
+}
+
+/*****************************************************************************
+ * module_Unneed: decrease the usage count of a module.
+ *****************************************************************************
+ * This function must be called by the thread that called module_Need, to
+ * decrease the reference count and allow for hiding of modules.
+ *****************************************************************************/
+void __module_Unneed( vlc_object_t * p_this, module_t * p_module )
+{
+    /* Use the close method */
+    if( p_module->pf_deactivate )
+    {
+        p_module->pf_deactivate( p_this );
+    }
+
+    msg_Dbg( p_this, "removing module \"%s\"", p_module->psz_object_name );
+
+    vlc_object_release( p_module );
+
+    return;
+}
+
+/*****************************************************************************
+ * module_Exists: tell if a module exists.
+ *****************************************************************************
+ * This function is a boolean function that tells if a module exist or not.
+ *****************************************************************************/
+
+vlc_bool_t __module_Exists(  vlc_object_t *p_this, const char * psz_name )
+{
+    vlc_list_t *p_list;
+    int i;
+    p_list = vlc_list_find( p_this, VLC_OBJECT_MODULE, FIND_ANYWHERE );
+    for( i = 0 ; i < p_list->i_count; i++)
+    {
+        const char *psz_module_name =
+            ((module_t *) p_list->p_values[i].p_object)->psz_shortname;
+        if( psz_module_name && !strcmp( psz_module_name, psz_name ) )
+        {
+            /* We can release the list, and return yes */
+            vlc_list_release( p_list ); return VLC_TRUE;
+        }
+    }
+    vlc_list_release( p_list ); return VLC_FALSE;
+}
+
+
+/*****************************************************************************
+ * Following functions are local.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * AllocateAllPlugins: load all plugin modules we can find.
+ *****************************************************************************/
+#ifdef HAVE_DYNAMIC_PLUGINS
+static void AllocateAllPlugins( vlc_object_t *p_this )
+{
+    /* Yes, there are two NULLs because we replace one with "plugin-path". */
+#if defined( WIN32 ) || defined( UNDER_CE )
+    const char *path[] = { "modules", "", "plugins", NULL, NULL };
+#else
+    const char *path[] = { "modules", PLUGIN_PATH, "plugins", NULL, NULL };
+#endif
+
+    const char *const *ppsz_path;
+
+    /* If the user provided a plugin path, we add it to the list */
+    char *userpath = config_GetPsz( p_this, "plugin-path" );
+    path[sizeof(path)/sizeof(path[0]) - 2] = userpath;
+
+    for (ppsz_path = path; *ppsz_path != NULL; ppsz_path++)
+    {
+        char *psz_fullpath;
+
+        if (!**ppsz_path) continue;
+
+#if defined( SYS_BEOS ) || defined( __APPLE__ ) || defined( WIN32 )
+
+        /* Handle relative as well as absolute paths */
+#ifdef WIN32
+        if( (*ppsz_path)[0] != '\\' && (*ppsz_path)[0] != '/' &&
+            (*ppsz_path)[1] != ':' )
+#else
+        if( (*ppsz_path)[0] != '/' )
+#endif
+        {
+            if( 0>= asprintf(&psz_fullpath, "%s"DIR_SEP"%s",
+                          p_this->p_libvlc_global->psz_vlcpath, *ppsz_path) )
+                psz_fullpath = NULL;
+        }
+        else
+#endif
+            psz_fullpath = strdup( *ppsz_path );
+
+        if( psz_fullpath == NULL )
+            continue;
+
+        msg_Dbg( p_this, "recursively browsing `%s'", psz_fullpath );
+
+        /* Don't go deeper than 5 subdirectories */
+        AllocatePluginDir( p_this, psz_fullpath, 5 );
+
+        free( psz_fullpath );
+    }
+
+    /* Free plugin-path */
+    free( userpath );
+}
+
+/*****************************************************************************
+ * AllocatePluginDir: recursively parse a directory to look for plugins
+ *****************************************************************************/
+static void AllocatePluginDir( vlc_object_t *p_this, const char *psz_dir,
+                               int i_maxdepth )
+{
+/* FIXME: Needs to be ported to wide char on ALL Windows builds */
+#ifdef WIN32
+# undef opendir
+# undef closedir
+# undef readdir
+#endif
+#if defined( UNDER_CE ) || defined( _MSC_VER )
+#ifdef UNDER_CE
+    wchar_t psz_wpath[MAX_PATH + 256];
+    wchar_t psz_wdir[MAX_PATH];
+#endif
+    char psz_path[MAX_PATH + 256];
+    WIN32_FIND_DATA finddata;
+    HANDLE handle;
+    int rc;
+#else
+    int    i_dirlen;
+    DIR *  dir;
+    struct dirent * file;
+#endif
+    char * psz_file;
+
+    if( p_this->p_libvlc->b_die || i_maxdepth < 0 )
+    {
+        return;
+    }
+
+#if defined( UNDER_CE ) || defined( _MSC_VER )
+#ifdef UNDER_CE
+    MultiByteToWideChar( CP_ACP, 0, psz_dir, -1, psz_wdir, MAX_PATH );
+
+    rc = GetFileAttributes( psz_wdir );
+    if( rc<0 || !(rc&FILE_ATTRIBUTE_DIRECTORY) ) return; /* Not a directory */
+
+    /* Parse all files in the directory */
+    swprintf( psz_wpath, L"%ls\\*", psz_wdir );
+#else
+    rc = GetFileAttributes( psz_dir );
+    if( rc<0 || !(rc&FILE_ATTRIBUTE_DIRECTORY) ) return; /* Not a directory */
+#endif
+
+    /* Parse all files in the directory */
+    sprintf( psz_path, "%s\\*", psz_dir );
+
+#ifdef UNDER_CE
+    handle = FindFirstFile( psz_wpath, &finddata );
+#else
+    handle = FindFirstFile( psz_path, &finddata );
+#endif
+    if( handle == INVALID_HANDLE_VALUE )
+    {
+        /* Empty directory */
+        return;
+    }
+
+    /* Parse the directory and try to load all files it contains. */
+    do
+    {
+#ifdef UNDER_CE
+        unsigned int i_len = wcslen( finddata.cFileName );
+        swprintf( psz_wpath, L"%ls\\%ls", psz_wdir, finddata.cFileName );
+        sprintf( psz_path, "%s\\%ls", psz_dir, finddata.cFileName );
+#else
+        unsigned int i_len = strlen( finddata.cFileName );
+        sprintf( psz_path, "%s\\%s", psz_dir, finddata.cFileName );
+#endif
+
+        /* Skip ".", ".." */
+        if( !*finddata.cFileName || !strcmp( finddata.cFileName, "." )
+         || !strcmp( finddata.cFileName, ".." ) )
+        {
+            if( !FindNextFile( handle, &finddata ) ) break;
+            continue;
+        }
+
+#ifdef UNDER_CE
+        if( GetFileAttributes( psz_wpath ) & FILE_ATTRIBUTE_DIRECTORY )
+#else
+        if( GetFileAttributes( psz_path ) & FILE_ATTRIBUTE_DIRECTORY )
+#endif
+        {
+            AllocatePluginDir( p_this, psz_path, i_maxdepth - 1 );
+        }
+        else if( i_len > strlen( LIBEXT )
+                  /* We only load files ending with LIBEXT */
+                  && !strncasecmp( psz_path + strlen( psz_path)
+                                   - strlen( LIBEXT ),
+                                   LIBEXT, strlen( LIBEXT ) ) )
+        {
+            WIN32_FILE_ATTRIBUTE_DATA attrbuf;
+            int64_t i_time = 0, i_size = 0;
+
+#ifdef UNDER_CE
+            if( GetFileAttributesEx( psz_wpath, GetFileExInfoStandard,
+                                     &attrbuf ) )
+#else
+            if( GetFileAttributesEx( psz_path, GetFileExInfoStandard,
+                                     &attrbuf ) )
+#endif
+            {
+                i_time = attrbuf.ftLastWriteTime.dwHighDateTime;
+                i_time <<= 32;
+                i_time |= attrbuf.ftLastWriteTime.dwLowDateTime;
+                i_size = attrbuf.nFileSizeHigh;
+                i_size <<= 32;
+                i_size |= attrbuf.nFileSizeLow;
+            }
+            psz_file = psz_path;
+
+            AllocatePluginFile( p_this, psz_file, i_time, i_size );
+        }
+    }
+    while( !p_this->p_libvlc->b_die && FindNextFile( handle, &finddata ) );
+
+    /* Close the directory */
+    FindClose( handle );
+
+#else
+    dir = opendir( psz_dir );
+    if( !dir )
+    {
+        return;
+    }
+
+    i_dirlen = strlen( psz_dir );
+
+    /* Parse the directory and try to load all files it contains. */
+    while( !p_this->p_libvlc->b_die && (file = readdir( dir )) )
+    {
+        struct stat statbuf;
+        unsigned int i_len;
+        int i_stat;
+
+        /* Skip ".", ".." */
+        if( !*file->d_name || !strcmp( file->d_name, "." )
+         || !strcmp( file->d_name, ".." ) )
+        {
+            continue;
+        }
+
+        i_len = strlen( file->d_name );
+        psz_file = malloc( i_dirlen + 1 + i_len + 1 );
+#ifdef WIN32
+        sprintf( psz_file, "%s\\%s", psz_dir, file->d_name );
+#else
+        sprintf( psz_file, "%s/%s", psz_dir, file->d_name );
+#endif
+
+        i_stat = stat( psz_file, &statbuf );
+        if( !i_stat && statbuf.st_mode & S_IFDIR )
+        {
+            AllocatePluginDir( p_this, psz_file, i_maxdepth - 1 );
+        }
+        else if( i_len > strlen( LIBEXT )
+                  /* We only load files ending with LIBEXT */
+                  && !strncasecmp( file->d_name + i_len - strlen( LIBEXT ),
+                                   LIBEXT, strlen( LIBEXT ) ) )
+        {
+            int64_t i_time = 0, i_size = 0;
+
+            if( !i_stat )
+            {
+                i_time = statbuf.st_mtime;
+                i_size = statbuf.st_size;
+            }
+
+            AllocatePluginFile( p_this, psz_file, i_time, i_size );
+        }
+
+        free( psz_file );
+    }
+
+    /* Close the directory */
+    closedir( dir );
+
+#endif
+}
+
+/*****************************************************************************
+ * AllocatePluginFile: load a module into memory and initialize it.
+ *****************************************************************************
+ * This function loads a dynamically loadable module and allocates a structure
+ * for its information data. The module can then be handled by module_Need
+ * and module_Unneed. It can be removed by DeleteModule.
+ *****************************************************************************/
+static int AllocatePluginFile( vlc_object_t * p_this, char * psz_file,
+                               int64_t i_file_time, int64_t i_file_size )
+{
+    module_t * p_module = NULL;
+    module_cache_t *p_cache_entry = NULL;
+
+    /*
+     * Check our plugins cache first then load plugin if needed
+     */
+    p_cache_entry =
+        CacheFind( p_this, psz_file, i_file_time, i_file_size );
+
+    if( !p_cache_entry )
+    {
+        p_module = AllocatePlugin( p_this, psz_file );
+    }
+    else
+    {
+        /* If junk dll, don't try to load it */
+        if( p_cache_entry->b_junk )
+        {
+            p_module = NULL;
+        }
+        else
+        {
+            module_config_t *p_item = NULL, *p_end = NULL;
+
+            p_module = p_cache_entry->p_module;
+            p_module->b_loaded = VLC_FALSE;
+
+            /* For now we force loading if the module's config contains
+             * callbacks or actions.
+             * Could be optimized by adding an API call.*/
+            for( p_item = p_module->p_config, p_end = p_item + p_module->confsize;
+                 p_item < p_end; p_item++ )
+            {
+                if( p_item->pf_callback || p_item->i_action )
+                {
+                    p_module = AllocatePlugin( p_this, psz_file );
+                    break;
+                }
+            }
+            if( p_module == p_cache_entry->p_module )
+                p_cache_entry->b_used = VLC_TRUE;
+        }
+    }
+
+    if( p_module )
+    {
+        /* Everything worked fine !
+         * The module is ready to be added to the list. */
+        p_module->b_builtin = VLC_FALSE;
+
+        /* msg_Dbg( p_this, "plugin \"%s\", %s",
+                    p_module->psz_object_name, p_module->psz_longname ); */
+
+        vlc_object_attach( p_module, p_this->p_libvlc_global->p_module_bank );
+
+        if( !p_this->p_libvlc_global->p_module_bank->b_cache )
+            return 0;
+
+        /* Add entry to cache */
+#define p_bank p_this->p_libvlc_global->p_module_bank
+        p_bank->pp_cache =
+            realloc( p_bank->pp_cache, (p_bank->i_cache + 1) * sizeof(void *) );
+        p_bank->pp_cache[p_bank->i_cache] = malloc( sizeof(module_cache_t) );
+        if( !p_bank->pp_cache[p_bank->i_cache] )
+            return -1;
+        p_bank->pp_cache[p_bank->i_cache]->psz_file = strdup( psz_file );
+        p_bank->pp_cache[p_bank->i_cache]->i_time = i_file_time;
+        p_bank->pp_cache[p_bank->i_cache]->i_size = i_file_size;
+        p_bank->pp_cache[p_bank->i_cache]->b_junk = p_module ? 0 : 1;
+        p_bank->pp_cache[p_bank->i_cache]->b_used = VLC_TRUE;
+        p_bank->pp_cache[p_bank->i_cache]->p_module = p_module;
+        p_bank->i_cache++;
+    }
+
+    return p_module ? 0 : -1;
+}
+
+/*****************************************************************************
+ * AllocatePlugin: load a module into memory and initialize it.
+ *****************************************************************************
+ * This function loads a dynamically loadable module and allocates a structure
+ * for its information data. The module can then be handled by module_Need
+ * and module_Unneed. It can be removed by DeleteModule.
+ *****************************************************************************/
+static module_t * AllocatePlugin( vlc_object_t * p_this, char * psz_file )
+{
+    module_t * p_module = NULL;
+    module_handle_t handle;
+
+    if( LoadModule( p_this, psz_file, &handle ) )
+        return NULL;
+
+    /* Now that we have successfully loaded the module, we can
+     * allocate a structure for it */
+    p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE );
+    if( p_module == NULL )
+    {
+        msg_Err( p_this, "out of memory" );
+        CloseModule( handle );
+        return NULL;
+    }
+
+    /* We need to fill these since they may be needed by CallEntry() */
+    p_module->psz_filename = psz_file;
+    p_module->handle = handle;
+#ifndef HAVE_SHARED_LIBVLC
+    p_module->p_symbols = &p_this->p_libvlc_global->p_module_bank->symbols;
+#endif
+    p_module->b_loaded = VLC_TRUE;
+
+    /* Initialize the module: fill p_module, default config */
+    if( CallEntry( p_module ) != 0 )
+    {
+        /* We couldn't call module_init() */
+        vlc_object_destroy( p_module );
+        CloseModule( handle );
+        return NULL;
+    }
+
+    DupModule( p_module );
+    p_module->psz_filename = strdup( p_module->psz_filename );
+
+    /* Everything worked fine ! The module is ready to be added to the list. */
+    p_module->b_builtin = VLC_FALSE;
+
+    return p_module;
+}
+
+/*****************************************************************************
+ * DupModule: make a plugin module standalone.
+ *****************************************************************************
+ * This function duplicates all strings in the module, so that the dynamic
+ * object can be unloaded. It acts recursively on submodules.
+ *****************************************************************************/
+static void DupModule( module_t *p_module )
+{
+    const char **pp_shortcut;
+    int i_submodule;
+
+    for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ )
+    {
+        *pp_shortcut = strdup( *pp_shortcut );
+    }
+
+    /* We strdup() these entries so that they are still valid when the
+     * module is unloaded. */
+    p_module->psz_object_name = strdup( p_module->psz_object_name );
+    p_module->psz_capability = strdup( p_module->psz_capability );
+    p_module->psz_shortname = p_module->psz_shortname ?
+                                 strdup( p_module->psz_shortname ) : NULL;
+    p_module->psz_longname = strdup( p_module->psz_longname );
+    p_module->psz_help = p_module->psz_help ? strdup( p_module->psz_help )
+                                            : NULL;
+
+    if( p_module->psz_program != NULL )
+    {
+        p_module->psz_program = strdup( p_module->psz_program );
+    }
+
+    for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ )
+    {
+        DupModule( (module_t*)p_module->pp_children[ i_submodule ] );
+    }
+}
+
+/*****************************************************************************
+ * UndupModule: free a duplicated module.
+ *****************************************************************************
+ * This function frees the allocations done in DupModule().
+ *****************************************************************************/
+static void UndupModule( module_t *p_module )
+{
+    const char **pp_shortcut;
+    int i_submodule;
+
+    for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ )
+    {
+        UndupModule( (module_t*)p_module->pp_children[ i_submodule ] );
+    }
+
+    for( pp_shortcut = p_module->pp_shortcuts ; *pp_shortcut ; pp_shortcut++ )
+    {
+        free( (void*)*pp_shortcut );
+    }
+
+    free( (void*)p_module->psz_object_name );
+    free( (void*)p_module->psz_capability );
+    free( (void*)p_module->psz_shortname );
+    free( (void*)p_module->psz_longname );
+    free( (void*)p_module->psz_help );
+    free( (void*)p_module->psz_program );
+}
+
+#endif /* HAVE_DYNAMIC_PLUGINS */
+
+/*****************************************************************************
+ * AllocateBuiltinModule: initialize a builtin module.
+ *****************************************************************************
+ * This function registers a builtin module and allocates a structure
+ * for its information data. The module can then be handled by module_Need
+ * and module_Unneed. It can be removed by DeleteModule.
+ *****************************************************************************/
+static int AllocateBuiltinModule( vlc_object_t * p_this,
+                                  int ( *pf_entry ) ( module_t * ) )
+{
+    module_t * p_module;
+
+    /* Now that we have successfully loaded the module, we can
+     * allocate a structure for it */
+    p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE );
+    if( p_module == NULL )
+    {
+        msg_Err( p_this, "out of memory" );
+        return -1;
+    }
+
+    /* Initialize the module : fill p_module->psz_object_name, etc. */
+    if( pf_entry( p_module ) != 0 )
+    {
+        /* With a well-written module we shouldn't have to print an
+         * additional error message here, but just make sure. */
+        msg_Err( p_this, "failed calling entry point in builtin module" );
+        vlc_object_destroy( p_module );
+        return -1;
+    }
+
+    /* Everything worked fine ! The module is ready to be added to the list. */
+    p_module->b_builtin = VLC_TRUE;
+
+    /* msg_Dbg( p_this, "builtin \"%s\", %s",
+                p_module->psz_object_name, p_module->psz_longname ); */
+
+    vlc_object_attach( p_module, p_this->p_libvlc_global->p_module_bank );
+
+    return 0;
+}
+
+/*****************************************************************************
+ * DeleteModule: delete a module and its structure.
+ *****************************************************************************
+ * This function can only be called if the module isn't being used.
+ *****************************************************************************/
+static int DeleteModule( module_t * p_module, vlc_bool_t b_detach )
+{
+    if( !p_module ) return VLC_EGENERIC;
+    if( b_detach )
+        vlc_object_detach( p_module );
+
+    /* We free the structures that we strdup()ed in Allocate*Module(). */
+#ifdef HAVE_DYNAMIC_PLUGINS
+    if( !p_module->b_builtin )
+    {
+        if( p_module->b_loaded && p_module->b_unloadable )
+        {
+            CloseModule( p_module->handle );
+        }
+        UndupModule( p_module );
+        free( p_module->psz_filename );
+    }
+#endif
+
+    /* Free and detach the object's children */
+    while( p_module->i_children )
+    {
+        vlc_object_t *p_this = p_module->pp_children[0];
+        vlc_object_detach( p_this );
+        vlc_object_destroy( p_this );
+    }
+
+    config_Free( p_module );
+    vlc_object_destroy( p_module );
+    p_module = NULL;
+    return 0;
+}
+
+#ifdef HAVE_DYNAMIC_PLUGINS
+/*****************************************************************************
+ * CallEntry: call an entry point.
+ *****************************************************************************
+ * This function calls a symbol given its name and a module structure. The
+ * symbol MUST refer to a function returning int and taking a module_t* as
+ * an argument.
+ *****************************************************************************/
+static int CallEntry( module_t * p_module )
+{
+    static const char * const psz_name = "vlc_entry" MODULE_SUFFIX;
+    int (* pf_symbol) ( module_t * p_module );
+
+    /* Try to resolve the symbol */
+    pf_symbol = (int (*)(module_t *)) GetSymbol( p_module->handle, psz_name );
+
+    if( pf_symbol == NULL )
+    {
+#if defined(HAVE_DL_DYLD) || defined(HAVE_DL_BEOS)
+        msg_Warn( p_module, "cannot find symbol \"%s\" in file `%s'",
+                            psz_name, p_module->psz_filename );
+#elif defined(HAVE_DL_WINDOWS)
+        char *psz_error = GetWindowsError();
+        msg_Warn( p_module, "cannot find symbol \"%s\" in file `%s' (%s)",
+                            psz_name, p_module->psz_filename, psz_error );
+        free( psz_error );
+#elif defined(HAVE_DL_DLOPEN)
+        msg_Warn( p_module, "cannot find symbol \"%s\" in file `%s' (%s)",
+                            psz_name, p_module->psz_filename, dlerror() );
+#elif defined(HAVE_DL_SHL_LOAD)
+        msg_Warn( p_module, "cannot find symbol \"%s\" in file `%s' (%s)",
+                            psz_name, p_module->psz_filename, strerror(errno) );
+#else
+#   error "Something is wrong in modules.c"
+#endif
+        return -1;
+    }
+
+    /* We can now try to call the symbol */
+    if( pf_symbol( p_module ) != 0 )
+    {
+        /* With a well-written module we shouldn't have to print an
+         * additional error message here, but just make sure. */
+        msg_Err( p_module, "Failed to call symbol \"%s\" in file `%s'",
+                           psz_name, p_module->psz_filename );
+        return -1;
+    }
+
+    /* Everything worked fine, we can return */
+    return 0;
+}
+
+/*****************************************************************************
+ * LoadModule: loads a dynamic library
+ *****************************************************************************
+ * This function loads a dynamically linked library using a system dependant
+ * method. Will return 0 on success as well as the module handle.
+ *****************************************************************************/
+static int LoadModule( vlc_object_t *p_this, char *psz_file,
+                       module_handle_t *p_handle )
+{
+    module_handle_t handle;
+
+#if defined(HAVE_DL_DYLD)
+    NSObjectFileImage image;
+    NSObjectFileImageReturnCode ret;
+
+    ret = NSCreateObjectFileImageFromFile( psz_file, &image );
+
+    if( ret != NSObjectFileImageSuccess )
+    {
+        msg_Warn( p_this, "cannot create image from `%s'", psz_file );
+        return -1;
+    }
+
+    /* Open the dynamic module */
+    handle = NSLinkModule( image, psz_file,
+                           NSLINKMODULE_OPTION_RETURN_ON_ERROR );
+
+    if( !handle )
+    {
+        NSLinkEditErrors errors;
+        const char *psz_file, *psz_err;
+        int i_errnum;
+        NSLinkEditError( &errors, &i_errnum, &psz_file, &psz_err );
+        msg_Warn( p_this, "cannot link module `%s' (%s)", psz_file, psz_err );
+        NSDestroyObjectFileImage( image );
+        return -1;
+    }
+
+    /* Destroy our image, we won't need it */
+    NSDestroyObjectFileImage( image );
+
+#elif defined(HAVE_DL_BEOS)
+    handle = load_add_on( psz_file );
+    if( handle < 0 )
+    {
+        msg_Warn( p_this, "cannot load module `%s'", psz_file );
+        return -1;
+    }
+
+#elif defined(HAVE_DL_WINDOWS)
+#ifdef UNDER_CE
+    {
+        wchar_t psz_wfile[MAX_PATH];
+        MultiByteToWideChar( CP_ACP, 0, psz_file, -1, psz_wfile, MAX_PATH );
+        handle = LoadLibrary( psz_wfile );
+    }
+#else
+    handle = LoadLibrary( psz_file );
+#endif
+    if( handle == NULL )
+    {
+        char *psz_err = GetWindowsError();
+        msg_Warn( p_this, "cannot load module `%s' (%s)", psz_file, psz_err );
+        free( psz_err );
+        return -1;
+    }
+
+#elif defined(HAVE_DL_DLOPEN) && defined(RTLD_NOW)
+    /* static is OK, we are called atomically */
+
+#   if defined(SYS_LINUX)
+    /* XXX HACK #1 - we should NOT open modules with RTLD_GLOBAL, or we
+     * are going to get namespace collisions when two modules have common
+     * public symbols, but ALSA is being a pest here. */
+    if( strstr( psz_file, "alsa_plugin" ) )
+    {
+        handle = dlopen( psz_file, RTLD_NOW | RTLD_GLOBAL );
+        if( handle == NULL )
+        {
+            msg_Warn( p_this, "cannot load module `%s' (%s)",
+                              psz_file, dlerror() );
+            return -1;
+        }
+    }
+#   endif
+
+    handle = dlopen( psz_file, RTLD_NOW );
+    if( handle == NULL )
+    {
+        msg_Warn( p_this, "cannot load module `%s' (%s)",
+                          psz_file, dlerror() );
+        return -1;
+    }
+
+#elif defined(HAVE_DL_DLOPEN)
+#   if defined(DL_LAZY)
+    handle = dlopen( psz_file, DL_LAZY );
+#   else
+    handle = dlopen( psz_file, 0 );
+#   endif
+    if( handle == NULL )
+    {
+        msg_Warn( p_this, "cannot load module `%s' (%s)",
+                          psz_file, dlerror() );
+        return -1;
+    }
+
+#elif defined(HAVE_DL_SHL_LOAD)
+    handle = shl_load( psz_file, BIND_IMMEDIATE | BIND_NONFATAL, NULL );
+    if( handle == NULL )
+    {
+        msg_Warn( p_this, "cannot load module `%s' (%s)",
+                          psz_file, strerror(errno) );
+        return -1;
+    }
+
+#else
+#   error "Something is wrong in modules.c"
+
+#endif
+
+    *p_handle = handle;
+    return 0;
+}
+
+/*****************************************************************************
+ * CloseModule: unload a dynamic library
+ *****************************************************************************
+ * This function unloads a previously opened dynamically linked library
+ * using a system dependant method. No return value is taken in consideration,
+ * since some libraries sometimes refuse to close properly.
+ *****************************************************************************/
+static void CloseModule( module_handle_t handle )
+{
+#if defined(HAVE_DL_DYLD)
+    NSUnLinkModule( handle, FALSE );
+
+#elif defined(HAVE_DL_BEOS)
+    unload_add_on( handle );
+
+#elif defined(HAVE_DL_WINDOWS)
+    FreeLibrary( handle );
+
+#elif defined(HAVE_DL_DLOPEN)
+    dlclose( handle );
+
+#elif defined(HAVE_DL_SHL_LOAD)
+    shl_unload( handle );
+
+#endif
+    return;
+}
+
+/*****************************************************************************
+ * GetSymbol: get a symbol from a dynamic library
+ *****************************************************************************
+ * This function queries a loaded library for a symbol specified in a
+ * string, and returns a pointer to it. We don't check for dlerror() or
+ * similar functions, since we want a non-NULL symbol anyway.
+ *****************************************************************************/
+static void * _module_getsymbol( module_handle_t, const char * );
+
+static void * GetSymbol( module_handle_t handle, const char * psz_function )
+{
+    void * p_symbol = _module_getsymbol( handle, psz_function );
+
+    /* MacOS X dl library expects symbols to begin with "_". So do
+     * some other operating systems. That's really lame, but hey, what
+     * can we do ? */
+    if( p_symbol == NULL )
+    {
+        char *psz_call = malloc( strlen( psz_function ) + 2 );
+
+        strcpy( psz_call + 1, psz_function );
+        psz_call[ 0 ] = '_';
+        p_symbol = _module_getsymbol( handle, psz_call );
+        free( psz_call );
+    }
+
+    return p_symbol;
+}
+
+static void * _module_getsymbol( module_handle_t handle,
+                                 const char * psz_function )
+{
+#if defined(HAVE_DL_DYLD)
+    NSSymbol sym = NSLookupSymbolInModule( handle, psz_function );
+    return NSAddressOfSymbol( sym );
+
+#elif defined(HAVE_DL_BEOS)
+    void * p_symbol;
+    if( B_OK == get_image_symbol( handle, psz_function,
+                                  B_SYMBOL_TYPE_TEXT, &p_symbol ) )
+    {
+        return p_symbol;
+    }
+    else
+    {
+        return NULL;
+    }
+
+#elif defined(HAVE_DL_WINDOWS) && defined(UNDER_CE)
+    wchar_t psz_real[256];
+    MultiByteToWideChar( CP_ACP, 0, psz_function, -1, psz_real, 256 );
+
+    return (void *)GetProcAddress( handle, psz_real );
+
+#elif defined(HAVE_DL_WINDOWS) && defined(WIN32)
+    return (void *)GetProcAddress( handle, (char *)psz_function );
+
+#elif defined(HAVE_DL_DLOPEN)
+    return dlsym( handle, psz_function );
+
+#elif defined(HAVE_DL_SHL_LOAD)
+    void *p_sym;
+    shl_findsym( &handle, psz_function, TYPE_UNDEFINED, &p_sym );
+    return p_sym;
+
+#endif
+}
+
+#if defined(HAVE_DL_WINDOWS)
+static char * GetWindowsError( void )
+{
+#if defined(UNDER_CE)
+    wchar_t psz_tmp[MAX_PATH];
+    char * psz_buffer = malloc( MAX_PATH );
+#else
+    char * psz_tmp = malloc( MAX_PATH );
+#endif
+    int i = 0, i_error = GetLastError();
+
+    FormatMessage( FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
+                   NULL, i_error, MAKELANGID (LANG_NEUTRAL, SUBLANG_DEFAULT),
+                   (LPTSTR)psz_tmp, MAX_PATH, NULL );
+
+    /* Go to the end of the string */
+    while( psz_tmp[i] && psz_tmp[i] != _T('\r') && psz_tmp[i] != _T('\n') )
+    {
+        i++;
+    }
+
+    if( psz_tmp[i] )
+    {
+#if defined(UNDER_CE)
+        swprintf( psz_tmp + i, L" (error %i)", i_error );
+        psz_tmp[ 255 ] = L'\0';
+#else
+        snprintf( psz_tmp + i, 256 - i, " (error %i)", i_error );
+        psz_tmp[ 255 ] = '\0';
+#endif
+    }
+
+#if defined(UNDER_CE)
+    wcstombs( psz_buffer, psz_tmp, MAX_PATH );
+    return psz_buffer;
+#else
+    return psz_tmp;
+#endif
+}
+#endif /* HAVE_DL_WINDOWS */
+
+/*****************************************************************************
+ * LoadPluginsCache: loads the plugins cache file
+ *****************************************************************************
+ * This function will load the plugin cache if present and valid. This cache
+ * will in turn be queried by AllocateAllPlugins() to see if it needs to
+ * actually load the dynamically loadable module.
+ * This allows us to only fully load plugins when they are actually used.
+ *****************************************************************************/
+static void CacheLoad( vlc_object_t *p_this )
+{
+    char *psz_filename, *psz_homedir;
+    FILE *file;
+    int i, j, i_size, i_read;
+    char p_cachestring[sizeof(PLUGINSCACHE_DIR COPYRIGHT_MESSAGE)];
+    char p_cachelang[6], p_lang[6];
+    int i_cache;
+    module_cache_t **pp_cache = 0;
+    int32_t i_file_size, i_marker;
+
+    psz_homedir = p_this->p_libvlc->psz_homedir;
+    if( !psz_homedir )
+    {
+        msg_Err( p_this, "psz_homedir is null" );
+        return;
+    }
+
+    i_size = asprintf( &psz_filename, "%s/%s/%s/%s", psz_homedir, CONFIG_DIR,
+                       PLUGINSCACHE_DIR, CacheName() );
+    if( i_size <= 0 )
+    {
+        msg_Err( p_this, "out of memory" );
+        return;
+    }
+
+    if( p_this->p_libvlc_global->p_module_bank->b_cache_delete )
+    {
+#if !defined( UNDER_CE )
+        unlink( psz_filename );
+#else
+        wchar_t psz_wf[MAX_PATH];
+        MultiByteToWideChar( CP_ACP, 0, psz_filename, -1, psz_wf, MAX_PATH );
+        DeleteFile( psz_wf );
+#endif
+        msg_Dbg( p_this, "removing plugins cache file %s", psz_filename );
+        free( psz_filename );
+        return;
+    }
+
+    msg_Dbg( p_this, "loading plugins cache file %s", psz_filename );
+
+    file = utf8_fopen( psz_filename, "rb" );
+    if( !file )
+    {
+        msg_Warn( p_this, "could not open plugins cache file %s for reading",
+                  psz_filename );
+        free( psz_filename );
+        return;
+    }
+    free( psz_filename );
+
+    /* Check the file size */
+    i_read = fread( &i_file_size, sizeof(char), sizeof(i_file_size), file );
+    if( i_read != sizeof(i_file_size) )
+    {
+        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
+                  "(too short)" );
+        fclose( file );
+        return;
+    }
+
+    fseek( file, 0, SEEK_END );
+    if( ftell( file ) != i_file_size )
+    {
+        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
+                  "(corrupted size)" );
+        fclose( file );
+        return;
+    }
+    fseek( file, sizeof(i_file_size), SEEK_SET );
+
+    /* Check the file is a plugins cache */
+    i_size = sizeof(PLUGINSCACHE_DIR COPYRIGHT_MESSAGE) - 1;
+    i_read = fread( p_cachestring, sizeof(char), i_size, file );
+    if( i_read != i_size ||
+        memcmp( p_cachestring, PLUGINSCACHE_DIR COPYRIGHT_MESSAGE, i_size ) )
+    {
+        msg_Warn( p_this, "This doesn't look like a valid plugins cache" );
+        fclose( file );
+        return;
+    }
+
+    /* Check Sub-version number */
+    i_read = fread( &i_marker, sizeof(char), sizeof(i_marker), file );
+    if( i_read != sizeof(i_marker) || i_marker != CACHE_SUBVERSION_NUM )
+    {
+        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
+                  "(corrupted header)" );
+        fclose( file );
+        return;
+    }
+
+    /* Check the language hasn't changed */
+    sprintf( p_lang, "%5.5s", _("C") ); i_size = 5;
+    i_read = fread( p_cachelang, sizeof(char), i_size, file );
+    if( i_read != i_size || memcmp( p_cachelang, p_lang, i_size ) )
+    {
+        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
+                  "(language changed)" );
+        fclose( file );
+        return;
+    }
+
+    /* Check header marker */
+    i_read = fread( &i_marker, sizeof(char), sizeof(i_marker), file );
+    if( i_read != sizeof(i_marker) ||
+        i_marker != ftell( file ) - (int)sizeof(i_marker) )
+    {
+        msg_Warn( p_this, "This doesn't look like a valid plugins cache "
+                  "(corrupted header)" );
+        fclose( file );
+        return;
+    }
+
+    p_this->p_libvlc_global->p_module_bank->i_loaded_cache = 0;
+    fread( &i_cache, sizeof(char), sizeof(i_cache), file );
+    if( i_cache )
+        pp_cache = p_this->p_libvlc_global->p_module_bank->pp_loaded_cache =
+                   malloc( i_cache * sizeof(void *) );
+
+#define LOAD_IMMEDIATE(a) \
+    if( fread( (void *)&a, sizeof(char), sizeof(a), file ) != sizeof(a) ) goto error
+#define LOAD_STRING(a) \
+{ \
+    a = NULL; \
+    if( ( fread( &i_size, sizeof(i_size), 1, file ) != 1 ) \
+     || ( i_size > 16384 ) ) \
+        goto error; \
+    if( i_size ) { \
+        char *psz = malloc( i_size ); \
+        if( fread( psz, i_size, 1, file ) != 1 ) { \
+            free( psz ); \
+            goto error; \
+        } \
+        if( psz[i_size-1] ) { \
+            free( psz ); \
+            goto error; \
+        } \
+        a = psz; \
+    } \
+}
+
+    for( i = 0; i < i_cache; i++ )
+    {
+        uint16_t i_size;
+        int i_submodules;
+
+        pp_cache[i] = malloc( sizeof(module_cache_t) );
+        p_this->p_libvlc_global->p_module_bank->i_loaded_cache++;
+
+        /* Load common info */
+        LOAD_STRING( pp_cache[i]->psz_file );
+        LOAD_IMMEDIATE( pp_cache[i]->i_time );
+        LOAD_IMMEDIATE( pp_cache[i]->i_size );
+        LOAD_IMMEDIATE( pp_cache[i]->b_junk );
+        pp_cache[i]->b_used = VLC_FALSE;
+
+        if( pp_cache[i]->b_junk ) continue;
+
+        pp_cache[i]->p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE );
+
+        /* Load additional infos */
+        LOAD_STRING( pp_cache[i]->p_module->psz_object_name );
+        LOAD_STRING( pp_cache[i]->p_module->psz_shortname );
+        LOAD_STRING( pp_cache[i]->p_module->psz_longname );
+        LOAD_STRING( pp_cache[i]->p_module->psz_help );
+        LOAD_STRING( pp_cache[i]->p_module->psz_program );
+        for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
+        {
+            LOAD_STRING( pp_cache[i]->p_module->pp_shortcuts[j] ); // FIX
+        }
+        LOAD_STRING( pp_cache[i]->p_module->psz_capability );
+        LOAD_IMMEDIATE( pp_cache[i]->p_module->i_score );
+        LOAD_IMMEDIATE( pp_cache[i]->p_module->i_cpu );
+        LOAD_IMMEDIATE( pp_cache[i]->p_module->b_unloadable );
+        LOAD_IMMEDIATE( pp_cache[i]->p_module->b_reentrant );
+        LOAD_IMMEDIATE( pp_cache[i]->p_module->b_submodule );
+
+        /* Config stuff */
+        if( CacheLoadConfig( pp_cache[i]->p_module, file ) != VLC_SUCCESS )
+            goto error;
+
+        LOAD_STRING( pp_cache[i]->p_module->psz_filename );
+
+        LOAD_IMMEDIATE( i_submodules );
+
+        while( i_submodules-- )
+        {
+            module_t *p_module = vlc_object_create( p_this, VLC_OBJECT_MODULE);
+            vlc_object_attach( p_module, pp_cache[i]->p_module );
+            p_module->b_submodule = VLC_TRUE;
+
+            LOAD_STRING( p_module->psz_object_name );
+            LOAD_STRING( p_module->psz_shortname );
+            LOAD_STRING( p_module->psz_longname );
+            LOAD_STRING( p_module->psz_help );
+            LOAD_STRING( p_module->psz_program );
+            for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
+            {
+                LOAD_STRING( p_module->pp_shortcuts[j] ); // FIX
+            }
+            LOAD_STRING( p_module->psz_capability );
+            LOAD_IMMEDIATE( p_module->i_score );
+            LOAD_IMMEDIATE( p_module->i_cpu );
+            LOAD_IMMEDIATE( p_module->b_unloadable );
+            LOAD_IMMEDIATE( p_module->b_reentrant );
+        }
+    }
+
+    fclose( file );
+    return;
+
+ error:
+
+    msg_Warn( p_this, "plugins cache not loaded (corrupted)" );
+
+    /* TODO: cleanup */
+    p_this->p_libvlc_global->p_module_bank->i_loaded_cache = 0;
+
+    fclose( file );
+    return;
+}
+
+
+int CacheLoadConfig( module_t *p_module, FILE *file )
+{
+    uint32_t i_lines;
+    uint16_t i_size;
+
+    /* Calculate the structure length */
+    LOAD_IMMEDIATE( p_module->i_config_items );
+    LOAD_IMMEDIATE( p_module->i_bool_items );
+
+    LOAD_IMMEDIATE( i_lines );
+
+    /* Allocate memory */
+    if (i_lines)
+    {
+        p_module->p_config =
+            (module_config_t *)calloc( i_lines, sizeof(module_config_t) );
+        if( p_module->p_config == NULL )
+        {
+            p_module->confsize = 0;
+            msg_Err( p_module, "config error: can't duplicate p_config" );
+            return VLC_ENOMEM;
+        }
+    }
+    p_module->confsize = i_lines;
+
+    /* Do the duplication job */
+    for (size_t i = 0; i < i_lines; i++ )
+    {
+        LOAD_IMMEDIATE( p_module->p_config[i] );
+
+        LOAD_STRING( p_module->p_config[i].psz_type );
+        LOAD_STRING( p_module->p_config[i].psz_name );
+        LOAD_STRING( p_module->p_config[i].psz_text );
+        LOAD_STRING( p_module->p_config[i].psz_longtext );
+        LOAD_STRING( p_module->p_config[i].psz_current );
+
+        if (IsConfigStringType (p_module->p_config[i].i_type))
+        {
+            LOAD_STRING (p_module->p_config[i].orig.psz);
+            p_module->p_config[i].value.psz =
+                    (p_module->p_config[i].orig.psz != NULL)
+                        ? strdup (p_module->p_config[i].orig.psz) : NULL;
+            p_module->p_config[i].saved.psz = NULL;
+        }
+        else
+        {
+            memcpy (&p_module->p_config[i].value, &p_module->p_config[i].orig,
+                    sizeof (p_module->p_config[i].value));
+            memcpy (&p_module->p_config[i].saved, &p_module->p_config[i].orig,
+                    sizeof (p_module->p_config[i].saved));
+        }
+
+        p_module->p_config[i].b_dirty = VLC_FALSE;
+
+        p_module->p_config[i].p_lock = &p_module->object_lock;
+
+        if( p_module->p_config[i].i_list )
+        {
+            if( p_module->p_config[i].ppsz_list )
+            {
+                int j;
+                p_module->p_config[i].ppsz_list =
+                    malloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
+                if( p_module->p_config[i].ppsz_list )
+                {
+                    for( j = 0; j < p_module->p_config[i].i_list; j++ )
+                        LOAD_STRING( p_module->p_config[i].ppsz_list[j] );
+                    p_module->p_config[i].ppsz_list[j] = NULL;
+                }
+            }
+            if( p_module->p_config[i].ppsz_list_text )
+            {
+                int j;
+                p_module->p_config[i].ppsz_list_text =
+                    malloc( (p_module->p_config[i].i_list+1) * sizeof(char *));
+                if( p_module->p_config[i].ppsz_list_text )
+                {
+                  for( j = 0; j < p_module->p_config[i].i_list; j++ )
+                      LOAD_STRING( p_module->p_config[i].ppsz_list_text[j] );
+                  p_module->p_config[i].ppsz_list_text[j] = NULL;
+                }
+            }
+            if( p_module->p_config[i].pi_list )
+            {
+                p_module->p_config[i].pi_list =
+                    malloc( (p_module->p_config[i].i_list + 1) * sizeof(int) );
+                if( p_module->p_config[i].pi_list )
+                {
+                    for (int j = 0; j < p_module->p_config[i].i_list; j++)
+                        LOAD_IMMEDIATE( p_module->p_config[i].pi_list[j] );
+                }
+            }
+        }
+
+        if( p_module->p_config[i].i_action )
+        {
+            p_module->p_config[i].ppf_action =
+                malloc( p_module->p_config[i].i_action * sizeof(void *) );
+            p_module->p_config[i].ppsz_action_text =
+                malloc( p_module->p_config[i].i_action * sizeof(char *) );
+
+            for (int j = 0; j < p_module->p_config[i].i_action; j++)
+            {
+                p_module->p_config[i].ppf_action[j] = 0;
+                LOAD_STRING( p_module->p_config[i].ppsz_action_text[j] );
+            }
+        }
+
+        LOAD_IMMEDIATE( p_module->p_config[i].pf_callback );
+    }
+
+    return VLC_SUCCESS;
+
+ error:
+
+    return VLC_EGENERIC;
+}
+
+/*****************************************************************************
+ * SavePluginsCache: saves the plugins cache to a file
+ *****************************************************************************/
+static void CacheSave( vlc_object_t *p_this )
+{
+    static char const psz_tag[] =
+        "Signature: 8a477f597d28d172789f06886806bc55\r\n"
+        "# This file is a cache directory tag created by VLC.\r\n"
+        "# For information about cache directory tags, see:\r\n"
+        "#   http://www.brynosaurus.com/cachedir/\r\n";
+
+    char *psz_filename, *psz_homedir;
+    FILE *file;
+    int i, j, i_cache;
+    module_cache_t **pp_cache;
+    int32_t i_file_size = 0;
+
+    psz_homedir = p_this->p_libvlc->psz_homedir;
+    if( !psz_homedir )
+    {
+        msg_Err( p_this, "psz_homedir is null" );
+        return;
+    }
+    psz_filename =
+       (char *)malloc( sizeof("/" CONFIG_DIR "/" PLUGINSCACHE_DIR "/" ) +
+                       strlen(psz_homedir) + strlen(CacheName()) );
+
+    if( !psz_filename )
+    {
+        msg_Err( p_this, "out of memory" );
+        return;
+    }
+
+    sprintf( psz_filename, "%s/%s", psz_homedir, CONFIG_DIR );
+
+    config_CreateDir( p_this, psz_filename );
+
+    strcat( psz_filename, "/" PLUGINSCACHE_DIR );
+
+    config_CreateDir( p_this, psz_filename );
+
+    strcat( psz_filename, "/CACHEDIR.TAG" );
+
+    file = utf8_fopen( psz_filename, "wb" );
+    if( file )
+    {
+        fwrite( psz_tag, 1, strlen(psz_tag), file );
+        fclose( file );
+    }
+
+    sprintf( psz_filename, "%s/%s/%s/%s", psz_homedir, CONFIG_DIR,
+             PLUGINSCACHE_DIR, CacheName() );
+
+    msg_Dbg( p_this, "saving plugins cache file %s", psz_filename );
+
+    file = utf8_fopen( psz_filename, "wb" );
+    if( !file )
+    {
+        msg_Warn( p_this, "could not open plugins cache file %s for writing",
+                  psz_filename );
+        free( psz_filename );
+        return;
+    }
+    free( psz_filename );
+
+    /* Empty space for file size */
+    fwrite( &i_file_size, sizeof(char), sizeof(i_file_size), file );
+
+    /* Contains version number */
+    fprintf( file, "%s", PLUGINSCACHE_DIR COPYRIGHT_MESSAGE );
+
+    /* Sub-version number (to avoid breakage in the dev version when cache
+     * structure changes) */
+    i_file_size = CACHE_SUBVERSION_NUM;
+    fwrite( &i_file_size, sizeof(char), sizeof(i_file_size), file );
+
+    /* Language */
+    fprintf( file, "%5.5s", _("C") );
+
+    /* Header marker */
+    i_file_size = ftell( file );
+    fwrite( &i_file_size, sizeof(char), sizeof(i_file_size), file );
+
+    i_cache = p_this->p_libvlc_global->p_module_bank->i_cache;
+    pp_cache = p_this->p_libvlc_global->p_module_bank->pp_cache;
+
+    fwrite( &i_cache, sizeof(char), sizeof(i_cache), file );
+
+#define SAVE_IMMEDIATE(a) \
+    fwrite( &a, sizeof(char), sizeof(a), file )
+#define SAVE_STRING(a) \
+    { i_size = a ? strlen( a ) + 1 : 0; \
+      fwrite( &i_size, sizeof(char), sizeof(i_size), file ); \
+      if( a ) fwrite( a, sizeof(char), i_size, file ); \
+    } while(0)
+
+    for( i = 0; i < i_cache; i++ )
+    {
+        uint16_t i_size;
+        uint32_t i_submodule;
+
+        /* Save common info */
+        SAVE_STRING( pp_cache[i]->psz_file );
+        SAVE_IMMEDIATE( pp_cache[i]->i_time );
+        SAVE_IMMEDIATE( pp_cache[i]->i_size );
+        SAVE_IMMEDIATE( pp_cache[i]->b_junk );
+
+        if( pp_cache[i]->b_junk ) continue;
+
+        /* Save additional infos */
+        SAVE_STRING( pp_cache[i]->p_module->psz_object_name );
+        SAVE_STRING( pp_cache[i]->p_module->psz_shortname );
+        SAVE_STRING( pp_cache[i]->p_module->psz_longname );
+        SAVE_STRING( pp_cache[i]->p_module->psz_help );
+        SAVE_STRING( pp_cache[i]->p_module->psz_program );
+        for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
+        {
+            SAVE_STRING( pp_cache[i]->p_module->pp_shortcuts[j] ); // FIX
+        }
+        SAVE_STRING( pp_cache[i]->p_module->psz_capability );
+        SAVE_IMMEDIATE( pp_cache[i]->p_module->i_score );
+        SAVE_IMMEDIATE( pp_cache[i]->p_module->i_cpu );
+        SAVE_IMMEDIATE( pp_cache[i]->p_module->b_unloadable );
+        SAVE_IMMEDIATE( pp_cache[i]->p_module->b_reentrant );
+        SAVE_IMMEDIATE( pp_cache[i]->p_module->b_submodule );
+
+        /* Config stuff */
+        CacheSaveConfig( pp_cache[i]->p_module, file );
+
+        SAVE_STRING( pp_cache[i]->p_module->psz_filename );
+
+        i_submodule = pp_cache[i]->p_module->i_children;
+        SAVE_IMMEDIATE( i_submodule );
+        for( i_submodule = 0;
+             i_submodule < (unsigned)pp_cache[i]->p_module->i_children;
+             i_submodule++ )
+        {
+            module_t *p_module =
+                (module_t *)pp_cache[i]->p_module->pp_children[i_submodule];
+
+            SAVE_STRING( p_module->psz_object_name );
+            SAVE_STRING( p_module->psz_shortname );
+            SAVE_STRING( p_module->psz_longname );
+            SAVE_STRING( p_module->psz_help );
+            SAVE_STRING( p_module->psz_program );
+            for( j = 0; j < MODULE_SHORTCUT_MAX; j++ )
+            {
+                SAVE_STRING( p_module->pp_shortcuts[j] ); // FIX
+            }
+            SAVE_STRING( p_module->psz_capability );
+            SAVE_IMMEDIATE( p_module->i_score );
+            SAVE_IMMEDIATE( p_module->i_cpu );
+            SAVE_IMMEDIATE( p_module->b_unloadable );
+            SAVE_IMMEDIATE( p_module->b_reentrant );
+        }
+    }
+
+    /* Fill-up file size */
+    i_file_size = ftell( file );
+    fseek( file, 0, SEEK_SET );
+    fwrite( &i_file_size, sizeof(char), sizeof(i_file_size), file );
+
+    fclose( file );
+
+    return;
+}
+
+void CacheSaveConfig( module_t *p_module, FILE *file )
+{
+    uint32_t i_lines = p_module->confsize;
+    uint16_t i_size;
+
+    SAVE_IMMEDIATE( p_module->i_config_items );
+    SAVE_IMMEDIATE( p_module->i_bool_items );
+    SAVE_IMMEDIATE( i_lines );
+
+    for (size_t i = 0; i < i_lines ; i++)
+    {
+        SAVE_IMMEDIATE( p_module->p_config[i] );
+
+        SAVE_STRING( p_module->p_config[i].psz_type );
+        SAVE_STRING( p_module->p_config[i].psz_name );
+        SAVE_STRING( p_module->p_config[i].psz_text );
+        SAVE_STRING( p_module->p_config[i].psz_longtext );
+        SAVE_STRING( p_module->p_config[i].psz_current );
+        if (IsConfigStringType (p_module->p_config[i].i_type))
+            SAVE_STRING( p_module->p_config[i].orig.psz );
+
+        if( p_module->p_config[i].i_list )
+        {
+            if( p_module->p_config[i].ppsz_list )
+            {
+                for (int j = 0; j < p_module->p_config[i].i_list; j++)
+                    SAVE_STRING( p_module->p_config[i].ppsz_list[j] );
+            }
+
+            if( p_module->p_config[i].ppsz_list_text )
+            {
+                for (int j = 0; j < p_module->p_config[i].i_list; j++)
+                    SAVE_STRING( p_module->p_config[i].ppsz_list_text[j] );
+            }
+            if( p_module->p_config[i].pi_list )
+            {
+                for (int j = 0; j < p_module->p_config[i].i_list; j++)
+                    SAVE_IMMEDIATE( p_module->p_config[i].pi_list[j] );
+            }
+        }
+
+        for (int j = 0; j < p_module->p_config[i].i_action; j++)
+            SAVE_STRING( p_module->p_config[i].ppsz_action_text[j] );
+
+        SAVE_IMMEDIATE( p_module->p_config[i].pf_callback );
+    }
+}
+
+/*****************************************************************************
+ * CacheName: Return the cache file name for this platform.
+ *****************************************************************************/
+static char *CacheName( void )
+{
+    static char psz_cachename[32];
+
+    /* Code int size, pointer size and endianness in the filename */
+    int32_t x = 0xbe00001e;
+    sprintf( psz_cachename, "plugins-%.2x%.2x%.2x.dat", (int)sizeof(int),
+             (int)sizeof(void *), (unsigned int)((unsigned char *)&x)[0] );
+    return psz_cachename;
+}
+
+/*****************************************************************************
+ * CacheMerge: Merge a cache module descriptor with a full module descriptor.
+ *****************************************************************************/
+static void CacheMerge( vlc_object_t *p_this, module_t *p_cache,
+                        module_t *p_module )
+{
+    int i_submodule;
+    (void)p_this;
+
+    p_cache->pf_activate = p_module->pf_activate;
+    p_cache->pf_deactivate = p_module->pf_deactivate;
+#ifndef HAVE_SHARED_LIBVLC
+    p_cache->p_symbols = p_module->p_symbols;
+#endif
+    p_cache->handle = p_module->handle;
+
+    for( i_submodule = 0; i_submodule < p_module->i_children; i_submodule++ )
+    {
+        module_t *p_child = (module_t*)p_module->pp_children[i_submodule];
+        module_t *p_cchild = (module_t*)p_cache->pp_children[i_submodule];
+        p_cchild->pf_activate = p_child->pf_activate;
+        p_cchild->pf_deactivate = p_child->pf_deactivate;
+#ifndef HAVE_SHARED_LIBVLC
+        p_cchild->p_symbols = p_child->p_symbols;
+#endif
+    }
+
+    p_cache->b_loaded = VLC_TRUE;
+    p_module->b_loaded = VLC_FALSE;
+}
+
+/*****************************************************************************
+ * CacheFind: finds the cache entry corresponding to a file
+ *****************************************************************************/
+static module_cache_t *CacheFind( vlc_object_t *p_this, char *psz_file,
+                                  int64_t i_time, int64_t i_size )
+{
+    module_cache_t **pp_cache;
+    int i_cache, i;
+
+    pp_cache = p_this->p_libvlc_global->p_module_bank->pp_loaded_cache;
+    i_cache = p_this->p_libvlc_global->p_module_bank->i_loaded_cache;
+
+    for( i = 0; i < i_cache; i++ )
+    {
+        if( !strcmp( pp_cache[i]->psz_file, psz_file ) &&
+            pp_cache[i]->i_time == i_time &&
+            pp_cache[i]->i_size == i_size ) return pp_cache[i];
+    }
+
+    return NULL;
+}
+
+#endif /* HAVE_DYNAMIC_PLUGINS */
diff --git a/src/modules/modules.h b/src/modules/modules.h
new file mode 100644 (file)
index 0000000..13be264
--- /dev/null
@@ -0,0 +1,82 @@
+/*****************************************************************************
+ * modules.h : Module management functions.
+ *****************************************************************************
+ * Copyright (C) 2001 the VideoLAN team
+ * $Id: modules.h 17958 2006-11-22 17:13:24Z courmisch $
+ *
+ * Authors: Samuel Hocevar <sam@zoy.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms