src/support/os_cygwin.cpp

   1 /**
   2  * \file os_cygwin.cpp
   3  * This file is part of LyX, the document processor.
   4  * Licence details can be found in the file COPYING.
   5  *
   6  * \author Ruurd A. Reitsma
   7  * \author Claus Hentschel
   8  * \author Angus Leeming
   9  * \author Enrico Forestieri
  10  *
  11  * Full author contact details are available in file CREDITS.
  12  *
  13  * Various OS specific functions
  14  */
  15
  16 #include <config.h>
  17
  18 #include "support/os.h"
  19
  20 #include "support/FileName.h"
  21 #include "support/lstrings.h"
  22 #include "support/debug.h"
  23
  24 #include <windows.h>
  25 #include <io.h>
  26 #include <windef.h>
  27 #include <shellapi.h>
  28 #include <shlwapi.h>
  29 #include <limits.h>
  30 #include <stdlib.h>
  31
  32 #include <sys/cygwin.h>
  33
  34 using namespace std;
  35
  36 namespace lyx {
  37 namespace support {
  38 namespace os {
  39
  40 namespace {
  41
  42 bool windows_style_tex_paths_ = false;
  43
  44 // In both is_posix_path() and is_windows_path() it is assumed that
  45 // a valid posix or pseudo-windows path is passed. They simply tell
  46 // whether the path looks posix/pseudo-windows or not.
  47
  48 bool is_posix_path(string const & p)
  49 {
  50         return  p.empty() ||
  51                 (!contains(p, '\\') && (p.length() <= 1 || p[1] != ':'));
  52 }
  53
  54 // This is a test for a win32 style path with forward slashes (pseudo-windows).
  55
  56 bool is_windows_path(string const & p)
  57 {
  58         return p.empty() || (!contains(p, '\\') && p[0] != '/');
  59 }
  60
  61
  62 enum PathStyle {
  63         posix,
  64         windows
  65 };
  66
  67
  68 /// Convert a path to or from posix style.
  69 /// \p p is encoded in local 8bit encoding or utf8.
  70 /// The result is returned in the same encoding as \p p.
  71 string convert_path(string const & p, PathStyle const & target)
  72 {
  73         char path_buf[PATH_MAX];
  74
  75         if ((target == posix && is_posix_path(p)) ||
  76             (target == windows && is_windows_path(p)))
  77                 return p;
  78
  79         path_buf[0] = '\0';
  80
  81         // cygwin_conv_to_posix_path and cygwin_conv_to_win32_path do not
  82         // care about the encoding.
  83         if (target == posix)
  84                 cygwin_conv_to_posix_path(p.c_str(), path_buf);
  85         else
  86                 cygwin_conv_to_win32_path(p.c_str(), path_buf);
  87
  88         return subst(path_buf[0] ? path_buf : p, '\\', '/');
  89 }
  90
  91
  92 /// Convert a path list to or from posix style.
  93 /// \p p is encoded in local 8bit encoding or utf8.
  94 /// The result is returned in the same encoding as \p p.
  95 string convert_path_list(string const & p, PathStyle const & target)
  96 {
  97         if (p.empty())
  98                 return p;
  99
 100         char const * const pc = p.c_str();
 101         PathStyle const actual = cygwin_posix_path_list_p(pc) ? posix : windows;
 102
 103         if (target != actual) {
 104                 int const target_size = (target == posix) ?
 105                                 cygwin_win32_to_posix_path_list_buf_size(pc) :
 106                                 cygwin_posix_to_win32_path_list_buf_size(pc);
 107
 108                 char * ptr = new char[target_size];
 109
 110                 if (ptr) {
 111                         // FIXME: See comment in convert_path() above
 112                         if (target == posix)
 113                                 cygwin_win32_to_posix_path_list(pc, ptr);
 114                         else
 115                                 cygwin_posix_to_win32_path_list(pc, ptr);
 116
 117                         string path_list = subst(ptr, '\\', '/');
 118                         delete ptr;
 119                         return path_list;
 120                 }
 121         }
 122
 123         return subst(p, '\\', '/');
 124 }
 125
 126 } // namespace anon
 127
 128 void init(int, char *[])
 129 {
 130         // Make sure that the TEMP variable is set
 131         // and sync the Windows environment.
 132
 133         setenv("TEMP", "/tmp", false);
 134         cygwin_internal(CW_SYNC_WINENV);
 135 }
 136
 137
 138 string current_root()
 139 {
 140         return string("/");
 141 }
 142
 143
 144 bool isFilesystemCaseSensitive()
 145 {
 146         return false;
 147 }
 148
 149
 150 docstring::size_type common_path(docstring const & p1, docstring const & p2)
 151 {
 152         docstring::size_type i = 0;
 153         docstring::size_type const p1_len = p1.length();
 154         docstring::size_type const p2_len = p2.length();
 155         while (i < p1_len && i < p2_len && uppercase(p1[i]) == uppercase(p2[i]))
 156                 ++i;
 157         if ((i < p1_len && i < p2_len)
 158             || (i < p1_len && p1[i] != '/' && i == p2_len)
 159             || (i < p2_len && p2[i] != '/' && i == p1_len))
 160         {
 161                 if (i)
 162                         --i;     // here was the last match
 163                 while (i && p1[i] != '/')
 164                         --i;
 165         }
 166         return i;
 167 }
 168
 169
 170 bool path_prefix_is(string const & path, string const & pre)
 171 {
 172         return path_prefix_is(const_cast<string &>(path), pre, CASE_UNCHANGED);
 173 }
 174
 175
 176 bool path_prefix_is(string & path, string const & pre, path_case how)
 177 {
 178         docstring const p1 = from_utf8(path);
 179         docstring const p2 = from_utf8(pre);
 180         docstring::size_type const p1_len = p1.length();
 181         docstring::size_type const p2_len = p2.length();
 182         docstring::size_type common_len = common_path(p1, p2);
 183
 184         if (p2[p2_len - 1] == '/' && p1_len != p2_len)
 185                 ++common_len;
 186
 187         if (common_len != p2_len)
 188                 return false;
 189
 190         if (how == CASE_ADJUSTED && !prefixIs(path, pre)) {
 191                 if (p1_len < common_len)
 192                         path = to_utf8(p2.substr(0, p1_len));
 193                 else
 194                         path = to_utf8(p2 + p1.substr(common_len,
 195                                                         p1_len - common_len));
 196         }
 197
 198         return true;
 199 }
 200
 201
 202 string external_path(string const & p)
 203 {
 204         return convert_path(p, PathStyle(posix));
 205 }
 206
 207
 208 string internal_path(string const & p)
 209 {
 210         return convert_path(p, PathStyle(posix));
 211 }
 212
 213
 214 string external_path_list(string const & p)
 215 {
 216         return convert_path_list(p, PathStyle(posix));
 217 }
 218
 219
 220 string internal_path_list(string const & p)
 221 {
 222         return convert_path_list(p, PathStyle(posix));
 223 }
 224
 225
 226 string latex_path(string const & p)
 227 {
 228         // We may need a posix style path or a windows style path (depending
 229         // on windows_style_tex_paths_), but we use always forward slashes,
 230         // since it gets written into a .tex file.
 231
 232         if (windows_style_tex_paths_ && FileName::isAbsolute(p)) {
 233                 string dos_path = convert_path(p, PathStyle(windows));
 234                 LYXERR(Debug::LATEX, "<Path correction for LaTeX> ["
 235                         << p << "]->>[" << dos_path << ']');
 236                 return dos_path;
 237         }
 238
 239         return convert_path(p, PathStyle(posix));
 240 }
 241
 242
 243 bool is_valid_strftime(string const & p)
 244 {
 245         string::size_type pos = p.find_first_of('%');
 246         while (pos != string::npos) {
 247                 if (pos + 1 == string::npos)
 248                         break;
 249                 if (!containsOnly(p.substr(pos + 1, 1),
 250                         "aAbBcCdDeEFgGhHIjklmMnOpPrRsStTuUVwWxXyYzZ%+"))
 251                         return false;
 252                 if (pos + 2 == string::npos)
 253                       break;
 254                 pos = p.find_first_of('%', pos + 2);
 255         }
 256         return true;
 257 }
 258
 259
 260 // returns a string suitable to be passed to popen when
 261 // reading a pipe
 262 char const * popen_read_mode()
 263 {
 264         return "r";
 265 }
 266
 267
 268 string const & nulldev()
 269 {
 270         static string const nulldev_ = "/dev/null";
 271         return nulldev_;
 272 }
 273
 274
 275 bool is_terminal(io_channel channel)
 276 {
 277         return isatty(channel);
 278 }
 279
 280
 281 shell_type shell()
 282 {
 283         return UNIX;
 284 }
 285
 286
 287 char path_separator()
 288 {
 289         return ':';
 290 }
 291
 292
 293 void windows_style_tex_paths(bool use_windows_paths)
 294 {
 295         windows_style_tex_paths_ = use_windows_paths;
 296 }
 297
 298
 299 bool canAutoOpenFile(string const & ext, auto_open_mode const mode)
 300 {
 301         if (ext.empty())
 302                 return false;
 303
 304         string const full_ext = "." + ext;
 305
 306         DWORD bufSize = MAX_PATH + 100;
 307         TCHAR buf[MAX_PATH + 100];
 308         // reference: http://msdn.microsoft.com/en-us/library/bb773471.aspx
 309         char const * action = (mode == VIEW) ? "open" : "edit";
 310         return S_OK == AssocQueryString(ASSOCF_INIT_IGNOREUNKNOWN,
 311                 ASSOCSTR_EXECUTABLE, full_ext.c_str(), action, buf, &bufSize);
 312 }
 313
 314
 315 bool autoOpenFile(string const & filename, auto_open_mode const mode)
 316 {
 317         // reference: http://msdn.microsoft.com/en-us/library/bb762153.aspx
 318         string const win_path = to_local8bit(from_utf8(convert_path(filename, PathStyle(windows))));
 319         char const * action = (mode == VIEW) ? "open" : "edit";
 320         return reinterpret_cast<int>(ShellExecute(NULL, action,
 321                 win_path.c_str(), NULL, NULL, 1)) > 32;
 322 }
 323
 324
 325 string real_path(string const & path)
 326 {
 327         char rpath[PATH_MAX + 1];
 328         char * result = realpath(path.c_str(), rpath);
 329         return FileName::fromFilesystemEncoding(result ? rpath : path).absFilename();
 330 }
 331
 332 } // namespace os
 333 } // namespace support
 334 } // namespace lyx