Revert "autotools: REMOVAL!"

This reverts commit e8c69667b01e2795c1e4ead0536652f935ffa674.

git push on a wrong branch, sorry. This will land today, but not now.

38 files changed, 4223 insertions, 0 deletions

diff --git a/m4/.gitignore b/m4/.gitignore
new file mode 100644
index 0000000000..53b4209599
--- /dev/null
+++ b/m4/.gitignore
@@ -0,0 +1,36 @@
+/libtool.m4
+/ltoptions.m4
+/ltsugar.m4
+/ltversion.m4
+/lt~obsolete.m4
+/codeset.m4
+/fcntl-o.m4
+/gettext.m4
+/glibc2.m4
+/glibc21.m4
+/iconv.m4
+/intdiv0.m4
+/intl.m4
+/intldir.m4
+/intlmacosx.m4
+/intmax.m4
+/inttypes-pri.m4
+/inttypes_h.m4
+/lcmessage.m4
+/lib-ld.m4
+/lib-link.m4
+/lib-prefix.m4
+/lock.m4
+/longlong.m4
+/nls.m4
+/po.m4
+/printf-posix.m4
+/progtest.m4
+/size_max.m4
+/stdint_h.m4
+/uintmax_t.m4
+/visibility.m4
+/threadlib.m4
+/wchar_t.m4
+/wint_t.m4
+/xsize.m4
diff --git a/m4/ac_define_if.m4 b/m4/ac_define_if.m4
new file mode 100644
index 0000000000..961ca64452
--- /dev/null
+++ b/m4/ac_define_if.m4
@@ -0,0 +1,7 @@
+dnl use: AC_DEFINE_IF(id, testcond, val, comment)
+AC_DEFUN([AC_DEFINE_IF],
+[
+if $2; then
+   AC_DEFINE($1, $3, $4)
+fi
+])
diff --git a/m4/ac_path_generic.m4 b/m4/ac_path_generic.m4
new file mode 100644
index 0000000000..d42724115f
--- /dev/null
+++ b/m4/ac_path_generic.m4
@@ -0,0 +1,137 @@
+dnl @synopsis AC_PATH_GENERIC(LIBRARY [, MINIMUM-VERSION [, ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]]])
+dnl
+dnl Runs a LIBRARY-config script and defines LIBRARY_CFLAGS and LIBRARY_LIBS
+dnl
+dnl The script must support `--cflags' and `--libs' args.
+dnl If MINIMUM-VERSION is specified, the script must also support the
+dnl `--version' arg.
+dnl If the `--with-library-[exec-]prefix' arguments to ./configure are given,
+dnl it must also support `--prefix' and `--exec-prefix'.
+dnl (In other words, it must be like gtk-config.)
+dnl
+dnl For example:
+dnl
+dnl    AC_PATH_GENERIC(Foo, 1.0.0)
+dnl
+dnl would run `foo-config --version' and check that it is at least 1.0.0
+dnl
+dnl If so, the following would then be defined:
+dnl
+dnl    FOO_CFLAGS to `foo-config --cflags`
+dnl    FOO_LIBS   to `foo-config --libs`
+dnl
+dnl At present there is no support for additional "MODULES" (see AM_PATH_GTK)
+dnl (shamelessly stolen from gtk.m4 and then hacked around a fair amount)
+dnl
+dnl @author Angus Lees <gusl@cse.unsw.edu.au>
+
+AC_DEFUN([AC_PATH_GENERIC],
+[dnl
+dnl we're going to need uppercase, lowercase and user-friendly versions of the
+dnl string `LIBRARY'
+pushdef([UP], translit([$1], [a-z], [A-Z]))dnl
+pushdef([DOWN], translit([$1], [A-Z], [a-z]))dnl
+
+dnl
+dnl Get the cflags and libraries from the LIBRARY-config script
+dnl
+AC_ARG_WITH(DOWN-prefix,
+        [  --with-]DOWN[-prefix=PFX       Prefix where $1 is installed (optional)],
+        DOWN[]_config_prefix="$withval", DOWN[]_config_prefix="")
+AC_ARG_WITH(DOWN-exec-prefix,
+        [  --with-]DOWN[-exec-prefix=PFX  Exec prefix where $1 is installed (optional)],
+        DOWN[]_config_exec_prefix="$withval", DOWN[]_config_exec_prefix="")
+
+  if test x$DOWN[]_config_exec_prefix != x ; then
+     DOWN[]_config_args="$DOWN[]_config_args --exec-prefix=$DOWN[]_config_exec_prefix"
+     if test x${UP[]_CONFIG+set} != xset ; then
+       UP[]_CONFIG=$DOWN[]_config_exec_prefix/bin/DOWN-config
+     fi
+  fi
+  if test x$DOWN[]_config_prefix != x ; then
+     DOWN[]_config_args="$DOWN[]_config_args --prefix=$DOWN[]_config_prefix"
+     if test x${UP[]_CONFIG+set} != xset ; then
+       UP[]_CONFIG=$DOWN[]_config_prefix/bin/DOWN-config
+     fi
+  fi
+
+  AC_PATH_PROG(UP[]_CONFIG, DOWN-config, no)
+  ifelse([$2], ,
+     AC_MSG_CHECKING(for $1),
+     AC_MSG_CHECKING(for $1 - version >= $2)
+  )
+  no_[]DOWN=""
+  if test "$UP[]_CONFIG" = "no" ; then
+     no_[]DOWN=yes
+  else
+     UP[]_CFLAGS="`$UP[]_CONFIG $DOWN[]_config_args --cflags`"
+     UP[]_LIBS="`$UP[]_CONFIG $DOWN[]_config_args --libs`"
+     ifelse([$2], , ,[
+        DOWN[]_config_major_version=`$UP[]_CONFIG $DOWN[]_config_args \
+         --version | sed 's/[[^0-9]]*\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\).*/\1/'`
+        DOWN[]_config_minor_version=`$UP[]_CONFIG $DOWN[]_config_args \
+         --version | sed 's/[[^0-9]]*\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\).*/\2/'`
+        DOWN[]_config_micro_version=`$UP[]_CONFIG $DOWN[]_config_args \
+         --version | sed 's/[[^0-9]]*\([[0-9]]*\).\([[0-9]]*\).\([[0-9]]*\).*/\3/'`
+        DOWN[]_wanted_major_version="regexp($2, [\<\([0-9]*\)], [\1])"
+        DOWN[]_wanted_minor_version="regexp($2, [\<\([0-9]*\)\.\([0-9]*\)], [\2])"
+        DOWN[]_wanted_micro_version="regexp($2, [\<\([0-9]*\).\([0-9]*\).\([0-9]*\)], [\3])"
+
+        # Compare wanted version to what config script returned.
+        # If I knew what library was being run, i'd probably also compile
+        # a test program at this point (which also extracted and tested
+        # the version in some library-specific way)
+        if test "$DOWN[]_config_major_version" -lt \
+                        "$DOWN[]_wanted_major_version" \
+          -o \( "$DOWN[]_config_major_version" -eq \
+                        "$DOWN[]_wanted_major_version" \
+            -a "$DOWN[]_config_minor_version" -lt \
+                        "$DOWN[]_wanted_minor_version" \) \
+          -o \( "$DOWN[]_config_major_version" -eq \
+                        "$DOWN[]_wanted_major_version" \
+            -a "$DOWN[]_config_minor_version" -eq \
+                        "$DOWN[]_wanted_minor_version" \
+            -a "$DOWN[]_config_micro_version" -lt \
+                        "$DOWN[]_wanted_micro_version" \) ; then
+          # older version found
+          no_[]DOWN=yes
+          echo -n "*** An old version of $1 "
+          echo -n "($DOWN[]_config_major_version"
+          echo -n ".$DOWN[]_config_minor_version"
+          echo    ".$DOWN[]_config_micro_version) was found."
+          echo -n "*** You need a version of $1 newer than "
+          echo -n "$DOWN[]_wanted_major_version"
+          echo -n ".$DOWN[]_wanted_minor_version"
+          echo    ".$DOWN[]_wanted_micro_version."
+          echo "***"
+          echo "*** If you have already installed a sufficiently new version, this error"
+          echo "*** probably means that the wrong copy of the DOWN-config shell script is"
+          echo "*** being found. The easiest way to fix this is to remove the old version"
+          echo "*** of $1, but you can also set the UP[]_CONFIG environment to point to the"
+          echo "*** correct copy of DOWN-config. (In this case, you will have to"
+          echo "*** modify your LD_LIBRARY_PATH environment variable, or edit /etc/ld.so.conf"
+          echo "*** so that the correct libraries are found at run-time)"
+        fi
+     ])
+  fi
+  if test "x$no_[]DOWN" = x ; then
+     AC_MSG_RESULT(yes)
+     ifelse([$3], , :, [$3])
+  else
+     AC_MSG_RESULT(no)
+     if test "$UP[]_CONFIG" = "no" ; then
+       echo "*** The DOWN-config script installed by $1 could not be found"
+       echo "*** If $1 was installed in PREFIX, make sure PREFIX/bin is in"
+       echo "*** your path, or set the UP[]_CONFIG environment variable to the"
+       echo "*** full path to DOWN-config."
+     fi
+     UP[]_CFLAGS=""
+     UP[]_LIBS=""
+     ifelse([$4], , :, [$4])
+  fi
+  AC_SUBST(UP[]_CFLAGS)
+  AC_SUBST(UP[]_LIBS)
+
+  popdef([UP])
+  popdef([DOWN])
+])
diff --git a/m4/ax_cxx_compile_stdcxx_11.m4 b/m4/ax_cxx_compile_stdcxx_11.m4
new file mode 100644
index 0000000000..af37acdb5c
--- /dev/null
+++ b/m4/ax_cxx_compile_stdcxx_11.m4
@@ -0,0 +1,133 @@
+# ============================================================================
+#  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
+# ============================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX_11([ext|noext],[mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the C++11
+#   standard; if necessary, add switches to CXXFLAGS to enable support.
+#
+#   The first argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for an extended mode.
+#
+#   The second argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline C++11 support is required and that the macro
+#   should error out if no mode with that support is found.  If specified
+#   'optional', then configuration proceeds regardless, after defining
+#   HAVE_CXX11 if and only if a supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 3
+
+m4_define([_AX_CXX_COMPILE_STDCXX_11_testbody], [
+  template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+    typedef check<check<bool>> right_angle_brackets;
+
+    int a;
+    decltype(a) b;
+
+    typedef check<int> check_type;
+    check_type c;
+    check_type&& cr = static_cast<check_type&&>(c);
+
+    auto d = a;
+])
+
+AC_DEFUN([AX_CXX_COMPILE_STDCXX_11], [dnl
+  m4_if([$1], [], [],
+        [$1], [ext], [],
+        [$1], [noext], [],
+        [m4_fatal([invalid argument `$1' to AX_CXX_COMPILE_STDCXX_11])])dnl
+  m4_if([$2], [], [ax_cxx_compile_cxx11_required=true],
+        [$2], [mandatory], [ax_cxx_compile_cxx11_required=true],
+        [$2], [optional], [ax_cxx_compile_cxx11_required=false],
+        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX_11])])dnl
+  AC_LANG_PUSH([C++])dnl
+  ac_success=no
+  AC_CACHE_CHECK(whether $CXX supports C++11 features by default,
+  ax_cv_cxx_compile_cxx11,
+  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+    [ax_cv_cxx_compile_cxx11=yes],
+    [ax_cv_cxx_compile_cxx11=no])])
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+
+  m4_if([$1], [noext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=gnu++11 -std=gnu++0x; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+                     $cachevar,
+        [ac_save_CXXFLAGS="$CXXFLAGS"
+         CXXFLAGS="$CXXFLAGS $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXXFLAGS="$ac_save_CXXFLAGS"])
+      if eval test x\$$cachevar = xyes; then
+        CXXFLAGS="$CXXFLAGS $switch"
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+
+  m4_if([$1], [ext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=c++11 -std=c++0x; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+                     $cachevar,
+        [ac_save_CXXFLAGS="$CXXFLAGS"
+         CXXFLAGS="$CXXFLAGS $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_11_testbody])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXXFLAGS="$ac_save_CXXFLAGS"])
+      if eval test x\$$cachevar = xyes; then
+        CXXFLAGS="$CXXFLAGS $switch"
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+  AC_LANG_POP([C++])
+  if test x$ax_cxx_compile_cxx11_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR([*** A compiler with support for C++11 language features is required.])
+    fi
+  else
+    if test x$ac_success = xno; then
+      HAVE_CXX11=0
+      AC_MSG_NOTICE([No compiler with C++11 support was found])
+    else
+      HAVE_CXX11=1
+      AC_DEFINE(HAVE_CXX11,1,
+                [define if the compiler supports basic C++11 syntax])
+    fi
+
+    AC_SUBST(HAVE_CXX11)
+  fi
+])
diff --git a/m4/ecore_check_c_extension.m4 b/m4/ecore_check_c_extension.m4
new file mode 100644
index 0000000000..da4b44fe0c
--- /dev/null
+++ b/m4/ecore_check_c_extension.m4
@@ -0,0 +1,25 @@
+dnl use: ECORE_CHECK_X_EXTENSION(Foo, header, lib, func)
+AC_DEFUN([ECORE_CHECK_X_EXTENSION],
+[
+pushdef([UP], translit([$1], [a-z], [A-Z]))dnl
+
+  SAVE_CFLAGS=$CFLAGS
+  CFLAGS="$CFLAGS $ECORE_X_XLIB_cflags"
+  AC_CHECK_HEADER(X11/extensions/$2,
+    [
+     SAVE_LIBS=$LIBS
+     LIBS="$LIBS $ECORE_X_XLIB_libs"
+     AC_CHECK_LIB($3, $4,
+       [AC_DEFINE(ECORE_[]UP, 1, [Build support for $1])],
+       [AC_MSG_ERROR([Missing support for X extension: $1])])
+     LIBS=$SAVE_LIBS
+    ],
+    [AC_MSG_ERROR([Missing X11/extensions/$2])],
+    [ #include <X11/Xlib.h> ]
+  )
+  CFLAGS=$SAVE_CFLAGS
+
+ECORE_X_LIBS="${ECORE_X_LIBS} -l$3"
+
+popdef([UP])
+])
diff --git a/m4/ecore_check_module.m4 b/m4/ecore_check_module.m4
new file mode 100644
index 0000000000..8fdec9bdc4
--- /dev/null
+++ b/m4/ecore_check_module.m4
@@ -0,0 +1,35 @@
+dnl use: ECORE_EVAS_MODULE(name, want, [DEPENDENCY-CHECK-CODE])
+AC_DEFUN([ECORE_EVAS_MODULE],
+[dnl
+m4_pushdef([UP], m4_translit([[$1]], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWN], m4_translit([[$1]], [-A-Z], [_a-z]))dnl
+
+have_ecore_evas_[]m4_defn([DOWN])="no"
+want_module="$2"
+
+ecore_evas_engines_[]m4_defn([DOWN])[]_cflags=""
+ecore_evas_engines_[]m4_defn([DOWN])[]_libs=""
+
+if test "x$want_module" = "xyes" || test "x$want_module" = "xstatic"; then
+   $3
+
+   AC_DEFINE([BUILD_ECORE_EVAS_]m4_defn([UP]), [1], [Support for $1 Engine in Ecore_Evas])
+   have_ecore_evas_[]m4_defn([DOWN])="yes"
+
+   case "$1" in
+      xgl-drm)
+         PKG_CHECK_MODULES([GBM], [gbm])
+         ecore_evas_engines_[]m4_defn([DOWN])[]_cflags="${GBM_CFLAGS}"
+         ecore_evas_engines_[]m4_defn([DOWN])[]_libs="${GBM_LIBS}"
+         ;;
+   esac
+fi
+
+AC_SUBST([ecore_evas_engines_]m4_defn([DOWN])[_cflags])
+AC_SUBST([ecore_evas_engines_]m4_defn([DOWN])[_libs])
+
+EFL_ADD_FEATURE([ECORE_EVAS], [$1], [${want_module}])dnl
+AM_CONDITIONAL([BUILD_ECORE_EVAS_]UP, [test "x$have_ecore_evas_]m4_defn([DOWN])[" = "xyes"])dnl
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
diff --git a/m4/efl.m4 b/m4/efl.m4
new file mode 100644
index 0000000000..a01c5b401c
--- /dev/null
+++ b/m4/efl.m4
@@ -0,0 +1,509 @@
+dnl file to manage modules in efl
+
+dnl EFL_VERSION(major, minor, micro, release)
+dnl This setup EFL version information and should be called BEFORE AC_INIT().
+dnl
+dnl release parameter is 'dev' to use from SVN or libtool -release field.
+dnl It may be empty if not dev (svn/live build) and no -release is to be used.
+dnl
+dnl Examples:
+dnl     EFL_VERSION(1, 7, 99, dev)
+dnl     EFL_VERSION(1, 7, 99, ver-1234)
+dnl This will define couple of m4 symbols:
+dnl     v_maj = given major number (first parameter)
+dnl     v_min = given minor number (second parameter)
+dnl     v_mic = given micro number (third parameter)
+dnl     v_rev = if release, it's 0, otherwise it's dev_version.
+dnl     v_rel = if release, it's -release followed by fourth parameter,
+dnl             otherwise it's empty. (mostly for libtool)
+dnl     efl_version = if release, it's major.minor.micro, otherwise it's
+dnl             major.minor.micro.dev_version
+dnl     dev_version = development version (svn revision).
+dnl     def_build_profile = dev or release based on 'dev' release parameter.
+AC_DEFUN([EFL_VERSION],
+[dnl
+m4_define([v_maj], [$1])dnl
+m4_define([v_min], [$2])dnl
+m4_define([v_mic], [$3])dnl
+m4_define([dev_version], m4_esyscmd([(git rev-list --count HEAD 2>/dev/null || echo 0) | tr -d '\n']))dnl
+m4_define([v_rev], m4_if($4, dev, [dev_version], [0]))dnl
+m4_define([v_rel], [])dnl
+m4_define([def_build_profile], m4_if($4, dev, [dev], [release]))dnl
+m4_define([efl_version], m4_if($4, dev, [v_maj.v_min.v_mic.v_rev], [v_maj.v_min.v_mic]))dnl
+dnl m4_define([efl_version], [v_maj.v_min.v_mic])dnl
+])
+
+dnl EFL_COLOR
+dnl will check if terminal supports color and if color is wanted by user.
+dnl
+dnl Used Variables:
+dnl     WANT_COLOR: if no, forces no color output.
+dnl     TERM: used to check if color should be enabled.
+dnl
+dnl Defined Variables:
+dnl     COLOR_YES: to be used in positive/yes conditions
+dnl     COLOR_NO: to be used in negative/no conditions
+dnl     COLOR_OTHER: to be used to highlight some other condition
+dnl     COLOR_RESET: to reset color
+dnl     want_color: yes or no
+AC_DEFUN([EFL_COLOR],
+[dnl
+case "$TERM" in
+   xterm|xterm-color|xterm-256color|Eterm|aterm|kterm|rxvt*|screen|gnome|interix)
+      want_color="${WANT_COLOR:-yes}"
+      ;;
+   *)
+      want_color="no"
+      ;;
+esac
+
+### echo compatibility
+
+## the BSD echo does not have the -e option (it is the default behaviour)
+echo_e=
+if test "`echo -e x`" = "x"; then
+   echo_e=-e
+fi
+AC_SUBST([ECHO_E], [${echo_e}])
+
+if test "${want_color}" = "yes"; then
+   COLOR_YES=`echo $echo_e "\033@<:@1;32m"`
+   COLOR_NO=`echo $echo_e "\033@<:@1;31m"`
+   COLOR_OTHER=`echo $echo_e "\033@<:@1;36m"`
+   COLOR_RESET=`echo $echo_e "\033@<:@0m"`
+else
+   COLOR_YES=""
+   COLOR_NO=""
+   COLOR_OTHER=""
+   COLOR_RESET=""
+fi
+])
+
+dnl EFL_INIT()
+dnl Will AC_DEFINE() the following:
+dnl     VMAJ = v_maj
+dnl     VMIN = v_min
+dnl     VMIC = v_mic
+dnl     VREV = v_rev
+dnl Will AC_SUBST() the following:
+dnl     VMAJ = v_maj
+dnl     VMIN = v_min
+dnl     VMIC = v_mic
+dnl     EFL_LTLIBRARY_FLAGS="-no-undefined -version-info ..."
+dnl     EFL_LTMODULE_FLAGS="-no-undefined -avoid-version"
+dnl Will define the following m4:
+dnl     lt_cur = libtool 'current' field of libtool's -version-info
+dnl     lt_rev = libtool 'revision' field of libtool's -version-info
+dnl     lt_age = libtool 'age' field of libtool's -version-info
+AC_DEFUN([EFL_INIT],
+[dnl
+AC_REQUIRE([EFL_COLOR])dnl
+AC_DEFINE_UNQUOTED([VMAJ], [v_maj], [Major version])dnl
+AC_DEFINE_UNQUOTED([VMIN], [v_min], [Minor version])dnl
+AC_DEFINE_UNQUOTED([VMIC], [v_mic], [Micro version])dnl
+AC_DEFINE_UNQUOTED([VREV], [v_rev], [Revison])dnl
+VMAJ=v_maj
+VMIN=v_min
+VMIC=v_mic
+AC_SUBST([VMAJ])dnl
+AC_SUBST([VMIN])dnl
+AC_SUBST([VMIC])dnl
+dnl
+dnl TODO: warning - lt_cur:
+dnl the previous code assumed v_maj + v_min, but this will be a problem when
+dnl we bump v_maj and reset v_min. 1 + 7 == 7 + 1, so if v_maj is bumped
+dnl we multiply it by 100.
+m4_define([lt_cur], m4_if(m4_cmp(v_maj, 1), 0, m4_eval(v_maj + v_min), m4_eval(v_maj * 100 + v_min)))dnl
+m4_define([lt_rev], v_mic)dnl
+m4_define([lt_age], v_min)dnl
+dnl
+EFL_LTLIBRARY_FLAGS="-no-undefined -version-info lt_cur:lt_rev:lt_age v_rel"
+AC_SUBST(EFL_LTLIBRARY_FLAGS)dnl
+EFL_LTMODULE_FLAGS="-no-undefined -avoid-version"
+AC_SUBST([EFL_LTMODULE_FLAGS])dnl
+AC_MSG_NOTICE([Initialized AC_PACKAGE_NAME (AC_PACKAGE_VERSION) development=dev_version v_rel])
+])
+
+dnl EFL_EVAL_PKGS(EFL)
+dnl does PKG_CHECK_MODULES() for given EFL
+AC_DEFUN([EFL_EVAL_PKGS],
+[dnl
+m4_pushdef([DOWNEFL], m4_translit([$1], [-A-Z], [_a-z]))dnl
+if test "x${requirements_pc_deps_[]m4_defn([DOWNEFL])}" != "x"; then
+   PKG_CHECK_MODULES([$1], [${requirements_pc_deps_[]m4_defn([DOWNEFL])}])
+fi
+m4_popdef([DOWNEFL])dnl
+])
+
+dnl EFL_INTERNAL_DEPEND_PKG(EFL, OTHEREFL)
+dnl Adds a pkg-config dependency on another EFL.
+AC_DEFUN([EFL_INTERNAL_DEPEND_PKG],
+[dnl
+m4_pushdef([DOWNEFL], m4_translit([$1], [-A-Z], [_a-z]))dnl
+m4_pushdef([DOWNOTHER], m4_translit([$2], [-A-Z], [_a-z]))dnl
+dnl TODO: we need to fix the package config names for 2.0
+dnl TODO: and make them uniform in scheme.
+depname="$2"
+libdirname="m4_defn([DOWNOTHER])"
+libname="m4_defn([DOWNOTHER])"
+case "m4_defn([DOWNOTHER])" in
+   ethumb_client)
+      depname="ethumb_client"
+      ;;
+   efreet_mime)
+      libdirname="efreet"
+      ;;
+   efreet_trash)
+      libdirname="efreet"
+      ;;
+   ecore_x)
+      depname="ecore-x"
+      ;;
+   ecore_wl2)
+      depname="ecore-wl2"
+      ;;
+   ecore_fb)
+      depname="ecore-fb"
+      ;;
+   ecore_drm)
+      depname="ecore-drm"
+      ;;
+   ecore_cocoa)
+      depname="ecore-cocoa"
+      ;;
+   ecore_win32)
+      depname="ecore-win32"
+      ;;
+   ecore_drm2)
+      depname="ecore-drm2"
+      ;;
+   ecore_sdl)
+      depname="ecore-sdl"
+      ;;
+   ecore_file)
+      depname="ecore-file"
+      ;;
+esac
+requirements_pc_[]m4_defn([DOWNEFL])="${depname} >= ${PACKAGE_VERSION} ${requirements_pc_[][]m4_defn([DOWNEFL])}"
+requirements_cflags_[]m4_defn([DOWNEFL])="${requirements_cflags_[][]m4_defn([DOWNEFL])} -I\$(top_srcdir)/src/lib/${libdirname} -I\$(top_builddir)/src/lib/${libdirname}"
+requirements_internal_libs_[]m4_defn([DOWNEFL])="${requirements_internal_libs_[][]m4_defn([DOWNEFL])} lib/${libdirname}/lib${libname}.la"
+requirements_internal_deps_libs_[]m4_defn([DOWNEFL])="${requirements_internal_deps_libs_[][]m4_defn([DOWNEFL])} ${requirements_public_libs_[]m4_defn([DOWNOTHER])}"
+m4_popdef([DOWNOTHER])dnl
+m4_popdef([DOWNEFL])dnl
+])
+
+dnl EFL_PLATFORM_DEPEND(EFL, PLATFORM)
+dnl PLATFORM is one of: all, evil, escape, exotic
+AC_DEFUN([EFL_PLATFORM_DEPEND],
+[dnl
+m4_pushdef([DOWNOTHER], m4_translit([$2], [-A-Z], [_a-z]))dnl
+case "m4_defn([DOWNOTHER])" in
+  all)
+    if test "x${efl_lib_optional_evil}" = "xyes"; then
+       EFL_INTERNAL_DEPEND_PKG([$1], [evil])
+    elif test "x${efl_lib_optional_escape}" = "xyes"; then
+       EFL_INTERNAL_DEPEND_PKG([$1], [escape])
+    elif test "x${efl_lib_optional_exotic}" = "xyes"; then
+       EFL_INTERNAL_DEPEND_PKG([$1], [exotic])
+    fi
+    ;;
+  *)
+    if test "x${efl_lib_optional_[]m4_defn([DOWNOTHER])}" = "xyes"; then
+       EFL_INTERNAL_DEPEND_PKG([$1], [$2])
+    fi
+    ;;
+esac
+m4_popdef([DOWNOTHER])dnl
+])
+
+dnl EFL_CRYPTO_DEPEND(EFL)
+dnl the given EFL will use/depend on system crypto settings
+AC_DEFUN([EFL_CRYPTO_DEPEND],
+[dnl
+m4_pushdef([DOWNEFL], m4_translit([$1], [-A-Z], [_a-z]))dnl
+requirements_pc_[]m4_defn([DOWNEFL])="${requirements_pc_[][]m4_defn([DOWNEFL])} ${requirements_pc_crypto}"
+requirements_pc_deps_[]m4_defn([DOWNEFL])="${requirements_pc_deps_[][]m4_defn([DOWNEFL])} ${requirements_pc_deps_crypto}"
+requirements_libs_[]m4_defn([DOWNEFL])="${requirements_libs_[][]m4_defn([DOWNEFL])} ${requirements_libs_crypto}"
+requirements_cflags_[]m4_defn([DOWNEFL])="${requirements_cflags_[][]m4_defn([DOWNEFL])} ${requirements_cflags_crypto}"
+m4_popdef([DOWNEFL])dnl
+])
+
+dnl EFL_DEPEND_PKG(EFL, NAME, PACKAGE, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl Adds a pkg-config dependency to an efl, AC_DEFINE() HAVE_NAME,
+dnl and inserts dependencies in proper variables
+AC_DEFUN([EFL_DEPEND_PKG],
+[dnl
+m4_pushdef([UPEFL], m4_translit([$1], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWNEFL], m4_translit([$1], [-A-Z], [_a-z]))dnl
+m4_pushdef([UPNAME], m4_translit([$2], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWNNAME], m4_translit([$2], [-A-Z], [_a-z]))dnl
+
+   have_[]m4_defn([DOWNNAME])="no"
+
+   EFL_PKG_CHECK_STRICT([$3], [
+      AC_DEFINE([HAVE_]m4_defn([UPNAME]), [1], [Have `]m4_defn([DOWNNAME])[' pkg-config installed.])
+      requirements_pc_[]m4_defn([DOWNEFL])="${requirements_pc_[][]m4_defn([DOWNEFL])} $3"
+      requirements_pc_deps_[]m4_defn([DOWNEFL])="${requirements_pc_deps_[]m4_defn([DOWNEFL])} $3"
+      have_[]m4_defn([DOWNNAME])="yes"
+
+      $4
+
+      ], [$5])
+
+m4_popdef([DOWNNAME])
+m4_popdef([UPNAME])
+m4_popdef([DOWNEFL])
+m4_popdef([UPEFL])
+])
+
+dnl EFL_OPTIONAL_DEPEND_PKG(EFL, VARIABLE, NAME, PACKAGE, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+AC_DEFUN([EFL_OPTIONAL_DEPEND_PKG],
+[dnl
+m4_pushdef([DOWN], m4_translit([$3], [-A-Z], [_a-z]))dnl
+
+   have_[]m4_defn([DOWN])="no"
+   if test "x$2" = "xyes"; then
+      EFL_DEPEND_PKG([$1], [$3], [$4], [$5], [$6])
+   fi
+m4_popdef([DOWN])dnl
+])
+
+dnl EFL_OPTIONAL_INTERNAL_DEPEND_PKG(EFL, VARIABLE, NAME)
+AC_DEFUN([EFL_OPTIONAL_INTERNAL_DEPEND_PKG],
+[dnl
+   if test "x$2" = "xyes"; then
+      EFL_INTERNAL_DEPEND_PKG([$1], [$3])
+   fi
+])
+
+dnl EFL_ADD_LIBS(PKG, LIBS)
+dnl Add libraries that the EFL library will depend on
+dnl See EFL_DEPEND_PKG() for pkg-config version.
+AC_DEFUN([EFL_ADD_LIBS],
+[dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+requirements_libs_[]m4_defn([DOWN])="${requirements_libs_[]m4_defn([DOWN])} $2"
+m4_popdef([DOWN])dnl
+])
+
+dnl EFL_ADD_PUBLIC_LIBS(PKG, PUBLIC_LIBS)
+dnl Add libraries that the EFL library will depend on when used.
+dnl
+dnl Unlike EFL_ADD_LIBS(), that is only used when generating PKG,
+dnl this one is used when linking PKG to other libraries or applications.
+dnl
+dnl For instance if you use some other library in your header that user
+dnl inclues.
+AC_DEFUN([EFL_ADD_PUBLIC_LIBS],
+[dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+requirements_public_libs_[]m4_defn([DOWN])="${requirements_public_libs_[]m4_defn([DOWN])} $2"
+m4_popdef([DOWN])dnl
+])
+
+dnl EFL_ADD_CFLAGS(PKG, CFLAGS)
+dnl Add CFLAGS that the EFL library will use
+dnl See EFL_DEPEND_PKG() for pkg-config version.
+AC_DEFUN([EFL_ADD_CFLAGS],
+[dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+requirements_cflags_[]m4_defn([DOWN])="${requirements_cflags_[]m4_defn([DOWN])} $2"
+m4_popdef([DOWN])dnl
+])
+
+dnl EFL_LIB_START(PKG)
+dnl start the setup of an EFL library, defines variables and prints a notice
+dnl
+dnl Exports (AC_SUBST)
+dnl     PKG_CFLAGS: what to use for CFLAGS
+dnl
+dnl     PKG_LDFLAGS: what to use for LDFLAGS
+dnl
+dnl     PKG_LIBS: what to use in automake's _LIBADD or _LDADD. Includes
+dnl             everything else.
+dnl
+dnl     PKG_INTERNAL_LIBS: all other EFL as lib/name/libname.la that this
+dnl             package depend. Used in automake's _DEPENDENCIES.
+dnl
+dnl     USE_PKG_LIBS: what to use in automake's _LIBADD or _LDADD when using
+dnl             this PKG (PKG_LIBS + libpkg.la)
+dnl
+dnl     USE_PKG_INTERNAL_LIBS: extends PKG_INTERNAL_LIBS with lib/pkg/libpkg.la
+dnl
+dnl     requirements_pc_pkg: all pkg-config (pc) files used by this pkg,
+dnl             includes internal EFL (used in 'Requires.private' in pkg.pc)
+dnl
+dnl     requirements_libs_pkg: external libraries this package needs when
+dnl             linking (used in 'Libs.private' in pkg.pc)
+dnl
+dnl     requirements_public_libs_pkg: external libraries other packages need
+dnl             when using this (used in 'Libs' in pkg.pc)
+dnl
+dnl     requirements_cflags_pkg: what to use for CFLAGS (same as PKG_CFLAGS).
+dnl
+dnl Variables:
+dnl     requirements_pc_deps_pkg: external pkg-config (pc) files used by this
+dnl             pkg (used in EFL_EVAL_PKGS())
+dnl
+dnl     requirements_internal_libs_pkg: all other EFL as lib/name/libname.la
+dnl             that this package depend.
+dnl
+dnl     requirements_internal_deps_libs_pkg: external libraries that are public
+dnl             dependencies (due internal libs).
+dnl
+AC_DEFUN([EFL_LIB_START],
+[dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+
+requirements_internal_libs_[]m4_defn([DOWN])=""
+requirements_internal_deps_libs_[]m4_defn([DOWN])=""
+requirements_libs_[]m4_defn([DOWN])=""
+requirements_public_libs_[]m4_defn([DOWN])=""
+requirements_cflags_[]m4_defn([DOWN])=""
+requirements_pc_[]m4_defn([DOWN])=""
+requirements_pc_deps_[]m4_defn([DOWN])=""
+
+m4_defn([UP])_LIBS="${m4_defn([UP])_LIBS}"
+m4_defn([UP])_INTERNAL_LIBS="${m4_defn([UP])_INTERNAL_LIBS}"
+USE_[]m4_defn([UP])_LIBS="${USE_[]m4_defn([UP])_LIBS}"
+USE_[]m4_defn([UP])_INTERNAL_LIBS="${USE_[]m4_defn([UP])_INTERNAL_LIBS}"
+m4_defn([UP])_LDFLAGS="${m4_defn([UP])_LDFLAGS}"
+m4_defn([UP])_CFLAGS="${m4_defn([UP])_CFLAGS}"
+
+AC_SUBST([requirements_libs_]m4_defn([DOWN]))dnl
+AC_SUBST([requirements_public_libs_]m4_defn([DOWN]))dnl
+AC_SUBST([requirements_cflags_]m4_defn([DOWN]))dnl
+AC_SUBST([requirements_pc_]m4_defn([DOWN]))dnl
+AC_SUBST(m4_defn([UP])[_LIBS])dnl
+AC_SUBST(m4_defn([UP])[_INTERNAL_LIBS])dnl
+AC_SUBST([USE_]m4_defn([UP])[_LIBS])dnl
+AC_SUBST([USE_]m4_defn([UP])[_INTERNAL_LIBS])dnl
+AC_SUBST(m4_defn([UP])[_LDFLAGS])dnl
+AC_SUBST(m4_defn([UP])[_CFLAGS])dnl
+AC_MSG_NOTICE([Start $1 checks])dnl
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
+
+dnl EFL_LIBS_SUBBUILD(TARGET, DEPENDENCIES)
+dnl Make TARGET contain all DEPENDENCIES relative to SUBDIR build
+AC_DEFUN([EFL_LIBS_SUBBUILD],
+[dnl
+$1=""
+_SUBDIR="../../"
+
+for dep in $2; do
+   case $dep in
+      lib*.la)
+         _DEPENDENCY=$_SUBDIR$dep
+      ;;
+      *)
+         _DEPENDENCY=$dep
+      ;;
+   esac
+
+   $1=${$1}" ${_DEPENDENCY}"
+done
+
+AC_SUBST([$1])
+])
+
+dnl EFL_LIB_END(PKG)
+dnl finishes the setup of an EFL library
+AC_DEFUN([EFL_LIB_END],
+[dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+
+libdirname="m4_defn([DOWN])"
+libname="m4_defn([DOWN])"
+
+m4_defn([UP])_LDFLAGS="${EFLALL_COV_LDFLAGS} ${EFLALL_LDFLAGS} ${m4_defn([UP])_LDFLAGS}"
+m4_defn([UP])_LIBS=" ${m4_defn([UP])_LDFLAGS} ${EFLALL_COV_LIBS} ${EFLALL_LIBS} ${m4_defn([UP])_LIBS} ${requirements_internal_libs_[]m4_defn([DOWN])} ${requirements_internal_deps_libs_[]m4_defn([DOWN])} ${requirements_public_libs_[]m4_defn([DOWN])} ${requirements_libs_[]m4_defn([DOWN])} ${requirements_libs_eflall} "
+m4_defn([UP])_INTERNAL_LIBS="${m4_defn([UP])_INTERNAL_LIBS} ${requirements_internal_libs_[]m4_defn([DOWN])}"
+USE_[]m4_defn([UP])_LIBS="${m4_defn([UP])_LIBS} lib/${libdirname}/lib${libname}.la"
+USE_[]m4_defn([UP])_INTERNAL_LIBS="${m4_defn([UP])_INTERNAL_LIBS} lib/${libdirname}/lib${libname}.la"
+m4_defn([UP])_CFLAGS="${EFL_WINDOWS_VERSION_CFLAGS} ${EFLALL_COV_CFLAGS} ${EFLALL_CFLAGS} ${m4_defn([UP])_CFLAGS} -I\$(top_srcdir)/src/lib/${libdirname} -I\$(top_builddir)/src/lib/${libdirname} -I\$(top_srcdir)/src/bindings/cxx/${libdirname} -I\$(top_builddir)/src/bindings/${libdirname} ${requirements_cflags_[]m4_defn([DOWN])} ${requirements_cflags_eflall}"
+requirements_pc_[]m4_defn([DOWN])="${requirements_pc_[]m4_defn([DOWN])} ${requirements_pc_eflall}"
+requirements_pc_deps_[]m4_defn([DOWN])="${requirements_pc_deps_[]m4_defn([DOWN])} ${requirements_pc_deps_eflall}"
+
+EFL_LIBS_SUBBUILD(m4_defn([UP])_SUBBUILD_LIBS, ${m4_defn([UP])_LIBS})
+EFL_LIBS_SUBBUILD(m4_defn([UP])_SUBBUILD_INTERNAL_LIBS, ${m4_defn([UP])_INTERNAL_LIBS})
+EFL_LIBS_SUBBUILD(USE_[]m4_defn([UP])_SUBBUILD_LIBS, "USE_[]m4_defn([UP])_LIBS")
+
+AC_MSG_NOTICE([Finished $1 checks])dnl
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
+
+dnl EFL_LIB_START_OPTIONAL(PKG, TEST)
+dnl test if library should be build and then EFL_LIB_START()
+dnl must call EFL_LIB_END_OPTIONAL() to close it.
+AC_DEFUN([EFL_LIB_START_OPTIONAL],
+[dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+
+if $2; then
+   efl_lib_optional_[]m4_defn([DOWN])="yes"
+else
+   efl_lib_optional_[]m4_defn([DOWN])="no"
+   AC_MSG_NOTICE([Skipping $1 checks (disabled)])
+fi
+
+if test "$efl_lib_optional_[]m4_defn([DOWN])" = "yes"; then
+   EFL_LIB_START([$1])
+   AC_DEFINE([HAVE_]m4_defn([UP]), [1], [optional EFL $1 is enabled])
+dnl closed at EFL_LIB_END_OPTIONAL()
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
+
+dnl EFL_LIB_END_OPTIONAL(PKG)
+dnl closes block started by EFL_LIB_START_OPTIONAL() and then
+dnl defines AM_CONDITIONAL([HAVE_PKG]) and AC_DEFINE([HAVE_PKG])
+AC_DEFUN([EFL_LIB_END_OPTIONAL],
+[dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+
+dnl close if started at EFL_LIB_START_OPTIONAL()
+   EFL_LIB_END([$1])
+fi
+
+AM_CONDITIONAL([HAVE_]m4_defn([UP]), [test "$efl_lib_optional_[]m4_defn([DOWN])" = "yes"])dnl
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
+
+dnl EFL_ADD_FEATURE(PKG, NAME, [VALUE])
+dnl if VALUE is not specified, will use ${have_name} instead.
+dnl
+dnl Defined Variables:
+dnl     features_pkg
+AC_DEFUN([EFL_ADD_FEATURE],
+[dnl
+m4_pushdef([DOWNPKG], m4_translit([$1], [-A-Z], [_a-z]))dnl
+m4_pushdef([DOWNNAME], m4_translit([$2], [-A-Z], [_a-z]))dnl
+
+value="m4_if($3, , [${have_]m4_defn([DOWNNAME])[:-${want_]m4_defn([DOWNNAME])[}}], [$3])"
+case "${value}" in
+   yes)
+      tmp="${COLOR_YES}+$2${COLOR_RESET}"
+      ;;
+   no)
+      tmp="${COLOR_NO}-$2${COLOR_RESET}"
+      ;;
+   *)
+      tmp="${COLOR_OTHER}$2=${value}${COLOR_RESET}"
+      ;;
+esac
+if test -z "${features_[]m4_defn([DOWNPKG])}"; then
+   features_[]m4_defn([DOWNPKG])="${tmp}"
+else
+   features_[]m4_defn([DOWNPKG])="${features_[]m4_defn([DOWNPKG])} ${tmp}"
+fi
+m4_popdef([DOWNNAME])dnl
+m4_popdef([DOWNPKG])dnl
+])
diff --git a/m4/efl_attribute.m4 b/m4/efl_attribute.m4
new file mode 100644
index 0000000000..4f31d93175
--- /dev/null
+++ b/m4/efl_attribute.m4
@@ -0,0 +1,83 @@
+dnl Copyright (C) 2011 Vincent Torri <vtorri at univ-evry dot fr>
+dnl That code is public domain and can be freely used or copied.
+
+dnl Macros for checking if the compiler supports some __attribute__ uses
+
+dnl Usage: EFL_ATTRIBUTE_VECTOR
+dnl call AC_DEFINE for HAVE_GCC_ATTRIBUTE_VECTOR if __attribute__((vector)) is available
+
+AC_DEFUN([EFL_ATTRIBUTE_VECTOR],
+[
+AC_MSG_CHECKING([for __attribute__ ((vector))])
+AC_COMPILE_IFELSE(
+   [AC_LANG_PROGRAM(
+       [[
+typedef int v4si __attribute__ ((vector_size (16)));
+       ]],
+       [[
+if (sizeof(v4si) == 16)
+  return 0;
+else
+  return -1;
+       ]])],
+   [have_attribute_vector="yes"],
+   [have_attribute_vector="no"])
+AC_MSG_RESULT([${have_attribute_vector}])
+
+if test "x${have_attribute_vector}" = "xyes" ; then
+   AC_DEFINE([HAVE_GCC_ATTRIBUTE_VECTOR], [1], [Define to 1 if your compiler supports __attribute__ ((vector)).])
+fi
+])
+
+dnl Usage: EFL_ATTRIBUTE_ALWAYS_INLINE
+dnl call AC_DEFINE for alway_inline if __attribute__((always_inline)) is available
+
+AC_DEFUN([EFL_ATTRIBUTE_ALWAYS_INLINE],
+[
+
+have_attribute_forceinline="no"
+
+AC_MSG_CHECKING([for __forceinline])
+
+AC_COMPILE_IFELSE(
+   [AC_LANG_PROGRAM(
+       [[
+#include <windows.h>
+static __forceinline void foo(void) {}
+       ]],
+       [[
+       ]])],
+   [
+    have_attribute_always_inline="yes"
+    have_attribute_forceinline="yes"
+   ],
+   [have_attribute_always_inline="no"])
+
+AC_MSG_RESULT([${have_attribute_always_inline}])
+
+if test "x${have_attribute_always_inline}" = "xno" ; then
+   AC_MSG_CHECKING([for __attribute__ ((__always_inline__))])
+   AC_COMPILE_IFELSE(
+      [AC_LANG_PROGRAM(
+          [[
+static __attribute__((__always_inline__)) inline void foo(void) {}
+          ]],
+          [[
+          ]])],
+      [have_attribute_always_inline="yes"],
+      [have_attribute_always_inline="no"])
+   AC_MSG_RESULT([${have_attribute_always_inline}])
+fi
+
+if test "x${have_attribute_always_inline}" = "xyes" ; then
+   if test "x${have_attribute_forceinline}" = "xyes" ; then
+      AC_DEFINE([EFL_ALWAYS_INLINE], [__forceinline], [Macro declaring a function to always be inlined.])
+   else
+      AC_DEFINE([EFL_ALWAYS_INLINE], [__attribute__ ((__always_inline__)) inline], [Macro declaring a function to always be inlined.])
+   fi
+else
+   AC_DEFINE([EFL_ALWAYS_INLINE], [static inline], [Macro declaring a function to always be inlined.])
+fi
+])
+
+dnl End of efl_attribute.m4
diff --git a/m4/efl_beta.m4 b/m4/efl_beta.m4
new file mode 100644
index 0000000000..c8047299f7
--- /dev/null
+++ b/m4/efl_beta.m4
@@ -0,0 +1,5 @@
+dnl use: EFL_ENABLE_BETA_API_SUPPORT
+AC_DEFUN([EFL_ENABLE_BETA_API_SUPPORT],
+[
+  AC_DEFINE([EFL_BETA_API_SUPPORT], [1], [Enable access to unstable EFL API that are still in beta])
+])
diff --git a/m4/efl_binary.m4 b/m4/efl_binary.m4
new file mode 100644
index 0000000000..d11e1db297
--- /dev/null
+++ b/m4/efl_binary.m4
@@ -0,0 +1,42 @@
+dnl Usage: EFL_WITH_BIN_SUFFIX(package, binary, suffix)
+dnl Call AC_SUBST(_binary) (_binary is the lowercase of binary, - being transformed into _ by default, or the value set by the user)
+
+AC_DEFUN([EFL_WITH_BIN_SUFFIX],
+[
+
+m4_pushdef([DOWN], m4_translit([[$2]], [-A-Z], [_a-z]))dnl
+m4_pushdef([UP], m4_translit([[$2]], [-a-z], [_A-Z]))dnl
+dnl configure option
+
+_efl_with_binary=""
+_efl_binary_define="no"
+
+AC_ARG_WITH([$2],
+   [AC_HELP_STRING([--with-$2=PATH], [specify a specific path to ]DOWN[ @<:@default=]DOWN[@:>@])],
+   [
+    _efl_with_binary=${withval}
+    _efl_binary_define="yes"
+   ], [])
+
+AC_ARG_WITH([bin-$2],
+   [AC_HELP_STRING([--with-bin-$2=PATH], [specify a specific path to ]DOWN[ @<:@default=]DOWN[@:>@ DEPRECATED])],
+   [
+    _efl_with_binary=${withval}
+    _efl_binary_define="yes"
+    efl_deprecated_option="yes"
+   ], [])
+
+DOWN[]$3=${_efl_with_binary}
+AC_MSG_NOTICE(DOWN[ set to ${_efl_with_binary}])
+
+with_binary_[]m4_defn([DOWN])[]$3=${_efl_with_binary}
+
+AM_CONDITIONAL(HAVE_[]UP[]m4_translit([[$3]], [a-z], [A-Z]), [test "x${_efl_binary_define}" = "xyes"])
+AC_SUBST(DOWN[]$3)
+
+])
+
+dnl Usage: EFL_WITH_BIN(package, binary)
+dnl Call AC_SUBST(_binary) (_binary is the lowercase of binary, - being transformed into _ by default, or the value set by the user)
+
+AC_DEFUN([EFL_WITH_BIN], [EFL_WITH_BIN_SUFFIX([$1], [$2], [])])
diff --git a/m4/efl_check_funcs.m4 b/m4/efl_check_funcs.m4
new file mode 100644
index 0000000000..b44f20bc55
--- /dev/null
+++ b/m4/efl_check_funcs.m4
@@ -0,0 +1,333 @@
+dnl Copyright (C) 2012 Vincent Torri <vincent dot torri at gmail dot com>
+dnl This code is public domain and can be freely used or copied.
+
+dnl Macros that check functions availability for the EFL:
+
+dnl dirfd
+dnl dladdr
+dnl dlopen
+dnl fcntl
+dnl fnmatch
+dnl gettimeofday
+dnl iconv
+dnl setxattr (an al.)
+dnl shm_open
+
+dnl EFL_CHECK_LIB_CODE(EFL, LIB, VARIABLE, HEADER, BODY)
+dnl wrapper around AC_LINK_IFELSE(AC_LANG_PROGRAM()) to check
+dnl if some code would work with the given lib.
+dnl If the code work, EFL_ADD_LIBS(EFL, LIB) will be called
+dnl At the end VARIABLE will be "yes" or "no"
+AC_DEFUN([EFL_CHECK_LIB_CODE],
+[
+LIBS_save="${LIBS}"
+LIBS="${LIBS} $2"
+AC_LINK_IFELSE([AC_LANG_PROGRAM([$4], [$5])],
+   [EFL_ADD_LIBS([$1], [$2])
+    $3="yes"], [$3="no"])
+LIBS="${LIBS_save}"
+])
+
+dnl EFL_FIND_LIB_FOR_CODE(EFL, LIBS, VARIABLE, HEADER, BODY)
+AC_DEFUN([EFL_FIND_LIB_FOR_CODE],
+[
+dnl first try without lib (libc)
+EFL_CHECK_LIB_CODE([$1], [], [$3], [$4], [$5])
+
+if test "${$3}" = "no" && test "x$2" != "x"; then
+dnl loop through given libraries
+  for trylib in $2; do
+     EFL_CHECK_LIB_CODE([$1], [${trylib}], [$3], [$4], [$5])
+     if test "${$3}" = "yes"; then
+       break
+     fi
+  done
+fi
+])
+
+dnl _EFL_CHECK_FUNC_DIRFD is for internal use
+dnl _EFL_CHECK_FUNC_DIRFD(EFL, VARIABLE)
+
+AC_DEFUN([_EFL_CHECK_FUNC_DIRFD],
+[EFL_CHECK_LIB_CODE([$1], [], [$2], [[
+#ifdef HAVE_DIRENT_H
+# include <dirent.h>
+#endif
+]], [[DIR *dirp; return dirfd(dirp);]])
+])
+
+dnl _EFL_CHECK_FUNC_DLADDR is for internal use
+dnl _EFL_CHECK_FUNC_DLADDR(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_DLADDR],
+[
+dllibs=""
+case "$host_os" in
+   linux*)
+      dllibs="-ldl"
+   ;;
+   *)
+   ;;
+esac
+case "$host_os" in
+   mingw*)
+      $2="yes"
+   ;;
+   *)
+      EFL_FIND_LIB_FOR_CODE([$1], [$dllibs], [$2], [[
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE
+#endif
+#include <stdlib.h>
+#include <dlfcn.h>
+]], [[int res = dladdr(NULL, NULL);]])
+   ;;
+esac
+])
+
+dnl _EFL_CHECK_FUNC_DLOPEN is for internal use
+dnl _EFL_CHECK_FUNC_DLOPEN(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_DLOPEN],
+[
+dllibs=""
+case "$host_os" in
+   linux*)
+      dllibs="-ldl"
+   ;;
+   *)
+   ;;
+esac
+case "$host_os" in
+   mingw*)
+      $2="yes"
+   ;;
+   *)
+      EFL_FIND_LIB_FOR_CODE([$1], [$dllibs], [$2], [[
+#include <dlfcn.h>
+]], [[void *h = dlopen(0, 0);]])
+   ;;
+esac
+])
+
+dnl _EFL_CHECK_FUNC_DLSYM is for internal use
+dnl _EFL_CHECK_FUNC_DLSYM(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_DLSYM],
+[
+dllibs=""
+case "$host_os" in
+   linux*)
+      dllibs="-ldl"
+   ;;
+   *)
+   ;;
+esac
+case "$host_os" in
+   mingw*)
+      $2="yes"
+   ;;
+   *)
+      EFL_FIND_LIB_FOR_CODE([$1], [$dllibs], [$2], [[
+#ifndef _GNU_SOURCE
+# define _GNU_SOURCE
+#endif
+#include <stdlib.h>
+#include <dlfcn.h>
+]], [[void *res = dlsym(NULL, NULL);]])
+   ;;
+esac
+])
+
+dnl _EFL_CHECK_FUNC_FCNTL is for internal use
+dnl _EFL_CHECK_FUNC_FCNTL(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_FCNTL],
+[
+case "$host_os" in
+   mingw*)
+      $2="yes"
+   ;;
+   *)
+      EFL_FIND_LIB_FOR_CODE([$1], [], [$2], [[
+#include <fcntl.h>
+]], [[int g = fcntl(0, 0);]])
+   ;;
+esac
+])
+
+dnl _EFL_CHECK_FUNC_FNMATCH is for internal use
+dnl _EFL_CHECK_FUNC_FNMATCH(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_FNMATCH],
+[
+case "$host_os" in
+   mingw*)
+      $2="yes"
+   ;;
+   *)
+      EFL_FIND_LIB_FOR_CODE([$1], [-lfnmatch -liberty], [$2], [[
+#include <stdlib.h>
+#include <fnmatch.h>
+]], [[int g = fnmatch(NULL, NULL, 0);]])
+   ;;
+esac
+])
+
+dnl _EFL_CHECK_FUNC_SCHED_GETCPU is for internal use
+dnl _EFL_CHECK_FUNC_SCHED_GETCPU(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_SCHED_GETCPU],
+[
+   EFL_CHECK_LIB_CODE([$1], [], [$2], [[
+#include <sched.h>
+]], [[int cpu = sched_getcpu();]])
+])
+
+dnl _EFL_CHECK_FUNC_GETTIMEOFDAY is for internal use
+dnl _EFL_CHECK_FUNC_GETTIMEOFDAY(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_GETTIMEOFDAY],
+[
+case "$host_os" in
+   mingw*)
+      $2="yes"
+   ;;
+   *)
+      EFL_CHECK_LIB_CODE([$1], [], [$2], [[
+#include <stdlib.h>
+#include <sys/time.h>
+]], [[int res = gettimeofday(NULL, NULL);]])
+
+      if test "${$2}" = "no" && test "x${enable_exotic}" = "xyes"; then
+         SAVE_CFLAGS="${CFLAGS}"
+         CFLAGS="${CFLAGS} ${EXOTIC_CFLAGS}"
+         EFL_CHECK_LIB_CODE([$1], [${EXOTIC_LIBS}], [$2], [[
+#include <Exotic.h>
+]], [[int res = gettimeofday(NULL, NULL);]])
+         CFLAGS="${SAVE_CFLAGS}"
+      fi
+   ;;
+esac
+])
+
+dnl _EFL_CHECK_FUNC_ICONV is for internal use
+dnl _EFL_CHECK_FUNC_ICONV(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_ICONV],
+[dnl
+AC_ARG_WITH([iconv-link],
+   AC_HELP_STRING([--with-iconv-link=ICONV_LINK], [explicitly specify an iconv link option]),
+   [
+    $2="yes"
+    iconv_libs=${withval}
+   ],
+   [$2="no"])
+
+if test "x${iconv_libs}" = "x" ; then
+   EFL_FIND_LIB_FOR_CODE([$1], [-liconv -liconv_plug], [$2], [[
+#include <stdlib.h>
+#include <iconv.h>
+]], [[iconv_t ic; size_t count = iconv(ic, NULL, NULL, NULL, NULL);]])
+fi
+])
+
+dnl _EFL_CHECK_FUNC_SETXATTR is for internal use
+dnl _EFL_CHECK_FUNC_SETXATTR(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_SETXATTR],
+[EFL_CHECK_LIB_CODE([$1], [], [$2], [[
+#include <stdlib.h>
+#include <sys/types.h>
+#include <sys/xattr.h>
+]], [[
+size_t tmp = listxattr("/", NULL, 0);
+tmp = getxattr("/", "user.ethumb.md5", NULL, 0);
+setxattr("/", "user.ethumb.md5", NULL, 0, 0);
+]])
+
+if test "${$2}" = "yes"; then
+  AC_DEFINE([HAVE_XATTR], [1], [Define to 1 if you have the `listxattr', `setxattr' and `getxattr' functions.])
+fi
+])
+
+dnl _EFL_CHECK_FUNC_SHM_OPEN is for internal use
+dnl _EFL_CHECK_FUNC_SHM_OPEN(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_SHM_OPEN],
+[
+shmlibs=""
+case "$host_os" in
+   linux*)
+      shmlibs="-lrt"
+   ;;
+   *)
+   ;;
+esac
+EFL_FIND_LIB_FOR_CODE([$1], [$shmlibs], [$2], [[
+#include <sys/mman.h>
+#include <sys/stat.h>        /* For mode constants */
+#include <fcntl.h>           /* For O_* constants */
+]], [[
+int fd = shm_open("/dev/null", O_RDONLY, S_IRWXU | S_IRWXG | S_IRWXO);
+]])
+])
+
+dnl _EFL_CHECK_FUNC_SPLICE is for internal use
+dnl _EFL_CHECK_FUNC_SPLICE(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_SPLICE],
+[EFL_FIND_LIB_FOR_CODE([$1], [], [$2], [[
+#include <unistd.h>
+#include <fcntl.h>
+]], [[
+long ret = splice(0, 0, 1, 0, 400, 0);
+]])
+])
+
+dnl _EFL_CHECK_FUNC_GETPAGESIZE is for internal use
+dnl _EFL_CHECK_FUNC_GETPAGESIZE(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_GETPAGESIZE],
+[EFL_FIND_LIB_FOR_CODE([$1], [], [$2], [[
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+]],
+[[
+long sz;
+sz = getpagesize();
+]])
+])
+
+dnl _EFL_CHECK_FUNC_PRCTL is for internal use
+dnl _EFL_CHECK_FUNC_PRCTL(EFL, VARIABLE)
+AC_DEFUN([_EFL_CHECK_FUNC_PRCTL],
+[EFL_FIND_LIB_FOR_CODE([$1], [], [$2], [[
+#include <sys/prctl.h>
+]],
+[[
+prctl(PR_SET_TIMERSLACK, 1, 0, 0, 0);
+]])
+])
+
+dnl Macro that checks function availability
+dnl
+dnl EFL_CHECK_FUNC(EFL, FUNCTION)
+dnl AC_SUBST : EFL_CFLAGS and EFL_LIBS (EFL being replaced by its value)
+dnl AC_DEFINE : HAVE_FUNCTION (FUNCTION being replaced by its value)
+dnl result in efl_func_function (function being replaced by its value)
+
+AC_DEFUN([EFL_CHECK_FUNC],
+[dnl
+m4_pushdef([UP], m4_translit([$2], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWN], m4_translit([$2], [-A-Z], [_a-z]))dnl
+
+m4_default([_EFL_CHECK_FUNC_]m4_defn([UP]))($1, [have_fct])
+AC_MSG_CHECKING([for $2])
+AC_MSG_RESULT([${have_fct}])
+
+if test "x${have_fct}" = "xyes" ; then
+  AC_DEFINE([HAVE_]m4_defn([UP]), [1], [Define to 1 if you have the `]m4_defn([DOWN])[' function.])
+fi
+
+efl_func_[]m4_defn([DOWN])="${have_fct}"
+m4_popdef([DOWN])dnl
+m4_popdef([UP])dnl
+])
+
+dnl Macro that iterates over a sequence of space separated functions
+dnl and that calls EFL_CHECK_FUNC() for each of these functions
+dnl
+dnl EFL_CHECK_FUNCS(EFL, FUNCTIONS)
+
+AC_DEFUN([EFL_CHECK_FUNCS],
+[m4_foreach_w([fct], [$2], [EFL_CHECK_FUNC($1, m4_defn([fct]))])])
diff --git a/m4/efl_check_libs.m4 b/m4/efl_check_libs.m4
new file mode 100644
index 0000000000..c64013bf7c
--- /dev/null
+++ b/m4/efl_check_libs.m4
@@ -0,0 +1,73 @@
+dnl Copyright (C) 2012 Vincent Torri <vincent dot torri at gmail dot com>
+dnl This code is public domain and can be freely used or copied.
+
+dnl Macro that check dependencies libraries for the EFL:
+
+dnl libjpeg
+dnl zlib
+
+dnl _EFL_CHECK_LIB_LIBJPEG is for internal use
+dnl _EFL_CHECK_LIB_LIBJPEG(EFL)
+dnl it will abort (AC_MSG_ERROR) if libjpeg is not found.
+
+AC_DEFUN([_EFL_CHECK_LIB_LIBJPEG],
+[dnl
+EFL_CHECK_LIB_CODE([$1], [-ljpeg], [have_fct], [[
+#include <stdio.h>
+#include <jpeglib.h>
+]], [[
+struct jpeg_error_mgr er; void *error = jpeg_std_error(&er);
+]])
+
+if test "${have_fct}" = "no"; then
+  AC_MSG_ERROR([Cannot find libjpeg. Make sure your CFLAGS and LDFLAGS environment variable are set properly.])
+fi
+])
+
+dnl _EFL_CHECK_LIB_ZLIB is for internal use
+dnl _EFL_CHECK_LIB_ZLIB(EFL)
+dnl it will abort (AC_MSG_ERROR) if zlib is not found.
+
+AC_DEFUN([_EFL_CHECK_LIB_ZLIB],
+[dnl
+m4_pushdef([DOWNEFL], m4_translit([$1], [-A-Z], [_a-z]))dnl
+
+PKG_CHECK_EXISTS([zlib >= 1.2.3], [_efl_have_lib="yes"], [_efl_have_lib="no"])
+
+if test "${_efl_have_lib}" = "yes"; then
+   requirements_pc_[]m4_defn([DOWNEFL])="${requirements_pc_[]m4_defn([DOWNEFL])} zlib >= 1.2.3"
+   requirements_pc_deps_[]m4_defn([DOWNEFL])="${requirements_pc_deps_[]m4_defn([DOWNEFL])} zlib >= 1.2.3"
+else
+   EFL_CHECK_LIB_CODE([$1], [-lz], [have_fct], [[
+#include <zlib.h>
+]], [[const char *v = zlibVersion();]])
+
+  if test "${have_fct}" = "no"; then
+    AC_MSG_ERROR([Cannot find zlib. Make sure your CFLAGS and LDFLAGS environment variable are set properly.])
+  fi
+fi
+m4_popdef([DOWNEFL])dnl
+])
+
+dnl Macro that checks for a library
+dnl
+dnl EFL_CHECK_LIB(EFL, LIBRARY)
+dnl it will abort if library is not found
+
+AC_DEFUN([EFL_CHECK_LIB],
+[dnl
+m4_pushdef([UP], m4_translit([$2], [-a-z], [_A-Z]))dnl
+m4_default([_EFL_CHECK_LIB_]m4_defn([UP]))($1)
+AC_MSG_CHECKING([for $2])
+AC_MSG_RESULT([yes])
+m4_popdef([UP])dnl
+])
+
+dnl Macro that iterates over a sequence of white separated libraries
+dnl and that calls EFL_CHECK_LIB() for each of these libraries
+dnl
+dnl EFL_CHECK_LIBS(EFL, LIBRARIES)
+dnl it will abort if libraries are not found
+
+AC_DEFUN([EFL_CHECK_LIBS],
+[m4_foreach_w([lib], [$2], [EFL_CHECK_LIB($1, m4_defn([lib]))])])
diff --git a/m4/efl_compiler.m4 b/m4/efl_compiler.m4
new file mode 100644
index 0000000000..1d3499222f
--- /dev/null
+++ b/m4/efl_compiler.m4
@@ -0,0 +1,90 @@
+dnl Copyright (C) 2012 Vincent Torri <vincent dot torri at gmail dot com>
+dnl This code is public domain and can be freely used or copied.
+
+dnl Macro that check if compiler of linker flags are available
+
+
+dnl Macro that checks for a compiler flag availability
+dnl
+dnl _EFL_CHECK_COMPILER_FLAGS(EFL, FLAGS)
+dnl AC_SUBST : EFL_CFLAGS (EFL being replaced by its value)
+dnl have_flag: yes or no.
+AC_DEFUN([_EFL_CHECK_COMPILER_FLAGS],
+[dnl
+m4_pushdef([UPEFL], m4_translit([[$1]], [-a-z], [_A-Z]))dnl
+
+dnl store in options -Wfoo if -Wno-foo is passed
+option="m4_bpatsubst([[$2]], [-Wno-], [-W])"
+CFLAGS_save="${CFLAGS}"
+CFLAGS="${CFLAGS} ${option}"
+AC_LANG_PUSH([C])
+
+AC_MSG_CHECKING([whether the compiler supports $2])
+AC_COMPILE_IFELSE(
+   [AC_LANG_PROGRAM([[]])],
+   [have_flag="yes"],
+   [have_flag="no"])
+AC_MSG_RESULT([${have_flag}])
+
+AC_LANG_POP([C])
+CFLAGS="${CFLAGS_save}"
+if test "x${have_flag}" = "xyes" ; then
+   UPEFL[_CFLAGS]="${UPEFL[_CFLAGS]} [$2]"
+fi
+AC_SUBST(UPEFL[_CFLAGS])dnl
+m4_popdef([UPEFL])dnl
+])
+
+dnl EFL_CHECK_COMPILER_FLAGS(EFL, FLAGS)
+dnl Checks if FLAGS are supported and add to EFL_CLFAGS.
+dnl
+dnl It will first try every flag at once, if one fails will try them one by one.
+AC_DEFUN([EFL_CHECK_COMPILER_FLAGS],
+[dnl
+_EFL_CHECK_COMPILER_FLAGS([$1], [$2])
+if test "${have_flag}" != "yes"; then
+m4_foreach_w([flag], [$2], [_EFL_CHECK_COMPILER_FLAGS([$1], m4_defn([flag]))])
+fi
+])
+
+
+dnl Macro that checks for a linker flag availability
+dnl
+dnl _EFL_CHECK_LINKER_FLAGS(EFL, FLAGS)
+dnl AC_SUBST : EFL_LDFLAGS (EFL being replaced by its value)
+dnl have_flag: yes or no
+AC_DEFUN([_EFL_CHECK_LINKER_FLAGS],
+[dnl
+m4_pushdef([UPEFL], m4_translit([[$1]], [-a-z], [_A-Z]))dnl
+
+LDFLAGS_save="${LDFLAGS}"
+LDFLAGS="${LDFLAGS} $2"
+AC_LANG_PUSH([C])
+
+AC_MSG_CHECKING([whether the linker supports $2])
+AC_LINK_IFELSE(
+   [AC_LANG_PROGRAM([[]])],
+   [have_flag="yes"],
+   [have_flag="no"])
+AC_MSG_RESULT([${have_flag}])
+
+AC_LANG_POP([C])
+LDFLAGS="${LDFLAGS_save}"
+if test "x${have_flag}" = "xyes" ; then
+   UPEFL[_LDFLAGS]="${UPEFL[_LDFLAGS]} [$2]"
+fi
+AC_SUBST(UPEFL[_LDFLAGS])dnl
+m4_popdef([UPEFL])dnl
+])
+
+dnl EFL_CHECK_LINKER_FLAGS(EFL, FLAGS)
+dnl Checks if FLAGS are supported and add to EFL_LDLFAGS.
+dnl
+dnl It will first try every flag at once, if one fails will try them one by one.
+AC_DEFUN([EFL_CHECK_LINKER_FLAGS],
+[dnl
+_EFL_CHECK_LINKER_FLAGS([$1], [$2])
+if test "${have_flag}" != "yes"; then
+m4_foreach_w([flag], [$2], [_EFL_CHECK_LINKER_FLAGS([$1], m4_defn([flag]))])
+fi
+])dnl
diff --git a/m4/efl_define.m4 b/m4/efl_define.m4
new file mode 100644
index 0000000000..2b73a691e8
--- /dev/null
+++ b/m4/efl_define.m4
@@ -0,0 +1,20 @@
+dnl
+dnl EFL_CHECK_DEFINE(symbol, header_file)
+dnl
+dnl NOTE: EFL_CHECK_DEFINE is strongly inspired by
+dnl       APR_CHECK_DEFINE which can be found in the
+dnl       sources of Apache's APR (under Apache Licence)
+dnl
+AC_DEFUN([EFL_CHECK_DEFINE], [
+  AC_CACHE_CHECK([for $1 in $2],ac_cv_define_$1,[
+    AC_EGREP_CPP(YES_IS_DEFINED, [
+#include <$2>
+#ifdef $1
+YES_IS_DEFINED
+#endif
+    ], ac_cv_define_$1=yes, ac_cv_define_$1=no)
+  ])
+  if test "$ac_cv_define_$1" = "yes"; then
+    AC_DEFINE(HAVE_$1, 1, [Define if $1 is defined in $2])
+  fi
+])
diff --git a/m4/efl_doxygen.m4 b/m4/efl_doxygen.m4
new file mode 100644
index 0000000000..0c1452fee0
--- /dev/null
+++ b/m4/efl_doxygen.m4
@@ -0,0 +1,98 @@
+dnl Copyright (C) 2008 Vincent Torri <vtorri at univ-evry dot fr>
+dnl That code is public domain and can be freely used or copied.
+
+dnl Macro that check if doxygen is available or not.
+
+dnl EFL_CHECK_DOXYGEN([ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
+dnl Test for the doxygen program
+dnl Defines efl_doxygen
+dnl Defines the automake conditionnal EFL_BUILD_DOC
+dnl
+AC_DEFUN([EFL_CHECK_DOXYGEN],
+[
+
+dnl
+dnl Disable the build of the documentation
+dnl
+AC_ARG_ENABLE([doc],
+   [AC_HELP_STRING(
+       [--disable-doc],
+       [Disable documentation build @<:@default=enabled@:>@])],
+   [
+    if test "x${enableval}" = "xyes" ; then
+       efl_enable_doc="yes"
+    else
+       efl_enable_doc="no"
+    fi
+   ],
+   [efl_enable_doc="yes"]
+)
+
+if test "x${efl_enable_doc}" = "xyes" ; then
+
+dnl
+dnl Specify the full file name, with path
+dnl
+
+   efl_doxygen="doxygen"
+
+   AC_ARG_WITH([doxygen],
+      [AC_HELP_STRING(
+          [--with-doxygen=FILE],
+          [doxygen program to use @<:@default=doxygen@:>@])],
+dnl
+dnl Check the given doxygen program.
+dnl
+      [efl_doxygen=${withval}
+       AC_CHECK_PROG([efl_have_doxygen],
+          [${efl_doxygen}],
+          [yes],
+          [no])
+       if test "x${efl_have_doxygen}" = "xno" ; then
+          echo "WARNING:"
+          echo "The doxygen program you specified:"
+          echo "$efl_doxygen"
+          echo "was not found.  Please check the path and make sure "
+          echo "the program exists and is executable."
+          AC_MSG_WARN([Warning: no doxygen detected. Documentation will not be built])
+       fi
+      ],
+      [AC_CHECK_PROG([efl_have_doxygen],
+          [${efl_doxygen}],
+          [yes],
+          [no])
+       if test "x${efl_have_doxygen}" = "xno" ; then
+          echo "WARNING:"
+          echo "The doxygen program was not found in your execute"
+          echo "You may have doxygen installed somewhere not covered by your path."
+          echo ""
+          echo "If this is the case make sure you have the packages installed, AND"
+          echo "that the doxygen program is in your execute path (see your"
+          echo "shell manual page on setting the \$PATH environment variable), OR"
+          echo "alternatively, specify the program to use with --with-doxygen."
+          AC_MSG_WARN([Warning: no doxygen detected. Documentation will not be built])
+       fi
+      ]
+   )
+fi
+
+dnl
+dnl Substitution
+dnl
+AC_SUBST([efl_doxygen])
+
+if ! test "x${efl_have_doxygen}" = "xyes" ; then
+   efl_enable_doc="no"
+fi
+
+AM_CONDITIONAL(EFL_BUILD_DOC, test "x${efl_enable_doc}" = "xyes")
+
+if test "x${efl_enable_doc}" = "xyes" ; then
+  ifelse([$1], , :, [$1])
+else
+  ifelse([$2], , :, [$2])
+fi
+
+])
+
+dnl End of doxygen.m4
diff --git a/m4/efl_eo.m4 b/m4/efl_eo.m4
new file mode 100644
index 0000000000..864baf5fc1
--- /dev/null
+++ b/m4/efl_eo.m4
@@ -0,0 +1,6 @@
+dnl use: EFL_ENABLE_EO_API_SUPPORT
+AC_DEFUN([EFL_ENABLE_EO_API_SUPPORT],
+[
+  AC_DEFINE([EFL_EO_API_SUPPORT], [1], [Enable access to unstable EFL Eo API])
+])
+
diff --git a/m4/efl_find_x.m4 b/m4/efl_find_x.m4
new file mode 100644
index 0000000000..8c9f5c3677
--- /dev/null
+++ b/m4/efl_find_x.m4
@@ -0,0 +1,194 @@
+# efl_find.x.m4 - Macros to locate X11.                       -*- Autoconf -*-
+# EFL_FIND_X(VARIABLE-PREFIX, [headers = "X11/Xlib.h"],
+#            [libs-and-functions = "X11 XOpenDisplay"],
+#            [action-if-found], [action-if-not-found])
+# checks for X11 using, in order:
+# 1) Xorg pkg-config files (using enviroment variables EFL_X11_CFLAGS
+#                           and EFL_X11_LIBS if set, but only if x11.pc exists)
+# 2) command line options: --x-includes=dir, --x-libraries=dir
+#                          assume there is an X11 in the given directories
+# 3) XMKMF environment variable if set
+# 4) xmkmf executable if found
+# 5) list of "standard" directories
+#
+# 2-5 is handled by A_PATH_X
+#
+# If a X11 is found, [action-if-success] is run and VARIABLE_cflags and
+# VARIABLE_libs and VARIABLE_libdirs are defined and substituted.
+# VARIABLE_libs will contain all of the libs listed in libs-and-functions.
+# VARIABLE_libdirs will contain all -Lpath:s found in VARIABLE_libs
+#
+# headers is a list of headers to look for. libs-and-functions is a list of
+# library and function pairs to look for.
+# Each lib and function is checked in pairs, example:
+# EFL_FIND_X([EVAS_X11], [X11/X.h], [X11 XCreateImage Xext XShmCreateImage])
+# will look for XCreateImage in X11 and XShmCreateImage in Xext and include
+# both -lX11 and -lXext in VARIABLE_libs
+#
+# action-if-found is only called if X11, all headers, all libraries and
+# all functions are found.
+# You can call EFL_FIND_X multiple times with different lists of headers, libs
+# and functions.
+
+AC_DEFUN([EFL_FIND_X],
+[
+  # Must print something as AC_CACHE_VAL writes (cached) if the value is cached
+  AC_MSG_CHECKING([how to find X])
+  efl_x11_need_result=1
+  AC_CACHE_VAL(efl_cv_x11_cache,
+    [
+      # this is ugly and breaks that AC_CACHE_VAL may not have side effects
+      # but I can't think of a better way right now
+      efl_x11_need_result=0
+      PKG_CHECK_EXISTS([x11],
+        [
+          AC_MSG_RESULT([use pkg-config])
+          PKG_CHECK_MODULES([EFL_X11],[x11],
+            [
+              efl_cv_have_x11=yes
+              efl_cv_x11_pkgconf=yes
+              efl_cv_x11_cflags=$EFL_X11_CFLAGS
+              efl_cv_x11_libs_pre=$EFL_X11_LIBS
+              efl_cv_x11_libs_post=
+            ])
+        ],
+        [
+          AC_MSG_RESULT([use xmkmf])
+          # Fallback to old AC_PATH_XTRA
+          AC_PATH_X
+          AC_PATH_XTRA
+          if test "$no_x" = yes; then
+            efl_cv_have_x11=no
+          else
+            efl_cv_have_x11=yes
+            efl_cv_x11_pkgconf=no
+            efl_cv_x11_cflags=$X_CFLAGS
+            efl_cv_x11_libs_pre="$X_PRE_LIBS $X_LIBS"
+            efl_cv_x11_libs_post=$X_EXTRA_LIBS
+          fi
+         ])
+      # Record where we found X for the cache.
+      if test "x$efl_cv_have_x11" = "xno"; then
+        efl_cv_x11_cache="efl_cv_have_x11=no"
+      else
+        efl_cv_x11_cache="efl_cv_have_x11=yes\
+          efl_cv_x11_pkgconf='$efl_cv_x11_pkgconf'\
+          efl_cv_x11_cflags='$efl_cv_x11_cflags'\
+          efl_cv_x11_libs_pre='$efl_cv_x11_libs_pre'\
+          efl_cv_x11_libs_post='$efl_cv_x11_libs_post'"
+      fi
+    ])
+  if test "x$efl_x11_need_result" = "x1"; then
+    AC_MSG_RESULT([already found])
+  fi
+  eval "$efl_cv_x11_cache"
+
+  if test "x$efl_cv_have_x11" = "xyes"; then
+    ELF_X11_CFLAGS_save="$CFLAGS"
+    ELF_X11_CPPFLAGS_save="$CPPFLAGS"
+    CFLAGS="$CFLAGS $efl_cv_x11_cflags"
+    CPPFLAGS="$CPPFLAGS $efl_cv_x11_cflags"
+    efl_x11_found_all=1
+    for efl_x11_header in ifelse([$2], , "X11/Xlib.h", [$2]); do
+      AC_CHECK_HEADER([$efl_x11_header],,[
+        efl_x11_found_all=0
+        break])
+    done
+    CPPFLAGS="$ELF_X11_CPPFLAGS_save"
+    CFLAGS="$ELF_X11_CFLAGS_save"
+
+    if test "x$efl_x11_found_all" = "x1"; then
+      EFL_X11_LIBS_save="$LIBS"
+      if test "x$efl_cv_x11_pkgconf" = "xyes"; then
+        efl_x11_modules="x11"
+        efl_x11_lib=""
+        for efl_x11_lib_function in ifelse([$3], , "X11 XOpenDisplay", [$3]); do
+          if test -z "$efl_x11_lib"; then
+            efl_x11_lib="$efl_x11_lib_function"
+            case $efl_x11_lib in
+              X11)
+                ;;
+              Xss)
+                efl_x11_modules="$efl_x11_modules xscrnsaver"
+                ;;
+              *)
+                efl_x11_lib=`echo $efl_x11_lib | tr '[A-Z]' '[a-z]'`
+                efl_x11_modules="$efl_x11_modules $efl_x11_lib"
+                ;;
+            esac
+          else
+            efl_x11_lib=
+          fi
+        done
+        efl_x11_modules="$efl_x11_modules x11-xcb"
+
+        PKG_CHECK_EXISTS([$efl_x11_modules],
+          [
+            PKG_CHECK_MODULES([$1],[$efl_x11_modules],
+              [
+                efl_x11_cflags=$[]$1[]_CFLAGS
+                efl_x11_libs=$[]$1[]_LIBS
+
+                LIBS="$LIBS $[]$1[]_LIBS"
+                efl_x11_lib=""
+                for efl_x11_lib_function in ifelse([$3], , "X11 XOpenDisplay", [$3]); do
+                  if test -z "$efl_x11_lib"; then
+                    efl_x11_lib="$efl_x11_lib_function"
+                  else
+                    # This is a ugly way of using AC_CHECK_FUNC with different
+                    # LIBS
+                    eval "unset ac_cv_func_$efl_x11_lib_function"
+                    AC_CHECK_FUNC([$efl_x11_lib_function],,
+                      [
+                        efl_x11_found_all=0
+                        break])
+                    efl_x11_lib=
+                  fi
+                done
+              ])
+           ],[efl_x11_found_all=0])
+      else
+        LIBS="$LIBS $efl_cv_x11_libs_pre"
+        efl_x11_libs="$efl_cv_x11_libs_pre"
+        efl_x11_lib=""
+        for efl_x11_lib_function in ifelse([$3], , "X11 XOpenDisplay", [$3]); do
+          if test -z "$efl_x11_lib"; then
+            efl_x11_lib="$efl_x11_lib_function"
+          else
+            AC_CHECK_LIB([$efl_x11_lib], [$efl_x11_lib_function],,[
+              efl_x11_found_all=0
+              break],["$efl_cv_x11_libs_post"])
+            efl_x11_libs="$efl_x11_libs -l$efl_x11_lib"
+            efl_x11_lib=
+          fi
+        done
+        if test -n "$efl_cv_x11_libs_post"; then
+          efl_x11_libs="$efl_x11_libs $efl_cv_x11_libs_post"
+        fi
+      fi
+      LIBS="$EFL_X11_LIBS_save"
+    fi
+  fi
+
+  if test "x$efl_x11_found_all" = "x1"; then
+    efl_x11_libdirs=""
+    for efl_x11_option in "$efl_x11_libs"; do
+      case $efl_x11_option in
+        -L*)
+          efl_x11_libdirs="$efl_x11_libdirs $efl_x11_option"
+          ;;
+        *)
+          ;;
+      esac
+    done
+
+    AC_SUBST([$1][_cflags],[$efl_cv_x11_cflags])
+    AC_SUBST([$1][_libs],[$efl_x11_libs])
+    AC_SUBST([$1][_libdirs],[$efl_x11_libdirs])
+
+    ifelse([$4], , :, [$4])
+  else
+    ifelse([$5], , :, [$5])
+  fi
+])
+
diff --git a/m4/efl_libunwind.m4 b/m4/efl_libunwind.m4
new file mode 100644
index 0000000000..e9ca682cfb
--- /dev/null
+++ b/m4/efl_libunwind.m4
@@ -0,0 +1,61 @@
+dnl This code is public domain and can be freely used or copied.
+dnl File to auto-detect libunwind
+
+dnl Macro that checks for libunwind, first by using
+dnl pkg-config, then by trying to compile and link a simple
+dnl program, to see if libunwind is distributed on the system
+dnl but has no pkg-config support
+dnl
+dnl The biggest usecase is on Mac OS X, where there are no
+dnl pkg-config files, and the libunwind headers are lost
+dnl in an obscure place on the system (but whom the compilers
+dnl distributed by Apple are aware of).
+dnl
+dnl Usage: EFL_CHECK_LIBUNWIND
+dnl  will inconditionaly set UNWIND_CFLAGS and UNWIND_LIBS
+dnl  to follow pkg-config fashion.
+dnl
+AC_DEFUN([EFL_CHECK_LIBUNWIND],
+[dnl
+   dnl First, check with pkg-config
+   PKG_CHECK_MODULES([UNWIND], [libunwind libunwind-generic],
+                     [have_unwind=yes], [have_unwind=no])
+
+   dnl No pkg-config file... maybe system built-in?
+   if test "x${have_unwind}" = "xno"; then
+      AC_LANG_PUSH([C])
+      AC_LINK_IFELSE(
+         [AC_LANG_PROGRAM(
+            [[
+#include <libunwind.h>
+            ]],
+            [[
+               unw_context_t ctx;
+               unw_getcontext(&ctx);
+            ]]
+         )],
+         [
+            have_unwind="yes"
+         ],
+         [
+            have_unwind="no"
+         ]
+      )
+      AC_MSG_CHECKING([for native libunwind])
+      AC_MSG_RESULT([${have_unwind}])
+      AC_LANG_POP([C])
+
+      dnl Provide dummy variables to automake.
+      dnl In case pkg-config succeeded, these will be set and
+      dnl used in other automake files. To avoid, problems,
+      dnl we define empty variables.
+      UNWIND_CFLAGS=""
+      UNWIND_LIBS=""
+      AC_SUBST([UNWIND_CFLAGS])
+      AC_SUBST([UNWIND_LIBS])
+   fi
+
+   AS_IF([test "x$have_unwind" = "xyes"],
+         [AC_DEFINE([HAVE_UNWIND], [1], [Have libunwind])])
+   AM_CONDITIONAL(HAVE_UNWIND, test "x$have_unwind" = "xyes")
+])
diff --git a/m4/efl_lua_old.m4 b/m4/efl_lua_old.m4
new file mode 100644
index 0000000000..537a6f336b
--- /dev/null
+++ b/m4/efl_lua_old.m4
@@ -0,0 +1,36 @@
+dnl EFL_CHECK_LUA_OLD(EFL)
+dnl checks for lua 5.1 or 5.2 in pkg-config (multiple names) and -llua directly
+dnl will call EFL_ADD_LIBS() or EFL_DEPEND_PKG() as required.
+dnl this is a strict call and will abort if lua is not found
+dnl keep in mind that this is only executed if --enable-lua-old is set
+AC_DEFUN([EFL_CHECK_LUA_OLD],
+[dnl
+requirement_lua=""
+PKG_CHECK_EXISTS([lua >= 5.1.0], [requirement_lua="lua >= 5.1.0"],
+   [PKG_CHECK_EXISTS([lua5.1 >= 5.1.0], [requirement_lua="lua5.1 >= 5.1.0"],
+      [PKG_CHECK_EXISTS([lua-5.1 >= 5.1.0], [requirement_lua="lua-5.1 >= 5.1.0"],
+         [PKG_CHECK_EXISTS([lua51 >= 5.1.0], [requirement_lua="lua51 >= 5.1.0"],
+            [PKG_CHECK_EXISTS([lua5.2 >= 5.2.0], [requirement_lua="lua5.2 >= 5.2.0"],
+               [PKG_CHECK_EXISTS([lua-5.2 >= 5.2.0], [requirement_lua="lua-5.2 >= 5.2.0"],
+                  [PKG_CHECK_EXISTS([lua52 >= 5.2.0], [requirement_lua="lua52 >= 5.2.0"])])])])])])])
+
+if test "x${requirement_lua}" = "x"; then
+   AC_MSG_CHECKING([whether lua_newstate() is in liblua])
+   AC_CHECK_LIB([lua], [lua_newstate],
+      [have_lua="yes"
+       EFL_ADD_LIBS([$1], [-llua])],
+      [have_lua="no"])
+   AC_MSG_RESULT([${have_lua}])
+   if test "${have_lua}" = "no"; then
+      AC_MSG_ERROR([Missing lua 5.1 or 5.2 support])
+   fi
+else
+   req_found="no"
+   EFL_DEPEND_PKG([$1], [LUA], [${requirement_lua}],
+                  [ req_found="yes" ],
+                  [ req_found="no" ])
+   if test "x${req_found}" = "xyes"; then
+      PKG_CHECK_MODULES([$1]_LUA, [${requirement_lua}])
+   fi
+fi
+])
diff --git a/m4/efl_mono.m4 b/m4/efl_mono.m4
new file mode 100644
index 0000000000..807526ee24
--- /dev/null
+++ b/m4/efl_mono.m4
@@ -0,0 +1,95 @@
+# # ============================================================================
+# #  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
+# # ============================================================================
+# #
+# # SYNOPSIS
+# #
+# #   AX_CXX_COMPILE_STDCXX_11([ext|noext],[mandatory|optional])
+# #
+# # DESCRIPTION
+# #
+# #   Check for baseline language coverage in the compiler for the C++11
+# #   standard; if necessary, add switches to CXXFLAGS to enable support.
+# #
+# #   The first argument, if specified, indicates whether you insist on an
+# #   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+# #   -std=c++11).  If neither is specified, you get whatever works, with
+# #   preference for an extended mode.
+# #
+# #   The second argument, if specified 'mandatory' or if left unspecified,
+# #   indicates that baseline C++11 support is required and that the macro
+# #   should error out if no mode with that support is found.  If specified
+# #   'optional', then configuration proceeds regardless, after defining
+# #   HAVE_CXX11 if and only if a supporting mode is found.
+# #
+# # LICENSE
+# #
+# #   Copyright (c) 2016 Felipe Magno de Almeida <felipe@expertisesolutions.com.br>
+# #
+# #   Copying and distribution of this file, with or without modification, are
+# #   permitted in any medium without royalty provided the copyright notice
+# #   and this notice are preserved. This file is offered as-is, without any
+# #   warranty.
+
+# AC_LANG(CSHARP)
+# -----------
+AC_LANG_DEFINE([CSHARP], [csharp], [MCS], [],
+[ac_ext=cs
+ac_compile='$MCS $MCSFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
+])
+
+AU_DEFUN([AC_LANG_CSHARP], [AC_LANG(CSHARP)])
+
+m4_define([AC_LANG_PROGRAM(CSHARP)],
+[$1
+class MyClass
+{
+    static void Main(string[] args)
+    {
+        $2
+    }
+}])
+
+AC_DEFUN([AC_LANG_COMPILER(CSHARP)],
+[AC_REQUIRE([AC_PROG_MCS])])
+
+AN_MAKEVAR([MCS], [AC_PROG_MCS])
+AN_PROGRAM([mcs], [AC_PROG_MCS])
+AC_DEFUN([AC_PROG_MCS],
+[AC_LANG_PUSH(CSHARP)dnl
+AC_ARG_VAR([MCS],     [MCS (C#) compiler command])dnl
+AC_ARG_VAR([MCSFLAGS],  [MCS (C#) compiler flags])dnl
+dnl _AC_ARG_VAR_LDFLAGS()dnl
+m4_ifval([$1],
+      [AC_CHECK_TOOLS(MCS, [$1])],
+[AC_CHECK_TOOL(MCS, mcs)
+if test -z "$MCS"; then
+  if test -n "$ac_tool_prefix"; then
+    AC_CHECK_PROG(MCS, [${ac_tool_prefix}mcs], [$ac_tool_prefix}mcs])
+  fi
+fi
+if test -z "$MCS"; then
+  AC_CHECK_PROG(MCS, mcs, mcs, , , false)
+fi
+if test -z "$MCS"; then
+  HAVE_MCS=0
+  AC_MSG_NOTICE([No C sharp compiler was found])
+else
+  HAVE_MCS=1
+  AC_DEFINE(HAVE_MCS,1,
+            [define if the MCS compiler is available])
+fi
+AC_SUBST(HAVE_MCS)
+])
+
+# Provide some information about the compiler.
+_AS_ECHO_LOG([checking for _AC_LANG compiler version])
+set X $ac_compile
+ac_compiler=$[2]
+_AC_DO_LIMIT([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
+m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
+m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
+AC_LANG_POP(CSHARP)dnl
+])# AC_PROG_MCS
+
+
diff --git a/m4/efl_path_max.m4 b/m4/efl_path_max.m4
new file mode 100644
index 0000000000..f57bfd2ab5
--- /dev/null
+++ b/m4/efl_path_max.m4
@@ -0,0 +1,36 @@
+dnl Check for PATH_MAX in limits.h, and define a default value if not found
+dnl This is a workaround for systems not providing PATH_MAX, like GNU/Hurd
+
+dnl EFL_CHECK_PATH_MAX([DEFAULT_VALUE_IF_NOT_FOUND])
+dnl
+dnl If PATH_MAX is not defined in <limits.h>, defines it
+dnl to DEFAULT_VALUE_IF_NOT_FOUND if it exists, or fallback
+dnl to using 4096
+
+AC_DEFUN([EFL_CHECK_PATH_MAX],
+[
+
+default_max=m4_default([$1], "4096")
+AC_LANG_PUSH([C])
+
+AC_MSG_CHECKING([for PATH_MAX in limits.h])
+AC_COMPILE_IFELSE(
+   [AC_LANG_PROGRAM(
+       [[
+#include <limits.h>
+       ]],
+       [[
+int i = PATH_MAX;
+       ]])],
+   [AC_MSG_RESULT([yes])],
+   [
+    AC_DEFINE_UNQUOTED([PATH_MAX],
+       [${default_max}],
+       [default value since PATH_MAX is not defined])
+    AC_MSG_RESULT([no: using ${default_max}])
+   ])
+
+AC_LANG_POP([C])
+
+])
+dnl end of efl_path_max.m4
diff --git a/m4/efl_pkg_config.m4 b/m4/efl_pkg_config.m4
new file mode 100644
index 0000000000..13a9516e90
--- /dev/null
+++ b/m4/efl_pkg_config.m4
@@ -0,0 +1,10 @@
+dnl file with extensions to pkg-config module
+dnl
+dnl EFL_PKG_CHECK_STRICT(MODULE, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND])
+dnl similar to PKG_CHECK_EXISTS() that will AC_MSG_ERROR() if not found
+AC_DEFUN([EFL_PKG_CHECK_STRICT],
+[
+   PKG_CHECK_EXISTS([$1], [$2],
+      [m4_ifval([$3], [$3], [AC_MSG_ERROR([pkg-config missing $1])])]
+      )
+])
diff --git a/m4/efl_stdcxx_11.m4 b/m4/efl_stdcxx_11.m4
new file mode 100644
index 0000000000..f606bc0379
--- /dev/null
+++ b/m4/efl_stdcxx_11.m4
@@ -0,0 +1,136 @@
+# ============================================================================
+#  http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx_11.html
+# ============================================================================
+#
+# SYNOPSIS
+#
+#   AX_CXX_COMPILE_STDCXX_11([ext|noext],[mandatory|optional])
+#
+# DESCRIPTION
+#
+#   Check for baseline language coverage in the compiler for the C++11
+#   standard; if necessary, add switches to CXXFLAGS to enable support.
+#
+#   The first argument, if specified, indicates whether you insist on an
+#   extended mode (e.g. -std=gnu++11) or a strict conformance mode (e.g.
+#   -std=c++11).  If neither is specified, you get whatever works, with
+#   preference for an extended mode.
+#
+#   The second argument, if specified 'mandatory' or if left unspecified,
+#   indicates that baseline C++11 support is required and that the macro
+#   should error out if no mode with that support is found.  If specified
+#   'optional', then configuration proceeds regardless, after defining
+#   HAVE_CXX11 if and only if a supporting mode is found.
+#
+# LICENSE
+#
+#   Copyright (c) 2008 Benjamin Kosnik <bkoz@redhat.com>
+#   Copyright (c) 2012 Zack Weinberg <zackw@panix.com>
+#   Copyright (c) 2013 Roy Stogner <roystgnr@ices.utexas.edu>
+#
+#   Copying and distribution of this file, with or without modification, are
+#   permitted in any medium without royalty provided the copyright notice
+#   and this notice are preserved. This file is offered as-is, without any
+#   warranty.
+
+#serial 3
+
+m4_define([_EFL_CXX_COMPILE_STDCXX_11_testbody], [
+  template <typename T>
+    struct check
+    {
+      static_assert(sizeof(int) <= sizeof(T), "not big enough");
+    };
+
+    typedef check<check<bool>> right_angle_brackets;
+
+    int a;
+    decltype(a) b;
+
+    typedef check<int> check_type;
+    check_type c;
+    check_type&& cr = static_cast<check_type&&>(c);
+
+    struct A { A(int); };
+    struct B : A { using A::A; };  // inheriting constructors
+
+    auto d = a;
+])
+
+AC_DEFUN([EFL_CXX_COMPILE_STDCXX_11], [dnl
+  m4_if([$1], [], [],
+        [$1], [ext], [],
+        [$1], [noext], [],
+        [m4_fatal([invalid argument `$1' to AX_CXX_COMPILE_STDCXX_11])])dnl
+  m4_if([$2], [], [ax_cxx_compile_cxx11_required=true],
+        [$2], [mandatory], [ax_cxx_compile_cxx11_required=true],
+        [$2], [optional], [ax_cxx_compile_cxx11_required=false],
+        [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX_11])])dnl
+  AC_LANG_PUSH([C++])dnl
+  ac_success=no
+  AC_CACHE_CHECK(whether $CXX supports C++11 features by default,
+  ax_cv_cxx_compile_cxx11,
+  [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_EFL_CXX_COMPILE_STDCXX_11_testbody])],
+    [ax_cv_cxx_compile_cxx11=yes],
+    [ax_cv_cxx_compile_cxx11=no])])
+  if test x$ax_cv_cxx_compile_cxx11 = xyes; then
+    ac_success=yes
+  fi
+
+  m4_if([$1], [noext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=gnu++11; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+                     $cachevar,
+        [ac_save_CXXFLAGS="$CXXFLAGS"
+         CXXFLAGS="$CXXFLAGS $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_EFL_CXX_COMPILE_STDCXX_11_testbody])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXXFLAGS="$ac_save_CXXFLAGS"])
+      if eval test x\$$cachevar = xyes; then
+        CXXFLAGS="$CXXFLAGS $switch"
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+
+  m4_if([$1], [ext], [], [dnl
+  if test x$ac_success = xno; then
+    for switch in -std=c++11; do
+      cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx11_$switch])
+      AC_CACHE_CHECK(whether $CXX supports C++11 features with $switch,
+                     $cachevar,
+        [ac_save_CXXFLAGS="$CXXFLAGS"
+         CXXFLAGS="$CXXFLAGS $switch"
+         AC_COMPILE_IFELSE([AC_LANG_SOURCE([_EFL_CXX_COMPILE_STDCXX_11_testbody])],
+          [eval $cachevar=yes],
+          [eval $cachevar=no])
+         CXXFLAGS="$ac_save_CXXFLAGS"])
+      if eval test x\$$cachevar = xyes; then
+        CXXFLAGS="$CXXFLAGS $switch"
+        ac_success=yes
+        break
+      fi
+    done
+  fi])
+  AC_LANG_POP([C++])
+  if test x$ax_cxx_compile_cxx11_required = xtrue; then
+    if test x$ac_success = xno; then
+      AC_MSG_ERROR([*** A compiler with support for C++11 language features is required.])
+    fi
+  else
+    if test x$ac_success = xno; then
+      HAVE_CXX11=0
+      AC_MSG_NOTICE([No compiler with C++11 support was found])
+    else
+      HAVE_CXX11=1
+      AC_DEFINE(HAVE_CXX11,1,
+                [define if the compiler supports basic C++11 syntax])
+    fi
+
+    AC_SUBST(HAVE_CXX11)
+  fi
+])
diff --git a/m4/efl_threads.m4 b/m4/efl_threads.m4
new file mode 100644
index 0000000000..54a5fc6d77
--- /dev/null
+++ b/m4/efl_threads.m4
@@ -0,0 +1,163 @@
+dnl Copyright (C) 2010 Vincent Torri <vtorri at univ-evry dot fr>
+dnl rwlock code added by Mike Blumenkrantz <mike at zentific dot com>
+dnl This code is public domain and can be freely used or copied.
+
+dnl Macro that check if POSIX or Win32 threads library is available or not.
+
+dnl Usage: EFL_CHECK_THREADS(ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND])
+dnl Call AC_SUBST(EFL_PTHREAD_CFLAGS)
+dnl Call AC_SUBST(EFL_PTHREAD_LIBS)
+dnl Defines EFL_HAVE_THREADS
+
+AC_DEFUN([EFL_CHECK_THREADS],
+[
+
+dnl Generic thread detection
+
+EFL_PTHREAD_CFLAGS="-D_REENTRANT"
+EFL_PTHREAD_LIBS=""
+
+_efl_have_posix_threads="no"
+
+dnl Use generic infrastructure for pthread detection (What a hell of a mess !)
+gl_LOCK
+
+AC_DEFINE([EFL_HAVE_THREADS], [1], [Define to mention that POSIX or Win32 threads are supported])
+
+_efl_have_posix_threads="${gl_use_threads}"
+
+dnl System specific CFLAGS
+if test "x${_efl_have_posix_threads}" = "xyes"; then
+   case "$host_os" in
+      osf*) EFL_PTHREAD_CFLAGS="-D_REENTRANT" ;;
+      aix* | freebsd*) EFL_PTHREAD_CFLAGS="-D_THREAD_SAFE" ;;
+      solaris*) EFL_PTHREAD_CFLAGS="-D_REENTRANT" ;;
+   esac
+fi
+
+dnl check if the compiler supports POSIX threads
+if test "x${_efl_have_posix_threads}" = "xyes" ; then
+
+   SAVE_LIBS=${LIBS}
+   LIBS="${LIBS} ${LIBMULTITHREAD}"
+   AC_LINK_IFELSE(
+      [AC_LANG_PROGRAM([[
+#include <pthread.h>
+                       ]],
+                       [[
+pthread_barrier_t barrier;
+pthread_barrier_init(&barrier, NULL, 1);
+                       ]])],
+      [efl_have_pthread_barrier="yes"],
+      [efl_have_pthread_barrier="no"])
+   AC_LINK_IFELSE(
+      [AC_LANG_PROGRAM([[
+#include <stdlib.h>
+#include <pthread.h>
+#include <sched.h>
+#ifndef __linux__
+#include <pthread_np.h>
+#endif
+                       ]],
+                       [[
+pthread_attr_setaffinity_np(NULL, 0, NULL);
+                       ]])],
+      [efl_have_setaffinity="yes"],
+      [efl_have_setaffinity="no"])
+   AC_LINK_IFELSE(
+      [AC_LANG_PROGRAM([[
+#define _GNU_SOURCE
+#include <stdlib.h>
+#include <pthread.h>
+#ifndef __linux__
+#include <pthread_np.h>
+#endif
+                       ]],
+                       [[
+#ifndef __linux__
+pthread_set_name_np(NULL, NULL);
+#else
+pthread_setname_np(NULL, NULL);
+#endif
+                       ]])],
+      [efl_have_setname="yes"],
+      [efl_have_setname="no"])
+   LIBS=${SAVE_LIBS}
+fi
+
+AC_MSG_CHECKING([which threads API is used])
+if test "x${_efl_have_posix_threads}" = "xyes" ; then
+   efl_have_threads="POSIX"
+fi
+AC_MSG_RESULT([${efl_have_threads}])
+
+EFL_PTHREAD_LIBS="${LTLIBMULTITHREAD}"
+
+AC_SUBST(EFL_PTHREAD_CFLAGS)
+AC_SUBST(EFL_PTHREAD_LIBS)
+
+dnl check if the compiler supports pthreads spinlock
+
+efl_have_posix_threads_spinlock="no"
+
+if test "x${_efl_have_posix_threads}" = "xyes" ; then
+   SAVE_LIBS=${LIBS}
+   LIBS="${LIBS} ${LIBMULTITHREAD}"
+   AC_LINK_IFELSE(
+      [AC_LANG_PROGRAM([[
+#include <pthread.h>
+#include <sched.h>
+                       ]],
+                       [[
+pthread_spinlock_t lock;
+int res;
+res = pthread_spin_init(&lock, PTHREAD_PROCESS_PRIVATE);
+sched_yield();
+                       ]])],
+      [efl_have_posix_threads_spinlock="yes"],
+      [efl_have_posix_threads_spinlock="no"])
+   LIBS=${SAVE_LIBS}
+
+fi
+
+AC_MSG_CHECKING([whether to build POSIX threads spinlock code])
+AC_MSG_RESULT([${efl_have_posix_threads_spinlock}])
+
+if test "x${efl_have_posix_threads_spinlock}" = "xyes" ; then
+   AC_DEFINE([EFL_HAVE_POSIX_THREADS_SPINLOCK], [1], [Define to mention that POSIX threads spinlocks are supported])
+fi
+
+
+dnl checks if the compiler supports OSX spinlock
+
+efl_have_osx_spinlock="no"
+
+if test "x${_efl_have_posix_threads}" = "xyes" ; then
+   AC_LINK_IFELSE(
+      [AC_LANG_PROGRAM([[
+#include <libkern/OSAtomic.h>
+                       ]],
+                       [[
+OSSpinLock spin_lock = 0;
+OSSpinLockTry(&spin_lock);
+                       ]])],
+      [efl_have_osx_spinlock="yes"],
+      [efl_have_osx_spinlock="no"])
+fi
+
+AC_MSG_CHECKING([whether to build OSX spinlock code])
+AC_MSG_RESULT([${efl_have_osx_spinlock}])
+
+if test "x${efl_have_osx_spinlock}" = "xyes" ; then
+   AC_DEFINE([EFL_HAVE_OSX_SPINLOCK], [1], [Define to mention that OSX spinlocks are supported])
+fi
+
+
+
+AS_IF([test "x$_efl_have_posix_threads" = "xyes"],
+   [$1],
+   [m4_if([$2], [$2], [AC_MSG_ERROR([Threads are required.])])])
+
+
+])
+
diff --git a/m4/eina_check.m4 b/m4/eina_check.m4
new file mode 100644
index 0000000000..251d4cb559
--- /dev/null
+++ b/m4/eina_check.m4
@@ -0,0 +1,49 @@
+dnl use: EINA_CHECK_MODULE(foo-bar, have_dependency, description)
+AC_DEFUN([EINA_CHECK_MODULE],
+[
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+
+# AC_ARG_ENABLE([mempool-$1],
+#    [AC_HELP_STRING([--enable-mempool-$1], [enable build of $3 @<:@default=$2@:>@])],
+#    [
+#     if test "x${enableval}" = "xyes" ; then
+#        enable_module="yes"
+#     else
+#        if test "x${enableval}" = "xstatic" ; then
+#           enable_module="static"
+#        else
+#           enable_module="no"
+#        fi
+#     fi
+#    ],
+#    [enable_module=$2])
+enable_module=$2
+
+have_module="no"
+if test "x${enable_module}" = "xyes" || test "x${enable_module}" = "xstatic" ; then
+   have_module="yes"
+fi
+
+AC_MSG_CHECKING([whether to enable $3 built])
+AC_MSG_RESULT([${have_module}])
+
+static_module="no"
+if test "x${enable_module}" = "xstatic" ; then
+   static_module="yes"
+   have_static_module="yes"
+   AC_DEFINE(EINA_STATIC_BUILD_[]UP, 1, [Set to 1 if $2 is statically built])
+fi
+
+if ! test "x${enable_module}" = "xno" ; then
+   AC_DEFINE(EINA_BUILD_[]UP, 1, [Set to 1 if $2 is built])
+fi
+
+AM_CONDITIONAL(EINA_BUILD_[]UP, [test "x${have_module}" = "xyes"])
+AM_CONDITIONAL(EINA_STATIC_BUILD_[]UP, [test "x${static_module}" = "xyes"])
+
+enable_[]DOWN=${enable_module}
+
+m4_popdef([UP])
+m4_popdef([DOWN])
+])
diff --git a/m4/eina_config.m4 b/m4/eina_config.m4
new file mode 100644
index 0000000000..609e4f9c74
--- /dev/null
+++ b/m4/eina_config.m4
@@ -0,0 +1,8 @@
+dnl use: EINA_CONFIG(configsuffix, testcond)
+AC_DEFUN([EINA_CONFIG],
+[
+if $2; then
+   EINA_CONFIGURE_$1="#define EINA_$1"
+fi
+AC_SUBST([EINA_CONFIGURE_$1])
+])
diff --git a/m4/eio_check_options.m4 b/m4/eio_check_options.m4
new file mode 100644
index 0000000000..5fb901273c
--- /dev/null
+++ b/m4/eio_check_options.m4
@@ -0,0 +1,12 @@
+dnl use: EIO_CHECK_NOTIFY_WIN32([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+AC_DEFUN([EIO_CHECK_NOTIFY_WIN32],
+[
+if test "x${have_win32}" = "xyes" ; then
+   AC_DEFINE([HAVE_NOTIFY_WIN32], [1], [ File monitoring with Windows notification ])
+fi
+
+AC_MSG_CHECKING([whether Windows notification is to be used for filemonitoring])
+AC_MSG_RESULT([${have_win32}])
+
+AS_IF([test "x${have_win32}" = "xyes"], [$1], [$2])
+])
diff --git a/m4/elm_check_backend.m4 b/m4/elm_check_backend.m4
new file mode 100644
index 0000000000..a51235718a
--- /dev/null
+++ b/m4/elm_check_backend.m4
@@ -0,0 +1,27 @@
+
+dnl use: ELM_CHECK_BACKEND(engine)
+AC_DEFUN([ELM_CHECK_BACKEND],
+[dnl
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+
+have_elementary_[]DOWN="no"
+want_backend="$2"
+
+AC_MSG_CHECKING([whether to enable $1 backend])
+AC_MSG_RESULT([${want_backend}])
+
+if test "x${want_backend}" != "xno"; then
+   AC_DEFINE([HAVE_ELEMENTARY_]UP, [1], [$1 support for Elementary])
+   have_elementary_[]DOWN="yes"
+   requirement_elm_pc="ecore-[]DOWN >= efl_version ${requirement_elm_pc}"
+fi
+
+AC_MSG_CHECKING([whether to build $1 backend])
+AC_MSG_RESULT([${have_elementary_[]DOWN}])
+
+EFL_ADD_FEATURE([ELEMENTARY], [$1], [${want_backend}])
+
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
diff --git a/m4/elm_check_option.m4 b/m4/elm_check_option.m4
new file mode 100644
index 0000000000..999636ad32
--- /dev/null
+++ b/m4/elm_check_option.m4
@@ -0,0 +1,60 @@
+
+dnl use: ELM_CHECK_OPTION_DEP(option, pkgver)
+AC_DEFUN([ELM_CHECK_OPTION_DEP],
+[dnl
+
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+
+ELM_[]UP[]_DEF="#undef"
+have_elementary_[]DOWN="no"
+
+AC_ARG_ENABLE(DOWN,
+   [AS_HELP_STRING([--disable-]DOWN, [disable ]DOWN[ support. @<:@default=detect@:>@])],
+   [want_option=$enableval],
+   [want_option="auto"])
+
+AC_MSG_CHECKING([whether to enable $1 option])
+AC_MSG_RESULT([${want_option}])
+
+if test "x${want_option}" != "xno"; then
+   PKG_CHECK_EXISTS(DOWN[ >= $2],
+      [
+       AC_DEFINE([HAVE_ELEMENTARY_]UP, [1], [$1 support for Elementary])
+       have_elementary_[]DOWN="yes"
+       ELM_[]UP[]_DEF="#define"
+       requirement_elm_pc="[]DOWN >= $2 ${requirement_elm_pc}"
+      ],
+      [have_elementary_]DOWN[="no"]
+   )
+fi
+
+AC_MSG_CHECKING([whether to build $1 option])
+AC_MSG_RESULT([${have_elementary_[]DOWN}])
+
+if test "x${want_elementary_[]DOWN}" = "xyes" && test "x${have_elementary_[]DOWN}" = "xno"; then
+   AC_MSG_ERROR([$1 support requested, but $1 was not found by pkg-config.])
+fi
+
+AC_SUBST([ELM_]UP[_DEF])
+
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
+
+dnl use: ELM_CHECK_OPTION(option, pkgver)
+AC_DEFUN([ELM_CHECK_OPTION],
+[dnl
+
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+
+if test "x$1" = "xeweb" ; then
+   ELM_CHECK_OPTION_DEP_EWK2
+else
+   ELM_CHECK_OPTION_DEP($1, $2)
+fi
+
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
diff --git a/m4/elm_quicklaunch.m4 b/m4/elm_quicklaunch.m4
new file mode 100644
index 0000000000..b51ff0f516
--- /dev/null
+++ b/m4/elm_quicklaunch.m4
@@ -0,0 +1,24 @@
+dnl Copyright (C) 2013 Cedric Bail <cedric dot bail at samsung dot com>
+dnl That code is public domain and can be freely used or copied
+
+dnl Macro that check if -pie -rdynamic can be given to ld
+
+dnl Usage: ELM_QUICKLAUNCH
+dnl add -pie -rdynamic to LDFLAGS and -fpie to CFLAGS
+
+AC_DEFUN([ELM_QUICKLAUNCH],
+[
+AC_MSG_CHECKING([If the compiler has what it takes to do quicklaunch (-pie -rdynamic)])
+old_LDFLAGS="$LDFLAGS"
+old_CFLAGS="$CFLAGS"
+
+LDFLAGS="$LDFLAGS -pie -rdynamic"
+CFLAGS="$CFLAGS -fpie"
+
+AC_LINK_IFELSE([AC_LANG_SOURCE([int main(){}])],
+        [AC_MSG_RESULT([yes])],
+        [LDFLAGS="$old_LDFLAGS"
+        CFLAGS="$old_CFLAGS"
+        AC_MSG_RESULT([no])
+        ])
+])
diff --git a/m4/emotion_generic_players.m4 b/m4/emotion_generic_players.m4
new file mode 100644
index 0000000000..d852dbaa29
--- /dev/null
+++ b/m4/emotion_generic_players.m4
@@ -0,0 +1,37 @@
+dnl EMOTION_GENERIC_PLAYER(NAME, DEFAULT_STATE, [PKG_CONFIG_DEPS])
+dnl Does the following:
+dnl  * AC_ARG_WITH(NAME)
+dnl  * define with_name to yes or no
+dnl  * PKG_CHECK_MODULES(NAME, PKG_CONFIG_DEPS)
+dnl  * AC_DEFINE([HAVE_NAME])
+dnl  * AM_CONDITIONAL([HAVE_NAME])
+AC_DEFUN([EMOTION_GENERIC_PLAYER],
+[dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+
+AC_ARG_WITH([DOWN],
+   [AC_HELP_STRING([--with-]m4_defn([DOWN]),
+       [build generic player ]m4_defn([UP])[. @<:@default=$2@:>@])],
+   [], [with_]m4_defn([DOWN])[="$2"])
+
+if test "${with_[]m4_defn([DOWN])}" = "yes"; then
+   m4_ifval([$3], [dnl
+      PKG_CHECK_MODULES(m4_defn([UP]), [$3])
+   ], [dnl
+      m4_defn([UP])_LIBS="${m4_defn([UP])_LIBS}"
+      m4_defn([UP])_CFLAGS="${m4_defn([UP])_CFLAGS}"
+      AC_SUBST(m4_defn([UP])[_LIBS])
+      AC_SUBST(m4_defn([UP])[_CFLAGS])
+   ])
+
+   AC_SEARCH_LIBS([shm_open], [rt], [], [AC_MSG_ERROR([unable to find the shm_open() function])])
+   if test "${ac_cv_search_shm_open}" != "none required"; then
+      m4_defn([UP])_LIBS="${m4_defn([UP])_LIBS} ${ac_cv_search_shm_open}"
+   fi
+fi
+AM_CONDITIONAL([HAVE_]m4_defn([UP]), [test "$with_[]m4_defn([DOWN])" = "yes"])
+
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
diff --git a/m4/emotion_module.m4 b/m4/emotion_module.m4
new file mode 100644
index 0000000000..184533fcdc
--- /dev/null
+++ b/m4/emotion_module.m4
@@ -0,0 +1,133 @@
+dnl use: EMOTION_MODULE_DEP_CHECK_XINE(want_engine)
+dnl where want_engine = yes or static
+AC_DEFUN([EMOTION_MODULE_DEP_CHECK_XINE],
+[dnl
+   requirements="libxine >= 1.1.1"
+   if test "$1" = "static"; then
+      EFL_DEPEND_PKG([EMOTION], [EMOTION_MODULE_XINE], [${requirements}])
+   else
+      PKG_CHECK_MODULES([EMOTION_MODULE_XINE], [${requirements}])
+   fi
+])
+
+dnl use: EMOTION_MODULE_DEP_CHECK_GSTREAMER(want_static)
+dnl where want_engine = yes or static
+AC_DEFUN([EMOTION_MODULE_DEP_CHECK_GSTREAMER],
+[dnl
+   GST_VER=0.10.2
+   requirements="gstreamer-0.10 >= ${GST_VER} gstreamer-plugins-base-0.10 >= ${GST_VER} gstreamer-video-0.10 >= ${GST_VER} gstreamer-interfaces-0.10 >= ${GST_VER}"
+   have_gst_xoverlay="no"
+   if test "$1" = "static"; then
+      EFL_DEPEND_PKG([EMOTION], [EMOTION_MODULE_GSTREAMER], [${requirements}])
+   else
+      PKG_CHECK_MODULES([EMOTION_MODULE_GSTREAMER], [${requirements}])
+   fi
+
+   if test "${want_x11_any}" = "yes"; then
+      if test "$1" = "static"; then # we need gstreamer cflags and libs to test xoverlay support
+         PKG_CHECK_MODULES([EMOTION_MODULE_GSTREAMER], [${requirements}])
+      fi
+      CFLAGS_save="${CFLAGS}"
+      CFLAGS="${CFLAGS} ${EMOTION_MODULE_GSTREAMER_CFLAGS}"
+      AC_CHECK_HEADER([gst/interfaces/xoverlay.h],
+         [have_gst_xoverlay="old" # will check for "new" later with AC_CHECK_LIB()
+          AC_DEFINE(HAVE_XOVERLAY_H, 1, [Build with Gstreamer Xoverlay support])],
+         [AC_MSG_WARN([Building Gstreamer with X11 but no gst/interfaces/xoverlay.h found])],
+         [#include <gst/gst.h>])
+      CFLAGS="${CFLAGS_save}"
+
+      LDFLAGS_save=${LDFLAGS}
+      LDFLAGS="${LDFLAGS} ${EMOTION_MODULE_GSTREAMER_LIBS}"
+      AC_CHECK_LIB([gstinterfaces-0.10], [gst_x_overlay_set_window_handle],
+         [have_gst_xoverlay="new"
+          AC_DEFINE([HAVE_X_OVERLAY_SET], [1], [Use gst_x_overlay_set_window_handle instead of old deprecated gst_x_overlay_set_xwindow_id])])
+      LDFLAGS="${LDFLAGS_save}"
+   fi
+])
+
+dnl use: EMOTION_MODULE_DEP_CHECK_GSTREAMER_1(want_static)
+dnl where want_engine = yes or static
+AC_DEFUN([EMOTION_MODULE_DEP_CHECK_GSTREAMER1],
+[dnl
+   GST_VER=1.0
+   requirements="gstreamer-1.0 >= ${GST_VER} gstreamer-plugins-base-1.0 >= ${GST_VER} gstreamer-video-1.0 >= ${GST_VER} gstreamer-audio-1.0 >= ${GST_VER} gstreamer-tag-1.0 >= ${GST_VER} gstreamer-pbutils-1.0 >= ${GST_VER}"
+   if test "$1" = "static"; then
+      EFL_DEPEND_PKG([EMOTION], [EMOTION_MODULE_GSTREAMER1], [${requirements}])
+   else
+      PKG_CHECK_MODULES([EMOTION_MODULE_GSTREAMER1], [${requirements}])
+   fi
+])
+
+
+dnl use: EMOTION_MODULE_DEP_CHECK_LIBVLC(want_static)
+dnl where want_engine = yes or static
+AC_DEFUN([EMOTION_MODULE_DEP_CHECK_LIBVLC],
+[dnl
+   LIBVLC_VER=3.0
+   requirements="libvlc >= ${LIBVLC_VER}"
+   if test "$1" = "static"; then
+      EFL_DEPEND_PKG([EMOTION], [EMOTION_MODULE_LIBVLC], [${requirements}])
+   else
+      PKG_CHECK_MODULES([EMOTION_MODULE_LIBVLC], [${requirements}])
+   fi
+])
+
+dnl use: EMOTION_MODULE_DEP_CHECK_GENERIC(want_static)
+dnl where want_engine = yes or static
+AC_DEFUN([EMOTION_MODULE_DEP_CHECK_GENERIC],
+[dnl
+   if test "$1" = "static"; then
+      EFL_ADD_LIBS([EMOTION], [${requirements_libs_shm}])
+   else
+      EMOTION_MODULE_GENERIC_CFLAGS=""
+      EMOTION_MODULE_GENERIC_LIBS="${requirements_libs_shm}"
+      AC_SUBST([EMOTION_MODULE_GENERIC_CFLAGS])
+      AC_SUBST([EMOTION_MODULE_GENERIC_LIBS])
+   fi
+])
+
+dnl use: EMOTION_MODULE(name, want_engine)
+dnl
+dnl defines EMOTION_BUILD_NAME if it should be built
+dnl defines EMOTION_STATIC_BUILD_NAME if should be built statically
+dnl
+AC_DEFUN([EMOTION_MODULE],
+[
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+
+want_engine="$2"
+want_static_engine="no"
+have_engine="no"
+have_emotion_module_[]DOWN="no"
+
+EMOTION_MODULE_[]m4_defn([UP])[]_CFLAGS=""
+EMOTION_MODULE_[]m4_defn([UP])[]_LIBS=""
+
+if test "x${want_engine}" = "xyes" -o "x${want_engine}" = "xstatic"; then
+
+   m4_default([EMOTION_MODULE_DEP_CHECK_]m4_defn([UP]))([${want_engine}])
+
+   have_engine="yes"
+   if test "x${want_engine}" = "xstatic" ; then
+      have_emotion_module_[]DOWN="static"
+      want_static_engine="yes"
+   else
+      have_emotion_module_[]DOWN="yes"
+   fi
+fi
+
+AC_DEFINE_IF(EMOTION_BUILD_[]UP, [test "${have_engine}" = "yes"],
+  [1], [Build $1 Evas engine])
+AM_CONDITIONAL(EMOTION_BUILD_[]UP, [test "${have_engine}" = "yes"])
+
+AC_DEFINE_IF(EMOTION_STATIC_BUILD_[]UP, [test "${want_static_engine}" = "yes"],
+  [1], [Build $1 Evas engine inside libevas])
+AM_CONDITIONAL(EMOTION_STATIC_BUILD_[]UP, [test "${want_static_engine}" = "yes"])
+
+AC_SUBST([EMOTION_MODULE_]m4_defn([UP])[_CFLAGS])
+AC_SUBST([EMOTION_MODULE_]m4_defn([UP])[_LIBS])
+
+m4_popdef([UP])
+m4_popdef([DOWN])
+])
diff --git a/m4/evas_check_engine.m4 b/m4/evas_check_engine.m4
new file mode 100644
index 0000000000..d15c8d5f01
--- /dev/null
+++ b/m4/evas_check_engine.m4
@@ -0,0 +1,629 @@
+AC_DEFUN([REQUIRED_WAYLAND_VERSION], [1.11.0])
+
+dnl use: EVAS_CHECK_ENGINE_DEP_SOFTWARE_XLIB(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_SOFTWARE_XLIB],
+[
+
+EFL_FIND_X(evas_engine_[]$1,
+  [X11/X.h], [X11 XCreateImage Xext XShmCreateImage],
+  [
+    if test "x$3" = "xstatic"; then
+      requirements_libs_evas="$evas_engine_[]$1[]_libs $requirements_libs_evas"
+    fi
+    ifelse([$4], , :, [$4])
+  ],[
+    ifelse([$5], , :, [$5])
+  ])
+])
+
+dnl use: EVAS_CHECK_ENGINE_DEP_GL_XLIB(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_GL_XLIB],
+[
+
+EFL_FIND_X(evas_engine_[]$1,
+  [X11/Xlib.h X11/Xatom.h X11/Xutil.h X11/extensions/Xrender.h X11/Xresource.h],
+  [X11 XCreateColormap Xrender XRenderCreatePicture],
+  [
+    CFLAGS_save="$CFLAGS"
+    CFLAGS="$evas_engine_[]$1[]_cflags $CFLAGS"
+    CPPFLAGS_save="$CPPFLAGS"
+    CPPFLAGS="$evas_engine_[]$1[]_cflags $CPPFLAGS"
+
+    AC_CHECK_HEADER([GL/gl.h],
+      [have_dep="yes"],
+      [have_dep="no"],
+      [
+#include <GL/gl.h>
+#include <GL/glext.h>
+#include <GL/glx.h>
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/Xrender.h>
+#include <X11/Xresource.h>
+      ])
+
+    gl_pt_lib=""
+    have_gl_pt="no"
+
+    AC_MSG_CHECKING([whether pthread_create() is supported])
+    CFLAGS_pt_save="$CFLAGS"
+    CFLAGS="$CFLAGS -pthread"
+    LIBS_pt_save="$LIBS"
+    LIBS="$LIBS -pthread"
+    AC_LINK_IFELSE(
+      [AC_LANG_PROGRAM([[
+#include <pthread.h>
+                       ]],
+                       [[
+pthread_create(NULL, NULL, NULL, NULL);
+                       ]])],
+      [have_gl_pt="yes"],
+      [have_gl_pt="no"])
+    CFLAGS=$CFLAGS_pt_save
+    LIBS=$LIBS_pt_save
+    AC_MSG_RESULT([$have_gl_pt])
+
+    if test "x$have_gl_pt" = "xyes" ; then
+      gl_pt_lib=" -pthread"
+    fi
+
+    if test "x$have_dep" = "xyes"; then
+      LIBS_save="$LIBS"
+      LIBS="$LIBS $evas_engine_[]$1[]_libs"
+      AC_CHECK_LIB([GL], [glXCreateContext], [have_dep="yes"], [have_dep="no"], [-lm $gl_pt_lib])
+      LIBS="$LIBS_save"
+    fi
+
+    if test "x${with_opengl}" = "xes" ; then
+      have_dep=no
+    fi
+
+    if test "x$have_dep" = "xyes" ; then
+      evas_engine_[]$1[]_libs="$evas_engine_[]$1[]_libs -lGL $gl_pt_lib"
+      evas_engine_gl_common_libs="$evas_engine_[]$1[]_libdirs -lGL $gl_pt_lib"
+    else
+      AC_CHECK_HEADER([GLES2/gl2.h],
+        [have_egl="yes"],
+        [have_egl="no"],
+        [
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <EGL/egl.h>
+#include <X11/Xlib.h>
+#include <X11/Xatom.h>
+#include <X11/Xutil.h>
+#include <X11/extensions/Xrender.h>
+#include <X11/Xresource.h>
+        ])
+      if test "x${have_egl}" = "xyes" ; then
+        AC_CHECK_LIB(GLESv2, glTexImage2D, [have_glesv2="yes"], , -lEGL -lm $gl_pt_lib)
+        if test "x${have_glesv2}" = "xyes" ; then
+          evas_engine_[]$1[]_libs="$evas_engine_[]$1[]_libs -lGLESv2 -lEGL -lm $gl_pt_lib"
+          evas_engine_gl_common_libs="$evas_engine_[]$1[]_libdirs -lGLESv2 -lm $gl_pt_lib"
+          have_dep="yes"
+          AC_DEFINE(GL_GLES, 1, [GLSL runtime shader GLES2 support])
+          gles_variety_sgx="yes"
+        fi
+      fi
+    fi
+
+    CPPFLAGS="$CPPFLAGS_save"
+    CFLAGS="$CFLAGS_save"
+
+    if test "x$3" = "xstatic" && test "x${have_dep}" = "xyes" ; then
+      requirements_libs_evas="$evas_engine_[]$1[]_libs $requirements_libs_evas"
+    fi
+
+    AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+  ],[
+    ifelse([$5], , :, [$5])
+  ])
+])
+
+dnl use: EVAS_CHECK_ENGINE_DEP_SOFTWARE_GDI(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_SOFTWARE_GDI],
+[
+
+have_dep="no"
+evas_engine_[]$1[]_cflags=""
+evas_engine_[]$1[]_libs=""
+
+AC_CHECK_HEADER([windows.h],
+   [
+    have_dep="yes"
+    evas_engine_[]$1[]_libs="-lgdi32"
+   ])
+
+if test "x$3" = "xstatic"  && test "x${have_dep}" = "xyes" ; then
+   requirements_libs_evas="${evas_engine_[]$1[]_libs} ${requirements_libs_evas}"
+fi
+
+AC_SUBST([evas_engine_$1_cflags])
+AC_SUBST([evas_engine_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+
+])
+
+dnl use: EVAS_CHECK_ENGINE_DEP_SOFTWARE_DDRAW(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_SOFTWARE_DDRAW],
+[
+
+have_dep="no"
+evas_engine_[]$1[]_cflags=""
+evas_engine_[]$1[]_libs=""
+
+AC_CHECK_HEADER([ddraw.h],
+   [
+    have_dep="yes"
+    evas_engine_[]$1[]_libs="-lddraw"
+   ])
+
+if test "x$3" = "xstatic" && test "x${have_dep}" = "xyes" ; then
+   requirements_libs_evas="${evas_engine_[]$1[]_libs} ${requirements_libs_evas}"
+fi
+
+AC_SUBST([evas_engine_$1_cflags])
+AC_SUBST([evas_engine_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+
+])
+
+dnl use: EVAS_CHECK_ENGINE_DEP_GL_COCOA(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_GL_COCOA],
+[
+
+evas_engine_[]$1[]_cflags=""
+evas_engine_[]$1[]_libs=""
+
+AC_LANG_PUSH([Objective C])
+
+LIBS_save="$LIBS"
+LIBS="$LIBS -framework Cocoa"
+AC_LINK_IFELSE(
+   [AC_LANG_PROGRAM(
+       [[
+#include <Cocoa/Cocoa.h>
+       ]],
+       [[
+NSWindow *window;
+window = [[NSWindow alloc]
+           initWithContentRect:NSMakeRect(0, 0, 1, 1)
+           styleMask:(NSTitledWindowMask)
+           backing:NSBackingStoreBuffered
+           defer:NO
+           screen:nil
+         ];
+       ]])],
+   [
+    have_dep="yes"
+    evas_engine_[]$1[]_libs="-framework Cocoa -framework OpenGL"
+    evas_engine_gl_common_libs="$evas_engine_[]$1[]_libdirs"
+   ],
+   [have_dep="no"])
+LIBS="$LIBS_save"
+
+AC_LANG_POP([Objective C])
+
+if test "x$3" = "xstatic"  && test "x${have_dep}" = "xyes" ; then
+   requirements_libs_evas="${evas_engine_[]$1[]_libs} ${requirements_libs_evas}"
+fi
+
+AC_SUBST([evas_engine_$1_cflags])
+AC_SUBST([evas_engine_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+
+])
+
+dnl use: EVAS_CHECK_ENGINE_DEP_GL_SDL(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_GL_SDL],
+[
+
+requirement=""
+have_dep="no"
+evas_engine_[]$1[]_cflags=""
+evas_engine_[]$1[]_libs=""
+
+PKG_CHECK_EXISTS([sdl2 >= 2.0.0],
+   [
+    have_dep="yes"
+    requirement="sdl2 >= 2.0.0"
+   ],
+   [have_dep="no"])
+
+if test "x${have_dep}" = "xyes" ; then
+   if test "x$3" = "xstatic" ; then
+      requirements_pc_evas="${requirement} ${requirements_pc_evas}"
+      requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
+   else
+      PKG_CHECK_MODULES([SDL], [${requirement}])
+      evas_engine_[]$1[]_cflags="${SDL_CFLAGS}"
+      evas_engine_[]$1[]_libs="${SDL_LIBS}"
+   fi
+fi
+
+gl_pt_lib="";
+have_gl_pt="no"
+
+AC_MSG_CHECKING([whether pthread_create() is supported])
+CFLAGS_save="${CFLAGS}"
+CFLAGS="${CFLAGS} -pthread"
+LIBS_save="${LIBS}"
+LIBS="${LIBS} -pthread"
+AC_LINK_IFELSE(
+  [AC_LANG_PROGRAM([[
+#include <pthread.h>
+                   ]],
+                   [[
+pthread_create(NULL, NULL, NULL, NULL);
+                   ]])],
+   [have_gl_pt="yes"],
+   [have_gl_pt="no"])
+CFLAGS=${CFLAGS_save}
+LIBS=${LIBS_save}
+AC_MSG_RESULT([${have_gl_pt}])
+
+if test "x$have_gl_pt" = "xyes" ; then
+   gl_pt_lib=" -pthread"
+fi
+
+AC_CHECK_HEADER([GL/gl.h],
+   [have_dep="yes"],
+   [have_dep="no"],
+   [
+#include <GL/gl.h>
+#include <GL/glext.h>
+   ])
+
+if test "x${with_opengl}" = "xes" ; then
+  have_dep=no
+fi
+
+if test "x${have_dep}" = "xyes" ; then
+   evas_engine_[]$1[]_libs="${evas_engine_[]$1[]_libs} -lGL -lm $gl_pt_lib"
+   evas_engine_gl_common_libs="-lGL -lm $gl_pt_lib"
+else
+   AC_CHECK_HEADER([SDL2/SDL_opengles.h],
+      [have_egl="yes"],
+      [have_egl="no"],
+      [
+#include <SDL2/SDL_opengles.h>
+#include <EGL/egl.h>
+      ])
+   if test "x${have_egl}" = "xyes" ; then
+      AC_CHECK_LIB(GLESv2, glTexImage2D, [have_glesv2="yes"], , -lEGL -lm $gl_pt_lib)
+      if test "x${have_glesv2}" = "xyes" ; then
+         evas_engine_[]$1[]_libs="${evas_engine_[]$1[]_libs} -lGLESv2 -lEGL -lm $gl_pt_lib"
+         evas_engine_gl_common_libs="-lGLESv2 -lm $gl_pt_lib"
+         have_dep="yes"
+         AC_DEFINE(GLES_VARIETY_SGX, 1, [Imagination SGX GLES2 support])
+         gles_variety_sgx="yes"
+      fi
+   fi
+fi
+
+AC_SUBST([evas_engine_$1_cflags])
+AC_SUBST([evas_engine_$1_libs])
+
+if test "x$3" = "xstatic" ; then
+   requirement_evas="${requirement} ${requirement_evas}"
+fi
+
+AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+
+])
+
+
+dnl use: EVAS_CHECK_ENGINE_DEP_WAYLAND_SHM(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_WAYLAND_SHM],
+[
+
+requirement=""
+have_dep="no"
+evas_engine_[]$1[]_cflags=""
+evas_engine_[]$1[]_libs=""
+
+PKG_CHECK_EXISTS([wayland-client >= REQUIRED_WAYLAND_VERSION],
+   [
+    have_dep="yes"
+    requirement="wayland-client"
+   ],
+   [have_dep="no"])
+
+if test "x${have_dep}" = "xyes" ; then
+   if test "x$3" = "xstatic" ; then
+      requirements_pc_evas="${requirement} ${requirements_pc_evas}"
+      requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
+   else
+      PKG_CHECK_MODULES([WAYLAND_SHM], [${requirement}])
+      evas_engine_[]$1[]_cflags="${WAYLAND_SHM_CFLAGS}"
+      evas_engine_[]$1[]_libs="${WAYLAND_SHM_LIBS}"
+   fi
+fi
+
+AC_SUBST([evas_engine_$1_cflags])
+AC_SUBST([evas_engine_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+
+])
+
+dnl use: EVAS_CHECK_ENGINE_DEP_WAYLAND_EGL(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_WAYLAND_EGL],
+[
+
+requirement=""
+have_dep="no"
+evas_engine_[]$1[]_cflags=""
+evas_engine_[]$1[]_libs=""
+
+if test "x${with_opengl}" = "xes" ; then
+    gl_library="glesv2"
+else
+    gl_library="gl"
+fi
+
+PKG_CHECK_EXISTS([egl ${gl_library} wayland-client >= REQUIRED_WAYLAND_VERSION wayland-egl],
+   [
+    have_dep="yes"
+    requirement="egl ${gl_library} wayland-client wayland-egl"
+   ],
+   [have_dep="no"])
+
+if test "x${have_dep}" = "xyes" ; then
+   if test "${gl_library}" != "gl" ; then
+      have_egl="yes"
+   fi
+   if test "x$3" = "xstatic" ; then
+      requirements_pc_evas="${requirement} ${requirements_pc_evas}"
+      requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
+   else
+      PKG_CHECK_MODULES([WAYLAND_EGL], [${requirement}])
+      evas_engine_[]$1[]_cflags="${WAYLAND_EGL_CFLAGS}"
+      evas_engine_[]$1[]_libs="${WAYLAND_EGL_LIBS}"
+      evas_engine_gl_common_libs="$evas_engine_[]$1[]_libdirs -lGLESv2 -lm -lEGL"
+   fi
+fi
+
+AC_SUBST([evas_engine_$1_cflags])
+AC_SUBST([evas_engine_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+
+])
+
+
+dnl use: EVAS_CHECK_ENGINE_DEP_DRM(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_DRM],
+[
+
+requirement=""
+have_dep="no"
+have_hw_dep="no"
+evas_engine_[]$1[]_cflags=""
+evas_engine_[]$1[]_libs=""
+
+PKG_CHECK_EXISTS([libdrm],
+  [
+    have_dep="yes"
+    requirement="libdrm"
+  ], [have_dep="no"])
+
+if test "x${have_dep}" = "xyes" ; then
+   if test "x$3" = "xstatic" ; then
+      requirements_pc_evas="${requirement} ${requirements_pc_evas}"
+      requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
+   else
+      PKG_CHECK_MODULES([DRM], [${requirement}])
+      evas_engine_[]$1[]_cflags="${DRM_CFLAGS}"
+      evas_engine_[]$1[]_libs="${DRM_LIBS}"
+   fi
+fi
+
+AC_SUBST([evas_engine_$1_cflags])
+AC_SUBST([evas_engine_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+
+])
+
+dnl use: EVAS_CHECK_ENGINE_DEP_GL_DRM(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_GL_DRM],
+[
+
+requirement=""
+have_dep="no"
+have_hw_dep="no"
+evas_engine_[]$1[]_cflags=""
+evas_engine_[]$1[]_libs=""
+
+if test "x${with_opengl}" = "xes" ; then
+   gl_library="glesv2"
+else
+   AC_MSG_ERROR([We currently do not support GL DRM without OpenGL ES. Please consider OpenGL ES if you want to use it.])
+fi
+
+PKG_CHECK_EXISTS([egl ${gl_library} libdrm gbm wayland-client >= REQUIRED_WAYLAND_VERSION],
+   [
+    have_dep="yes"
+    requirement="egl ${gl_library} libdrm gbm wayland-client >= REQUIRED_WAYLAND_VERSION"
+   ],
+   [have_dep="no"])
+
+if test "x${have_dep}" = "xyes" ; then
+   if test "x$3" = "xstatic" ; then
+      requirements_pc_evas="${requirement} ${requirements_pc_evas}"
+      requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
+   else
+      PKG_CHECK_MODULES([GL_DRM], [${requirement}])
+      evas_engine_[]$1[]_cflags="${GL_DRM_CFLAGS}"
+      evas_engine_[]$1[]_libs="${GL_DRM_LIBS}"
+      evas_engine_gl_common_libs="$evas_engine_[]$1[]_libdirs -lGLESv2 -lm -lEGL"
+   fi
+fi
+
+AC_SUBST([evas_engine_$1_cflags])
+AC_SUBST([evas_engine_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+
+])
+
+dnl use: EVAS_CHECK_ENGINE_DEP_EGLFS(engine, simple, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_ENGINE_DEP_EGLFS],
+[
+
+requirement=""
+have_dep="no"
+have_hw_dep="no"
+evas_engine_[]$1[]_cflags=""
+evas_engine_[]$1[]_libs=""
+
+if test "x${with_opengl}" = "xes" ; then
+   gl_library="glesv2"
+else
+   AC_MSG_ERROR([We do not support Eglfs without OpenGL ES. Please consider OpenGL ES if you want to use it.])
+fi
+
+PKG_CHECK_EXISTS([egl >= 7.10 ${gl_library}],
+   [
+    have_dep="yes"
+    requirement="egl >= 7.10 ${gl_library}"
+   ],
+   [have_dep="no"])
+
+if test "x${have_dep}" = "xyes" ; then
+   if test "x$3" = "xstatic" ; then
+      requirements_pc_evas="${requirement} ${requirements_pc_evas}"
+      requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
+   else
+      PKG_CHECK_MODULES([EGLFS], [${requirement}])
+      evas_engine_[]$1[]_cflags="${EGLFS_CFLAGS}"
+      evas_engine_[]$1[]_libs="${EGLFS_LIBS}"
+      evas_engine_gl_common_libs="$evas_engine_[]$1[]_libdirs -lGLESv2 -lm -lEGL"
+   fi
+fi
+
+AC_SUBST([evas_engine_$1_cflags])
+AC_SUBST([evas_engine_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$4], [$5])
+
+])
+
+
+dnl use: EVAS_ENGINE(name, want_engine, [DEPENDENCY-CHECK-CODE])
+dnl
+dnl defines BUILD_ENGINE_NAME if it should be built
+dnl defines BUILD_STATIC_BUILD_NAME if should be built statically
+dnl
+dnl will call DEPENDENCY-CHECK-CODE if it should be built,
+dnl if some dependency fail just call AC_MSG_ERROR() to abort.
+
+AC_DEFUN([EVAS_ENGINE],
+[dnl
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+
+want_engine="$2"
+want_static_engine="no"
+have_engine="no"
+have_evas_engine_[]DOWN="no"
+
+evas_engine_[]m4_defn([DOWN])[]_cflags=""
+evas_engine_[]m4_defn([DOWN])[]_libs=""
+
+if test "x${want_engine}" = "xyes" -o "x${want_engine}" = "xstatic"; then
+   $3
+
+   have_engine="yes"
+   if test "x${want_engine}" = "xstatic" ; then
+      have_evas_engine_[]DOWN="static"
+      want_static_engine="yes"
+   else
+      have_evas_engine_[]DOWN="yes"
+   fi
+fi
+
+AC_DEFINE_IF(BUILD_ENGINE_[]UP, [test "${have_engine}" = "yes"],
+  [1], [Build $1 Evas engine])
+AM_CONDITIONAL(BUILD_ENGINE_[]UP, [test "${have_engine}" = "yes"])
+
+AC_DEFINE_IF(EVAS_STATIC_BUILD_[]UP, [test "${want_static_engine}" = "yes"],
+  [1], [Build $1 Evas engine inside libevas])
+AM_CONDITIONAL(EVAS_STATIC_BUILD_[]UP, [test "${want_static_engine}" = "yes"])
+
+AC_SUBST([evas_engine_]m4_defn([DOWN])[_cflags])
+AC_SUBST([evas_engine_]m4_defn([DOWN])[_libs])
+
+EFL_ADD_FEATURE([EVAS_ENGINE], [$1], [${have_evas_engine_]DOWN[}])dnl
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
+
+
+
+dnl use: EVAS_CHECK_ENGINE(engine, want_engine, simple, description)
+AC_DEFUN([EVAS_CHECK_ENGINE],
+[dnl
+m4_pushdef([UP], m4_translit([$1], [-a-z], [_A-Z]))dnl
+m4_pushdef([DOWN], m4_translit([$1], [-A-Z], [_a-z]))dnl
+
+want_engine="$2"
+want_static_engine="no"
+have_engine="no"
+have_evas_engine_[]DOWN="no"
+
+AC_MSG_CHECKING([whether to enable $4 rendering backend])
+AC_MSG_RESULT([${want_engine}])
+
+if test "x${want_engine}" = "xyes" -o "x${want_engine}" = "xstatic"; then
+   m4_default([EVAS_CHECK_ENGINE_DEP_]m4_defn([UP]))(DOWN, $3, ${want_engine}, [have_engine="yes"], [have_engine="no"])
+fi
+
+if test "x${have_engine}" = "xno" -a "x${want_engine}" = "xyes"; then
+   AC_MSG_ERROR([$4 dependencies not found])
+fi
+
+AC_MSG_CHECKING([whether $4 rendering backend will be built])
+AC_MSG_RESULT([${have_engine}])
+
+if test "x${have_engine}" = "xyes" ; then
+   if test "x${want_engine}" = "xstatic" ; then
+      have_evas_engine_[]DOWN="static"
+      want_static_engine="yes"
+   else
+      have_evas_engine_[]DOWN="yes"
+   fi
+fi
+
+if test "x${have_engine}" = "xyes" ; then
+   AC_DEFINE(BUILD_ENGINE_[]UP, [1], [$4 rendering backend])
+fi
+
+AM_CONDITIONAL(BUILD_ENGINE_[]UP, [test "x${have_engine}" = "xyes"])
+
+if test "x${want_static_engine}" = "xyes" ; then
+   AC_DEFINE(EVAS_STATIC_BUILD_[]UP, [1], [Build $1 engine inside libevas])
+   have_static_module="yes"
+fi
+
+EFL_ADD_FEATURE([EVAS_ENGINE], [$1], [${have_evas_engine_]DOWN[}])
+AM_CONDITIONAL(EVAS_STATIC_BUILD_[]UP, [test "x${want_static_engine}" = "xyes"])dnl
+m4_popdef([UP])dnl
+m4_popdef([DOWN])dnl
+])
diff --git a/m4/evas_check_loader.m4 b/m4/evas_check_loader.m4
new file mode 100644
index 0000000000..ff48c3c388
--- /dev/null
+++ b/m4/evas_check_loader.m4
@@ -0,0 +1,678 @@
+
+dnl use: ARG_ENABLE_EVAS_VG_LOADER(loader, default_value)
+
+AC_DEFUN([ARG_ENABLE_EVAS_VG_LOADER],
+[dnl
+m4_pushdef([DOWN], m4_tolower([$1]))dnl
+
+AC_ARG_ENABLE([vg-loader-[]DOWN],
+   [AC_HELP_STRING([--enable-vg-loader-[]DOWN], [enable $1 vg loader. @<:@default=$2@:>@])],
+   [
+      if test "x${enableval}" = "xyes" ; then
+         want_evas_vg_loader_[]DOWN="yes"
+      else
+         if test "x${enableval}" = "xstatic" ; then
+            want_evas_vg_loader_[]DOWN="static"
+         else
+            if test "x${enableval}" = "xauto" ; then
+               want_evas_vg_loader_[]DOWN="auto"
+            else
+               want_evas_vg_loader_[]DOWN="no"
+            fi
+         fi
+      fi
+   ],
+   [want_evas_vg_loader_[]DOWN="$2"])
+m4_popdef([DOWN])dnl
+])
+
+dnl use: EVAS_CHECK_VG_LOADER_DEP_SVG(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_VG_LOADER_DEP_SVG],
+[
+
+have_dep="yes"
+evas_vg_loader_[]$1[]_cflags=""
+evas_vg_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_vg_loader_$1_cflags])
+AC_SUBST([evas_vg_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_VG_LOADER_DEP_EET(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_VG_LOADER_DEP_EET],
+[
+
+have_dep="yes"
+evas_vg_loader_[]$1[]_cflags=""
+evas_vg_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_vg_loader_$1_cflags])
+AC_SUBST([evas_vg_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: ARG_ENABLE_EVAS_IMAGE_LOADER(loader, default_value)
+
+AC_DEFUN([ARG_ENABLE_EVAS_IMAGE_LOADER],
+[dnl
+m4_pushdef([DOWN], m4_tolower([$1]))dnl
+
+AC_ARG_ENABLE([image-loader-[]DOWN],
+   [AC_HELP_STRING([--enable-image-loader-[]DOWN], [enable $1 image loader. @<:@default=$2@:>@])],
+   [
+      if test "x${enableval}" = "xyes" ; then
+         want_evas_image_loader_[]DOWN="yes"
+      else
+         if test "x${enableval}" = "xstatic" ; then
+            want_evas_image_loader_[]DOWN="static"
+         else
+            if test "x${enableval}" = "xauto" ; then
+               want_evas_image_loader_[]DOWN="auto"
+            else
+               want_evas_image_loader_[]DOWN="no"
+            fi
+         fi
+      fi
+   ],
+   [want_evas_image_loader_[]DOWN="$2"])
+m4_popdef([DOWN])dnl
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_BMP(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_BMP],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_DDS(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_DDS],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_EET(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_EET],
+[
+
+requirement=""
+have_dep="no"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+dnl Eet is required
+have_dep="yes"
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_GENERIC(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_GENERIC],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_GIF(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_GIF],
+[
+
+have_dep="no"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_CHECK_HEADER([gif_lib.h], [have_dep="yes"])
+
+if test "x${have_dep}"  = "xyes" ; then
+   AC_CHECK_LIB([gif],
+      [DGifOpenFileName],
+      [
+       evas_image_loader_[]$1[]_libs="-lgif"
+      ],
+      [have_dep="no"]
+   )
+
+   if test "x${have_dep}"  = "xno" ; then
+      AC_CHECK_LIB([ungif],
+         [DGifOpenFileName],
+         [
+          have_dep="yes"
+          evas_image_loader_[]$1[]_libs="-lungif"
+         ]
+      )
+   fi
+fi
+
+if test "x$2" = "xstatic"  && test "x${have_dep}" = "xyes" ; then
+   requirements_libs_evas="${evas_image_loader_[]$1[]_libs} ${requirements_libs_evas}"
+fi
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_ICO(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_ICO],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_JPEG(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_JPEG],
+[
+
+have_dep="no"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_CHECK_HEADER([jpeglib.h], [have_dep="yes"])
+
+if test "x${have_dep}"  = "xyes" ; then
+   AC_CHECK_LIB([jpeg],
+      [jpeg_CreateDecompress],
+      [
+       evas_image_loader_[]$1[]_libs="-ljpeg"
+       AC_COMPILE_IFELSE(
+          [AC_LANG_PROGRAM(
+              [[
+#include <stdio.h>
+#include <jpeglib.h>
+#include <setjmp.h>
+              ]],
+              [[
+struct jpeg_decompress_struct decomp;
+decomp.region_x = 0;
+              ]])],
+          [have_jpeg_region="yes"],
+          [have_jpeg_region="no"])
+      ],
+      [have_dep="no"]
+   )
+   if test "x${have_jpeg_region}" = "xyes" ; then
+     AC_DEFINE(BUILD_LOADER_JPEG_REGION, [1], [JPEG Region Decode Support])
+   fi
+fi
+
+if test "x$2" = "xstatic"  && test "x${have_dep}" = "xyes" ; then
+   requirements_libs_evas="${evas_image_loader_[]$1[]_libs} ${requirements_libs_evas}"
+fi
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_JP2K(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_JP2K],
+[
+
+requirement=""
+have_dep="no"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+PKG_CHECK_EXISTS([libopenjp2 >= 2.0],
+   [
+    have_dep="yes"
+    requirement="libopenjp2 >= 2.0"
+   ],
+   [have_dep="no"])
+
+if test "x${have_dep}" = "xyes" ; then
+   if test "x$2" = "xstatic" ; then
+      requirements_pc_evas="${requirement} ${requirements_pc_evas}"
+      requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
+   fi
+   PKG_CHECK_MODULES([JP2K], [${requirement}])
+   evas_image_loader_[]$1[]_cflags="${JP2K_CFLAGS}"
+   evas_image_loader_[]$1[]_libs="${JP2K_LIBS}"
+fi
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_PMAPS(loader, want_static[[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_PMAPS],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_PNG(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_PNG],
+[
+
+requirement=""
+have_dep="no"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+dnl libpng.pc is the latest version of libpng that ahs been installed.
+dnl We check it first.
+PKG_CHECK_EXISTS([libpng >= 1.2.10],
+   [
+    have_dep="yes"
+    requirement="libpng >= 1.2.10"
+   ],
+   [have_dep="no"])
+
+if test "x${have_dep}" = "xno" ; then
+   PKG_CHECK_EXISTS([libpng15],
+      [
+       have_dep="yes"
+       requirement="libpng15"
+      ],
+      [have_dep="no"])
+fi
+
+if test "x${have_dep}" = "xno" ; then
+   PKG_CHECK_EXISTS([libpng14],
+      [
+       have_dep="yes"
+       requirement="libpng14"
+      ],
+      [have_dep="no"])
+fi
+
+if test "x${have_dep}" = "xno" ; then
+   PKG_CHECK_EXISTS([libpng12 >= 1.2.10],
+      [
+       have_dep="yes"
+       requirement="libpng12 >= 1.2.10"
+      ],
+      [have_dep="no"])
+fi
+
+if test "x${have_dep}" = "xyes" ; then
+   if test "x$2" = "xstatic" ; then
+      requirements_pc_evas="${requirement} ${requirements_pc_evas}"
+      requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
+   fi
+   PKG_CHECK_MODULES([PNG], [${requirement}])
+   evas_image_loader_[]$1[]_cflags="${PNG_CFLAGS}"
+   evas_image_loader_[]$1[]_libs="${PNG_LIBS}"
+fi
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_PSD(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_PSD],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_TGV(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_TGV],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_SVG(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_SVG],
+[
+
+requirement=""
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+version_esvg="0.0.18"
+version_ender="0.0.6"
+
+PKG_CHECK_EXISTS([esvg >= ${version_esvg} ender >= ${version_ender}],
+   [
+    have_dep="yes"
+    requirement="esvg >= ${version_esvg} ender >= ${version_ender}"
+   ],
+   [have_dep="no"])
+
+if test "x${have_dep}" = "xyes" ; then
+   if test "x$2" = "xstatic" ; then
+      requirements_pc_evas="${requirement} ${requirements_pc_evas}"
+      requirements_pc_deps_evas="${requirement} ${requirements_pc_deps_evas}"
+   fi
+   PKG_CHECK_MODULES([SVG], [${requirement}])
+   evas_image_loader_[]$1[]_cflags="${SVG_CFLAGS}"
+   evas_image_loader_[]$1[]_libs="${SVG_LIBS}"
+fi
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_TGA(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_TGA],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_TIFF(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_TIFF],
+[
+
+have_dep="no"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_CHECK_HEADER([tiffio.h], [have_dep="yes"])
+
+if test "x${have_dep}"  = "xyes" ; then
+   AC_CHECK_LIB([tiff],
+      [TIFFReadScanline],
+      [
+       evas_image_loader_[]$1[]_libs="-ltiff"
+      ],
+      [have_dep="no"]
+   )
+
+   if test "x${have_dep}"  = "xno" ; then
+      AC_CHECK_LIB([tiff],
+         [TIFFReadScanline],
+         [
+          have_dep="yes"
+          evas_image_loader_[]$1[]_libs="-ltiff -ljpeg -lz -lm"
+         ]
+      )
+   fi
+
+   if test "x${have_dep}"  = "xno" ; then
+      AC_CHECK_LIB([tiff34],
+         [TIFFReadScanline],
+         [
+          have_dep="yes"
+          evas_image_loader_[]$1[]_libs="-ltiff34 -ljpeg -lz -lm"
+         ]
+      )
+   fi
+fi
+
+if test "x$2" = "xstatic"  && test "x${have_dep}" = "xyes" ; then
+   requirements_libs_evas="${evas_image_loader_[]$1[]_libs} ${requirements_libs_evas}"
+fi
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_WBMP(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_WBMP],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_WEBP(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_WEBP],
+[
+
+have_dep="no"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_CHECK_HEADER([webp/decode.h], [have_dep="yes"])
+
+if test "x${have_dep}"  = "xyes" ; then
+   AC_CHECK_LIB([webp],
+      [WebPDecodeRGBA],
+      [
+       evas_image_loader_[]$1[]_libs="-lwebp"
+      ],
+      [have_dep="no"]
+   )
+fi
+
+if test "x$2" = "xstatic"  && test "x${have_dep}" = "xyes" ; then
+   requirements_libs_evas="${evas_image_loader_[]$1[]_libs} ${requirements_libs_evas}"
+fi
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_LOADER_DEP_XPM(loader, want_static[, ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
+
+AC_DEFUN([EVAS_CHECK_LOADER_DEP_XPM],
+[
+
+have_dep="yes"
+evas_image_loader_[]$1[]_cflags=""
+evas_image_loader_[]$1[]_libs=""
+
+AC_SUBST([evas_image_loader_$1_cflags])
+AC_SUBST([evas_image_loader_$1_libs])
+
+AS_IF([test "x${have_dep}" = "xyes"], [$3], [$4])
+
+])
+
+dnl use: EVAS_CHECK_IMAGE_LOADER(loader, want_loader, macro)
+AC_DEFUN([EVAS_CHECK_IMAGE_LOADER],
+[dnl
+m4_pushdef([UP], m4_toupper([$1]))dnl
+m4_pushdef([DOWN], m4_tolower([$1]))dnl
+
+want_loader="$2"
+want_static_loader="no"
+have_loader="no"