merge: add evil files

SVN revision: 76464

77 files changed, 17758 insertions, 0 deletions

diff --git a/src/lib/evil/Evil.h b/src/lib/evil/Evil.h
new file mode 100644
index 0000000000..e807dffb61
--- /dev/null
+++ b/src/lib/evil/Evil.h
@@ -0,0 +1,186 @@
+#ifndef __EVIL_H__
+#define __EVIL_H__
+
+/**
+ * @mainpage Evil
+ * @image html  e_big.png
+ * @author Vincent Torri
+ * @version 1.7.0
+ * @date 2008-2012
+ *
+ * @section intro_sec Introduction
+ *
+ * The Evil library is an evil library that ports some evil Unix
+ * functions to the Windows (XP or above, or Mobile) platform. The
+ * evilness is so huge that the most of the functions are not POSIX or
+ * BSD compliant.
+ *
+ * These functions are intended to be used in the Enlightenment
+ * Foundation Libraries only and can be compiled only on Windows,
+ * using MSYS/MinGW on Windows, and cross-compilation on Unix. This
+ * library is minimal in the sense that only the functions needed to
+ * compile the EFL are available. The purpose of this library is NOT
+ * to have a full POSIX emulation et it is NOT a replacement of
+ * cygwin. To compare the size of the DLL themselves, Evil is around
+ * 33 KB and cygwin DLL is around 800 KB.
+ *
+ * @section acknowledgments_sec Acknowledgments
+ *
+ * This library has receive some from people interested in the EFL or
+ * not. Among them, evil thanks to Lars Munch, Raoul Hecky, Nicolas
+ * Aguirre, Tor Lillqvist, Lance Fetters, Vincent Richomme, Paul
+ * Vixie, Daniel Stenberg, who helped the author of the library in
+ * different fields (code and tests).
+ *
+ * @section license_sec license
+ *
+ * The Evil library is distributes under a modified BSD license. See
+ * the files COPYING and COPYING-PLAIN in the top level directory for
+ * the full license text.
+ *
+ * @section reference_sec Reference API
+ *
+ * Use the horizontal menu above to navigate into the reference API
+ */
+
+/**
+ * @file Evil.h
+ * @brief The file that provides miscellaneous functions ported from Unix.
+ * @defgroup Evil Miscellaneous functions ported from Unix.
+ *
+ * This header provides miscellaneous functions that exist on Unix
+ * but not on Windows platform. They try to follow the conformance of
+ * the Unix versions.
+ */
+
+/**
+ * @cond LOCAL
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+#include <limits.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <math.h>
+#include <direct.h>
+
+
+#ifdef _MSC_VER
+
+# include <io.h>
+
+# define F_OK 0  /* Check for file existence */
+# define X_OK 1  /* MS access() doesn't check for execute permission. */
+# define W_OK 2  /* Check for write permission */
+# define R_OK 4  /* Check for read permission */
+
+typedef DWORD          pid_t;
+typedef unsigned short mode_t;
+
+typedef unsigned short uint16_t;
+typedef unsigned int uint32_t;
+typedef signed int int32_t;
+typedef __int64 int64_t;
+typedef unsigned __int64 uint64_t;
+typedef SSIZE_T ssize_t;
+
+# define strdup(s) _strdup(s)
+# define unlink(filename) _unlink(filename)
+# define fileno(f) _fileno(f)
+# define fdopen(fd,m) _fdopen((fd),(m))
+# define access(p,m) _access((p),(m))
+# define hypot(x,y) _hypot((x),(y))
+# define tzset _tzset
+
+#endif /* _MSC_VER */
+
+#ifdef _WIN32_WCE
+# ifndef offsetof
+#  define offsetof(type, ident) ((size_t)&(((type*)0)->ident))
+# endif
+#endif
+
+typedef unsigned long  uid_t;
+typedef unsigned long  gid_t;
+
+
+#include "evil_macro.h"
+#include "evil_fcntl.h"
+#include "evil_inet.h"
+#include "evil_langinfo.h"
+#include "evil_libgen.h"
+#include "evil_main.h"
+#include "evil_print.h"
+#include "evil_stdlib.h"
+#include "evil_stdio.h"
+#include "evil_string.h"
+#include "evil_time.h"
+#include "evil_unistd.h"
+#include "evil_util.h"
+#include "evil_macro_pop.h"
+
+
+#if (defined(_WIN32) && !defined(_UWIN) && !defined(__CYGWIN__))
+# if defined(_MSC_VER) || defined(__MINGW32__)
+
+# ifdef S_ISDIR
+#  undef S_ISDIR
+# endif
+# ifdef S_ISREG
+#  undef S_ISREG
+# endif
+# define S_ISDIR(m) (((m) & _S_IFMT) == _S_IFDIR)
+# define S_ISREG(m) (((m) & _S_IFMT) == _S_IFREG)
+
+# define S_ISLNK(m) 0
+
+# define S_IRUSR _S_IRUSR
+# define S_IWUSR _S_IWUSR
+# define S_IXUSR _S_IXUSR
+# define S_IRGRP S_IRUSR
+# define S_IROTH S_IRUSR
+# define S_IWGRP S_IWUSR
+# define S_IWOTH S_IWUSR
+# define S_IXGRP S_IXUSR
+# define S_IXOTH S_IXUSR
+
+# define _S_IRWXU (_S_IREAD | _S_IWRITE | _S_IEXEC)
+# define _S_IXUSR _S_IEXEC
+# define _S_IWUSR _S_IWRITE
+# define _S_IRUSR _S_IREAD
+
+#  define mkdir(p,m) _mkdir(p)
+  /*
+#  define close(fd) _close(fd)
+#  define read(fd,buffer,count) _read((fd),(buffer),(count))
+#  define write(fd,buffer,count) _write((fd),(buffer),(count))
+#  define unlink(filename) _unlink((filename))
+#  define lstat(f,s) _stat((f),(s))
+  */
+
+# endif
+#endif
+
+
+#ifdef __cplusplus
+}
+#endif
+
+/**
+ * @endcond
+ */
+
+#endif /* __EVIL_H__ */
diff --git a/src/lib/evil/Makefile.am b/src/lib/evil/Makefile.am
new file mode 100644
index 0000000000..62d0d56bf3
--- /dev/null
+++ b/src/lib/evil/Makefile.am
@@ -0,0 +1,132 @@
+
+MAINTAINERCLEANFILES = Makefile.in
+
+lib_LTLIBRARIES = libevil.la libdl.la
+
+install_evilheadersdir = $(includedir)/evil-@VMAJ@
+dist_install_evilheaders_DATA = \
+Evil.h \
+evil_fcntl.h \
+evil_inet.h \
+evil_langinfo.h \
+evil_libgen.h \
+evil_macro.h \
+evil_macro_pop.h \
+evil_main.h \
+evil_print.h \
+evil_stdlib.h \
+evil_stdio.h \
+evil_string.h \
+evil_time.h \
+evil_unistd.h \
+evil_util.h
+
+stdheadersdir = $(includedir)/evil-@VMAJ@
+nobase_dist_stdheaders_DATA = pwd.h sys/mman.h fnmatch.h dirent.h dlfcn.h
+
+if EVIL_HAVE_WINCE
+
+nobase_dist_stdheaders_DATA += mingw32ce/errno.h
+
+endif
+
+# gdtoa
+libevil_la_SOURCES = \
+gdtoa/arithchk.c \
+gdtoa/dmisc.c \
+gdtoa/dtoa.c \
+gdtoa/gd_arith.h \
+gdtoa/g_dfmt.c \
+gdtoa/gd_qnan.h \
+gdtoa/gdtoa.c \
+gdtoa/gdtoa_fltrnds.h \
+gdtoa/gdtoa.h \
+gdtoa/gdtoaimp.h \
+gdtoa/gethex.c \
+gdtoa/g_ffmt.c \
+gdtoa/g__fmt.c \
+gdtoa/gmisc.c \
+gdtoa/g_xfmt.c \
+gdtoa/hd_init.c \
+gdtoa/hexnan.c \
+gdtoa/misc.c \
+gdtoa/qnan.c \
+gdtoa/smisc.c \
+gdtoa/strtodg.c \
+gdtoa/strtof.c \
+gdtoa/strtopx.c \
+gdtoa/sum.c \
+gdtoa/ulp.c
+
+#evil
+libevil_la_SOURCES += \
+evil_dirent.c \
+evil_fcntl.c \
+evil_fnmatch.c \
+evil_fnmatch_list_of_states.c \
+evil_inet.c \
+evil_langinfo.c \
+evil_libgen.c \
+evil_main.c \
+evil_mman.c \
+evil_pformata.c \
+evil_pformatw.c \
+evil_printa.c \
+evil_printw.c \
+evil_pwd.c \
+evil_stdlib.c \
+evil_stdio.c \
+evil_string.c \
+evil_time.c \
+evil_unistd.c \
+evil_util.c \
+evil_uuid.c \
+evil_pformat.h \
+evil_private.h \
+evil_fnmatch_private.h
+
+if EVIL_HAVE_WINCE
+
+libevil_la_SOURCES += evil_errno.c evil_link_ce.c
+
+else
+
+libevil_la_SOURCES += evil_link_xp.cpp
+
+endif
+
+libevil_la_CPPFLAGS = @EVIL_CPPFLAGS@
+libevil_la_CFLAGS = @EVIL_CFLAGS@
+libevil_la_CXXFLAGS = @EVIL_CXXFLAGS@
+libevil_la_LIBADD = @EVIL_LIBS@
+libevil_la_LDFLAGS = -no-undefined -Wl,--enable-auto-import -version-info @version_info@
+
+if EVIL_HAVE_WINCE
+
+libevil_la_LINK = $(LINK) $(libevil_la_LDFLAGS)
+
+else
+
+libevil_la_LINK = $(CXXLINK) $(libevil_la_LDFLAGS)
+
+endif
+
+libdl_la_SOURCES = dlfcn.c
+
+libdl_la_CPPFLAGS = @EVIL_DLFCN_CPPFLAGS@
+libdl_la_CFLAGS = @EVIL_CFLAGS@
+libdl_la_LIBADD = $(top_builddir)/src/lib/libevil.la @EVIL_DLFCN_LIBS@
+libdl_la_LDFLAGS = -no-undefined -Wl,--enable-auto-import -version-info @version_info@
+
+EXTRA_DIST = gdtoa/README gdtoa/README.mingw
+
+install-data-hook:
+        rm -f $(libdir)/libevil.la $(libdir)/libdl.la
+
+uninstall-local:
+        rm -f $(DESTDIR)$(bindir)/libevil-@VMAJ@.dll
+        rm -f $(DESTDIR)$(bindir)/libdl-@VMAJ@.dll
+        rm -f $(DESTDIR)$(libdir)/libevil.dll.a
+        rm -f $(DESTDIR)$(libdir)/libevil.a
+        rm -f $(DESTDIR)$(libdir)/libdl.dll.a
+        rm -f $(DESTDIR)$(libdir)/libdl.a
diff --git a/src/lib/evil/dirent.h b/src/lib/evil/dirent.h
new file mode 100644
index 0000000000..3fe9d12866
--- /dev/null
+++ b/src/lib/evil/dirent.h
@@ -0,0 +1,141 @@
+#ifndef __EVIL_DIRENT_H__
+#define __EVIL_DIRENT_H__
+
+#ifdef EAPI
+# undef EAPI
+#endif /* EAPI */
+
+#ifdef _WIN32
+# ifdef EFL_EVIL_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EVIL_BUILD */
+#endif /* _WIN32 */
+
+
+/**
+ * @file dirent.h
+ * @brief The file that provides functions ported from Unix in dirent.h.
+ * @defgroup Evil_Dirent_Group Dirent.h functions
+ *
+ * This header provides functions ported from Unix in dirent.h.
+ *
+ * @{
+ */
+
+
+#ifdef UNICODE
+# include <wchar.h>
+#endif
+
+/**
+ * @def DT_UNKNOWN
+ * Specifies that the file type is unknown.
+ */
+#define DT_UNKNOWN 0
+
+/**
+ * @def DT_DIR
+ * Specifies that the file type is a directory.
+ */
+#define DT_DIR     4
+
+/**
+ * @typedef DIR
+ * @brief A structure that describes a directory stream.
+ */
+typedef struct DIR DIR;
+
+/**
+ * @struct dirent
+ * @brief A structure that describes a directory stream.
+ */
+struct dirent
+{
+   char          d_name[260 + 1]; /**< The filename. */
+   int           d_mode;          /**< The mode */
+   unsigned char d_type;          /**< The type */
+};
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+
+/**
+ * @brief Open the given directory.
+ *
+ * @param name The directory to open.
+ * @return A pointer to the directory stream.
+ *
+ * This function opens the directory @p name and return the directory
+ * stream. On error or if @p dir is NULL, -1 is returned, and errno is
+ * set appropriately (on Windows XP only). On success, 0 is returned.
+ *
+ * @see closedir()
+ * @see readdir()
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows XP, CE.
+ */
+EAPI DIR *opendir(char const *name);
+
+/**
+ * @brief Close the given directory.
+ *
+ * @param dir The directory stream to close.
+ * @return A pointer to the directory stream.
+ *
+ * This function closes the stream directory @p dir. On error or is
+ * @p path is NULL or an empty string, NULL is returned, and errno is set
+ * appropriately (on Windows XP only).
+ *
+ * @see opendir()
+ * @see readdir()
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows XP, CE.
+ */
+EAPI int closedir(DIR *dir);
+
+/**
+ * @brief Read the given directory.
+ *
+ * @param dir The directory stream to read.
+ * @return A pointer to a dirent structure, @c NULL oterhwise.
+ *
+ * This function returns a pointer to a dirent structure representing
+ * the next directory entry in the directory stream pointed to by
+ * @p dir. It returns NULL on reaching the end of the directory stream
+ * or if an error occurred and errno is set appropriately (on Windows XP only).
+ *
+ * @see opendir()
+ * @see readdir()
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows XP, CE.
+ */
+EAPI struct dirent *readdir(DIR *dir);
+
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+
+
+
+/**
+ * @}
+ */
+
+
+#endif /* __EVIL_DIRENT_H__ */
diff --git a/src/lib/evil/dlfcn.c b/src/lib/evil/dlfcn.c
new file mode 100644
index 0000000000..818cabf014
--- /dev/null
+++ b/src/lib/evil/dlfcn.c
@@ -0,0 +1,272 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+
+#if defined(__MINGW32CE__) || defined(_MSC_VER)
+# include <limits.h>
+#endif /* __MINGW32CE__ || _MSC_VER */
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#ifdef _WIN32_WCE
+# include <tlhelp32.h> /* CreateToolhelp32Snapshot */
+#else
+# include <psapi.h> /*  EnumProcessModules(Ex) */
+#endif
+
+#include "Evil.h"
+
+#include "dlfcn.h"
+
+
+static char *dl_err = NULL;
+static int dl_err_viewed = 0;
+
+static void
+get_last_error(char *desc)
+{
+   char  *str;
+   size_t l1;
+   size_t l2;
+
+   str = evil_last_error_get();
+
+   l1 = strlen(desc);
+   l2 = strlen(str);
+
+   if (dl_err)
+     free(dl_err);
+
+   dl_err = (char *)malloc(sizeof(char) * (l1 + l2 + 1));
+   if (!dl_err)
+     dl_err = strdup("not enough resource");
+   else
+     {
+        memcpy(dl_err, desc, l1);
+        memcpy(dl_err + l1, str, l2);
+        dl_err[l1 + l2] = '\0';
+     }
+   free(str);
+   dl_err_viewed = 0;
+}
+
+void *
+dlopen(const char* path, int mode __UNUSED__)
+{
+   HMODULE module = NULL;
+
+   if (!path)
+     {
+        module = GetModuleHandle(NULL);
+        if (!module)
+          get_last_error("GetModuleHandle returned: ");
+     }
+   else
+     {
+        char        *new_path;
+        size_t       l;
+        unsigned int i;
+
+        /* according to MSDN, we must change the slash to backslash */
+        l = strlen(path);
+        new_path = (char *)malloc(sizeof(char) * (l + 1));
+        if (!new_path)
+          {
+             if (dl_err)
+               free(dl_err);
+             dl_err = strdup("not enough resource");
+             dl_err_viewed = 0;
+             return NULL;
+          }
+        for (i = 0; i <= l; i++)
+          {
+             if (path[i] == '/')
+               new_path[i] = '\\';
+             else
+               new_path[i] = path[i];
+          }
+#ifdef UNICODE
+        {
+           wchar_t *wpath;
+
+           wpath = evil_char_to_wchar(new_path);
+           module = LoadLibrary(wpath);
+           free(wpath);
+        }
+#else
+        module = LoadLibraryEx(new_path, NULL,
+                               LOAD_WITH_ALTERED_SEARCH_PATH);
+#endif /* ! UNICODE */
+        if (!module)
+          get_last_error("LoadLibraryEx returned: ");
+
+        free(new_path);
+     }
+
+   return module;
+}
+
+int
+dlclose(void* handle)
+{
+   if (FreeLibrary(handle))
+     return 0;
+   else
+     {
+        get_last_error("FreeLibrary returned: ");
+        return -1;
+     }
+}
+
+void *
+dlsym(void *handle, const char *symbol)
+{
+   FARPROC fp = NULL;
+   LPCTSTR new_symbol;
+
+   if (!symbol || !*symbol) return NULL;
+
+#ifdef UNICODE
+   new_symbol = evil_char_to_wchar(symbol);
+#else
+   new_symbol = symbol;
+#endif /* UNICODE */
+
+   if (handle == RTLD_DEFAULT)
+     {
+#ifdef _WIN32_WCE
+        HANDLE snapshot;
+        MODULEENTRY32 module;
+
+        snapshot = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS |
+                                            TH32CS_SNAPMODULE |
+                                            TH32CS_GETALLMODS,
+                                            0);
+        if (!snapshot)
+          return NULL;
+
+        module.dwSize = sizeof(module);
+        if (Module32First(snapshot, &module))
+          do {
+            fp = GetProcAddress(module.hModule, new_symbol);
+            if (fp) break;
+          } while (Module32Next(snapshot, &module));
+
+        CloseToolhelp32Snapshot(snapshot);
+#else
+        HMODULE modules[1024];
+        DWORD needed;
+        DWORD i;
+
+        /* TODO: use EnumProcessModulesEx() on Windows >= Vista */
+        if (!EnumProcessModules(GetCurrentProcess(),
+                                modules, sizeof(modules), &needed))
+          return NULL;
+
+        for (i = 0; i < (needed /  sizeof(HMODULE)); i++)
+          {
+            fp = GetProcAddress(modules[i], new_symbol);
+            if (fp) break;
+          }
+#endif
+     }
+   else
+     fp = GetProcAddress(handle, new_symbol);
+
+#ifdef UNICODE
+   free((void *)new_symbol);
+#endif /* UNICODE */
+
+   if (!fp)
+     get_last_error("GetProcAddress returned: ");
+
+   return fp;
+}
+
+int
+dladdr (const void *addr __UNUSED__, Dl_info *info)
+{
+   TCHAR  tpath[PATH_MAX];
+   MEMORY_BASIC_INFORMATION mbi;
+   char  *path;
+   char  *tmp;
+   size_t length;
+   int    ret = 0;
+
+   if (!info)
+     return 0;
+
+#ifdef _WIN32_WINNT
+   length = VirtualQuery(addr, &mbi, sizeof(mbi));
+   if (!length)
+     return 0;
+
+   if (mbi.State != MEM_COMMIT)
+     return 0;
+
+   if (!mbi.AllocationBase)
+     return 0;
+
+   ret = GetModuleFileName((HMODULE)mbi.AllocationBase, (LPTSTR)&tpath, PATH_MAX);
+   if (!ret)
+     return 0;
+#else
+   ret = GetModuleFileName(NULL, (LPTSTR)&tpath, PATH_MAX);
+   if (!ret)
+     return 0;
+#endif
+
+#ifdef UNICODE
+   path = evil_wchar_to_char(tpath);
+#else
+   path = tpath;
+#endif /* ! UNICODE */
+
+   length = strlen (path);
+   if (length >= PATH_MAX)
+     {
+       length = PATH_MAX - 1;
+       path[PATH_MAX - 1] = '\0';
+     }
+
+   /* replace '/' by '\' */
+   tmp = path;
+   while (*tmp)
+     {
+        if (*tmp == '/') *tmp = '\\';
+        tmp++;
+     }
+
+   memcpy (info->dli_fname, path, length + 1);
+   info->dli_fbase = NULL;
+   info->dli_sname = NULL;
+   info->dli_saddr = NULL;
+
+#ifdef UNICODE
+   free (path);
+#endif /* ! UNICODE */
+
+   return 1;
+}
+
+char *
+dlerror (void)
+{
+   if (!dl_err_viewed)
+     {
+        dl_err_viewed = 1;
+        return dl_err;
+     }
+   else
+     {
+        if (dl_err)
+          free(dl_err);
+        return NULL;
+     }
+}
diff --git a/src/lib/evil/dlfcn.h b/src/lib/evil/dlfcn.h
new file mode 100644
index 0000000000..610331b702
--- /dev/null
+++ b/src/lib/evil/dlfcn.h
@@ -0,0 +1,258 @@
+#ifndef __EVIL_DLFCN_H__
+#define __EVIL_DLFCN_H__
+
+
+#include <limits.h>
+
+
+#ifdef EAPI
+# undef EAPI
+#endif /* EAPI */
+
+#ifdef _WIN32
+# ifdef EFL_EVIL_DLFCN_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EVIL_DLFCN_BUILD */
+#endif /* _WIN32 */
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifdef _WIN32_WCE
+# ifndef PATH_MAX
+#  define PATH_MAX 260
+# endif
+#endif
+
+
+/**
+ * @file dlfcn.h
+ * @brief The file that provides functions to manage dynamic-link libraries
+ * @defgroup Dlfcn Functions that manage dynamic-link libraries.
+ *
+ * This header provides functions to load and unload dynamic-link
+ * libaries, to get the address of a symbol, and to get diagnostic
+ * information.
+ */
+
+
+/**
+ * @def RTLD_LAZY
+ * Lazy function call binding.
+ */
+# define RTLD_LAZY    0x00001  /* lazy function call binding */
+
+/**
+ * @def RTLD_NOW
+ * Immediate function call binding.
+ */
+# define RTLD_NOW     0x00002  /* immediate function call binding */
+
+/**
+ * @def RTLD_GLOBAL
+ * Symbols in this dlopen'ed obj are visible to other dlopen'ed objs.
+ */
+# define RTLD_GLOBAL  0x00100  /* symbols in this dlopen'ed obj are visible
+                                  to other dlopen'ed objs */
+
+/**
+ * @def RTLD_NODELETE
+ * Symbols are not deleted when closed.
+ */
+#define RTLD_NODELETE 0x01000  /* do not delete object when closed.  */
+
+/**
+ * @def RTLD_DEFAULT
+ * Symbols are searched in all the DLL opened by the current process.
+ */
+#define RTLD_DEFAULT ((void*)1) /* search the symbol on all the DLL of the current process */
+
+/**
+ * @typedef Dl_info
+ * @brief A structure that stores infomation of a calling process.
+ */
+typedef struct Dl_info Dl_info;
+
+/**
+ * @struct Dl_info
+ * @brief A structure that stores infomation of a calling process.
+ */
+struct Dl_info
+{
+   char        dli_fname[PATH_MAX];  /**< Filename of defining object */
+   void       *dli_fbase;            /**< Load address of that object */
+   const char *dli_sname;            /**< Name of nearest lower symbol */
+   void       *dli_saddr;            /**< Exact value of nearest symbol */
+};
+
+/**
+ * @brief Map a specified executable module (either a .dll or .exe file)
+ * into the address space of the user process.
+ *
+ * @param path Name of the module.
+ * @param mode Unused.
+ * @return A pointer that represent the module, or @c NULL on failure.
+ *
+ * Map a specified executable module (either a .dll or .exe file)
+ * into the address space of the user process. If @p path is @c NULL,
+ * then the module corresponding to the current process is returned.
+ * Otherwise the module specified by @p path is loaded if it exists.
+ * If not, @c NULL is returned. The directory separators can be forward
+ * slash, or backward ones. Mapping a module can map other modules.
+ * @p mode is unused.
+ *
+ * If an error occurred, an error string can be retrived with dlerror().
+ *
+ * According to the OS, the search order of the module can change,
+ * according to the value of SafeDllSearchMode.
+ *
+ *  - For Windows Vista, Windows Server 2003, and Windows XP SP2:
+ *    SafeDLLSearchMode is enabled by default.
+ *  - For Windows XP and Windows 2000 SP4:  SafeDLLSearchMode is disabled
+ *    by default.
+ *
+ * If SafeDllSearchMode is enabled
+ *  - The directory from which the application loaded.
+ *  - The system directory. Use the GetSystemDirectory() function
+ *    to get the path of this directory.
+ *  - The 16-bit system directory. There is no function that obtains
+ *    the path of this directory, but it is searched.
+ *  - The Windows directory. Use the GetWindowsDirectory() function
+ *    to get the path of this directory.
+ *  - The current directory.
+ *  - The directories that are listed in the PATH environment variable.
+ *    Note that this does not include the per-application path specified
+ *    by the App Paths registry key.
+ *
+ * If SafeDllSearchMode is disabled
+ *  - The directory from which the application loaded.
+ *  - The current directory.
+ *  - The system directory. Use the GetSystemDirectory() function
+ *    to get the path of this directory.
+ *  - The 16-bit system directory. There is no function that obtains
+ *    the path of this directory, but it is searched.
+ *  - The Windows directory. Use the GetWindowsDirectory() function
+ *    to get the path of this directory.
+ *  - The directories that are listed in the PATH environment variable.
+ *    Note that this does not include the per-application path specified
+ *    by the App Paths registry key.
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI void *dlopen(const char* path, int mode);
+
+/**
+ * @brief Close a dynamic-link library.
+ *
+ * @param handle Handle that references a dynamic-link library.
+ * @return O on sucess, -1 otherwise.
+ *
+ * Release a reference to the dynamic-link library referenced
+ * by @p handle.  If the reference count drops to 0, the handle is
+ * removed from the address space and is rendered invalid. @p handle
+ * is the value returned by a previous call to dlopen().
+ *
+ * If no error occurred, the returned value is 0, otherwise the
+ * returned value is -1 and an error string can be retrived with
+ * dlerror().
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI int   dlclose(void* handle);
+
+/**
+ * @brief Get the address of a symbol.
+ *
+ * @param handle Handle that references a dynamic-link library.
+ * @param symbol @c NULL-terminated string.
+ * @return O on sucess, NULL otherwise.
+ *
+ * Return the address of the code or data location specified by the
+ * string @p symbol.  @p handle references a library that contains
+ * the function or variable @p symbol.
+ *
+ * If no error occurred, the returned value is the code or data
+ * location, otherwise the returned value is NULL and an error
+ * string can be retrived with dlerror().
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI void *dlsym(void* handle, const char* symbol);
+
+/**
+ * @brief Get the location of the current process (.exe)
+ *
+ * @param addr Unused.
+ * @param info Pointer to the Dl_info to fill.
+ * @return 1 on success, 0 otherwise.
+ *
+ * Fill the dli_fname member of @p info with the absolute name
+ * of the current calling process (.exe file that is executed).
+ * All other members are set to @c NULL.
+ *
+ * Contrary to the unix function, the full name of the shared
+ * library is not returned, but insted the full name of the current
+ * calling process (.exe file).
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI int dladdr (const void *addr, Dl_info *info);
+
+/**
+ * @brief Get diagnostic information
+ *
+ * @return A @c NULL-terminated string if an error occured, @c NULL
+ * otherwise.
+ *
+ * Return a @c NULL-terminated character string describing the last
+ * error that occurred on this thread during a call to dlopen(),
+ * dlsym(), or dlclose(). If no such error has occurred, dlerror()
+ * returns a null pointer.  At each call to dlerror(), the error
+ * indication is reset.  Thus in the case of two calls to dlerror(),
+ * where the second call follows the first immediately, the second
+ * call will always return a null pointer.
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Dlfcn
+ */
+EAPI char *dlerror (void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __EVIL_DLFCN_H__ */
diff --git a/src/lib/evil/evil_dirent.c b/src/lib/evil/evil_dirent.c
new file mode 100644
index 0000000000..e02b95fe27
--- /dev/null
+++ b/src/lib/evil/evil_dirent.c
@@ -0,0 +1,197 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <dirent.h>
+
+#ifdef HAVE_ERRNO_H
+# include <errno.h>
+#endif
+
+#include "Evil.h"
+
+
+struct DIR
+{
+   struct dirent   dirent;
+   WIN32_FIND_DATA data;
+   HANDLE          handle;
+};
+
+
+DIR *opendir(char const *name)
+{
+   DIR     *dir;
+   char    *tmp1;
+   char    *tmp2;
+   DWORD    attr;
+   size_t   l;
+#ifdef UNICODE
+   wchar_t *wname;
+   char    *d_name;
+#endif
+
+   /* valid name */
+   if (!name || !*name)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOENT;
+#endif
+        return NULL;
+     }
+
+#ifdef UNICODE
+   wname = evil_char_to_wchar(name);
+   if (!wname)
+     {
+# ifdef HAVE_ERRNO_H
+        errno = ENOMEM;
+# endif
+        return NULL;
+     }
+
+   if((attr = GetFileAttributes(wname)) == 0xFFFFFFFF)
+#else
+   if((attr = GetFileAttributes(name)) == 0xFFFFFFFF)
+#endif
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOENT;
+#endif
+        return NULL;
+     }
+
+#ifdef UNICODE
+   free(wname);
+#endif
+
+   /* directory */
+   if (!(attr & FILE_ATTRIBUTE_DIRECTORY))
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOTDIR;
+#endif
+        return NULL;
+     }
+
+   dir = (DIR *)malloc(sizeof(DIR));
+   if (!dir)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOMEM;
+#endif
+        return NULL;
+     }
+
+   l = strlen(name);
+   tmp1 = (char *)malloc(sizeof(char) * l + 5);
+   if (!tmp1)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOMEM;
+#endif
+        return NULL;
+     }
+
+   memcpy(tmp1, name, l);
+   memcpy(tmp1 + l, "\\*.*", 5);
+
+   tmp2 = tmp1;
+   while (*tmp2)
+     {
+        if (*tmp2 == '/') *tmp2 = '\\';
+        tmp2++;
+     }
+
+#ifdef UNICODE
+   wname = evil_char_to_wchar(tmp1);
+   if (!wname)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = ENOMEM;
+#endif
+        free(tmp1);
+
+        return NULL;
+     }
+   dir->handle = FindFirstFile(wname, &dir->data);
+   free(wname);
+#else
+   dir->handle = FindFirstFile(tmp1, &dir->data);
+#endif
+
+   free(tmp1);
+
+   if (dir->handle == INVALID_HANDLE_VALUE)
+     {
+        free(dir);
+        return NULL;
+     }
+
+#ifdef UNICODE
+   d_name = evil_wchar_to_char(dir->data.cFileName);
+   strcpy(dir->dirent.d_name, d_name);
+   free(d_name);
+#else
+   strcpy(dir->dirent.d_name, dir->data.cFileName);
+#endif
+   dir->dirent.d_mode = (int)dir->data.dwFileAttributes;
+
+   if (dir->data.dwFileAttributes == FILE_ATTRIBUTE_DIRECTORY)
+     dir->dirent.d_type = DT_DIR;
+   else
+     dir->dirent.d_type = DT_UNKNOWN;
+
+   return dir;
+}
+
+int closedir(DIR *dir)
+{
+   if (!dir)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = EBADF;
+#endif
+        return -1;
+     }
+
+   if (dir->handle != INVALID_HANDLE_VALUE)
+     FindClose(dir->handle);
+   free(dir);
+
+   return 0;
+}
+
+struct dirent *readdir(DIR *dir)
+{
+#ifdef UNICODE
+   char *d_name;
+#endif
+
+   if (!dir)
+     {
+#ifdef HAVE_ERRNO_H
+        errno = EBADF;
+#endif
+        return NULL;
+     }
+
+   if (dir->handle == INVALID_HANDLE_VALUE)
+     return NULL;
+
+#ifdef UNICODE
+     d_name = evil_wchar_to_char(dir->data.cFileName);
+     strcpy(dir->dirent.d_name, d_name);
+     free(d_name);
+#else
+     strcpy(dir->dirent.d_name, dir->data.cFileName);
+#endif
+
+   if (!FindNextFile(dir->handle, &dir->data))
+     {
+        FindClose(dir->handle);
+        dir->handle = INVALID_HANDLE_VALUE;
+     }
+
+   return &dir->dirent;
+}
diff --git a/src/lib/evil/evil_errno.c b/src/lib/evil/evil_errno.c
new file mode 100644
index 0000000000..37cac611f0
--- /dev/null
+++ b/src/lib/evil/evil_errno.c
@@ -0,0 +1,9 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Evil.h"
+#include "mingw32ce/errno.h"
+
+
+int errno = 0;
diff --git a/src/lib/evil/evil_fcntl.c b/src/lib/evil/evil_fcntl.c
new file mode 100644
index 0000000000..7c62c2a310
--- /dev/null
+++ b/src/lib/evil/evil_fcntl.c
@@ -0,0 +1,124 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdio.h>
+
+#ifdef _MSC_VER
+# include <io.h>   /* for _get_osfhandle _lseek and _locking */
+#endif
+
+#include <sys/locking.h>
+
+#include <winsock2.h> /* for ioctlsocket */
+
+#include "Evil.h"
+
+
+#ifdef __MINGW32CE__
+# define _get_osfhandle(FILEDES) ((HANDLE)FILEDES)
+#endif /* __MINGW32CE__ */
+
+
+/*
+ * port of fcntl function
+ *
+ */
+
+int fcntl(int fd, int cmd, ...)
+{
+   va_list va;
+   HANDLE  h;
+   int     res = -1;
+
+   va_start (va, cmd);
+
+   h = (HANDLE)_get_osfhandle(fd);
+   if (h == INVALID_HANDLE_VALUE)
+     return -1;
+
+   if (cmd == F_GETFD)
+     {
+#ifndef __MINGW32CE__
+        DWORD flag;
+
+        if (!GetHandleInformation(h, &flag))
+          return -1;
+
+        res = 0;
+#endif /* ! __MINGW32CE__ */
+     }
+
+   if (cmd == F_SETFD)
+     {
+        long flag;
+
+        flag = va_arg(va, long);
+        if (flag == FD_CLOEXEC)
+          {
+#ifndef __MINGW32CE__
+             if (SetHandleInformation(h, HANDLE_FLAG_INHERIT, 0))
+               res = 0;
+#endif /* ! __MINGW32CE__ */
+          }
+     }
+   else if (cmd == F_SETFL)
+     {
+        long flag;
+
+        flag = va_arg(va, long);
+        if (flag == O_NONBLOCK)
+          {
+             u_long arg = 1;
+             int    type;
+             int    len;
+             int    ret;
+
+             len = (int)sizeof(int);
+             ret = getsockopt((SOCKET)fd, SOL_SOCKET, SO_TYPE, (char *)&type, &len);
+             if (!ret && (type == SOCK_STREAM))
+               {
+                  if (!ioctlsocket((SOCKET)fd, FIONBIO, &arg) == SOCKET_ERROR)
+                    res = 0;
+               }
+          }
+     }
+#ifndef __MINGW32CE__
+   else if ((cmd == F_SETLK) || (cmd == F_SETLKW))
+     {
+        struct flock *fl;
+        off_t        length = 0;
+        long         pos;
+
+        fl = va_arg(va, struct flock *);
+
+        if (fl->l_len == 0)
+          {
+             length = _lseek(fd, 0L, SEEK_END);
+             if (length != -1L)
+               res = 0;
+          }
+        fl->l_len = length - fl->l_start - 1;
+
+        pos = _lseek(fd, fl->l_start, fl->l_whence);
+        if (pos != -1L)
+          res = 0;
+
+        if ((fl->l_type == F_RDLCK) || (fl->l_type == F_WRLCK))
+          {
+             if (cmd == F_SETLK)
+               res = _locking(fd, _LK_NBLCK, fl->l_len); /* if cannot be locked, we return immediatly */
+             else /* F_SETLKW */
+               res = _locking(fd, _LK_LOCK, fl->l_len); /* otherwise, we try several times */
+          }
+
+        if (fl->l_type == F_UNLCK)
+          res = _locking(fd, _LK_UNLCK, fl->l_len);
+     }
+
+#endif /* ! __MINGW32CE__ */
+
+   va_end(va);
+
+   return res;
+}
diff --git a/src/lib/evil/evil_fcntl.h b/src/lib/evil/evil_fcntl.h
new file mode 100644
index 0000000000..194341b369
--- /dev/null
+++ b/src/lib/evil/evil_fcntl.h
@@ -0,0 +1,110 @@
+#ifndef __EVIL_FCNTL_H__
+#define __EVIL_FCNTL_H__
+
+
+# include <sys/types.h>
+
+
+/**
+ * @def FD_CLOEXEC
+ * Specifies that the file descriptor should be closed when an exec()
+ * function is invoked.
+ */
+# define FD_CLOEXEC 1
+
+/**
+ * @def O_NONBLOCK
+ * Specifies that the socket is in non-blocking mode.
+ */
+# define O_NONBLOCK 04000
+
+/**
+ * @def F_SETFD
+ * Specifies that fcntl() should set the file descriptor flags
+ * associated with the filedes argument.
+ */
+
+/**
+ * @def F_SETLK
+ * Specifies that fcntl() should set or clear a file segment lock
+ * according to the lock description pointed to by the third argument.
+ */
+
+/**
+ * @def F_SETLKW
+ * Equivalent to F_SETLK except that if a shared or exclusive lock
+ * is blocked by other locks, the thread shall wait until the request
+ * can be satisfied.
+ */
+
+# define F_GETFD    1
+# define F_SETFD    2
+# define F_SETFL    4
+# define F_SETLK    6
+# define F_SETLKW   7
+
+/**
+ * @def F_RDLCK
+ * Read (or shared) lock
+ */
+
+/**
+ * @def F_WRLCK
+ * Write (or exclusive) lock
+ */
+
+/**
+ * @def F_UNLCK
+ * Remove lock
+ */
+
+# ifndef F_RDLCK
+#  define F_RDLCK     0
+#  define F_WRLCK     1
+#  define F_UNLCK     2
+# endif /* ! F_RDLCK */
+
+/**
+ * @struct flock
+ * @brief A structure that controls the lock of a file descriptor.
+ */
+struct flock
+{
+   short int l_type;   /**< lock type: read, write, ... */
+   short int l_whence; /**< type of l_start */
+   off_t     l_start;  /**< starting offset */
+   off_t     l_len;    /**< 0 means end of the file */
+   pid_t     l_pid;    /**< lock owner */
+};
+
+
+/**
+ * @brief Provide control over file descriptors.
+ *
+ * @param fd The file descriptor.
+ * @param cmd The type of control.
+ * @return 0 on success, -1 otherwise.
+ *
+ * Performs one of various miscellaneous operations on @p fd.
+ * The operation in question is determined by @p cmd:
+ *
+ * - F_SETFD: Set the close-on-exec flag to the value specified
+ *   by the argument after command (only the least significant
+ *   bit is used).
+ * - F_SETLK and F_SETLKW: used to manage discretionary file locks.
+ *   The third argument must be a pointer to a struct flock (that
+ *   may be overwritten by this call).
+ *
+ * This function returns 0 on success, -1 otherwise.
+ *
+ * Conformity: None.
+ *
+ * Supported OS: Windows Vista, Windows XP or Windows 2000
+ * Professional.
+ *
+ * @ingroup Evil
+ */
+EAPI int fcntl(int fd, int cmd, ...);
+
+
+#endif /* __EVIL_FCNTL_H__ */
diff --git a/src/lib/evil/evil_fnmatch.c b/src/lib/evil/evil_fnmatch.c
new file mode 100644
index 0000000000..0b4af7bfb0
--- /dev/null
+++ b/src/lib/evil/evil_fnmatch.c
@@ -0,0 +1,231 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <assert.h>
+#include <string.h>
+
+#include "fnmatch.h"
+#include "evil_fnmatch_private.h"
+
+enum fnmatch_status
+{
+  fnmatch_not_found    = 0,
+  fnmatch_found        = 1,
+  fnmatch_syntax_error = 2
+};
+
+static
+size_t
+fnmatch_match_class_token(enum fnmatch_status *status,
+                          const char          *class_token,
+                          char                 c)
+{
+  if (! *class_token)
+    {
+      *status = fnmatch_syntax_error;
+      return 0;
+    }
+  else if (class_token[1] == '-' && class_token[2] != ']')
+    {
+      if (class_token[0] <= c && c <= class_token[2])
+        *status = fnmatch_found;
+      return 3;
+    }
+  else
+    {
+      if (c == *class_token)
+        *status = fnmatch_found;
+      return 1;
+    }
+}
+
+static
+size_t
+fnmatch_complement_class(const char *class_token)
+{
+  switch (*class_token)
+    {
+    case 0:
+      return FNM_SYNTAXERR;
+
+    case '!':
+      return 1;
+
+    default:
+      return 0;
+    }
+}
+
+static
+size_t
+fnmatch_match_class(const char *class,
+                    char        c)
+{
+  const size_t        complement = fnmatch_complement_class(class + 1);
+  enum fnmatch_status status;
+  size_t              pos;
+
+  if (complement == FNM_SYNTAXERR)
+    return FNM_SYNTAXERR;
+
+  status = fnmatch_not_found;
+  pos = 1 + complement;
+
+  do
+    pos += fnmatch_match_class_token(&status, class + pos, c);
+  while (class[pos] && class[pos] != ']');
+
+  if (status == fnmatch_syntax_error || ! class[pos])
+    return FNM_SYNTAXERR;
+
+  if (status == fnmatch_found)
+    return complement ? 0 : pos + 1;
+  else
+    return complement ? pos + 1 : 0;
+}
+
+static
+size_t
+fnmatch_chrcasecmp(char a,
+                   char b)
+{
+  if ('A' <= a && a <= 'Z')
+    a += 'a' - 'A';
+  if ('A' <= b && b <= 'Z')
+    b += 'a' - 'A';
+  return a == b;
+}
+
+static
+size_t
+fnmatch_match_token(const char *token,
+                    char        c,
+                    e_bool      leading,
+                    int         flags)
+{
+  if (*token == '\\' && !(flags & FNM_NOESCAPE))
+    return token[1] ? (token[1] == c ? 2 : 0) : FNM_SYNTAXERR;
+
+  if (c == '/' && (flags & FNM_PATHNAME))
+    return *token == '/';
+
+  if (c == '.' && leading && (flags & FNM_PERIOD))
+    return *token == '.';
+
+  switch (*token)
+    {
+    case '?':
+      return 1;
+
+    case '[':
+      return fnmatch_match_class(token, c);
+
+    default:
+      if (flags & FNM_CASEFOLD)
+        return fnmatch_chrcasecmp(*token, c);
+      return *token == c ? 1 : 0;
+    }
+}
+
+static
+void
+fnmatch_init_states(struct list_of_states *states)
+{
+  states->size = 1;
+  states->states[0] = 0;
+  memset(states->has, 0, states->reserved * sizeof (*states->has));
+  states->has[0] = 1;
+}
+
+static
+size_t
+fnmatch_check_finals(const char                  *pattern,
+                     const struct list_of_states *states)
+{
+   size_t i, j;
+   for (i = 0; i < states->size; ++i)
+     {
+       e_bool match = 1;
+
+       for (j = states->states[i]; pattern[j]; ++j)
+         if (pattern[j] != '*')
+           {
+             match = 0;
+             break;
+           }
+
+       if (match)
+         return 0;
+     }
+   return FNM_NOMATCH;
+}
+
+int
+fnmatch(const char *pattern,
+        const char *string,
+        int         flags)
+{
+   struct list_of_states *states;
+   struct list_of_states *new_states;
+   e_bool                 leading = 1;
+   char                  *c;
+   size_t                 r;
+
+  assert(pattern);
+  assert(string);
+
+  states = fnmatch_list_of_states_alloc(2, strlen(pattern));
+  new_states = states + 1;
+
+  if (! states)
+    return FNM_NOMEM;
+  fnmatch_init_states(states);
+
+
+  for (c = (char *)string; *c && states->size; ++c)
+    {
+       size_t i;
+      fnmatch_list_of_states_clear(new_states);
+
+      for (i = 0; i < states->size; ++i)
+        {
+          const size_t pos = states->states[i];
+
+          if (! pattern[pos])
+            {
+              if (*c == '/' && (flags & FNM_LEADING_DIR))
+                return 0;
+              continue;
+            }
+          else if (pattern[pos] == '*')
+            {
+              fnmatch_list_of_states_insert(states, pos + 1);
+              if ((*c != '/' || !(flags & FNM_PATHNAME)) &&
+                  (*c != '.' || !leading || !(flags & FNM_PERIOD)))
+                fnmatch_list_of_states_insert(new_states, pos);
+            }
+          else
+            {
+              const size_t m = fnmatch_match_token(pattern + pos, *c,
+                                                leading, flags);
+
+              if (m == FNM_SYNTAXERR)
+                return FNM_SYNTAXERR;
+              else if (m)
+                fnmatch_list_of_states_insert(new_states, pos + m);
+            }
+        }
+      {
+        struct list_of_states *tmp = states;
+
+        states = new_states;
+        new_states = tmp;
+      }
+      leading = *c == '/' && (flags & FNM_PATHNAME);
+    }
+
+  r = fnmatch_check_finals(pattern, states);
+  fnmatch_list_of_states_free(states < new_states ? states : new_states, 2);
+  return (int)r;
+}
diff --git a/src/lib/evil/evil_fnmatch_list_of_states.c b/src/lib/evil/evil_fnmatch_list_of_states.c
new file mode 100644
index 0000000000..c6cfb7fe81
--- /dev/null
+++ b/src/lib/evil/evil_fnmatch_list_of_states.c
@@ -0,0 +1,77 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <assert.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "evil_fnmatch_private.h"
+
+struct list_of_states*
+fnmatch_list_of_states_alloc(size_t n,
+                             size_t pattern_len)
+{
+  struct list_of_states *l;
+
+  const size_t  reserved        = pattern_len + 1;
+  const size_t  states_size     = sizeof (*l->states) * reserved;
+  const size_t  has_size        = sizeof (*l->has) * reserved;
+  const size_t  states_has_size = states_size + has_size;
+  const size_t  struct_size     = sizeof (*l) + states_has_size;
+
+  unsigned char *states;
+  unsigned char *has;
+  size_t         i;
+
+  l = malloc(n * struct_size);
+  if (!l)
+    return 0;
+
+  states = (unsigned char *) (l + n);
+  has = states + states_size;
+
+  for (i = 0; i < n; ++i)
+    {
+      l[i].reserved = reserved;
+      l[i].states = (size_t *) states;
+      l[i].has = (e_bool *) has;
+      states += states_has_size;
+      has += states_has_size;
+    }
+
+  return l;
+}
+
+void
+fnmatch_list_of_states_free(struct list_of_states *lists,
+                            size_t                 n)
+{
+  assert(lists);
+
+  (void) n;
+  free(lists);
+}
+
+void
+fnmatch_list_of_states_insert(struct list_of_states *list,
+                              size_t                 state)
+{
+  assert(list);
+  assert(state < list->reserved);
+
+  if (list->has[state])
+    return;
+
+  list->states[list->size++] = state;
+  list->has[state] = 1;
+}
+
+void
+fnmatch_list_of_states_clear(struct list_of_states *list)
+{
+  assert(list);
+
+  list->size = 0;
+  memset(list->has, 0, list->reserved * sizeof (*list->has));
+}
diff --git a/src/lib/evil/evil_fnmatch_private.h b/src/lib/evil/evil_fnmatch_private.h
new file mode 100644
index 0000000000..f5ced5d68f
--- /dev/null
+++ b/src/lib/evil/evil_fnmatch_private.h
@@ -0,0 +1,24 @@
+#ifndef __EVIL_FNMATCH_PRIVATE_H__
+#define __EVIL_FNMATCH_PRIVATE_H__
+
+
+typedef int e_bool;
+
+struct list_of_states
+{
+  size_t        reserved;
+  size_t        size;
+  size_t        *states;
+  e_bool                *has;
+};
+
+struct list_of_states *fnmatch_list_of_states_alloc(size_t n, size_t pattern_len);
+
+void fnmatch_list_of_states_free(struct list_of_states *lists, size_t n);
+
+void fnmatch_list_of_states_insert(struct list_of_states *list, size_t state);
+
+void fnmatch_list_of_states_clear(struct list_of_states *list);
+
+
+#endif /* __EVIL_FNMATCH_PRIVATE_H__ */
diff --git a/src/lib/evil/evil_inet.c b/src/lib/evil/evil_inet.c
new file mode 100644
index 0000000000..99ce14edc2
--- /dev/null
+++ b/src/lib/evil/evil_inet.c
@@ -0,0 +1,648 @@
+
+/*
+ * Copyright (c) 2004 by Internet Systems Consortium, Inc. ("ISC")
+ * Copyright (c) 1996,1999 by Internet Software Consortium.
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
+ * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+/*
+ * Modifications: Vincent Torri, for the integration in Evil
+ * - modification of the name of some functions
+ * * modification of the management of the error
+ */
+
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdio.h>
+#include <ctype.h>
+
+#ifdef HAVE_ERRNO_H
+# include <errno.h>
+#endif /* HAVE_ERRNO_H */
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <winsock2.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include "evil_macro.h"
+#include "evil_inet.h"
+#include "evil_private.h"
+#define APICHAR char
+#include "evil_print.h"
+
+#ifndef EMSGSIZE
+# define EMSGSIZE WSAEMSGSIZE
+#endif
+
+#ifndef EAFNOSUPPORT
+# define EAFNOSUPPORT WSAEAFNOSUPPORT
+#endif
+
+#define SPRINTF(x) ((size_t)sprintf x)
+
+#define ERRNO         ((int)GetLastError())
+#define SET_ERRNO(x)  (SetLastError((DWORD)(x)))
+
+#define ISDIGIT(x)  (isdigit((int)  ((unsigned char)x)))
+#define ISXDIGIT(x) (isxdigit((int) ((unsigned char)x)))
+#define ISUPPER(x)  (isupper((int)  ((unsigned char)x)))
+
+#define NS_IN6ADDRSZ 16
+#define NS_INT16SZ 2
+#define NS_INADDRSZ sizeof(IN_ADDR)
+
+
+struct ares_in6_addr {
+  union {
+    unsigned char _S6_u8[16];
+  } _S6_un;
+};
+
+const struct ares_in6_addr ares_in6addr_any = { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } };
+
+
+/*
+ * static int
+ * inet_net_pton_ipv4(src, dst, size)
+ *      convert IPv4 network number from presentation to network format.
+ *      accepts hex octets, hex strings, decimal octets, and /CIDR.
+ *      "size" is in bytes and describes "dst".
+ * return:
+ *      number of bits, either imputed classfully or specified with /CIDR,
+ *      or -1 if some failure occurred (check errno).  ENOENT means it was
+ *      not an IPv4 network specification.
+ * note:
+ *      network byte order assumed.  this means 192.5.5.240/28 has
+ *      0b11110000 in its fourth octet.
+ * note:
+ *      On Windows we store the error in the thread errno, not
+ *      in the winsock error code. This is to avoid loosing the
+ *      actual last winsock error. So use macro ERRNO to fetch the
+ *      errno this funtion sets when returning (-1), not SOCKERRNO.
+ * author:
+ *      Paul Vixie (ISC), June 1996
+ */
+static int
+inet_net_pton_ipv4(const char *src, unsigned char *dst, size_t size)
+{
+  static const char xdigits[] = "0123456789abcdef";
+  static const char digits[] = "0123456789";
+  int n, ch, tmp = 0, dirty, bits;
+  const unsigned char *odst = dst;
+
+  ch = *src++;
+  if (ch == '0' && (src[0] == 'x' || src[0] == 'X')
+      && ISXDIGIT(src[1])) {
+    /* Hexadecimal: Eat nybble string. */
+    if (!size)
+      goto emsgsize;
+    dirty = 0;
+    src++;  /* skip x or X. */
+    while ((ch = *src++) != '\0' && ISXDIGIT(ch)) {
+      if (ISUPPER(ch))
+        ch = tolower(ch);
+      n = (int)(strchr(xdigits, ch) - xdigits);
+      if (dirty == 0)
+        tmp = n;
+      else
+        tmp = (tmp << 4) | n;
+      if (++dirty == 2) {
+        if (!size--)
+          goto emsgsize;
+        *dst++ = (unsigned char) tmp;
+        dirty = 0;
+      }
+    }
+    if (dirty) {  /* Odd trailing nybble? */
+      if (!size--)
+        goto emsgsize;
+      *dst++ = (unsigned char) (tmp << 4);
+    }
+  } else if (ISDIGIT(ch)) {
+    /* Decimal: eat dotted digit string. */
+    for (;;) {
+      tmp = 0;
+      do {
+        n = (int)(strchr(digits, ch) - digits);
+        tmp *= 10;
+        tmp += n;
+        if (tmp > 255)
+          goto enoent;
+      } while ((ch = *src++) != '\0' &&
+               ISDIGIT(ch));
+      if (!size--)
+        goto emsgsize;
+      *dst++ = (unsigned char) tmp;
+      if (ch == '\0' || ch == '/')
+        break;
+      if (ch != '.')
+        goto enoent;
+      ch = *src++;
+      if (!ISDIGIT(ch))
+        goto enoent;
+    }
+  } else
+    goto enoent;
+
+  bits = -1;
+  if (ch == '/' &&
+      ISDIGIT(src[0]) && dst > odst) {
+    /* CIDR width specifier.  Nothing can follow it. */
+    ch = *src++;    /* Skip over the /. */
+    bits = 0;
+    do {
+      n = (int)(strchr(digits, ch) - digits);
+      bits *= 10;
+      bits += n;
+    } while ((ch = *src++) != '\0' && ISDIGIT(ch));
+    if (ch != '\0')
+      goto enoent;
+    if (bits > 32)
+      goto emsgsize;
+  }
+
+  /* Firey death and destruction unless we prefetched EOS. */
+  if (ch != '\0')
+    goto enoent;
+
+  /* If nothing was written to the destination, we found no address. */
+  if (dst == odst)
+    goto enoent;
+  /* If no CIDR spec was given, infer width from net class. */
+  if (bits == -1) {
+    if (*odst >= 240)       /* Class E */
+      bits = 32;
+    else if (*odst >= 224)  /* Class D */
+      bits = 8;
+    else if (*odst >= 192)  /* Class C */
+      bits = 24;
+    else if (*odst >= 128)  /* Class B */
+      bits = 16;
+    else                    /* Class A */
+      bits = 8;
+    /* If imputed mask is narrower than specified octets, widen. */
+    if (bits < ((dst - odst) * 8))
+      bits = (int)(dst - odst) * 8;
+    /*
+     * If there are no additional bits specified for a class D
+     * address adjust bits to 4.
+     */
+    if (bits == 8 && *odst == 224)
+      bits = 4;
+  }
+  /* Extend network to cover the actual mask. */
+  while (bits > ((dst - odst) * 8)) {
+    if (!size--)
+      goto emsgsize;
+    *dst++ = '\0';
+  }
+  return (bits);
+
+  enoent:
+  SET_ERRNO(ENOENT);
+  return (-1);
+
+  emsgsize:
+  SET_ERRNO(EMSGSIZE);
+  return (-1);
+}
+
+static int
+getbits(const char *src, int *bitsp)
+{
+  static const char digits[] = "0123456789";
+  int n;
+  int val;
+  char ch;
+
+  val = 0;
+  n = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    pch = strchr(digits, ch);
+    if (pch != NULL) {
+      if (n++ != 0 && val == 0)       /* no leading zeros */
+        return (0);
+      val *= 10;
+      val += (pch - digits);
+      if (val > 128)                  /* range */
+        return (0);
+      continue;
+    }
+    return (0);
+  }
+  if (n == 0)
+    return (0);
+  *bitsp = val;
+  return (1);
+}
+
+static int
+getv4(const char *src, unsigned char *dst, int *bitsp)
+{
+  static const char digits[] = "0123456789";
+  unsigned char *odst = dst;
+  int n;
+  unsigned int val;
+  char ch;
+
+  val = 0;
+  n = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    pch = strchr(digits, ch);
+    if (pch != NULL) {
+      if (n++ != 0 && val == 0)       /* no leading zeros */
+        return (0);
+      val *= 10;
+      val += (pch - digits);
+      if (val > 255)                  /* range */
+        return (0);
+      continue;
+    }
+    if (ch == '.' || ch == '/') {
+      if (dst - odst > 3)             /* too many octets? */
+        return (0);
+      *dst++ = (unsigned char)val;
+      if (ch == '/')
+        return (getbits(src, bitsp));
+      val = 0;
+      n = 0;
+      continue;
+    }
+    return (0);
+  }
+  if (n == 0)
+    return (0);
+  if (dst - odst > 3)             /* too many octets? */
+    return (0);
+  *dst++ = (unsigned char)val;
+  return (1);
+}
+
+static int
+inet_net_pton_ipv6(const char *src, unsigned char *dst, size_t size)
+{
+  static const char xdigits_l[] = "0123456789abcdef",
+    xdigits_u[] = "0123456789ABCDEF";
+  unsigned char tmp[NS_IN6ADDRSZ], *tp, *endp, *colonp;
+  const char *xdigits, *curtok;
+  int ch, saw_xdigit;
+  unsigned int val;
+  int digits;
+  int bits;
+  size_t bytes;
+  int words;
+  int ipv4;
+
+  memset((tp = tmp), '\0', NS_IN6ADDRSZ);
+  endp = tp + NS_IN6ADDRSZ;
+  colonp = NULL;
+  /* Leading :: requires some special handling. */
+  if (*src == ':')
+    if (*++src != ':')
+      goto enoent;
+  curtok = src;
+  saw_xdigit = 0;
+  val = 0;
+  digits = 0;
+  bits = -1;
+  ipv4 = 0;
+  while ((ch = *src++) != '\0') {
+    const char *pch;
+
+    if ((pch = strchr((xdigits = xdigits_l), ch)) == NULL)
+      pch = strchr((xdigits = xdigits_u), ch);
+    if (pch != NULL) {
+      val <<= 4;
+      val |= (pch - xdigits);
+      if (++digits > 4)
+        goto enoent;
+      saw_xdigit = 1;
+      continue;
+    }
+    if (ch == ':') {
+      curtok = src;
+      if (!saw_xdigit) {
+        if (colonp)
+          goto enoent;
+        colonp = tp;
+        continue;
+      } else if (*src == '\0')
+        goto enoent;
+      if (tp + NS_INT16SZ > endp)
+        return (0);
+      *tp++ = (unsigned char)((val >> 8) & 0xff);
+      *tp++ = (unsigned char)(val & 0xff);
+      saw_xdigit = 0;
+      digits = 0;
+      val = 0;
+      continue;
+    }
+    if (ch == '.' && ((tp + NS_INADDRSZ) <= endp) &&
+        getv4(curtok, tp, &bits) > 0) {
+      tp += NS_INADDRSZ;
+      saw_xdigit = 0;
+      ipv4 = 1;
+      break;  /* '\0' was seen by inet_pton4(). */
+    }
+    if (ch == '/' && getbits(src, &bits) > 0)
+      break;
+    goto enoent;
+  }
+  if (saw_xdigit) {
+    if (tp + NS_INT16SZ > endp)
+      goto enoent;
+    *tp++ = (unsigned char)((val >> 8) & 0xff);
+    *tp++ = (unsigned char)(val & 0xff);
+  }
+  if (bits == -1)
+    bits = 128;
+
+  words = (bits + 15) / 16;
+  if (words < 2)
+    words = 2;
+  if (ipv4)
+    words = 8;
+  endp =  tmp + 2 * words;
+
+  if (colonp != NULL) {
+    /*
+     * Since some memmove()'s erroneously fail to handle
+     * overlapping regions, we'll do the shift by hand.
+     */
+    const ssize_t n = tp - colonp;
+    ssize_t i;
+
+    if (tp == endp)
+      goto enoent;
+    for (i = 1; i <= n; i++) {
+      *(endp - i) = *(colonp + n - i);
+      *(colonp + n - i) = 0;
+    }
+    tp = endp;
+  }
+  if (tp != endp)
+    goto enoent;
+
+  bytes = (bits + 7) / 8;
+  if (bytes > size)
+    goto emsgsize;
+  memcpy(dst, tmp, bytes);
+  return (bits);
+
+  enoent:
+  SET_ERRNO(ENOENT);
+  return (-1);
+
+  emsgsize:
+  SET_ERRNO(EMSGSIZE);
+  return (-1);
+}
+
+/*
+ * int
+ * inet_net_pton(af, src, dst, size)
+ *      convert network number from presentation to network format.
+ *      accepts hex octets, hex strings, decimal octets, and /CIDR.
+ *      "size" is in bytes and describes "dst".
+ * return:
+ *      number of bits, either imputed classfully or specified with /CIDR,
+ *      or -1 if some failure occurred (check errno).  ENOENT means it was
+ *      not a valid network specification.
+ * note:
+ *      On Windows we store the error in the thread errno, not
+ *      in the winsock error code. This is to avoid loosing the
+ *      actual last winsock error. So use macro ERRNO to fetch the
+ *      errno this funtion sets when returning (-1), not SOCKERRNO.
+ * author:
+ *      Paul Vixie (ISC), June 1996
+ */
+static int
+ares_inet_net_pton(int af, const char *src, void *dst, size_t size)
+{
+  switch (af) {
+  case AF_INET:
+    return (inet_net_pton_ipv4(src, dst, size));
+  case AF_INET6:
+    return (inet_net_pton_ipv6(src, dst, size));
+  default:
+    SET_ERRNO(EAFNOSUPPORT);
+    return (-1);
+  }
+}
+
+int
+evil_inet_pton(int af, const char *src, void *dst)
+{
+  int result;
+  size_t size;
+
+  if (af == AF_INET)
+    size = sizeof(struct in_addr);
+  else if (af == AF_INET6)
+    size = sizeof(struct ares_in6_addr);
+  else
+  {
+    SET_ERRNO(EAFNOSUPPORT);
+    return -1;
+  }
+  result = ares_inet_net_pton(af, src, dst, size);
+  if ((result == -1) && (ERRNO == ENOENT))
+    return 0;
+  return (result > -1 ? 1 : -1);
+}
+
+
+/* const char *
+ * inet_ntop4(src, dst, size)
+ *     format an IPv4 address, more or less like inet_ntoa()
+ * return:
+ *     `dst' (as a const)
+ * notes:
+ *     (1) uses no statics
+ *     (2) takes a unsigned char* not an in_addr as input
+ * author:
+ *     Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop4(const unsigned char *src, char *dst, size_t size)
+{
+  static const char fmt[] = "%u.%u.%u.%u";
+  char tmp[sizeof "255.255.255.255"];
+
+  if (SPRINTF((tmp, fmt, src[0], src[1], src[2], src[3])) > size)
+    {
+      SET_ERRNO(ENOSPC);
+      return (NULL);
+    }
+    strcpy(dst, tmp);
+    return (dst);
+}
+
+/* const char *
+ * inet_ntop6(src, dst, size)
+ *    convert IPv6 binary address into presentation (printable) format
+ * author:
+ *    Paul Vixie, 1996.
+ */
+static const char *
+inet_ntop6(const unsigned char *src, char *dst, size_t size)
+{
+  /*
+   * Note that int32_t and int16_t need only be "at least" large enough
+   * to contain a value of the specified size.  On some systems, like
+   * Crays, there is no such thing as an integer variable with 16 bits.
+   * Keep this in mind if you think this function should have been coded
+   * to use pointer overlays.  All the world's not a VAX.
+   */
+  char tmp[sizeof("ffff:ffff:ffff:ffff:ffff:ffff:255.255.255.255")];
+  char *tp;
+  struct {
+    long base;
+    long len;
+  } best, cur;
+  unsigned long words[NS_IN6ADDRSZ / NS_INT16SZ];
+  int i;
+
+  /*
+   * Preprocess:
+   *  Copy the input (bytewise) array into a wordwise array.
+   *  Find the longest run of 0x00's in src[] for :: shorthanding.
+   */
+  memset(words, '\0', sizeof(words));
+  for (i = 0; i < NS_IN6ADDRSZ; i++)
+      words[i / 2] |= (src[i] << ((1 - (i % 2)) << 3));
+
+  best.base = -1;
+  cur.base = -1;
+  best.len = 0;
+  cur.len = 0;
+
+  for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++)
+    {
+      if (words[i] == 0)
+        {
+          if (cur.base == -1)
+            cur.base = i, cur.len = 1;
+          else
+            cur.len++;
+        }
+      else
+        {
+          if (cur.base != -1)
+            {
+              if (best.base == -1 || cur.len > best.len)
+                best = cur;
+              cur.base = -1;
+            }
+        }
+    }
+  if (cur.base != -1)
+    {
+      if (best.base == -1 || cur.len > best.len)
+        best = cur;
+    }
+  if (best.base != -1 && best.len < 2)
+    best.base = -1;
+
+  /*
+   * Format the result.
+   */
+  tp = tmp;
+  for (i = 0; i < (NS_IN6ADDRSZ / NS_INT16SZ); i++)
+    {
+      /* Are we inside the best run of 0x00's? */
+      if (best.base != -1 && i >= best.base &&
+          i < (best.base + best.len))
+        {
+          if (i == best.base)
+             *tp++ = ':';
+          continue;
+        }
+      /* Are we following an initial run of 0x00s or any real hex? */
+      if (i != 0)
+        *tp++ = ':';
+      /* Is this address an encapsulated IPv4? */
+      if (i == 6 && best.base == 0 &&
+          (best.len == 6 || (best.len == 5 && words[5] == 0xffff)))
+        {
+          if (!inet_ntop4(src+12, tp, sizeof(tmp) - (tp - tmp)))
+            return (NULL);
+          tp += strlen(tp);
+          break;
+        }
+        tp += SPRINTF((tp, "%lx", words[i]));
+    }
+
+  /* Was it a trailing run of 0x00's? */
+  if (best.base != -1 && (best.base + best.len) == (NS_IN6ADDRSZ / NS_INT16SZ))
+    *tp++ = ':';
+  *tp++ = '\0';
+
+  /*
+   * Check for overflow, copy, and we're done.
+   */
+  if ((size_t)(tp - tmp) > size)
+    {
+      SET_ERRNO(ENOSPC);
+      return (NULL);
+    }
+  strcpy(dst, tmp);
+  return (dst);
+}
+
+/* char *
+ * inet_ntop(af, src, dst, size)
+ *     convert a network format address to presentation format.
+ * return:
+ *     pointer to presentation format address (`dst'), or NULL (see errno).
+ * note:
+ *      On Windows we store the error in the thread errno, not
+ *      in the winsock error code. This is to avoid loosing the
+ *      actual last winsock error. So use macro ERRNO to fetch the
+ *      errno this funtion sets when returning NULL, not SOCKERRNO.
+ * author:
+ *     Paul Vixie, 1996.
+ */
+static const char *
+ares_inet_ntop(int af, const void *src, char *dst, size_t size)
+{
+  switch (af)
+    {
+    case AF_INET:
+      return (inet_ntop4(src, dst, size));
+    case AF_INET6:
+      return (inet_ntop6(src, dst, size));
+    default:
+      SET_ERRNO(EAFNOSUPPORT);
+      return (NULL);
+    }
+  /* NOTREACHED */
+}
+
+const char *evil_inet_ntop(int af, const char *src, void *dst, size_t size)
+{
+  const char *result;
+  result = ares_inet_ntop(af, src, dst, size);
+  if ((result == NULL) && (ERRNO == ENOSPC))
+    return NULL;
+  return result;
+}
diff --git a/src/lib/evil/evil_inet.h b/src/lib/evil/evil_inet.h
new file mode 100644
index 0000000000..b81b8ff715
--- /dev/null
+++ b/src/lib/evil/evil_inet.h
@@ -0,0 +1,149 @@
+
+/* Copyright (C) 2005 by Daniel Stenberg
+ *
+ * Permission to use, copy, modify, and distribute this
+ * software and its documentation for any purpose and without
+ * fee is hereby granted, provided that the above copyright
+ * notice appear in all copies and that both that copyright
+ * notice and this permission notice appear in supporting
+ * documentation, and that the name of M.I.T. not be used in
+ * advertising or publicity pertaining to distribution of the
+ * software without specific, written prior permission.
+ * M.I.T. makes no representations about the suitability of
+ * this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ */
+
+#ifndef __EVIL_INET_H__
+#define __EVIL_INET_H__
+
+
+/**
+ * @file evil_inet.h
+ * @brief The file that provides functions ported from Unix in arpa/inet.h.
+ * @defgroup Evil_Inet_Group Inet.h functions
+ *
+ * This header provides functions ported from Unix in arpa/inet.h.
+ *
+ * @{
+ */
+
+/**
+ * @brief Convert IPv4 and IPv6 addresses from text to binary form.
+ *
+ * @param af The address family.
+ * @param src The address to convert.
+ * @param dst The converted address structure.
+ * @return 1 on success, 0 or -1 otherwise.
+ *
+ * This function converts IPv4 and IPv6 addresses from @p src to the
+ * binary form @p dst. The following address families to pass to @p af
+ * are currently supported:
+ *
+ * <ul>
+ * <li>i AF_INET: @p src points to a character string containing an IPv4
+ * network address in dotted-decimal format, "ddd.ddd.ddd.ddd", where
+ * ddd is a decimal number of up to three digits in the range 0 to
+ * 255. The address is converted to a struct in_addr and copied to
+ * dst, which must be sizeof(struct in_addr) (4) bytes (32 bits) long.
+ * <li> AF_INET6: @p     src points to a character string containing an
+ * IPv6 network address. The address is converted to a struct in6_addr
+ * and copied to dst, which must be sizeof(struct in6_addr) (16) bytes
+ * (128 bits) long. The allowed formats for IPv6 addresses follow
+ * these rules:
+ * <ol>
+ * <li>The preferred format is x:x:x:x:x:x:x:x. This form consists of
+ * eight hexadecimal numbers, each of which expresses a 16-bit value
+ * (i.e., each x can be up to 4 hex digits).
+ * <li>A series of contiguous zero values in the preferred format can
+ * be abbreviated to ::. Only one instance of :: can occur in an
+ * address. For example, the loopback address 0:0:0:0:0:0:0:1 can be
+ * abbreviated as ::1. The wildcard address, consisting of all zeros,
+ * can be written as ::.
+ * <li>An alternate format is useful for expressing IPv4-mapped IPv6
+ * addresses. This form is written as x:x:x:x:x:x:d.d.d.d, where the
+ * six leading xs are hexadecimal values that define the six
+ * most-significant 16-bit pieces of the address (i.e., 96 bits), and
+ * the ds express a value in dotted-decimal notation that defines the
+ * least significant 32 bits of the address. An example of such an
+ * address is :: FFFF:204.152.189.116.
+ * </ul>
+ * </ul>
+ * On success this function returns 1 (network address was successfully
+ * converted). 0 is returned if @p src does not contain a character
+ * string representing a valid network address in the specified
+ * address family. If af does not contain a valid address family, -1
+ * is returned and errno is set to EAFNOSUPPORT.
+ *
+ * @see evil_inet_ntop()
+ * @see inet_ntop()
+ *
+ * Conformity: POSIX.1-2001.
+ *
+ * Supported OS: Windows XP, CE.
+ *
+ */
+EAPI int evil_inet_pton(int af, const char *src, void *dst);
+
+/**
+ * @def inet_pton(x,y,z)
+ *
+ * Wrapper around evil_inet_pton().
+ */
+#define inet_pton(x,y,z) evil_inet_pton(x,y,z)
+
+/**
+ * @brief Convert IPv4 and IPv6 addresses from binary to text form.
+ *
+ * @param af The address family.
+ * @param src The address structure to convert.
+ * @param dst A buffer containing the converted string.
+ * @param size The size of the buffer.
+ * @return 1 on success, 0 otherwise.
+ *
+ * This function converts the network address structure @p src in the
+ * @p af address family into a character string. The resulting string
+ * is copied to the buffer pointed to by @p dst, which must be a
+ * non-NULL pointer. The caller specifies the number of bytes
+ * available in this buffer in the argument @p size. The following
+ * address families to pass to @p af are currently supported:
+ *
+ * @li AF_INET: @p src points to a struct in_addr (in network byte
+ * order) which is converted to an IPv4 network address in the
+ * dotted-decimal format, "ddd.ddd.ddd.ddd". The buffer @p dst must be
+ * at least INET_ADDRSTRLEN bytes long.
+ * @li AF_INET6: @p src points to a struct in6_addr (in network byte
+ * order) which is converted to a representation of this address in
+ * the most appropriate IPv6 network address format for this
+ * address. The buffer @p dst must be at least INET6_ADDRSTRLEN bytes
+ * long.
+ *
+ * On success, this function returns a non-NULL pointer to @p dst. NULL is
+ * returned if there was an error, with errno set to indicate the
+ * error.
+ *
+ * @see evil_inet_pton()
+ * @see inet_pton()
+ *
+ * Conformity: POSIX.1-2001.
+ *
+ * Supported OS: Windows XP, CE.
+ *
+ */
+EAPI const char *evil_inet_ntop(int af, const char *src, void *dst, size_t size);
+
+/**
+ * @def inet_ntop(x,y,z,s)
+ *
+ * Wrapper around evil_inet_ntop().
+ */
+#define inet_ntop(x,y,z,s) evil_inet_ntop(x,y,z,s)
+
+
+
+/**
+ * @}
+ */
+
+
+#endif /* __EVIL_INET_H__ */
diff --git a/src/lib/evil/evil_langinfo.c b/src/lib/evil/evil_langinfo.c
new file mode 100644
index 0000000000..32b1f41386
--- /dev/null
+++ b/src/lib/evil/evil_langinfo.c
@@ -0,0 +1,53 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include "Evil.h"
+
+
+#ifndef __MINGW32CE__
+
+static char *
+replace(char *prev, char *value)
+{
+   if (!value)
+     return prev;
+
+   if (prev)
+     free (prev);
+   return strdup (value);
+}
+
+char *
+nl_langinfo(nl_item index)
+{
+   static char *result = NULL;
+   static char *nothing = "";
+
+   switch (index)
+     {
+      case CODESET:
+        {
+           char *p;
+           result = replace(result, setlocale(LC_CTYPE, NULL));
+           if (!(p = strrchr(result, '.')))
+             return nothing;
+
+           if ((++p - result) > 2)
+             strcpy(result, "cp");
+           else
+             *result = '\0';
+           strcat(result, p);
+
+           return result;
+        }
+      case RADIXCHAR:
+        {
+           return localeconv()->decimal_point;
+        }
+     }
+
+   return nothing;
+}
+
+#endif /* ! __MINGW32CE__ */
diff --git a/src/lib/evil/evil_langinfo.h b/src/lib/evil/evil_langinfo.h
new file mode 100644
index 0000000000..0e9485a5c1
--- /dev/null
+++ b/src/lib/evil/evil_langinfo.h
@@ -0,0 +1,41 @@
+#ifndef __EVIL_LANGINFO_H__
+#define __EVIL_LANGINFO_H__
+
+
+#ifndef __MINGW32CE__
+
+#include <locale.h>
+
+
+typedef int            nl_item;
+
+#define __NL_ITEM( CATEGORY, INDEX )  ((CATEGORY << 16) | INDEX)
+#define __NL_ITEM_CATEGORY( ITEM )    (ITEM >> 16)
+#define __NL_ITEM_INDEX( ITEM )       (ITEM & 0xffff)
+
+enum {
+  /*
+   * LC_CTYPE category...
+   * Character set classification items.
+   */
+  _NL_CTYPE_CODESET     = __NL_ITEM( LC_CTYPE, 0 ),
+  _NL_NUMERIC_RADIXCHAR = __NL_ITEM( LC_NUMERIC, 0 ),
+
+  /*
+   * Dummy entry, to terminate the list.
+   */
+  _NL_ITEM_CLASSIFICATION_END
+};
+
+/*
+ * Define the public aliases for the enumerated classification indices...
+ */
+# define CODESET       _NL_CTYPE_CODESET
+# define RADIXCHAR     _NL_NUMERIC_RADIXCHAR
+
+EAPI char *nl_langinfo(nl_item index);
+
+#endif /* __MINGW32CE__ */
+
+
+#endif /*__EVIL_LANGINFO_H__ */
diff --git a/src/lib/evil/evil_libgen.c b/src/lib/evil/evil_libgen.c
new file mode 100644
index 0000000000..7e98f74386
--- /dev/null
+++ b/src/lib/evil/evil_libgen.c
@@ -0,0 +1,103 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <string.h>
+
+#include "Evil.h"
+
+char _evil_basename_buf[PATH_MAX];
+char _evil_dirname_buf[PATH_MAX];
+
+char *
+evil_basename(char *path)
+{
+   char *p1;
+   char *p2;
+   size_t length;
+
+   /* path must begin by "?:\" or "?:/" */
+   if ((!path) || !evil_path_is_absolute(path))
+     {
+        memcpy(_evil_basename_buf, "C:\\", 4);
+        return _evil_basename_buf;
+     }
+
+   /* '/' --> '\\' */
+   length = strlen(path);
+   p1 = strdup(path);
+   if (!p1)
+     {
+        memcpy(_evil_basename_buf, "C:\\", 4);
+        return _evil_basename_buf;
+     }
+   p2 = p1;
+   while (*p2)
+     {
+        if (*p2 == '/') *p2 = '\\';
+        p2++;
+     }
+
+   /* remove trailing backslashes */
+   p2 = p1 + (length - 1);
+   if (*p2 == '\\')
+     {
+       while (*p2 == '\\')
+         p2--;
+     }
+   *(p2 + 1) = '\0';
+
+   p2 = strrchr(p1, '\\');
+   memcpy(_evil_basename_buf, p2 + 1, (p1 + length + 1) - p2);
+
+   free(p1);
+
+   return _evil_basename_buf;
+}
+
+char *
+evil_dirname(char *path)
+{
+   char *p1;
+   char *p2;
+   size_t length;
+
+   /* path must begin by "?:\" or "?:/" */
+   if ((!path) || !evil_path_is_absolute(path))
+     {
+        memcpy(_evil_dirname_buf, "C:\\", 4);
+        return _evil_dirname_buf;
+     }
+
+   /* '/' --> '\\' */
+   length = strlen(path);
+   p1 = strdup(path);
+   if (!p1)
+     {
+        memcpy(_evil_dirname_buf, "C:\\", 4);
+        return _evil_dirname_buf;
+     }
+   p2 = p1;
+   while (*p2)
+     {
+        if (*p2 == '/') *p2 = '\\';
+        p2++;
+     }
+
+   /* remove trailing backslashes */
+   p2 = p1 + (length - 1);
+   if (*p2 == '\\')
+     {
+       while (*p2 == '\\')
+         p2--;
+     }
+   *(p2 + 1) = '\0';
+
+   p2 = strrchr(p1, '\\');
+   *p2 = '\0';
+   memcpy(_evil_dirname_buf, p1, strlen(p1) + 1);
+
+   free(p1);
+
+   return _evil_dirname_buf;
+}
diff --git a/src/lib/evil/evil_libgen.h b/src/lib/evil/evil_libgen.h
new file mode 100644
index 0000000000..4ca977ce86
--- /dev/null
+++ b/src/lib/evil/evil_libgen.h
@@ -0,0 +1,88 @@
+#ifndef __EVIL_LIBGEN_H__
+#define __EVIL_LIBGEN_H__
+
+
+/**
+ * @file evil_libgen.h
+ * @brief The file that provides functions ported from Unix in libgen.h.
+ * @defgroup Evil_Libgen_Group Libgen.h functions.
+ *
+ * This header provides functions ported from Unix in libgen.h.
+ *
+ * @{
+ */
+
+/**
+ * @brief Parse the base name component of a path.
+ *
+ * @param path The path to parse.
+ * @return The component following the final '/'.
+ *
+ * This function parses @p path and returns its component following
+ * the final '\'. Trailing '\' are not taken into account. On Windows
+ * XP, @p path must beginning by a drive letter followed by ':/' or
+ * ':\', otherwise "C:\" is returned. All characters '/' are replaced by '\'. On
+ * error (memory allocation failure), "C:\" is returned, otherwise the
+ * component following the final '\' is returned as a statically
+ * allocated memory. Hence the returns value must not be freed.
+ *
+ * Concatenating the string returned by dirname(), a "\", and the
+ * string returned by basename() yields a complete pathname.
+ *
+ * @see evil_dirname()
+ * @see dirname()
+ *
+ * Conformity: Non applicable.
+ *
+ * Supported OS: Windows XP.
+ */
+EAPI char *evil_basename(char *path);
+
+/**
+ * @def basename(p)
+ *
+ * Wrapper around evil_basename().
+ */
+#define basename(p) evil_basename(p)
+
+/**
+ * @brief Parse the dir name component of a path.
+ *
+ * @param path The path to parse.
+ * @return The component up to, but not including, the final '/'.
+ *
+ * This function parses @p path and returns its component up to, but
+ * not including, the final '/'. Trailing '\' are not taken into
+ * account. On Windows XP, @p path must beginning by a drive letter
+ * followed by ':/' or ':\', otherwise "C:\" is returned. All
+ * characters '/' are replaced by '\'. On error (memory allocation
+ * failure), "C:\" is returned, otherwise,  the component up to, but
+ * not including, the final '/' is returned as a statically allocated
+ * memory. Hence the returns value must not be freed.
+ *
+ * Concatenating the string returned by dirname(), a "\", and the
+ * string returned by basename() yields a complete pathname.
+ *
+ * @see evil_basename()
+ * @see basename()
+ *
+ * Conformity: Non applicable.
+ *
+ * Supported OS: Windows XP.
+ */
+EAPI char *evil_dirname(char *path);
+
+/**
+ * @def dirname(p)
+ *
+ * Wrapper around evil_dirname().
+ */
+#define dirname(p) evil_dirname(p)
+
+
+/**
+ * @}
+ */
+
+
+#endif /* __EVIL_LIBGEN_H__ */
diff --git a/src/lib/evil/evil_link_ce.c b/src/lib/evil/evil_link_ce.c
new file mode 100644
index 0000000000..17532cc4d6
--- /dev/null
+++ b/src/lib/evil/evil_link_ce.c
@@ -0,0 +1,90 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include <shellapi.h>
+
+#include "Evil.h"
+#include "evil_private.h"
+
+
+/*
+ * Symbolic links and directory related functions
+ *
+ */
+
+
+/* REMARK: Windows has no symbolic link. */
+/*         Nevertheless, it can create and read .lnk files */
+
+int
+symlink(const char *oldpath, const char *newpath)
+{
+   wchar_t *w_oldpath;
+   wchar_t *w_newpath;
+   BOOL     res;
+
+   w_oldpath = evil_char_to_wchar(oldpath);
+   if (!w_oldpath)
+     return -1;
+
+   w_newpath = evil_char_to_wchar(newpath);
+   if (!w_newpath)
+     {
+        free(w_oldpath);
+        return -1;
+     }
+
+   res = SHCreateShortcut(w_newpath, w_oldpath);
+   if (!res)
+     _evil_last_error_display(__FUNCTION__);
+
+   free(w_oldpath);
+   free(w_newpath);
+
+   return res ? 0 : -1;
+}
+
+ssize_t
+readlink(const char *path, char *buf, size_t bufsiz)
+{
+   wchar_t *w_path;
+   wchar_t  w_newpath[1024];
+   char    *newpath;
+   size_t   length;
+   BOOL     res;
+
+   w_path = evil_char_to_wchar(path);
+   if (!w_path)
+     return -1;
+
+   res = SHGetShortcutTarget(w_path, w_newpath, 1024);
+   if (!res)
+     _evil_last_error_display(__FUNCTION__);
+
+   free(w_path);
+
+   if (!res)
+     return -1;
+
+   newpath = evil_wchar_to_char(w_newpath);
+   if (!newpath)
+     return -1;
+
+   /* That stupid SHGetShortcutTarget add " around the file name... */
+   length = strlen(newpath) - 2;
+   if (length > bufsiz)
+     length = bufsiz;
+
+   memcpy(buf, newpath + 1, length);
+
+   free(newpath);
+
+   return length;
+}
diff --git a/src/lib/evil/evil_link_xp.cpp b/src/lib/evil/evil_link_xp.cpp
new file mode 100644
index 0000000000..675908f75b
--- /dev/null
+++ b/src/lib/evil/evil_link_xp.cpp
@@ -0,0 +1,151 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#ifdef HAVE_ERRNO_H
+#include <errno.h>
+#endif /* HAVE_ERRNO_H */
+
+#include <shlobj.h>
+#include <objidl.h>
+#include <cstdio>
+
+#include "Evil.h"
+
+
+/*
+ * Symbolic links and directory related functions
+ *
+ */
+
+
+/* REMARK: Windows has no symbolic link. */
+/*         Nevertheless, it can create and read .lnk files */
+int
+symlink(const char *oldpath, const char *newpath)
+{
+   char          fullname[PATH_MAX];
+   wchar_t      *wnewpath;
+   IShellLink   *pISL;
+   IPersistFile *pIPF;
+   HRESULT       res;
+   size_t        size;
+
+   realpath(oldpath, fullname);
+
+   res = CoInitialize(NULL);
+   if (FAILED(res))
+     {
+        if (res == E_OUTOFMEMORY)
+          errno = ENOMEM;
+        return -1;
+     }
+
+   if (FAILED(CoCreateInstance(CLSID_ShellLink,
+                               NULL,
+                               CLSCTX_INPROC_SERVER,
+                               IID_IShellLink,
+                               (void **)&pISL)))
+     goto no_instance;
+
+   if (FAILED(pISL->SetPath(fullname)))
+     goto no_setpath;
+
+   if (FAILED(pISL->QueryInterface(IID_IPersistFile, (void **)&pIPF)))
+     goto no_queryinterface;
+
+   size = mbstowcs(NULL, newpath, 0);
+   wnewpath = (wchar_t *)malloc((size + 1) * sizeof(wchar_t));
+   if (!wnewpath)
+     goto malloc_failure;
+   if (mbstowcs(wnewpath, newpath, size + 1) == (size_t)(-1))
+     goto translation_failure;
+   if (FAILED(pIPF->Save(wnewpath, FALSE)))
+     goto no_save;
+
+   free(wnewpath);
+   pIPF->Release();
+   pISL->Release();
+   CoUninitialize();
+
+   return 0;
+
+ no_save:
+ translation_failure:
+ malloc_failure:
+   pIPF->Release();
+ no_queryinterface:
+ no_setpath:
+   pISL->Release();
+ no_instance:
+   CoUninitialize();
+   return -1;
+}
+
+ssize_t
+readlink(const char *path, char *buf, size_t bufsiz)
+{
+   wchar_t      *wpath;
+   char          new_path[PATH_MAX];
+   IShellLink   *pISL;
+   IPersistFile *pIPF;
+   size_t        length;
+   HRESULT       res;
+   size_t        size;
+
+   res = CoInitialize(NULL);
+   if (FAILED(res))
+     {
+        if (res == E_OUTOFMEMORY)
+          errno = ENOMEM;
+        return -1;
+     }
+
+   if (FAILED(CoCreateInstance(CLSID_ShellLink,
+                               NULL,
+                               CLSCTX_INPROC_SERVER,
+                               IID_IShellLink,
+                               (void **)&pISL)))
+     goto couninitialize;
+
+   if (FAILED(pISL->QueryInterface(IID_IPersistFile, (void **)&pIPF)))
+     goto release_shell_link;
+
+   size = mbstowcs(NULL, path, 0);
+   wpath = (wchar_t *)malloc((size + 1) * sizeof(wchar_t));
+   if (!wpath)
+     goto release_persist_file;
+
+   mbstowcs(wpath, path, size + 1);
+   if (FAILED(pIPF->Load(wpath, STGM_READ)))
+     goto free_wpath;
+
+   if (FAILED(pISL->Resolve(NULL, SLR_UPDATE | SLR_NO_UI)))
+     goto free_wpath;
+
+   if (FAILED(pISL->GetPath(new_path, PATH_MAX, NULL, 0)))
+     goto free_wpath;
+
+   length = strlen(new_path);
+   if (length > bufsiz)
+     length = bufsiz;
+
+   memcpy(buf, new_path, length);
+
+   free(wpath);
+   pISL->Release();
+   pIPF->Release();
+   CoUninitialize();
+
+   return length;
+
+ free_wpath:
+   free(wpath);
+ release_persist_file:
+   pIPF->Release();
+ release_shell_link:
+   pISL->Release();
+ couninitialize:
+   CoUninitialize();
+   return -1;
+}
diff --git a/src/lib/evil/evil_macro.h b/src/lib/evil/evil_macro.h
new file mode 100644
index 0000000000..b2500d33c7
--- /dev/null
+++ b/src/lib/evil/evil_macro.h
@@ -0,0 +1,193 @@
+#ifndef __EVIL_MACRO_H__
+#define __EVIL_MACRO_H__
+
+
+#ifndef __cdecl
+# define EVIL_CDECL_IS_DEFINED
+# ifdef __GNUC__
+#  define __cdecl __attribute__((__cdecl__))
+# else
+#  define __cdecl
+# endif
+#endif /* __cdecl */
+
+
+#ifdef EAPI
+# undef EAPI
+#endif /* EAPI */
+
+#ifdef _WIN32
+# ifdef EFL_EVIL_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_EVIL_BUILD */
+#endif /* _WIN32 */
+
+
+#ifndef __EVIL_GNUC_PREREQ
+# if defined __GNUC__ && defined __GNUC_MINOR__
+#  define __EVIL_GNUC_PREREQ( major, minor )\
+     (__GNUC__ > (major) || (__GNUC__ == (major) && __GNUC_MINOR__ >= (minor)))
+# else
+#  define __EVIL_GNUC_PREREQ( major, minor )
+# endif
+#endif /* __EVIL_GNUC_PREREQ */
+
+
+#ifndef  __EVIL_NOTHROW
+# if __EVIL_GNUC_PREREQ( 3, 3 )
+#  define __EVIL_NOTHROW  __attribute__((__nothrow__))
+# else
+#  define __EVIL_NOTHROW
+# endif
+#endif /* __EVIL_NOTHROW */
+
+
+#ifndef  __EVIL_PRINTF
+# if __EVIL_GNUC_PREREQ( 2, 4 )
+#  define __EVIL_PRINTF(fmt, arg) __attribute__((__format__ (__gnu_printf__, fmt, arg)))
+# else
+#  define __EVIL_PRINTF(fmt, arg)
+# endif
+#endif /* __EVIL_PRINTF */
+
+
+#ifndef PATH_MAX
+# define PATH_MAX MAX_PATH
+#endif /* PATH_MAX */
+#ifdef fprintf
+# undef fprintf
+#endif
+
+#ifdef printf
+# undef printf
+#endif
+
+#ifdef sprintf
+# undef sprintf
+#endif
+
+#ifdef snprintf
+# undef snprintf
+#endif
+
+#ifdef vfprintf
+# undef vfprintf
+#endif
+
+#ifdef vprintf
+# undef vprintf
+#endif
+
+#ifdef vsprintf
+# undef vsprintf
+#endif
+
+#ifdef vsnprintf
+# undef vsnprintf
+#endif
+
+#ifdef fscanf
+# undef fscanf
+#endif
+
+#ifdef scanf
+# undef scanf
+#endif
+
+#ifdef sscanf
+# undef sscanf
+#endif
+
+#ifdef vfscanf
+# undef vfscanf
+#endif
+
+#ifdef vscanf
+# undef vscanf
+#endif
+
+#ifdef vsscanf
+# undef vsscanf
+#endif
+
+#ifdef asprintf
+# undef asprintf
+#endif
+
+#ifdef vasprintf
+# undef vasprintf
+#endif
+
+
+#if defined(_INTTYPES_H_) && defined(PRId64)
+
+#undef PRId64
+#undef PRIdLEAST64
+#undef PRIdFAST64
+#undef PRIdMAX
+#undef PRIi64
+#undef PRIiLEAST64
+#undef PRIiFAST64
+#undef PRIiMAX
+#undef PRIo64
+#undef PRIoLEAST64
+#undef PRIoFAST64
+#undef PRIoMAX
+#undef PRIu64
+#undef PRIuLEAST64
+#undef PRIuFAST64
+#undef PRIuMAX
+#undef PRIx64
+#undef PRIxLEAST64
+#undef PRIxFAST64
+#undef PRIxMAX
+#undef PRIX64
+#undef PRIXLEAST64
+#undef PRIXFAST64
+#undef PRIXMAX
+
+#undef SCNd64
+#undef SCNdLEAST64
+#undef SCNdFAST64
+#undef SCNdMAX
+#undef SCNi64
+#undef SCNiLEAST64
+#undef SCNiFAST64
+#undef SCNiMAX
+#undef SCNo64
+#undef SCNoLEAST64
+#undef SCNoFAST64
+#undef SCNoMAX
+#undef SCNx64
+#undef SCNxLEAST64
+#undef SCNxFAST64
+#undef SCNxMAX
+#undef SCNu64
+#undef SCNuLEAST64
+#undef SCNuFAST64
+#undef SCNuMAX
+
+#ifdef _WIN64
+#undef PRIdPTR
+#undef PRIiPTR
+#undef PRIoPTR
+#undef PRIuPTR
+#undef PRIxPTR
+#undef PRIXPTR
+
+#undef SCNdPTR
+#undef SCNiPTR
+#undef SCNoPTR
+#undef SCNxPTR
+#undef SCNuPTR
+#endif /* _WIN64 */
+
+#endif /* defined(_INTTYPES_H_) && defined(PRId64) */
+
+#endif /* __EVIL_MACRO_H__ */
diff --git a/src/lib/evil/evil_macro_pop.h b/src/lib/evil/evil_macro_pop.h
new file mode 100644
index 0000000000..a82818da9b
--- /dev/null
+++ b/src/lib/evil/evil_macro_pop.h
@@ -0,0 +1,93 @@
+#ifndef __EVIL_MACRO_POP_H__
+#define __EVIL_MACRO_POP_H__
+
+
+#ifdef EVIL_CDECL_IS_DEFINED
+# undef __cdecl
+# undef EVIL_CDECL_IS_DEFINED
+#endif
+
+#define fprintf   _evil_fprintfa
+#define printf    _evil_printfa
+#define snprintf  _evil_snprintfa
+#define sprintf   _evil_sprintfa
+#define vfprintf  _evil_vfprintfa
+#define vprintf   _evil_vprintfa
+#define vsnprintf _evil_vsnprintfa
+#define vsprintf  _evil_vsprintfa
+
+#define fscanf    _evil_fscanf
+#define scanf     _evil_scanf
+#define sscanf    _evil_sscanf
+#define vfscanf   _evil_vfscanf
+#define vscanf    _evil_vscanf
+#define vsscanf   _evil_vsscanf
+
+#define asprintf  _evil_asprintf
+#define vasprintf _evil_vasprintf
+
+/* Redefine to GNU specific PRI... and SCN... macros.  */
+
+#define PRId64 "lld"
+#define PRIdLEAST64 "lld"
+#define PRIdFAST64 "lld"
+#define PRIdMAX "lld"
+#define PRIi64 "lli"
+#define PRIiLEAST64 "lli"
+#define PRIiFAST64 "lli"
+#define PRIiMAX "lli"
+#define PRIo64 "llo"
+#define PRIoLEAST64 "llo"
+#define PRIoFAST64 "llo"
+#define PRIoMAX "llo"
+#define PRIu64 "llu"
+#define PRIuLEAST64 "llu"
+#define PRIuFAST64 "llu"
+#define PRIuMAX "llu"
+#define PRIx64 "llx"
+#define PRIxLEAST64 "llx"
+#define PRIxFAST64 "llx"
+#define PRIxMAX "llx"
+#define PRIX64 "llX"
+#define PRIXLEAST64 "llX"
+#define PRIXFAST64 "llX"
+#define PRIXMAX "llX"
+
+#define SCNd64 "lld"
+#define SCNdLEAST64 "lld"
+#define SCNdFAST64 "lld"
+#define SCNdMAX "lld"
+#define SCNi64 "lli"
+#define SCNiLEAST64 "lli"
+#define SCNiFAST64 "lli"
+#define SCNiMAX "lli"
+#define SCNo64 "llo"
+#define SCNoLEAST64 "llo"
+#define SCNoFAST64 "llo"
+#define SCNoMAX "llo"
+#define SCNx64 "llx"
+#define SCNxLEAST64 "llx"
+#define SCNxFAST64 "llx"
+#define SCNxMAX "llx"
+#define SCNu64 "llu"
+#define SCNuLEAST64 "llu"
+#define SCNuFAST64 "llu"
+#define SCNuMAX "llu"
+
+#ifdef _WIN64
+#define PRIdPTR "lld"
+#define PRIiPTR "lli"
+#define PRIoPTR "llo"
+#define PRIuPTR "llu"
+#define PRIxPTR "llx"
+#define PRIXPTR "llX"
+
+#define SCNdPTR "lld"
+#define SCNiPTR "lli"
+#define SCNoPTR "llo"
+#define SCNxPTR "llx"
+#define SCNuPTR "llu"
+#endif /* _WIN64 */
+
+
+#endif /* __EVIL_MACRO_POP_H__ */
diff --git a/src/lib/evil/evil_main.c b/src/lib/evil/evil_main.c
new file mode 100644
index 0000000000..ee1eb1d113
--- /dev/null
+++ b/src/lib/evil/evil_main.c
@@ -0,0 +1,74 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <winsock2.h>
+#undef WIN32_LEAN_AND_MEAN
+
+#include "Evil.h"
+#include "evil_private.h"
+
+
+static int      _evil_init_count = 0;
+
+extern LONGLONG _evil_time_freq;
+extern LONGLONG _evil_time_count;
+extern long     _evil_time_second;
+
+int
+evil_init(void)
+{
+   SYSTEMTIME    st;
+   LARGE_INTEGER freq;
+   LARGE_INTEGER count;
+   WORD          second = 59;
+
+   if (++_evil_init_count != 1)
+     return _evil_init_count;
+
+   if (!QueryPerformanceFrequency(&freq))
+       return 0;
+
+   _evil_time_freq = freq.QuadPart;
+
+   /* be sure that second + 1 != 0 */
+   while (second == 59)
+     {
+        GetSystemTime(&st);
+        second = st.wSecond;
+     }
+
+   /* retrieve the tick corresponding to the time we retrieve above */
+   while (1)
+     {
+        GetSystemTime(&st);
+        QueryPerformanceCounter(&count);
+        if (st.wSecond == second + 1)
+          break;
+     }
+
+   _evil_time_second = _evil_systemtime_to_time(st);
+   if (_evil_time_second < 0)
+     return --_evil_init_count;
+
+   _evil_time_count = count.QuadPart;
+
+   if (!evil_sockets_init())
+     return --_evil_init_count;
+
+   return _evil_init_count;
+}
+
+int
+evil_shutdown(void)
+{
+   if (--_evil_init_count != 0)
+     return _evil_init_count;
+
+   evil_sockets_shutdown();
+
+   return _evil_init_count;
+}
diff --git a/src/lib/evil/evil_main.h b/src/lib/evil/evil_main.h
new file mode 100644
index 0000000000..157e6028b7
--- /dev/null
+++ b/src/lib/evil/evil_main.h
@@ -0,0 +1,52 @@
+#ifndef __EVIL_MAIN_H__
+#define __EVIL_MAIN_H__
+
+
+/**
+ * @file evil_main.h
+ * @brief The file that provides functions to initialize and shut down Evil.
+ * @defgroup Evil_Main_Group Main
+ *
+ * This header provides functions to initialize and shut down the Evil
+ * library.
+ *
+ * @{
+ */
+
+
+/**
+ * @brief Initialize the Evil library.
+ *
+ * This function initializes the Evil library. It must be called before
+ * using evil_time_get(), gettimeofday() or pipe(). It returns  0 on
+ * failure, otherwise it returns the number of times it has already been
+ * called.
+ *
+ * When Evil is not used anymore, call evil_shutdown() to shut down
+ * the Evil library.
+ */
+EAPI int evil_init(void);
+
+/**
+ * @brief Shut down the Evil library.
+ *
+ * @return 0 when the Evil library is completely shut down, 1 or
+ * greater otherwise.
+ *
+ * This function shuts down the Evil library. It returns 0 when it has
+ * been called the same number of times than evil_init().
+ *
+ * Once this function succeeds (that is, @c 0 is returned), you must
+ * not call any of the Evil function listed in evil_init()
+ * documentation anymore . You must call evil_init() again to use these
+ * functions again.
+ */
+EAPI int evil_shutdown(void);
+
+
+/**
+ * @}
+ */
+
+
+#endif /* __EVIL_MAIN_H__ */
diff --git a/src/lib/evil/evil_mman.c b/src/lib/evil/evil_mman.c
new file mode 100644
index 0000000000..8898357cfc
--- /dev/null
+++ b/src/lib/evil/evil_mman.c
@@ -0,0 +1,234 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif /* HAVE_CONFIG_H */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <sys/types.h>
+
+#ifndef _MSC_VER
+# include <unistd.h>
+#endif
+
+#ifndef WIN32_LEAN_AND_MEAN
+# define WIN32_LEAN_AND_MEAN
+#endif
+#include <windows.h>
+#undef WIN32_LEAN_AND_MEAN
+
+# include <io.h>
+
+#include "evil_macro.h"
+#include "sys/mman.h"
+#include "evil_util.h"
+#include "evil_private.h"
+#define APICHAR char
+#include "evil_print.h"
+
+#ifdef __MINGW32CE__
+# define _get_osfhandle(FILEDES) ((long)FILEDES)
+#endif /* __MINGW32CE__ */
+
+
+/***** API *****/
+
+
+void *
+mmap(void  *addr __UNUSED__,
+     size_t len,
+     int    prot,
+     int    flags,
+     int    fd,
+     off_t  offset)
+{
+   OSVERSIONINFO os_version;
+
+   os_version.dwOSVersionInfoSize = sizeof(os_version);
+   if (!GetVersionEx(&os_version))
+     {
+        char *str;
+
+        str = evil_last_error_get();
+        fprintf(stderr, "[Evil] [mmap] GetVersionEx failed: %s\n", str);
+        free(str);
+
+        return MAP_FAILED;
+     }
+
+#ifdef _WIN32_WCE
+   if ((os_version.dwPlatformId == VER_PLATFORM_WIN32_CE) &&
+       (os_version.dwMajorVersion < 5))
+     {
+        void  *data;
+        size_t size;
+
+        data = malloc(len);
+        if (!data)
+          {
+             fprintf (stderr, "[Evil] [mmap] malloc failed\n");
+             return MAP_FAILED;
+          }
+
+        size = read(fd, data, len);
+        if (size != len)
+          {
+             fprintf (stderr, "[Evil] [mmap] read failed\n");
+             free(data);
+             return MAP_FAILED;
+          }
+
+        if (lseek(fd, 0, SEEK_SET) == -1)
+          {
+             fprintf (stderr, "[Evil] [mmap] lseek failed\n");
+             free(data);
+             return MAP_FAILED;
+          }
+
+        return data;
+     }
+   else
+#endif /* ! _WIN32_WCE */
+     {
+        HANDLE fm;
+        DWORD  protect = PAGE_NOACCESS;
+        DWORD  acs = 0;
+        HANDLE handle;
+        void  *data;
+
+        /* support only MAP_SHARED */
+        if (!(flags & MAP_SHARED))
+          return MAP_FAILED;
+
+        if (prot & PROT_EXEC)
+          {
+             if (prot & PROT_READ)
+               {
+                  if (prot & PROT_WRITE)
+                    protect = PAGE_EXECUTE_READWRITE;
+                  else
+                    protect = PAGE_EXECUTE_READ;
+               }
+             else
+               {
+                  if (prot & PROT_WRITE)
+                    protect = PAGE_EXECUTE_WRITECOPY;
+                  else
+                    protect = PAGE_EXECUTE;
+               }
+          }
+        else
+          {
+             if (prot & PROT_READ)
+               {
+                  if (prot & PROT_WRITE)
+                    protect = PAGE_READWRITE;
+                  else
+                    protect = PAGE_READONLY;
+               }
+             else if (prot & PROT_WRITE)
+               protect = PAGE_WRITECOPY;
+          }
+
+        handle = (HANDLE)_get_osfhandle(fd);
+        if (handle == INVALID_HANDLE_VALUE)
+          {
+             fprintf(stderr, "[Evil] [mmap] _get_osfhandle failed\n");
+
+             return MAP_FAILED;
+          }
+
+        fm = CreateFileMapping(handle, NULL, protect, 0, 0, NULL);
+        if (!fm)
+          {
+             char *str;
+
+             str = evil_last_error_get();
+             fprintf(stderr, "[Evil] [mmap] CreateFileMapping failed: %s\n", str);
+             free(str);
+
+             return MAP_FAILED;
+          }
+
+        if (protect & PAGE_READWRITE)
+          acs = FILE_MAP_ALL_ACCESS;
+        if (protect & PAGE_WRITECOPY)
+          acs = FILE_MAP_COPY;
+#if 0
+        if (protect & (PAGE_EXECUTE_READWRITE | PAGE_EXECUTE_READ))
+          acs = FILE_MAP_EXECUTE;
+#endif
+        if (protect & (PAGE_READWRITE | PAGE_READONLY))
+          acs = FILE_MAP_READ;
+        else
+          {
+             if (protect & PAGE_READWRITE)
+               acs = FILE_MAP_WRITE;
+          }
+
+        data = MapViewOfFile(fm,
+                             acs,
+                             offset & 0xffff0000,
+                             offset & 0x0000ffff,
+                             len);
+        CloseHandle(fm);
+
+        if (!data)
+          {
+             char *str;
+
+             str = evil_last_error_get();
+             fprintf(stderr, "[Evil] [mmap] MapViewOfFile failed: %s\n", str);
+             free(str);
+
+             return MAP_FAILED;
+          }
+
+        return data;
+     }
+}
+
+int
+munmap(void  *addr,
+       size_t len __UNUSED__)
+{
+#ifdef _WIN32_WCE
+   OSVERSIONINFO os_version;
+
+   os_version.dwOSVersionInfoSize = sizeof(os_version);
+   if (!GetVersionEx(&os_version))
+     {
+        char *str;
+
+        str = evil_last_error_get();
+        fprintf(stderr, "[Evil] [munmap] GetVersionEx failed: %s\n", str);
+        free(str);
+
+        return -1;
+     }
+
+   if ((os_version.dwPlatformId == VER_PLATFORM_WIN32_CE) &&
+       (os_version.dwMajorVersion < 5))
+     {
+        if (addr && (addr != MAP_FAILED))
+          free(addr);
+
+        return 0;
+     }
+   else
+#endif /* ! _WIN32_WCE */
+     {
+        BOOL res;
+
+        res = UnmapViewOfFile(addr);
+        if (!res)
+          {
+             char *str;
+
+             str = evil_last_error_get();
+             fprintf(stderr, "[Evil] [munmap] UnmapViewOfFile failed: %s\n", str);
+             free(str);
+          }
+
+        return (res == 0) ? -1 : 0;
+     }
+}
diff --git a/src/lib/evil/evil_pformat.h b/src/lib/evil/evil_pformat.h
new file mode 100644
index 0000000000..ad9b61e024
--- /dev/null
+++ b/src/lib/evil/evil_pformat.h
@@ -0,0 +1,61 @@
+#ifndef __EVIL_PRIVATE_H__
+#define __EVIL_PRIVATE_H__
+
+
+#include "evil_macro.h"
+
+
+#ifdef __BUILD_WIDEAPI
+#define APICHAR wchar_t
+#else
+#define APICHAR char
+#endif
+
+/* The following are the declarations specific to the `pformat' API...
+ */
+#define PFORMAT_TO_FILE     0x1000
+#define PFORMAT_NOLIMIT     0x2000
+
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+#ifdef __BUILD_WIDEAPI
+# define __fputc(X,STR)  fputwc((wchar_t) (X), (STR))
+# define _evil_pformat   _evil_pformatw
+
+# define _evil_fprintf   _evil_fprintfw
+# define _evil_printf    _evil_printfw
+# define _evil_snprintf  _evil_snprintfw
+# define _evil_sprintf   _evil_sprintfw
+
+# define _evil_vfprintf  _evil_vfprintfw
+# define _evil_vprintf   _evil_vprintfw
+# define _evil_vsnprintf _evil_vsnprintfw
+# define _evil_vsprintf  _evil_vsprintfw
+#else
+# define __fputc(X,STR)  fputc((X), (STR))
+# define _evil_pformat   _evil_pformata
+
+# define _evil_fprintf   _evil_fprintfa
+# define _evil_printf    _evil_printfa
+# define _evil_snprintf  _evil_snprintfa
+# define _evil_sprintf   _evil_sprintfa
+
+# define _evil_vfprintf  _evil_vfprintfa
+# define _evil_vprintf   _evil_vprintfa
+# define _evil_vsnprintf _evil_vsnprintfa
+# define _evil_vsprintf  _evil_vsprintfa
+#endif
+
+int __cdecl _evil_pformat(int, void *, int, const APICHAR *, va_list) __EVIL_NOTHROW;
+
+
+#ifdef __cplusplus
+}
+#endif
+
+
+#endif /* __EVIL_PRIVATE_H__ */
diff --git a/src/lib/evil/evil_pformata.c b/src/lib/evil/evil_pformata.c
new file mode 100644
index 0000000000..ee1d68e772
--- /dev/null
+++ b/src/lib/evil/evil_pformata.c
@@ -0,0 +1,2493 @@
+/* pformat.c
+ *
+ * $Id: pformat.c,v 1.9 2011/01/07 22:57:00 keithmarshall Exp $
+ *
+ * Provides a core implementation of the formatting capabilities
+ * common to the entire `printf()' family of functions; it conforms
+ * generally to C99 and SUSv3/POSIX specifications, with extensions
+ * to support Microsoft's non-standard format specifications.
+ *
+ * Written by Keith Marshall <keithmarshall@users.sourceforge.net>
+ *
+ * This is free software.  You may redistribute and/or modify it as you
+ * see fit, without restriction of copyright.
+ *
+ * This software is provided "as is", in the hope that it may be useful,
+ * but WITHOUT WARRANTY OF ANY KIND, not even any implied warranty of
+ * MERCHANTABILITY, nor of FITNESS FOR ANY PARTICULAR PURPOSE.  At no
+ * time will the author accept any form of liability for any damages,
+ * however caused, resulting from the use of this software.
+ *
+ * The elements of this implementation which deal with the formatting
+ * of floating point numbers, (i.e. the `%e', `%E', `%f', `%F', `%g'
+ * and `%G' format specifiers, but excluding the hexadecimal floating
+ * point `%a' and `%A' specifiers), make use of the `__gdtoa' function
+ * written by David M. Gay, and are modelled on his sample code, which
+ * has been deployed under its accompanying terms of use:--
+ *
+ ******************************************************************
+ * Copyright (C) 1997, 1999, 2001 Lucent Technologies
+ * All Rights Reserved
+ *
+ * Permission to use, copy, modify, and distribute this software and
+ * its documentation for any purpose and without fee is hereby
+ * granted, provided that the above copyright notice appear in all
+ * copies and that both that the copyright notice and this
+ * permission notice and warranty disclaimer appear in supporting
+ * documentation, and that the name of Lucent or any of its entities
+ * not be used in advertising or publicity pertaining to
+ * distribution of the software without specific, written prior
+ * permission.
+ *
+ * LUCENT DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE,
+ * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS.
+ * IN NO EVENT SHALL LUCENT OR ANY OF ITS ENTITIES BE LIABLE FOR ANY
+ * SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER
+ * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+ * THIS SOFTWARE.
+ ******************************************************************
+ *
+ */
+#include <stdio.h>
+#include <stdarg.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <limits.h>
+#include <locale.h>
+#include <wchar.h>
+#include <math.h>
+
+/* FIXME: The following belongs in values.h, but current MinGW
+ * has nothing useful there!  OTOH, values.h is not a standard
+ * header, and it's use may be considered obsolete; perhaps it
+ * is better to just keep these definitions here.
+ */
+#ifndef _VALUES_H
+/*
+ * values.h
+ *
+ */
+#define _VALUES_H
+
+#include <limits.h>
+
+#define _TYPEBITS(type)     (sizeof(type) * CHAR_BIT)
+
+#define LLONGBITS           _TYPEBITS(long long)
+
+#endif /* !defined _VALUES_H -- end of file */
+
+#include "evil_pformat.h"
+#include "gdtoa/gdtoa.h"
+
+/* Bit-map constants, defining the internal format control
+ * states, which propagate through the flags.
+ */
+#define PFORMAT_GROUPED     0x1000
+#define PFORMAT_HASHED      0x0800