svn-ex2-1.diff - Exiv2

Patch #1278 » svn-ex2-1.diff

Initial XMP SDK split patch. - Ben Touchette, 27 Feb 2017 21:51

     endif()
     ##
     if( EXISTS "${CMAKE_SOURCE_DIR}/xmpsdk/include"  )
         set( ADOBE_XMP_SDK_INCLUDE ON )
     else()
         set( ADOBE_XMP_SDK_INCLUDE OFF )
         message( FATAL_ERROR "Missing Adobe XMP SDK include files. Setup cannot proceed." )
     endif()
     CMAKE_MINIMUM_REQUIRED( VERSION 3.1.0 )
     PROJECT( exiv2 )
-...
     SET( GENERIC_LIB_SOVERSION  "14" )
     # options and their default values
     OPTION( EXIV2_CPP_STANDARD           "Set the C++ Standard to compile with"                 11  )
     OPTION( EXIV2_CPP_STANDARD_REQUIRED  "Set C++ Standard to required"                         ON  )
     OPTION( EXIV2_CPP_EXTENSION          "Set C++ Extensions to required"                       OFF )
     OPTION( EXIV2_ENABLE_VERBOSITY       "Enable verbosity"                                     OFF )
     OPTION( EXIV2_ENABLE_SHARED        "Build exiv2 as a shared library (dll)"                 ON  )
     OPTION( EXIV2_ENABLE_XMP           "Build with XMP metadata support"                       ON  )
     OPTION( EXIV2_ENABLE_LIBXMP        "Build a static convenience Library for XMP"            ON  )
     OPTION( EXIV2_ENABLE_PNG           "Build with png support (requires libz)"                ON  )
     OPTION( EXIV2_ENABLE_NLS           "Build native language support (requires gettext)"      ON  )
     OPTION( EXIV2_ENABLE_PRINTUCS2     "Build with Printucs2"                                  ON  )
-...
     ENDIF()
     SET ( CMAKE_VERBOSE_MAKEFILE ${EXIV2_ENABLE_VERBOSITY} )
     IF ( NOT ${EXIV2_CPP_STANDARD} )
         SET ( EXIV2_CPP_STANDARD 11 )
     ENDIF ()
     # set include path for FindXXX.cmake files
     set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_SOURCE_DIR}/config/")
     IF ( WIN32 OR MINGW OR MSVC )
         SET( XMPLIB_EXT lib )
     ELSE()
         SET( XMPLIB_EXT a )
     ENDIF()
     IF ( EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/libXMPCore.${XMPLIB_EXT}" AND EXISTS "${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/libXMPFiles.${XMPLIB_EXT}" )
         MESSAGE( STATUS "Has xmp sdk library files" )
         SET ( EXV_HAS_XMP_SDK_LIBS ON )
     ELSE()
         MESSAGE( STATUS "Doesn't have xmp sdk library files" )
         SET ( EXV_HAS_XMP_SDK_LIBS OFF )
     ENDIF()
     IF( MINGW OR UNIX )
         IF ( CMAKE_CXX_COMPILER STREQUAL "g++" OR CMAKE_C_COMPILER STREQUAL "gcc" )
             ADD_DEFINITIONS(-Wall
-...
         message(STATUS Compiler: ${COMPILER} " Major:" ${GCC_MAJOR} " Minor:" ${GCC_MINOR})
         IF ( CYGWIN OR ( ${GCC_MAJOR} GREATER 5 ))
             ADD_DEFINITIONS( -std=gnu++98 ) # to support snprintf
         ELSE()
             ADD_DEFINITIONS( -std=c++98 )
         ENDIF()
     ENDIF( MINGW OR UNIX )
     set( CMAKE_CXX_STANDARD ${EXIV2_CPP_STANDARD} )
     set( CMAKE_CXX_STANDARD_REQUIRED ${EXIV2_CPP_STANDARD_REQUIRED} )
     set( CMAKE_CXX_EXTENSIONS ${EXIV2_CPP_EXTENSION} )
     IF ( ${EXIV2_CPP_STANDARD} LESS 98 AND ${EXIV2_CPP_STANDARD} GREATER 10  )
         ADD_DEFINITIONS( -DEXV_USING_CPP_ELEVEN=1  )
     ENDIF()
     IF( EXIV2_ENABLE_COMMERCIAL )
         SET (EXIV2_ENABLE_LENSDATA OFF)
         SET (EXIV2_ENABLE_NLS OFF)
-...
          ARCHIVE DESTINATION ${CMAKE_INSTALL_LIBDIR}
+    )
     ##
     # add sources from XMPSDK directory
     # this needs to be done here to be visible to xmpsdk, src and sample sub directories
     SET( XMPSRC ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/ExpatAdapter.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/MD5.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/ParseRDF.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/UnicodeConversions.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/WXMPIterator.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/WXMPMeta.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/WXMPUtils.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/XML_Node.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/XMPCore_Impl.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/XMPIterator.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/XMPMeta-GetSet.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/XMPMeta-Parse.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/XMPMeta-Serialize.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/XMPMeta.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/XMPUtils-FileInfo.cpp
                 ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/src/XMPUtils.cpp
     IF ( WIN32 OR MINGW OR MSVC )
         SET( XMPLIB_EXT lib )
     ELSE()
         SET( XMPLIB_EXT a )
     ENDIF()
     IF ( EXV_HAS_XMP_SDK_LIBS )
         SET ( XMPLIBS ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/libXMPCore.${XMPLIB_EXT}
                       ${CMAKE_CURRENT_SOURCE_DIR}/xmpsdk/libXMPFiles.${XMPLIB_EXT}
+    )
     ENDIF()
     ##
     # Adobe XMP SDK definitions
     IF( MSVC OR WIN32 OR MINGW)
       ADD_DEFINITIONS( -DXMP_WinBuild=1 -DWIN_ENV=1 )
     ELSEIF( UNIX AND APPLE)
       ADD_DEFINITIONS( -DXMP_MacBuild=1 -DMAC_ENV=1 )
     ELSE()
       ADD_DEFINITIONS( -DXMP_UNIXBuild=1 -DUNIX_ENV=1 )
     ENDIF()
     # the following lines need to be added to circumvent the error in xmpsdk\src\MD5.h
     IF( ${EXV_HAVE_STDINT_H} )
-...
       ENDIF()
     ENDIF()
     ADD_SUBDIRECTORY( xmpsdk )
     ADD_SUBDIRECTORY( src )
     IF ( EXV_HAS_XMP_SDK_LIBS )
     IF( EXIV2_ENABLE_BUILD_SAMPLES )
         ADD_SUBDIRECTORY( samples )
     ENDIF( EXIV2_ENABLE_BUILD_SAMPLES )
     ENDIF()
     IF( EXIV2_ENABLE_BUILD_PO )
         ADD_SUBDIRECTORY( po )
-...
     ##
     # tests
     IF ( EXV_HAS_XMP_SDK_LIBS )
     ADD_CUSTOM_TARGET(tests       COMMAND env EXIV2_BINDIR="${CMAKE_BINARY_DIR}"/bin make tests       WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" )
     ADD_CUSTOM_TARGET(geotag-test COMMAND env EXIV2_BINDIR="${CMAKE_BINARY_DIR}"/bin make geotag-test WORKING_DIRECTORY "${CMAKE_SOURCE_DIR}" )
     ENDIF()
     ##
     # http://dev.exiv2.org/boards/3/topics/1364

         $5
       ])
     ])
     # ===========================================================================
     #   http://www.gnu.org/software/autoconf-archive/ax_cxx_compile_stdcxx.html
     # ===========================================================================
+    #
     # SYNOPSIS
+    #
     #   AX_CXX_COMPILE_STDCXX(VERSION, [ext|noext], [mandatory|optional])
+    #
     # DESCRIPTION
+    #
     #   Check for baseline language coverage in the compiler for the specified
     #   version of the C++ standard.  If necessary, add switches to CXX and
     #   CXXCPP to enable support.  VERSION may be '11' (for the C++11 standard)
     #   or '14' (for the C++14 standard).
+    #
     #   The second 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 third argument, if specified 'mandatory' or if left unspecified,
     #   indicates that baseline support for the specified C++ standard 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_CXX${VERSION} 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>
     #   Copyright (c) 2014, 2015 Google Inc.; contributed by Alexey Sokolov <sokolov@google.com>
     #   Copyright (c) 2015 Paul Norman <penorman@mac.com>
     #   Copyright (c) 2015 Moritz Klammler <moritz@klammler.eu>
     #   Copyright (c) 2016 Krzesimir Nowak <qdlacz@gmail.com>
+    #
     #   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 6
     dnl  This macro is based on the code from the AX_CXX_COMPILE_STDCXX_11 macro
     dnl  (serial version number 13).
     AX_REQUIRE_DEFINED([AC_MSG_WARN])
     AC_DEFUN([AX_CXX_COMPILE_STDCXX], [dnl
       m4_if([$1], [11], [ax_cxx_compile_alternatives="11 0x"],
             [$1], [14], [ax_cxx_compile_alternatives="14 1y"],
             [$1], [17], [ax_cxx_compile_alternatives="17 1z"],
             [m4_fatal([invalid first argument `$1' to AX_CXX_COMPILE_STDCXX])])dnl
       m4_if([$2], [], [],
             [$2], [ext], [],
             [$2], [noext], [],
             [m4_fatal([invalid second argument `$2' to AX_CXX_COMPILE_STDCXX])])dnl
       m4_if([$3], [], [ax_cxx_compile_cxx$1_required=true],
             [$3], [mandatory], [ax_cxx_compile_cxx$1_required=true],
             [$3], [optional], [ax_cxx_compile_cxx$1_required=false],
             [m4_fatal([invalid third argument `$3' to AX_CXX_COMPILE_STDCXX])])
       AC_LANG_PUSH([C++])dnl
       ac_success=no
       AC_CACHE_CHECK(whether $CXX supports C++$1 features by default,
       ax_cv_cxx_compile_cxx$1,
       [AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
         [ax_cv_cxx_compile_cxx$1=yes],
         [ax_cv_cxx_compile_cxx$1=no])])
       if test x$ax_cv_cxx_compile_cxx$1 = xyes; then
         ac_success=yes
       fi
       m4_if([$2], [noext], [], [dnl
       if test x$ac_success = xno; then
         for alternative in ${ax_cxx_compile_alternatives}; do
           switch="-std=gnu++${alternative}"
           cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
           AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
                          $cachevar,
             [ac_save_CXX="$CXX"
              CXX="$CXX $switch"
              AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
               [eval $cachevar=yes],
               [eval $cachevar=no])
              CXX="$ac_save_CXX"])
           if eval test x\$$cachevar = xyes; then
             CXX="$CXX $switch"
             if test -n "$CXXCPP" ; then
               CXXCPP="$CXXCPP $switch"
             fi
             ac_success=yes
             break
           fi
         done
       fi])
       m4_if([$2], [ext], [], [dnl
       if test x$ac_success = xno; then
         dnl HP's aCC needs +std=c++11 according to:
         dnl http://h21007.www2.hp.com/portal/download/files/unprot/aCxx/PDF_Release_Notes/769149-001.pdf
         dnl Cray's crayCC needs "-h std=c++11"
         for alternative in ${ax_cxx_compile_alternatives}; do
           for switch in -std=c++${alternative} +std=c++${alternative} "-h std=c++${alternative}"; do
             cachevar=AS_TR_SH([ax_cv_cxx_compile_cxx$1_$switch])
             AC_CACHE_CHECK(whether $CXX supports C++$1 features with $switch,
                            $cachevar,
               [ac_save_CXX="$CXX"
                CXX="$CXX $switch"
                AC_COMPILE_IFELSE([AC_LANG_SOURCE([_AX_CXX_COMPILE_STDCXX_testbody_$1])],
                 [eval $cachevar=yes],
                 [eval $cachevar=no])
                CXX="$ac_save_CXX"])
             if eval test x\$$cachevar = xyes; then
               CXX="$CXX $switch"
               if test -n "$CXXCPP" ; then
                 CXXCPP="$CXXCPP $switch"
               fi
               ac_success=yes
               break
             fi
           done
           if test x$ac_success = xyes; then
             break
           fi
         done
       fi])
       AC_LANG_POP([C++])
       if test x$ax_cxx_compile_cxx$1_required = xtrue; then
         if test x$ac_success = xno; then
           AC_MSG_ERROR([*** A compiler with support for C++$1 language features is required.])
         fi
       fi
       if test x$ac_success = xno; then
         HAVE_CXX$1=0
         AC_MSG_NOTICE([No compiler with C++$1 support was found])
       else
         HAVE_CXX$1=1
         AC_DEFINE(HAVE_CXX$1,1,
                   [define if the compiler supports basic C++$1 syntax])
       fi
       AC_SUBST(HAVE_CXX$1)
       m4_if([$1], [17], [AC_MSG_WARN([C++17 is not yet standardized, so the checks may change in incompatible ways anytime])])
     ])
     dnl  Test body for checking C++11 support
     m4_define([_AX_CXX_COMPILE_STDCXX_testbody_11],
       _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
+    )
     dnl  Test body for checking C++14 support
     m4_define([_AX_CXX_COMPILE_STDCXX_testbody_14],
       _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
       _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
+    )
     m4_define([_AX_CXX_COMPILE_STDCXX_testbody_17],
       _AX_CXX_COMPILE_STDCXX_testbody_new_in_11
       _AX_CXX_COMPILE_STDCXX_testbody_new_in_14
       _AX_CXX_COMPILE_STDCXX_testbody_new_in_17
+    )
     dnl  Tests for new features in C++11
     m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_11], [[
     // If the compiler admits that it is not ready for C++11, why torture it?
     // Hopefully, this will speed up the test.
     #ifndef __cplusplus
     #error "This is not a C++ compiler"
     #elif __cplusplus < 201103L
     #error "This is not a C++11 compiler"
     #else
     namespace cxx11
+    {
       namespace test_static_assert
+      {
         template <typename T>
         struct check
+        {
           static_assert(sizeof(int) <= sizeof(T), "not big enough");
         };
+      }
       namespace test_final_override
+      {
         struct Base
+        {
           virtual void f() {}
         };
         struct Derived : public Base
+        {
           virtual void f() override {}
         };
+      }
       namespace test_double_right_angle_brackets
+      {
         template < typename T >
         struct check {};
         typedef check<void> single_type;
         typedef check<check<void>> double_type;
         typedef check<check<check<void>>> triple_type;
         typedef check<check<check<check<void>>>> quadruple_type;
+      }
       namespace test_decltype
+      {
         int
         f()
+        {
           int a = 1;
           decltype(a) b = 2;
           return a + b;
+        }
+      }
       namespace test_type_deduction
+      {
         template < typename T1, typename T2 >
         struct is_same
+        {
           static const bool value = false;
         };
         template < typename T >
         struct is_same<T, T>
+        {
           static const bool value = true;
         };
         template < typename T1, typename T2 >
         auto
         add(T1 a1, T2 a2) -> decltype(a1 + a2)
+        {
           return a1 + a2;
+        }
         int
         test(const int c, volatile int v)
+        {
           static_assert(is_same<int, decltype(0)>::value == true, "");
           static_assert(is_same<int, decltype(c)>::value == false, "");
           static_assert(is_same<int, decltype(v)>::value == false, "");
           auto ac = c;
           auto av = v;
           auto sumi = ac + av + 'x';
           auto sumf = ac + av + 1.0;
           static_assert(is_same<int, decltype(ac)>::value == true, "");
           static_assert(is_same<int, decltype(av)>::value == true, "");
           static_assert(is_same<int, decltype(sumi)>::value == true, "");
           static_assert(is_same<int, decltype(sumf)>::value == false, "");
           static_assert(is_same<int, decltype(add(c, v))>::value == true, "");
           return (sumf > 0.0) ? sumi : add(c, v);
+        }
+      }
       namespace test_noexcept
+      {
         int f() { return 0; }
         int g() noexcept { return 0; }
         static_assert(noexcept(f()) == false, "");
         static_assert(noexcept(g()) == true, "");
+      }
       namespace test_constexpr
+      {
         template < typename CharT >
         unsigned long constexpr
         strlen_c_r(const CharT *const s, const unsigned long acc) noexcept
+        {
           return *s ? strlen_c_r(s + 1, acc + 1) : acc;
+        }
         template < typename CharT >
         unsigned long constexpr
         strlen_c(const CharT *const s) noexcept
+        {
           return strlen_c_r(s, 0UL);
+        }
         static_assert(strlen_c("") == 0UL, "");
         static_assert(strlen_c("1") == 1UL, "");
         static_assert(strlen_c("example") == 7UL, "");
         static_assert(strlen_c("another\0example") == 7UL, "");
+      }
       namespace test_rvalue_references
+      {
         template < int N >
         struct answer
+        {
           static constexpr int value = N;
         };
         answer<1> f(int&)       { return answer<1>(); }
         answer<2> f(const int&) { return answer<2>(); }
         answer<3> f(int&&)      { return answer<3>(); }
         void
         test()
+        {
           int i = 0;
           const int c = 0;
           static_assert(decltype(f(i))::value == 1, "");
           static_assert(decltype(f(c))::value == 2, "");
           static_assert(decltype(f(0))::value == 3, "");
+        }
+      }
       namespace test_uniform_initialization
+      {
         struct test
+        {
           static const int zero {};
           static const int one {1};
         };
         static_assert(test::zero == 0, "");
         static_assert(test::one == 1, "");
+      }
       namespace test_lambdas
+      {
         void
         test1()
+        {
           auto lambda1 = [](){};
           auto lambda2 = lambda1;
           lambda1();
           lambda2();
+        }
         int
         test2()
+        {
           auto a = [](int i, int j){ return i + j; }(1, 2);
           auto b = []() -> int { return '0'; }();
           auto c = [=](){ return a + b; }();
           auto d = [&](){ return c; }();
           auto e = [a, &b](int x) mutable {
             const auto identity = [](int y){ return y; };
             for (auto i = 0; i < a; ++i)
               a += b--;
             return x + identity(a + b);
           }(0);
           return a + b + c + d + e;
+        }
         int
         test3()
+        {
           const auto nullary = [](){ return 0; };
           const auto unary = [](int x){ return x; };
           using nullary_t = decltype(nullary);
           using unary_t = decltype(unary);
           const auto higher1st = [](nullary_t f){ return f(); };
           const auto higher2nd = [unary](nullary_t f1){
             return [unary, f1](unary_t f2){ return f2(unary(f1())); };
           };
           return higher1st(nullary) + higher2nd(nullary)(unary);
+        }
+      }
       namespace test_variadic_templates
+      {
         template <int...>
         struct sum;
         template <int N0, int... N1toN>
         struct sum<N0, N1toN...>
+        {
           static constexpr auto value = N0 + sum<N1toN...>::value;
         };
         template <>
         struct sum<>
+        {
           static constexpr auto value = 0;
         };
         static_assert(sum<>::value == 0, "");
         static_assert(sum<1>::value == 1, "");
         static_assert(sum<23>::value == 23, "");
         static_assert(sum<1, 2>::value == 3, "");
         static_assert(sum<5, 5, 11>::value == 21, "");
         static_assert(sum<2, 3, 5, 7, 11, 13>::value == 41, "");
+      }
       // http://stackoverflow.com/questions/13728184/template-aliases-and-sfinae
       // Clang 3.1 fails with headers of libstd++ 4.8.3 when using std::function
       // because of this.
       namespace test_template_alias_sfinae
+      {
         struct foo {};
         template<typename T>
         using member = typename T::member_type;
         template<typename T>
         void func(...) {}
         template<typename T>
         void func(member<T>*) {}
         void test();
         void test() { func<foo>(0); }
+      }
     }  // namespace cxx11
     #endif  // __cplusplus >= 201103L
     ]])
     dnl  Tests for new features in C++14
     m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_14], [[
     // If the compiler admits that it is not ready for C++14, why torture it?
     // Hopefully, this will speed up the test.
     #ifndef __cplusplus
     #error "This is not a C++ compiler"
     #elif __cplusplus < 201402L
     #error "This is not a C++14 compiler"
     #else
     namespace cxx14
+    {
       namespace test_polymorphic_lambdas
+      {
         int
         test()
+        {
           const auto lambda = [](auto&&... args){
             const auto istiny = [](auto x){
               return (sizeof(x) == 1UL) ? 1 : 0;
             };
             const int aretiny[] = { istiny(args)... };
             return aretiny[0];
           };
           return lambda(1, 1L, 1.0f, '1');
+        }
+      }
       namespace test_binary_literals
+      {
         constexpr auto ivii = 0b0000000000101010;
         static_assert(ivii == 42, "wrong value");
+      }
       namespace test_generalized_constexpr
+      {
         template < typename CharT >
         constexpr unsigned long
         strlen_c(const CharT *const s) noexcept
+        {
           auto length = 0UL;
           for (auto p = s; *p; ++p)
             ++length;
           return length;
+        }
         static_assert(strlen_c("") == 0UL, "");
         static_assert(strlen_c("x") == 1UL, "");
         static_assert(strlen_c("test") == 4UL, "");
         static_assert(strlen_c("another\0test") == 7UL, "");
+      }
       namespace test_lambda_init_capture
+      {
         int
         test()
+        {
           auto x = 0;
           const auto lambda1 = [a = x](int b){ return a + b; };
           const auto lambda2 = [a = lambda1(x)](){ return a; };
           return lambda2();
+        }
+      }
       namespace test_digit_separators
+      {
         constexpr auto ten_million = 100'000'000;
         static_assert(ten_million == 100000000, "");
+      }
       namespace test_return_type_deduction
+      {
         auto f(int& x) { return x; }
         decltype(auto) g(int& x) { return x; }
         template < typename T1, typename T2 >
         struct is_same
+        {
           static constexpr auto value = false;
         };
         template < typename T >
         struct is_same<T, T>
+        {
           static constexpr auto value = true;
         };
         int
         test()
+        {
           auto x = 0;
           static_assert(is_same<int, decltype(f(x))>::value, "");
           static_assert(is_same<int&, decltype(g(x))>::value, "");
           return x;
+        }
+      }
     }  // namespace cxx14
     #endif  // __cplusplus >= 201402L
     ]])
     dnl  Tests for new features in C++17
     m4_define([_AX_CXX_COMPILE_STDCXX_testbody_new_in_17], [[
     // If the compiler admits that it is not ready for C++17, why torture it?
     // Hopefully, this will speed up the test.
     #ifndef __cplusplus
     #error "This is not a C++ compiler"
     #elif __cplusplus <= 201402L
     #error "This is not a C++17 compiler"
     #else
     #if defined(__clang__)
       #define REALLY_CLANG
     #else
       #if defined(__GNUC__)
         #define REALLY_GCC
       #endif
     #endif
     #include <initializer_list>
     #include <utility>
     #include <type_traits>
     namespace cxx17
+    {
     #if !defined(REALLY_CLANG)
       namespace test_constexpr_lambdas
+      {
         // TODO: test it with clang++ from git
         constexpr int foo = [](){return 42;}();
+      }
     #endif // !defined(REALLY_CLANG)
       namespace test::nested_namespace::definitions
+      {
+      }
       namespace test_fold_expression
+      {
         template<typename... Args>
         int multiply(Args... args)
+        {
           return (args * ... * 1);
+        }
         template<typename... Args>
         bool all(Args... args)
+        {
           return (args && ...);
+        }
+      }
       namespace test_extended_static_assert
+      {
         static_assert (true);
+      }
       namespace test_auto_brace_init_list
+      {
         auto foo = {5};
         auto bar {5};
         static_assert(std::is_same<std::initializer_list<int>, decltype(foo)>::value);
         static_assert(std::is_same<int, decltype(bar)>::value);
+      }
       namespace test_typename_in_template_template_parameter
+      {
         template<template<typename> typename X> struct D;
+      }
       namespace test_fallthrough_nodiscard_maybe_unused_attributes
+      {
         int f1()
+        {
           return 42;
+        }
         [[nodiscard]] int f2()
+        {
           [[maybe_unused]] auto unused = f1();
           switch (f1())
+          {
           case 17:
             f1();
             [[fallthrough]];
           case 42:
             f1();
+          }
           return f1();
+        }
+      }
       namespace test_extended_aggregate_initialization
+      {
         struct base1
+        {
           int b1, b2 = 42;
         };
         struct base2
+        {
           base2() {
             b3 = 42;
+          }
           int b3;
         };
         struct derived : base1, base2
+        {
             int d;
         };
         derived d1 {{1, 2}, {}, 4};  // full initialization
         derived d2 {{}, {}, 4};      // value-initialized bases
+      }
       namespace test_general_range_based_for_loop
+      {
         struct iter
+        {
           int i;
           int& operator* ()
+          {
             return i;
+          }
           const int& operator* () const
+          {
             return i;
+          }
           iter& operator++()
+          {
             ++i;
             return *this;
+          }
         };
         struct sentinel
+        {
           int i;
         };
         bool operator== (const iter& i, const sentinel& s)
+        {
           return i.i == s.i;
+        }
         bool operator!= (const iter& i, const sentinel& s)
+        {
           return !(i == s);
+        }
         struct range
+        {
           iter begin() const
+          {
             return {0};
+          }
           sentinel end() const
+          {
             return {5};
+          }
         };
         void f()
+        {
           range r {};
           for (auto i : r)
+          {
             [[maybe_unused]] auto v = i;
+          }
+        }
+      }
       namespace test_lambda_capture_asterisk_this_by_value
+      {
         struct t
+        {
           int i;
           int foo()
+          {
             return [*this]()
+            {
               return i;
             }();
+          }
         };
+      }
       namespace test_enum_class_construction
+      {
         enum class byte : unsigned char
         {};
         byte foo {42};
+      }
       namespace test_constexpr_if
+      {
         template <bool cond>
         int f ()
+        {
           if constexpr(cond)
+          {
             return 13;
+          }
           else
+          {
             return 42;
+          }
+        }
+      }
       namespace test_selection_statement_with_initializer
+      {
         int f()
+        {
           return 13;
+        }
         int f2()
+        {
           if (auto i = f(); i > 0)
+          {
             return 3;
+          }
           switch (auto i = f(); i + 4)
+          {
           case 17:
             return 2;
           default:
             return 1;
+          }
+        }
+      }
     #if !defined(REALLY_CLANG)
       namespace test_template_argument_deduction_for_class_templates
+      {
         // TODO: test it with clang++ from git
         template <typename T1, typename T2>
         struct pair
+        {
           pair (T1 p1, T2 p2)
             : m1 {p1},
               m2 {p2}
           {}
           T1 m1;
           T2 m2;
         };
         void f()
+        {
           [[maybe_unused]] auto p = pair{13, 42u};
+        }
+      }
     #endif // !defined(REALLY_CLANG)
       namespace test_non_type_auto_template_parameters
+      {
         template <auto n>
         struct B
         {};
         B<5> b1;
         B<'a'> b2;
+      }
     #if !defined(REALLY_CLANG)
       namespace test_structured_bindings
+      {
         // TODO: test it with clang++ from git
         int arr[2] = { 1, 2 };
         std::pair<int, int> pr = { 1, 2 };
         auto f1() -> int(&)[2]
+        {
           return arr;
+        }
         auto f2() -> std::pair<int, int>&
+        {
           return pr;
+        }
         struct S
+        {
           int x1 : 2;
           volatile double y1;
         };
         S f3()
+        {
           return {};
+        }
         auto [ x1, y1 ] = f1();
         auto& [ xr1, yr1 ] = f1();
         auto [ x2, y2 ] = f2();
         auto& [ xr2, yr2 ] = f2();
         const auto [ x3, y3 ] = f3();
+      }
     #endif // !defined(REALLY_CLANG)
     #if !defined(REALLY_CLANG)
       namespace test_exception_spec_type_system
+      {
         // TODO: test it with clang++ from git
         struct Good {};
         struct Bad {};
         void g1() noexcept;
         void g2();
         template<typename T>
         Bad
         f(T*, T*);
         template<typename T1, typename T2>
         Good
         f(T1*, T2*);
         static_assert (std::is_same_v<Good, decltype(f(g1, g2))>);
+      }
     #endif // !defined(REALLY_CLANG)
       namespace test_inline_variables
+      {
         template<class T> void f(T)
         {}
         template<class T> inline T g(T)
+        {
           return T{};
+        }
         template<> inline void f<>(int)
         {}
         template<> int g<>(int)
+        {
           return 5;
+        }
+      }
     }  // namespace cxx17
     #endif  // __cplusplus <= 201402L
     ]])

         ENDIF( EXIV2_ENABLE_SSH )
     ENDIF( EXIV2_ENABLE_WEBREADY )
     IF ( EXV_HAS_XMP_SDK_LIBS )
     IF (EXIV2_ENABLE_XMP)
         FIND_PACKAGE(EXPAT REQUIRED)
         INCLUDE_DIRECTORIES(${EXPAT_INCLUDE_DIR})
-...
             ENDIF( NOT EXPAT_FOUND )
         ENDIF( MINGW OR UNIX )
     ENDIF (EXIV2_ENABLE_XMP)
     ENDIF ()
     IF( EXIV2_ENABLE_SHARED )
         ADD_DEFINITIONS( -DEXV_HAVE_DLL )
-...
     MESSAGE( STATUS "------------------------------------------------------------------" )
     MESSAGE( STATUS "${PACKAGE_STRING} configure results        <${PACKAGE_URL}>"        )
     MESSAGE( STATUS "C++ standard                        ${EXIV2_CPP_STANDARD}"          )
     OptionOutput( "C++ standard required               " EXIV2_CPP_STANDARD_REQUIRED     )
     OptionOutput( "C++ extensions required             " EXIV2_CPP_EXTENSION             )
     OptionOutput( "Enabled compilation verbosity       " EXIV2_ENABLE_VERBOSITY          )
     OptionOutput( "Building PNG support:               " EXIV2_ENABLE_PNG AND ZLIB_FOUND )
     OptionOutput( "Building shared library:            " EXIV2_ENABLE_SHARED             )
     OptionOutput( "XMP metadata support:               " EXIV2_ENABLE_XMP                )
     OptionOutput( "Building static libxmp:             " EXIV2_ENABLE_LIBXMP             )
     OptionOutput( "Native language support:            " EXIV2_ENABLE_NLS                )
     OptionOutput( "Conversion of Windows XP tags:      " EXIV2_ENABLE_PRINTUCS2          )
     OptionOutput( "Nikon lens database:                " EXIV2_ENABLE_LENSDATA           )

     ENABLE_XMP = @ENABLE_XMP@
     ifdef ENABLE_XMP
             XMPSDK_LIBRARY = xmpsdk
             XMPSDK_DIR = $(top_srcdir)/xmpsdk
             XMPSDK_CPPFLAGS = -I$(XMPSDK_DIR)/include
             XMPSDK_LDFLAGS = -L$(XMPSDK_DIR)/src
             XMPSDK_LIBS = -l$(XMPSDK_LIBRARY)
             XMPSDK_LDFLAGS = -L$(XMPSDK_DIR)
             XMPSDK_LIBRARIES = -lXMPCore -lXMPFiles
             XMPSDK_STATIC_LIBS = $(XMPSDK_DIR)/libXMPCore.a $(XMPSDK_DIR)/libXMPFiles.a
             ifeq ($(OS),Windows_NT)
                     XMPSDK_CPPFLAGS += -DWIN_ENV=1 -DXMP_WinBuild=1
             else
                     UNAME_S := $(shell uname -s)
                     ifeq ($(UNAME_S),Linux)
                             XMPSDK_CPPFLAGS += -DUNIX_ENV=1 -DXMP_UNIXBuild=1
                     else
                             XMPSDK_CPPFLAGS += -DMAC_ENV=1 -DXMP_MacBuild=1
                     endif
             endif
     else
             # Enable additional warnings. XMP Toolkit doesn't compile
             # with these.

     AC_CONFIG_HEADER([./config/config.h])
     AC_CONFIG_AUX_DIR([./config])
     AC_CHECK_FILES([${srcdir}/xmpsdk/include/XMP.hpp], , [echo "Did not find XMP SDK headers"; exit -1])
     AC_CHECK_FILES([${srcdir}/xmpsdk/libXMPCore.a ${srcdir}/xmpsdk/libXMPFiles.a], , [echo "Did not find XMP SDK static lib"; exit -1])
     # ---------------------------------------------------------------------------
     # Checks for programs.
     # ---------------------------------------------------------------------------
-...
     ac_cv_prog_cxx_g=no
     AC_PROG_CXX
     AC_PROG_CXXCPP
     AX_CXX_COMPILE_STDCXX(11, noext, optional)
     # Don't use -g to compile C code
     ac_cv_prog_cc_g=no
     AC_PROG_CC
-...
     AC_MSG_RESULT($COMMERCIAL_VERSION)
     AC_SUBST(COMMERCIAL_VERSION,$COMMERCIAL_VERSION)
     AC_MSG_CHECKING([whether to enable XMP support (requires expat)])
     AC_ARG_ENABLE(xmp,
         [  --disable-xmp           do not compile XMP support and the XMP Toolkit ],
         USE_XMP_TOOLKIT=$enableval, USE_XMP_TOOLKIT=yes)
     AC_MSG_RESULT($USE_XMP_TOOLKIT)
     AC_MSG_CHECKING([whether to compile with video support])
     AC_ARG_ENABLE(video,
         [  --enable-video          compile with video support ],
-...
       fi
     ])
     ENABLE_XMP=
     if test "$USE_XMP_TOOLKIT" = "yes"; then
         # Check for expat library
         found_expat=yes
         EXPAT_CPPFLAGS=
-...
             PTHREAD="-lpthread"
         fi
         if test "$with_expat" = "no" -o "$found_expat" = "no"; then
             AC_MSG_ERROR(either specify a valid expat installation with --with-expat=DIR or disable XMP support with --disable-xmp)
         AC_MSG_ERROR(either specify a valid expat installation with --with-expat=DIR)
         fi
         AC_DEFINE(HAVE_XMP_TOOLKIT,1)
         ENABLE_XMP=1
         AC_SUBST(EXPAT_CPPFLAGS)
         AC_SUBST(EXPAT_LDFLAGS)
         AC_SUBST(EXPAT_LIBS)
         AC_CHECK_LIB(pthread, pthread_create, [PTHREAD_LIBS+=-lpthread])
         AC_SUBST(PTHREAD_LIBS)
     fi
     AC_SUBST(ENABLE_XMP)
     CPPFLAGS=${_cppflags}
     LDFLAGS=${_ldflags}
-...
       AC_SUBST([GCC_VERSION])
     ])
     AC_ARG_ENABLE(stdcpp11,
         [  --disable-stdcpp11    do not use the c++11 standard ],
         STDCPP11_SUPPORT=$enableval, STDCPP11_SUPPORT=$visibility)
     AC_MSG_RESULT($STDCPP11_SUPPORT)
     if test "$STDCPP11_SUPPORT" = "yes"; then
         CPPFLAGS="${CPPFLAGS} -std=c++11 -DEXV_USING_CPP_ELEVEN"
     else
     # 1188 v0.26 uses c++98
     # 1188 v0.27 should have an option to specify versions such as c++11
     case "$host_os" in
-...
             fi
         ;;
     esac
     fi
     # ---------------------------------------------------------------------------
     # Create output files.
-...
     *)   echo "-- Nikon lens database............ NO" ;;
     esac
     case "$USE_XMP_TOOLKIT" in
     yes) echo "-- XMP metadata support........... YES" ;;
     *)   echo "-- XMP metadata support........... NO"
          echo ""
          echo "Expat is required for XMP support. Make sure the Expat header"
          echo "files are installed and use --with-expat=DIR if it is in a"
          echo "non-standard location. You can get Expat from"
          echo "http://expat.sourceforge.net/"
          echo "" ;;
     esac
     case "x$ENABLE_VIDEO" in
     x1)  echo "-- Video support.................. YES" ;;
     *)   echo "-- Video support.................. NO"

     SHELL = /bin/sh
     ENABLE_XMP = 1
     .PHONY: all doc config samples xmpsdk                \
     .PHONY: all doc config samples                 \
             mostlyclean clean distclean maintainer-clean \
             install uninstall tests teste testv
     all install: config/config.mk xmpsdk
     all install: config/config.mk
     	cd src && $(MAKE) $(MAKECMDGOALS)
     	cd po && $(MAKE) $(MAKECMDGOALS)
-...
     config:
     	cd config && $(MAKE) -f config.make $(MAKECMDGOALS)
     xmpsdk: src/svn_version.h config/config.mk
     	if test "x$(ENABLE_XMP)" = "x1"; then cd xmpsdk/src && $(MAKE) $@; fi;
     src/svn_version.h:
     	cd src && $(MAKE) svn_version.h
-...
     	cd doc && $(MAKE) $(MAKECMDGOALS)
     	cd samples && $(MAKE) $(MAKECMDGOALS)
     	cd test && $(MAKE) $(MAKECMDGOALS)
     	cd xmpsdk/src && $(MAKE) $(MAKECMDGOALS)
     	cd config && $(MAKE) -f config.make $(MAKECMDGOALS)
     	cd po && $(MAKE) $(MAKECMDGOALS)
     	rm -f include/exiv2/exv_conf.h src/svn_version.h

exiv2-0.26.svn/contrib/cmake/msvc/ReadMe.txt 2017-02-27 16:18:00.275050258 -0500
172	172	C:\cygwin64\home\rmills\gnu\exiv2\trunk>grep OPTION CMakeLists.txt
173	173	OPTION( EXIV2_ENABLE_SHARED "Build exiv2 as a shared library (dll)" ON )
174	174	OPTION( EXIV2_ENABLE_XMP "Build with XMP metadata support" ON )
175		OPTION( EXIV2_ENABLE_LIBXMP "Build a static convenience Library for XMP" ON )
176	175	OPTION( EXIV2_ENABLE_VIDEO "Build with video support" OFF )
177	176	OPTION( EXIV2_ENABLE_PNG "Build with png support (requires libz)" ON )
178	177	OPTION( EXIV2_ENABLE_NLS "Build native language support (requires gettext)" ON )

     #include <exiv2/exif.hpp>
     #include <exiv2/iptc.hpp>
     #include <exiv2/tags.hpp>
     //#include <exiv2/xmp.hpp>
     //#include <exiv2/xmp_exiv2.hpp>
     #include <cassert>
     #include <sstream>
     #include <ctime>

         class EXIV2API BasicIo {
         public:
             //! BasicIo auto_ptr type
     #ifdef EXV_USING_CPP_ELEVEN
             typedef std::unique_ptr<BasicIo> AutoPtr;
     #else
             typedef std::auto_ptr<BasicIo> AutoPtr;
     #endif
             //! Seek starting positions
             enum Position { beg, cur, end };

         class EXIV2API IptcKey : public Key {
         public:
             //! Shortcut for an %IptcKey auto pointer.
     #ifdef EXV_USING_CPP_ELEVEN
             typedef std::unique_ptr<IptcKey> AutoPtr;
     #else
             typedef std::auto_ptr<IptcKey> AutoPtr;
     #endif
             //! @name Creators
             //@{

     #include "types.hpp"
     #include "value.hpp"
     #include "version.hpp"
     #include "xmp.hpp"
     #include "xmp_exiv2.hpp"
     #include "xmpsidecar.hpp"
     #endif                                  // #ifndef EXIV2_HPP_

     #include "basicio.hpp"
     #include "exif.hpp"
     #include "iptc.hpp"
     #include "xmp.hpp"
     #include "xmp_exiv2.hpp"
     // + standard includes
     #include <string>
-...
         class EXIV2API Image {
         public:
             //! Image auto_ptr type
     #ifdef EXV_USING_CPP_ELEVEN
             typedef std::unique_ptr<Image> AutoPtr;
     #else
             typedef std::auto_ptr<Image> AutoPtr;
     #endif
             //! @name Creators
             //@{

         class EXIV2API Key {
         public:
             //! Shortcut for a %Key auto pointer.
     #ifdef EXV_USING_CPP_ELEVEN
             typedef std::unique_ptr<Key> AutoPtr;
     #else
             typedef std::auto_ptr<Key> AutoPtr;
     #endif
             //! @name Creators
             //@{

         class EXIV2API XmpKey : public Key {
         public:
             //! Shortcut for an %XmpKey auto pointer.
     #ifdef EXV_USING_CPP_ELEVEN
             typedef std::unique_ptr<XmpKey> AutoPtr;
     #else
             typedef std::auto_ptr<XmpKey> AutoPtr;
     #endif
             //! @name Creators
             //@{

         class EXIV2API ExifKey : public Key {
         public:
             //! Shortcut for an %ExifKey auto pointer.
     #ifdef EXV_USING_CPP_ELEVEN
             typedef std::unique_ptr<ExifKey> AutoPtr;
     #else
             typedef std::auto_ptr<ExifKey> AutoPtr;
     #endif
             //! @name Creators
             //@{

         class EXIV2API Value {
         public:
             //! Shortcut for a %Value auto pointer.
     #ifdef EXV_USING_CPP_ELEVEN
             typedef std::unique_ptr<Value> AutoPtr;
     #else
             typedef std::auto_ptr<Value> AutoPtr;
     #endif
             //! @name Creators
             //@{
-...
         class EXIV2API DataValue : public Value {
         public:
             //! Shortcut for a %DataValue auto pointer.
     #ifdef EXV_USING_CPP_ELEVEN
             typedef std::unique_ptr<DataValue> AutoPtr;

... This diff was truncated because it exceeds the maximum size that can be displayed.

« Previous
1
2
3
4
Next »

(1-1/4)

Project

General

Profile

Exiv2

Patch #1278 » svn-ex2-1.diff