Fix mess up of internal/external paths (from Enrico Forestieri)

	* src/frontends/qt2/QPrefs.C:
	(internal_path_list, external_path_list): Handle the PATH prefix
	style according to the user-prefs style.
	(QPrefs::apply, QPrefs::update_contents): fix inverted logic of
	rc.cygwin_path_fix

	* src/support/os.h: New declarations to deal with PATH lists.
	* src/support/os_cygwin.C: Major rewrite to account for path style
	problems.
	* src/support/os_unix.C:
	* src/support/os_win32.C: Stub functions for PATH lists.
	* src/support/environment.C: fix bug 2344: Wrong path_prefix handling
	in cygwin
	* src/support/filetools.C (ChangeExtension): fix for the path
	style to be written in .tex files (cygwin related).

git-svn-id: svn://svn.lyx.org/lyx/lyx-devel/trunk@13558 a592a061-630c-0410-9148-cb99ea01b6c8

diff --git a/src/frontends/qt2/QPrefs.C b/src/frontends/qt2/QPrefs.C
index 1a9038bc8484fc2529fa8badf3d8e7d006f7bca7..e6f97c8a8574acce9f0d18d47541716d41dedd1c 100644 (file)
--- a/src/frontends/qt2/QPrefs.C
+++ b/src/frontends/qt2/QPrefs.C
@@ -148,6 +148,11 @@ string const internal_path(QString const & input)
        return lyx::support::os::internal_path(fromqstr(input));
 }
 
+string const internal_path_list(QString const & input)
+{
+       return lyx::support::os::internal_path_list(fromqstr(input));
+}
+
 }
 
 
@@ -199,7 +204,7 @@ void QPrefs::apply()
 
 #if defined(__CYGWIN__) || defined(__CYGWIN32__)
        QPrefCygwinPathModule * cygwinmod(dialog_->cygwinpathModule);
-       rc.cygwin_path_fix = cygwinmod->pathCB->isChecked();
+       rc.cygwin_path_fix = !cygwinmod->pathCB->isChecked();
 #endif
 
        QPrefLatexModule * latexmod(dialog_->latexModule);
@@ -253,7 +258,7 @@ void QPrefs::apply()
        rc.template_path = internal_path(pathsmod->templateDirED->text());
        rc.backupdir_path = internal_path(pathsmod->backupDirED->text());
        rc.tempdir_path = internal_path(pathsmod->tempDirED->text());
-       rc.path_prefix = fromqstr(pathsmod->pathPrefixED->text());
+       rc.path_prefix = internal_path_list(pathsmod->pathPrefixED->text());
        // FIXME: should be a checkbox only
        rc.lyxpipes = internal_path(pathsmod->lyxserverDirED->text());
 
@@ -467,6 +472,11 @@ QString const external_path(string const & input)
        return toqstr(lyx::support::os::external_path(input));
 }
 
+QString const external_path_list(string const & input)
+{
+       return toqstr(lyx::support::os::external_path_list(input));
+}
+
 }
 
 
@@ -536,7 +546,7 @@ void QPrefs::update_contents()
 
 #if defined(__CYGWIN__) || defined(__CYGWIN32__)
        QPrefCygwinPathModule * cygwinmod(dialog_->cygwinpathModule);
-       cygwinmod->pathCB->setChecked(rc.cygwin_path_fix);
+       cygwinmod->pathCB->setChecked(!rc.cygwin_path_fix);
 #endif
 
        QPrefLatexModule * latexmod(dialog_->latexModule);
@@ -583,7 +593,7 @@ void QPrefs::update_contents()
        pathsmod->templateDirED->setText(external_path(rc.template_path));
        pathsmod->backupDirED->setText(external_path(rc.backupdir_path));
        pathsmod->tempDirED->setText(external_path(rc.tempdir_path));
-       pathsmod->pathPrefixED->setText(toqstr(rc.path_prefix));
+       pathsmod->pathPrefixED->setText(external_path_list(rc.path_prefix));
        // FIXME: should be a checkbox only
        pathsmod->lyxserverDirED->setText(external_path(rc.lyxpipes));
 

diff --git a/src/support/environment.C b/src/support/environment.C
index c1a5710978608c5e304ccde41ed541fcd7a907bd..616025cf2a47ee78e0c790cab5805937a77bf673 100644 (file)
--- a/src/support/environment.C
+++ b/src/support/environment.C
@@ -95,7 +95,14 @@ void setEnvPath(string const & name, vector<string> const & env)
        for (; it != end; ++it) {
                if (it != begin)
                        ss << separator;
+#if defined(__CYGWIN__) || defined(__CYGWIN32__)
+               // On cygwin, os::external_path returns either posix or
+               // pseudo-win style paths, but here we always need posix style.
+               // This fixes bug 2344.
+               ss << os::internal_path(*it);
+#else
                ss << os::external_path(*it);
+#endif
        }
        setEnv(name, ss.str());
 }

diff --git a/src/support/filetools.C b/src/support/filetools.C
index e45208b98507476fecbbb7ec80c666374e81327a..9c51d2aff9a3e85edfec5b1312be984d5b34cf68 100644 (file)
--- a/src/support/filetools.C
+++ b/src/support/filetools.C
@@ -86,16 +86,19 @@ string const latex_path(string const & original_path,
                latex_path_extension extension,
                latex_path_dots dots)
 {
-       string path = subst(original_path, "\\", "/");
        // On cygwin, we may need windows or posix style paths.
-       path = os::latex_path(path);
+       string path = os::latex_path(original_path);
        path = subst(path, "~", "\\string~");
        if (path.find(' ') != string::npos) {
                // We can't use '"' because " is sometimes active (e.g. if
                // babel is loaded with the "german" option)
                if (extension == EXCLUDE_EXTENSION) {
-                       string const base = ChangeExtension(path, string());
+                       // ChangeExtension calls os::internal_path internally
+                       // so don't use it to remove the extension.
                        string const ext = GetExtension(path);
+                       string const base = ext.empty() ?
+                               path :
+                               path.substr(0, path.length() - ext.length() - 1);
                        // ChangeExtension calls os::internal_path internally
                        // so don't use it to re-add the extension.
                        path = "\\string\"" + base + "\\string\"." + ext;

diff --git a/src/support/os.h b/src/support/os.h
index 85e97bfa857f28949f9bfc14c5b2b0cdcec864c9..4d6d54d231767699eaf3ecc7dd5ce9694b23cd50 100644 (file)
--- a/src/support/os.h
+++ b/src/support/os.h
@@ -47,6 +47,12 @@ std::string external_path(std::string const & p);
 /// Converts a host OS style path to unix style.
 std::string internal_path(std::string const & p);
 
+/// Converts a unix style path list to host OS style.
+std::string external_path_list(std::string const & p);
+
+/// Converts a host OS style path list to unix style.
+std::string internal_path_list(std::string const & p);
+
 /**
  * Converts a unix style path into a form suitable for inclusion in a LaTeX
  * document.

diff --git a/src/support/os_cygwin.C b/src/support/os_cygwin.C
index dce059d40b49b84c712710d54f208c87ff8662a0..e169f10e29e357e814340f012a2751fd21a86fcc 100644 (file)
--- a/src/support/os_cygwin.C
+++ b/src/support/os_cygwin.C
@@ -27,6 +27,8 @@
 using std::endl;
 using std::string;
 
+using lyx::support::contains;
+
 
 namespace lyx {
 namespace support {
@@ -66,39 +68,103 @@ namespace {
 
 bool cygwin_path_fix_ = false;
 
-} // namespace anon
+// In both is_posix_path() and is_windows_path() it is assumed that
+// a valid posix or pseudo-windows path is passed. They simply tell
+// whether the path looks posix/pseudo-windows or not.
 
+bool is_posix_path(string const & p)
+{
+       return  p.empty() ||
+               (!contains(p, '\\') && (p.length() <= 1 || p[1] != ':'));
+}
 
-string external_path(string const & p)
+// This is a test for a win32 style path with forward slashes (pseudo-windows).
+
+bool is_windows_path(string const & p)
 {
-       string dos_path;
+       return p.empty() ||
+               (!contains(p, '\\') && (p.length() <= 1 || p[1] == ':'));
+}
 
-       // Translate from cygwin path syntax to dos path syntax
-       if (cygwin_path_fix_ && is_absolute_path(p)) {
-               char dp[PATH_MAX];
-               cygwin_conv_to_full_win32_path(p.c_str(), dp);
-               dos_path = !dp ? "" : dp;
+
+enum PathStyle {
+    posix,
+    windows
+};
+
+
+string convert_path(string const & p, PathStyle const & target)
+{
+       char path_buf[PATH_MAX];
+
+       if ((target == posix && is_posix_path(p)) ||
+           (target == windows && is_windows_path(p)))
+               return p;
+
+       path_buf[0] = '\0';
+
+       if (target == posix)
+               cygwin_conv_to_posix_path(p.c_str(), path_buf);
+       else
+               cygwin_conv_to_win32_path(p.c_str(), path_buf);
+
+       return subst(path_buf[0] ? path_buf : p, '\\', '/');
+}
+
+
+string convert_path_list(string const & p, PathStyle const & target)
+{
+       char const * const pc = p.c_str();
+       PathStyle const actual = cygwin_posix_path_list_p(pc) ? posix : windows;
+
+       if (target != actual) {
+               int const target_size = (target == posix) ?
+                               cygwin_win32_to_posix_path_list_buf_size(pc) :
+                               cygwin_posix_to_win32_path_list_buf_size(pc);
+
+               char * ptr = new char[target_size];
+
+               if (ptr) {
+                       if (target == posix)
+                               cygwin_win32_to_posix_path_list(pc, ptr);
+                       else
+                               cygwin_posix_to_win32_path_list(pc, ptr);
+
+                       string path_list = subst(ptr, '\\', '/');
+                       delete ptr;
+                       return path_list;
+               }
        }
 
-       else return p;
+       return subst(p, '\\', '/');
+}
 
-       //No backslashes in LaTeX files
-       dos_path = subst(dos_path,'\\','/');
+} // namespace anon
 
-       lyxerr[Debug::LATEX]
-               << "<Cygwin path correction> ["
-               << p << "]->>["
-               << dos_path << ']' << endl;
-       return dos_path;
+
+string external_path(string const & p)
+{
+       return convert_path(p, cygwin_path_fix_ ? PathStyle(windows)
+                                               : PathStyle(posix));
 }
 
 
 string internal_path(string const & p)
 {
-       char posix_path[PATH_MAX];
-       posix_path[0] = '\0';
-       cygwin_conv_to_posix_path(p.c_str(), posix_path);
-       return posix_path;
+       return convert_path(p, PathStyle(posix));
+}
+
+
+string external_path_list(string const & p)
+{
+       return convert_path_list(p, cygwin_path_fix_ ? PathStyle(windows)
+                                                    : PathStyle(posix));
+}
+
+
+string internal_path_list(string const & p)
+{
+       return convert_path_list(p, PathStyle(posix));
 }
 
 
@@ -107,7 +173,17 @@ string latex_path(string const & p)
        // We may need a posix style path or a windows style path (depending
        // on cygwin_path_fix_), but we use always forward slashes, since it
        // gets written into a .tex file.
-       return external_path(p);
+
+       if (cygwin_path_fix_ && is_absolute_path(p)) {
+               string dos_path = convert_path(p, PathStyle(windows));
+               lyxerr[Debug::LATEX]
+                       << "<Cygwin path correction> ["
+                       << p << "]->>["
+                       << dos_path << ']' << endl;
+               return dos_path;
+       }
+
+       return convert_path(p, PathStyle(posix));
 }
 
 

diff --git a/src/support/os_unix.C b/src/support/os_unix.C
index d53b9345a52a6098231e336148eda408eeb7b4db..0ffce418c998fa6ad7d4e5a28d79d48a3c1293d7 100644 (file)
--- a/src/support/os_unix.C
+++ b/src/support/os_unix.C
@@ -63,6 +63,18 @@ string internal_path(string const & p)
 }
 
 
+string external_path_list(string const & p)
+{
+       return p;
+}
+
+
+string internal_path_list(string const & p)
+{
+       return p;
+}
+
+
 string latex_path(string const & p)
 {
        return p;

diff --git a/src/support/os_win32.C b/src/support/os_win32.C
index db823e522019966895f9fa1dcc692bb151731d17..71d2ff5d5642894574091eaee927647bf900baa8 100644 (file)
--- a/src/support/os_win32.C
+++ b/src/support/os_win32.C
@@ -216,9 +216,21 @@ string internal_path(string const & p)
 }
 
 
+string external_path_list(string const & p)
+{
+       return subst(p, '/', '\\');
+}
+
+
+string internal_path_list(string const & p)
+{
+       return subst(p, '\\', '/');
+}
+
+
 string latex_path(string const & p)
 {
-       return p;
+       return subst(p, '\\', '/');
 }