KWSys 2017-08-11 (e1006189)

Code extracted from:

    https://gitlab.kitware.com/utils/kwsys.git

at commit e100618908f7f7a41cbe623afa79ca0e4f17834a (master).

Upstream Shortlog
-----------------

Chuck Atkins (2):
      993f0ea4 Add an option to split object and interface libs.
      b61faf89 Fix install rules and usage requirements for interface+object libs

Justin Berger (2):
      6d73752d Allow KWSYSPE_USE_SELECT macro to be overriden at compile time.
      da61baff Added cmake settable property to enable the macro

Sean McBride (1):
      dfa13188 Fixed a couple of trivial clang -Wunused-macros warnings

Shawn Waldon (1):
      da8a9e65 SystemTools: make GetFilenameName handle either kind of slash

CMakeLists.txt

@@ -20,6 +20,21 @@
 #  KWSYS_HEADER_ROOT = The directory into which to generate the kwsys headers.
 #                      A directory called "${KWSYS_NAMESPACE}" will be
 #                      created under this root directory to hold the files.
+#  KWSYS_SPLIT_OBJECTS_FROM_INTERFACE
+#                    = Instead of creating a single ${KWSYS_NAMESPACE} library
+#                      target, create three separate targets:
+#                        ${KWSYS_NAMESPACE}
+#                          - An INTERFACE library only containing usage
+#                            requirements.
+#                        ${KWSYS_NAMESPACE}_objects
+#                          - An OBJECT library for the built kwsys objects.
+#                            Note: This is omitted from the install rules
+#                        ${KWSYS_NAMESPACE}_private
+#                          - An INTERFACE library combining both that is
+#                            appropriate for use with PRIVATE linking in
+#                            target_link_libraries. Because of how interface
+#                            properties propagate, this target is not suitable
+#                            for use with PUBLIC or INTERFACE linking.
 #
 #    Example:
 #
@@ -79,6 +94,10 @@ FOREACH(p
 ENDFOREACH()
 SET(CMAKE_LEGACY_CYGWIN_WIN32 0)
 
+IF(CMAKE_VERSION VERSION_LESS 3.0)
+  SET(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE 0)
+ENDIF()
+
 #-----------------------------------------------------------------------------
 # If a namespace is not specified, use "kwsys" and enable testing.
 # This should be the case only when kwsys is not included inside
@@ -430,6 +449,11 @@ SET_SOURCE_FILES_PROPERTIES(ProcessUNIX.c System.c PROPERTIES
   COMPILE_FLAGS "-DKWSYS_C_HAS_PTRDIFF_T=${KWSYS_C_HAS_PTRDIFF_T} -DKWSYS_C_HAS_SSIZE_T=${KWSYS_C_HAS_SSIZE_T}"
   )
 
+IF(DEFINED KWSYS_PROCESS_USE_SELECT)
+  GET_PROPERTY(ProcessUNIX_FLAGS SOURCE ProcessUNIX.c PROPERTY COMPILE_FLAGS)
+  SET_PROPERTY(SOURCE ProcessUNIX.c PROPERTY COMPILE_FLAGS "${ProcessUNIX_FLAGS} -DKWSYSPE_USE_SELECT=${KWSYSPE_USE_SELECT}")
+ENDIF()
+
 IF(KWSYS_USE_DynamicLoader)
   GET_PROPERTY(KWSYS_SUPPORTS_SHARED_LIBS GLOBAL PROPERTY TARGET_SUPPORTS_SHARED_LIBS)
   IF(KWSYS_SUPPORTS_SHARED_LIBS)
@@ -795,68 +819,144 @@ ENDFOREACH()
 #-----------------------------------------------------------------------------
 # Add the library with the configured name and list of sources.
 IF(KWSYS_C_SRCS OR KWSYS_CXX_SRCS)
-  ADD_LIBRARY(${KWSYS_NAMESPACE} ${KWSYS_LIBRARY_TYPE}
-    ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
-  SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY C_CLANG_TIDY "")
-  SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY CXX_CLANG_TIDY "")
-  SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY C_INCLUDE_WHAT_YOU_USE "")
-  SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
-  SET_PROPERTY(TARGET ${KWSYS_NAMESPACE} PROPERTY LABELS ${KWSYS_LABELS_LIB})
+  IF(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
+    SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
+    SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE}_objects)
+    SET(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE}_private)
+    SET(KWSYS_TARGET_INSTALL ${KWSYS_TARGET_INTERFACE} ${KWSYS_TARGET_LINK})
+    SET(KWSYS_LINK_DEPENDENCY INTERFACE)
+    ADD_LIBRARY(${KWSYS_TARGET_OBJECT} OBJECT
+      ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
+    IF(KWSYS_BUILD_SHARED)
+      SET_PROPERTY(TARGET ${KWSYS_TARGET_OBJECT} PROPERTY
+        POSITION_INDEPENDENT_CODE TRUE)
+    ENDIF()
+    ADD_LIBRARY(${KWSYS_TARGET_INTERFACE} INTERFACE)
+    ADD_LIBRARY(${KWSYS_TARGET_LINK} INTERFACE)
+    TARGET_LINK_LIBRARIES(${KWSYS_TARGET_LINK} INTERFACE
+      ${KWSYS_TARGET_INTERFACE})
+    TARGET_SOURCES(${KWSYS_TARGET_LINK} INTERFACE
+      $<TARGET_OBJECTS:${KWSYS_TARGET_OBJECT}>)
+  ELSE()
+    SET(KWSYS_TARGET_INTERFACE ${KWSYS_NAMESPACE})
+    SET(KWSYS_TARGET_OBJECT ${KWSYS_NAMESPACE})
+    SET(KWSYS_TARGET_LINK ${KWSYS_NAMESPACE})
+    set(KWSYS_TARGET_INSTALL ${KWSYS_TARGET_LINK})
+    SET(KWSYS_LINK_DEPENDENCY PUBLIC)
+    ADD_LIBRARY(${KWSYS_TARGET_INTERFACE} ${KWSYS_LIBRARY_TYPE}
+      ${KWSYS_C_SRCS} ${KWSYS_CXX_SRCS})
+  ENDIF()
+  SET_TARGET_PROPERTIES(${KWSYS_TARGET_OBJECT} PROPERTIES
+    C_CLANG_TIDY ""
+    CXX_CLANG_TIDY ""
+    C_INCLUDE_WHAT_YOU_USE ""
+    CXX_INCLUDE_WHAT_YOU_USE ""
+    LABELS "${KWSYS_LABELS_LIB}")
   IF(KWSYS_USE_DynamicLoader)
     IF(UNIX)
-      TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ${CMAKE_DL_LIBS})
+      TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+        ${CMAKE_DL_LIBS})
     ENDIF()
   ENDIF()
 
   IF(KWSYS_USE_SystemInformation)
     IF(WIN32)
-      TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ws2_32)
+      TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY} ws2_32)
       IF(KWSYS_SYS_HAS_PSAPI)
-        TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} Psapi)
+        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+          Psapi)
       ENDIF()
     ELSEIF(UNIX)
       IF (EXECINFO_LIB AND KWSYS_CXX_HAS_BACKTRACE)
         # backtrace on FreeBSD is not in libc
-        TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ${EXECINFO_LIB})
+        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+          ${EXECINFO_LIB})
       ENDIF()
       IF (KWSYS_CXX_HAS_DLADDR)
         # for symbol lookup using dladdr
-        TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} ${CMAKE_DL_LIBS})
+        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+          ${CMAKE_DL_LIBS})
       ENDIF()
       IF (CMAKE_SYSTEM_NAME STREQUAL "SunOS")
-        TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE} socket)
+        TARGET_LINK_LIBRARIES(${KWSYS_TARGET_INTERFACE} ${KWSYS_LINK_DEPENDENCY}
+          socket)
       ENDIF()
     ENDIF()
   ENDIF()
 
   # Apply user-defined target properties to the library.
   IF(KWSYS_PROPERTIES_CXX)
-    SET_TARGET_PROPERTIES(${KWSYS_NAMESPACE} PROPERTIES
-      ${KWSYS_PROPERTIES_CXX}
-      )
+    SET_TARGET_PROPERTIES(${KWSYS_TARGET_INTERFACE} PROPERTIES
+      ${KWSYS_PROPERTIES_CXX})
+  ENDIF()
+
+  # Set up include usage requirement
+  IF(COMMAND TARGET_INCLUDE_DIRECTORIES)
+    TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_INTERFACE} INTERFACE
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+    IF(KWSYS_INSTALL_INCLUDE_DIR)
+      TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_INTERFACE} INTERFACE
+        $<INSTALL_INTERFACE:${KWSYS_INSTALL_INCLUDE_DIR}>)
+    ENDIF()
   ENDIF()
 
   # Create an install target for the library.
   IF(KWSYS_INSTALL_LIBRARY_RULE)
-    INSTALL(TARGETS ${KWSYS_NAMESPACE} ${KWSYS_INSTALL_LIBRARY_RULE})
+    INSTALL(TARGETS ${KWSYS_TARGET_INSTALL} ${KWSYS_INSTALL_LIBRARY_RULE})
   ENDIF()
 ENDIF()
 
 # Add a C-only library if requested.
 IF(KWSYS_ENABLE_C AND KWSYS_C_SRCS)
-  ADD_LIBRARY(${KWSYS_NAMESPACE}_c ${KWSYS_LIBRARY_TYPE} ${KWSYS_C_SRCS})
-  SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}_c PROPERTY LABELS ${KWSYS_LABELS_LIB})
+ IF(KWSYS_SPLIT_OBJECTS_FROM_INTERFACE)
+    SET(KWSYS_TARGET_C_INTERFACE ${KWSYS_NAMESPACE}_c)
+    SET(KWSYS_TARGET_C_OBJECT ${KWSYS_NAMESPACE}_c_objects)
+    SET(KWSYS_TARGET_C_LINK ${KWSYS_NAMESPACE}_c_private)
+    SET(KWSYS_TARGET_C_INSTALL
+      ${KWSYS_TARGET_C_INTERFACE} ${KWSYS_TARGET_C_LINK})
+    SET(KWSYS_LINK_DEPENDENCY INTERFACE)
+    ADD_LIBRARY(${KWSYS_TARGET_C_OBJECT} OBJECT ${KWSYS_C_SRCS})
+    IF(KWSYS_BUILD_SHARED)
+      SET_PROPERTY(TARGET ${KWSYS_TARGET_C_OBJECT} PROPERTY
+        POSITION_INDEPENDENT_CODE TRUE)
+    ENDIF()
+    ADD_LIBRARY(${KWSYS_TARGET_C_INTERFACE} INTERFACE)
+    ADD_LIBRARY(${KWSYS_TARGET_C_LINK} INTERFACE)
+    TARGET_LINK_LIBRARIES(${KWSYS_TARGET_C_LINK} INTERFACE
+      ${KWSYS_TARGET_C_INTERFACE})
+    TARGET_SOURCES(${KWSYS_TARGET_C_LINK} INTERFACE
+      $<TARGET_OBJECTS:${KWSYS_TARGET_C_OBJECT}>)
+  ELSE()
+    SET(KWSYS_TARGET_C_INTERFACE ${KWSYS_NAMESPACE}_c)
+    SET(KWSYS_TARGET_C_OBJECT ${KWSYS_NAMESPACE}_c)
+    SET(KWSYS_TARGET_C_LINK ${KWSYS_NAMESPACE}_c)
+    SET(KWSYS_TARGET_C_INSTALL ${KWSYS_TARGET_C_LINK})
+    SET(KWSYS_LINK_DEPENDENCY PUBLIC)
+    ADD_LIBRARY(${KWSYS_TARGET_C_INTERFACE} ${KWSYS_LIBRARY_TYPE}
+      ${KWSYS_C_SRCS})
+  ENDIF()
+  SET_TARGET_PROPERTIES(${KWSYS_TARGET_C_OBJECT} PROPERTIES
+    LABELS "${KWSYS_LABELS_LIB}")
 
   # Apply user-defined target properties to the library.
   IF(KWSYS_PROPERTIES_C)
-    SET_TARGET_PROPERTIES(${KWSYS_NAMESPACE}_c PROPERTIES
-      ${KWSYS_PROPERTIES_C}
-      )
+    SET_TARGET_PROPERTIES(${KWSYS_TARGET_C_INTERFACE} PROPERTIES
+      ${KWSYS_PROPERTIES_C})
+  ENDIF()
+
+  # Set up include usage requirement
+  IF(COMMAND TARGET_INCLUDE_DIRECTORIES)
+    TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_C_INTERFACE} INTERFACE
+      $<BUILD_INTERFACE:${CMAKE_CURRENT_BINARY_DIR}>)
+    IF(KWSYS_INSTALL_INCLUDE_DIR)
+      TARGET_INCLUDE_DIRECTORIES(${KWSYS_TARGET_C_INTERFACE} INTERFACE
+        $<INSTALL_INTERFACE:${KWSYS_INSTALL_INCLUDE_DIR}>)
+    ENDIF()
   ENDIF()
 
   # Create an install target for the library.
   IF(KWSYS_INSTALL_LIBRARY_RULE)
-    INSTALL(TARGETS ${KWSYS_NAMESPACE}_c ${KWSYS_INSTALL_LIBRARY_RULE})
+    INSTALL(TARGETS ${KWSYS_TARGET_C_INSTALL})
   ENDIF()
 ENDIF()
 
@@ -915,7 +1015,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       )
     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestsC ${KWSYS_C_TEST_SRCS})
     SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsC PROPERTY LABELS ${KWSYS_LABELS_EXE})
-    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsC ${KWSYS_NAMESPACE}_c)
+    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsC ${KWSYS_TARGET_C_LINK})
     FOREACH(test ${KWSYS_C_TESTS})
       ADD_TEST(kwsys.${test} ${EXEC_DIR}/${KWSYS_NAMESPACE}TestsC ${test} ${KWSYS_TEST_ARGS_${test}})
       SET_PROPERTY(TEST kwsys.${test} PROPERTY LABELS ${KWSYS_LABELS_TEST})
@@ -950,7 +1050,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       SET_PROPERTY(TARGET testConsoleBufChild PROPERTY C_INCLUDE_WHAT_YOU_USE "")
       SET_PROPERTY(TARGET testConsoleBufChild PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
       SET_PROPERTY(TARGET testConsoleBufChild PROPERTY LABELS ${KWSYS_LABELS_EXE})
-      TARGET_LINK_LIBRARIES(testConsoleBufChild ${KWSYS_NAMESPACE})
+      TARGET_LINK_LIBRARIES(testConsoleBufChild ${KWSYS_TARGET_LINK})
       SET(KWSYS_CXX_TESTS ${KWSYS_CXX_TESTS}
         testConsoleBuf
         )
@@ -969,7 +1069,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
       # If kwsys contains the DynamicLoader, need extra library
       ADD_LIBRARY(${KWSYS_NAMESPACE}TestDynload MODULE testDynload.c)
       SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestDynload PROPERTY LABELS ${KWSYS_LABELS_LIB})
-      ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestDynload ${KWSYS_NAMESPACE})
+      ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestDynload ${KWSYS_TARGET_INTERFACE})
     ENDIF()
     CREATE_TEST_SOURCELIST(
       KWSYS_CXX_TEST_SRCS ${KWSYS_NAMESPACE}TestsCxx.cxx
@@ -981,7 +1081,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
     SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY C_INCLUDE_WHAT_YOU_USE "")
     SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY CXX_INCLUDE_WHAT_YOU_USE "")
     SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestsCxx PROPERTY LABELS ${KWSYS_LABELS_EXE})
-    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_NAMESPACE})
+    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestsCxx ${KWSYS_TARGET_LINK})
 
     SET(TEST_SYSTEMTOOLS_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}")
     SET(TEST_SYSTEMTOOLS_BINARY_DIR "${CMAKE_CURRENT_BINARY_DIR}")
@@ -1032,7 +1132,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
     # Process tests.
     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestProcess testProcess.c)
     SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestProcess PROPERTY LABELS ${KWSYS_LABELS_EXE})
-    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestProcess ${KWSYS_NAMESPACE}_c)
+    TARGET_LINK_LIBRARIES(${KWSYS_NAMESPACE}TestProcess ${KWSYS_TARGET_C_LINK})
     IF(NOT CYGWIN)
       SET(KWSYS_TEST_PROCESS_7 7)
     ENDIF()
@@ -1060,7 +1160,7 @@ IF(KWSYS_STANDALONE OR CMake_SOURCE_DIR)
     ADD_EXECUTABLE(${KWSYS_NAMESPACE}TestSharedForward
                    ${PROJECT_BINARY_DIR}/testSharedForward.c)
     SET_PROPERTY(TARGET ${KWSYS_NAMESPACE}TestSharedForward PROPERTY LABELS ${KWSYS_LABELS_EXE})
-    ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestSharedForward ${KWSYS_NAMESPACE}_c)
+    ADD_DEPENDENCIES(${KWSYS_NAMESPACE}TestSharedForward ${KWSYS_TARGET_C_LINK})
     ADD_TEST(kwsys.testSharedForward ${EXEC_DIR}/${KWSYS_NAMESPACE}TestSharedForward 1)
     SET_PROPERTY(TEST kwsys.testSharedForward PROPERTY LABELS ${KWSYS_LABELS_TEST})
 

ProcessUNIX.c

@@ -99,7 +99,8 @@ static inline void kwsysProcess_usleep(unsigned int msec)
  * pipes' file handles to be non-blocking and just poll them directly
  * without select().
  */
-#if !defined(__BEOS__) && !defined(__VMS) && !defined(__MINT__)
+#if !defined(__BEOS__) && !defined(__VMS) && !defined(__MINT__) &&            \
+  !defined(KWSYSPE_USE_SELECT)
 #define KWSYSPE_USE_SELECT 1
 #endif
 

RegularExpression.cxx

@@ -258,11 +258,6 @@ const unsigned char MAGIC = 0234;
 
 #define UCHARAT(p) (reinterpret_cast<const unsigned char*>(p))[0]
 
-#define FAIL(m)                                                               \
-  {                                                                           \
-    regerror(m);                                                              \
-    return (0);                                                               \
-  }
 #define ISMULT(c) ((c) == '*' || (c) == '+' || (c) == '?')
 #define META "^$.[()|?+*\\"
 

SystemTools.cxx

@@ -847,6 +847,8 @@ void SystemTools::ReplaceString(std::string& source, const char* replace,
   free(orig);
 }
 
+#if defined(_WIN32) && !defined(__CYGWIN__)
+
 #if defined(KEY_WOW64_32KEY) && defined(KEY_WOW64_64KEY)
 #define KWSYS_ST_KEY_WOW64_32KEY KEY_WOW64_32KEY
 #define KWSYS_ST_KEY_WOW64_64KEY KEY_WOW64_64KEY
@@ -855,7 +857,6 @@ void SystemTools::ReplaceString(std::string& source, const char* replace,
 #define KWSYS_ST_KEY_WOW64_64KEY 0x0100
 #endif
 
-#if defined(_WIN32) && !defined(__CYGWIN__)
 static bool SystemToolsParseRegistryKey(const std::string& key,
                                         HKEY& primaryKey, std::string& second,
                                         std::string& valuename)
@@ -3796,11 +3797,7 @@ std::string SystemTools::GetFilenamePath(const std::string& filename)
  */
 std::string SystemTools::GetFilenameName(const std::string& filename)
 {
-#if defined(_WIN32)
   std::string::size_type slash_pos = filename.find_last_of("/\\");
-#else
-  std::string::size_type slash_pos = filename.rfind('/');
-#endif
   if (slash_pos != std::string::npos) {
     return filename.substr(slash_pos + 1);
   } else {

testSystemTools.cxx

@@ -758,6 +758,30 @@ static bool CheckGetPath()
   return res;
 }
 
+static bool CheckGetFilenameName()
+{
+  const char* windowsFilepath = "C:\\somewhere\\something";
+  const char* unixFilepath = "/somewhere/something";
+
+  std::string expectedFilename = "something";
+
+  bool res = true;
+  std::string filename = kwsys::SystemTools::GetFilenameName(windowsFilepath);
+  if (filename != expectedFilename) {
+    std::cerr << "GetFilenameName(" << windowsFilepath << ") yielded "
+              << filename << " instead of " << expectedFilename << std::endl;
+    res = false;
+  }
+
+  filename = kwsys::SystemTools::GetFilenameName(unixFilepath);
+  if (filename != expectedFilename) {
+    std::cerr << "GetFilenameName(" << unixFilepath << ") yielded " << filename
+              << " instead of " << expectedFilename << std::endl;
+    res = false;
+  }
+  return res;
+}
+
 static bool CheckFind()
 {
   bool res = true;
@@ -875,5 +899,7 @@ int testSystemTools(int, char* [])
 
   res &= CheckGetLineFromStream();
 
+  res &= CheckGetFilenameName();
+
   return res ? 0 : 1;
 }