CMake: fix merged build, seems GCC could not handle the namespaces correctly

[lyx.git] / src / support / os_cygwin.cpp

diff --git a/src/support/os_cygwin.cpp b/src/support/os_cygwin.cpp
index 43e56bbfd399f8963bca85d2a2de01027c1bb0f9..6c5c91dd1ba91839857f71e0f90da328e22cb036 100644 (file)
--- a/src/support/os_cygwin.cpp
+++ b/src/support/os_cygwin.cpp
@@ -29,11 +29,17 @@
 #include <limits.h>
 #include <stdlib.h>
 
+#include <cygwin/version.h>
 #include <sys/cygwin.h>
 
+#include <ostream>
+
 using namespace std;
 
 namespace lyx {
+
+void lyx_exit(int);
+
 namespace support {
 namespace os {
 
@@ -59,6 +65,63 @@ bool is_windows_path(string const & p)
 }
 
 
+// Starting from Cygwin 1.7, new APIs for path conversions were introduced.
+// The old ones are now deprecated, so avoid them if we detect a modern Cygwin.
+
+#if CYGWIN_VERSION_DLL_MAJOR >= 1007
+
+enum PathStyle {
+       posix = CCP_WIN_A_TO_POSIX | CCP_RELATIVE,
+       windows = CCP_POSIX_TO_WIN_A | CCP_RELATIVE
+};
+
+
+/// Convert a path to or from posix style.
+/// \p p is encoded in local 8bit encoding or utf8.
+/// The result is returned in the same encoding as \p p.
+string convert_path(string const & p, PathStyle const & target)
+{
+       if ((target == posix && is_posix_path(p)) ||
+           (target == windows && is_windows_path(p)))
+               return p;
+
+       char path_buf[PATH_MAX];
+
+       // cygwin_conv_path does not care about the encoding.
+       if (cygwin_conv_path(target, p.c_str(), path_buf, sizeof(path_buf))) {
+               lyxerr << "LyX: Cannot convert path: " << p << endl;
+               return subst(p, '\\', '/');
+       }
+       return subst(path_buf, '\\', '/');
+}
+
+
+/// Convert a path list to or from posix style.
+/// \p p is encoded in local 8bit encoding or utf8.
+/// The result is returned in the same encoding as \p p.
+string convert_path_list(string const & p, PathStyle const & target)
+{
+       if (p.empty())
+               return p;
+
+       char const * const pc = p.c_str();
+       PathStyle const actual = cygwin_posix_path_list_p(pc) ? posix : windows;
+
+       if (target != actual) {
+               int const size = cygwin_conv_path_list(target, pc, NULL, 0);
+               char * ptr = new char[size];
+               if (ptr && cygwin_conv_path_list(target, pc, ptr, size) == 0) {
+                       string const path_list = subst(ptr, '\\', '/');
+                       delete ptr;
+                       return path_list;
+               } else
+                       lyxerr << "LyX: Cannot convert path list: " << p << endl;
+       }
+       return subst(p, '\\', '/');
+}
+
+#else
+
 enum PathStyle {
        posix,
        windows
@@ -123,15 +186,31 @@ string convert_path_list(string const & p, PathStyle const & target)
        return subst(p, '\\', '/');
 }
 
+#endif
+
+
+BOOL terminate_handler(DWORD event)
+{
+       if (event == CTRL_CLOSE_EVENT
+           || event == CTRL_LOGOFF_EVENT
+           || event == CTRL_SHUTDOWN_EVENT) {
+               lyx::lyx_exit(1);
+               return TRUE;
+       }
+       return FALSE;
+}
+
 } // namespace anon
 
 void init(int, char *[])
 {
        // Make sure that the TEMP variable is set
        // and sync the Windows environment.
-
        setenv("TEMP", "/tmp", false);
        cygwin_internal(CW_SYNC_WINENV);
+
+       // Catch shutdown events.
+       SetConsoleCtrlHandler((PHANDLER_ROUTINE)terminate_handler, TRUE);
 }
 
 
@@ -162,9 +241,7 @@ docstring::size_type common_path(docstring const & p1, docstring const & p2)
                        --i;     // here was the last match
                while (i && p1[i] != '/')
                        --i;
-       } else
-               --i;
-
+       }
        return i;
 }
 
@@ -179,13 +256,23 @@ bool path_prefix_is(string & path, string const & pre, path_case how)
 {
        docstring const p1 = from_utf8(path);
        docstring const p2 = from_utf8(pre);
-       docstring::size_type i = common_path(p1, p2);
+       docstring::size_type const p1_len = p1.length();
+       docstring::size_type const p2_len = p2.length();
+       docstring::size_type common_len = common_path(p1, p2);
+
+       if (p2[p2_len - 1] == '/' && p1_len != p2_len)
+               ++common_len;
 
-       if (i == 0 || i + 1 != p2.length())
+       if (common_len != p2_len)
                return false;
 
-       if (how == CASE_ADJUSTED && !prefixIs(path, pre))
-               path = to_utf8(p2 + p1.substr(i + 1, p1.length() - i + 1));
+       if (how == CASE_ADJUSTED && !prefixIs(path, pre)) {
+               if (p1_len < common_len)
+                       path = to_utf8(p2.substr(0, p1_len));
+               else
+                       path = to_utf8(p2 + p1.substr(common_len,
+                                                       p1_len - common_len));
+       }
 
        return true;
 }