src/support/os_unix.cpp

   1 /**
   2  * \file os_unix.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  *
   8  * Full author contact details are available in file CREDITS.
   9  *
  10  * Various OS specific functions
  11  */
  12
  13 #include <config.h>
  14
  15 #include "LyXRC.h"
  16
  17 #include "support/os.h"
  18 #include "support/docstring.h"
  19 #include "support/environment.h"
  20 #include "support/FileName.h"
  21 #include "support/filetools.h"
  22 #include "support/lstrings.h"
  23 #include "support/lassert.h"
  24
  25 #include <limits.h>
  26 #include <stdlib.h>
  27
  28 #ifdef __APPLE__
  29 #include <CoreServices/CoreServices.h>
  30 #endif
  31
  32 using namespace std;
  33
  34 namespace lyx {
  35 namespace support {
  36 namespace os {
  37
  38 namespace {
  39
  40 int argc_ = 0;
  41 char ** argv_ = 0;
  42
  43 } // namespace anon
  44
  45 void init(int argc, char * argv[])
  46 {
  47         argc_ = argc;
  48         argv_ = argv;
  49 }
  50
  51
  52 string utf8_argv(int i)
  53 {
  54         LASSERT(i < argc_, return "");
  55         return to_utf8(from_local8bit(argv_[i]));
  56 }
  57
  58
  59 void remove_internal_args(int, int)
  60 {}
  61
  62
  63 string current_root()
  64 {
  65         return "/";
  66 }
  67
  68
  69 bool isFilesystemCaseSensitive()
  70 {
  71 #ifdef __APPLE__
  72         return false;
  73 #else
  74         return true;
  75 #endif
  76 }
  77
  78
  79 docstring::size_type common_path(docstring const & p1, docstring const & p2)
  80 {
  81         docstring::size_type i = 0;
  82         docstring::size_type const p1_len = p1.length();
  83         docstring::size_type const p2_len = p2.length();
  84 #ifdef __APPLE__
  85         while (i < p1_len && i < p2_len && uppercase(p1[i]) == uppercase(p2[i]))
  86                 ++i;
  87 #else
  88         while (i < p1_len && i < p2_len && p1[i] == p2[i])
  89                 ++i;
  90 #endif
  91         if ((i < p1_len && i < p2_len)
  92             || (i < p1_len && p1[i] != '/' && i == p2_len)
  93             || (i < p2_len && p2[i] != '/' && i == p1_len))
  94         {
  95                 if (i)
  96                         --i;     // here was the last match
  97                 while (i && p1[i] != '/')
  98                         --i;
  99         }
 100         return i;
 101 }
 102
 103
 104 bool path_prefix_is(string const & path, string const & pre)
 105 {
 106 #ifdef __APPLE__
 107         return path_prefix_is(const_cast<string &>(path), pre, CASE_UNCHANGED);
 108 #else
 109         return prefixIs(path, pre);
 110 #endif
 111 }
 112
 113
 114 bool path_prefix_is(string & path, string const & pre, path_case how)
 115 {
 116 #ifdef __APPLE__
 117         docstring const p1 = from_utf8(path);
 118         docstring const p2 = from_utf8(pre);
 119         docstring::size_type const p1_len = p1.length();
 120         docstring::size_type const p2_len = p2.length();
 121         docstring::size_type common_len = common_path(p1, p2);
 122
 123         if (p2[p2_len - 1] == '/' && p1_len != p2_len)
 124                 ++common_len;
 125
 126         if (common_len != p2_len)
 127                 return false;
 128
 129         if (how == CASE_ADJUSTED && !prefixIs(path, pre)) {
 130                 if (p1_len < common_len)
 131                         path = to_utf8(p2.substr(0, p1_len));
 132                 else
 133                         path = to_utf8(p2 + p1.substr(common_len,
 134                                                         p1_len - common_len));
 135         }
 136
 137         return true;
 138 #else
 139         // silence compiler warnings
 140         (void)how;
 141
 142         return prefixIs(path, pre);
 143 #endif
 144 }
 145
 146
 147 string external_path(string const & p)
 148 {
 149         return p;
 150 }
 151
 152
 153 string internal_path(string const & p)
 154 {
 155         return p;
 156 }
 157
 158
 159 string safe_internal_path(string const & p, file_access)
 160 {
 161         return p;
 162 }
 163
 164
 165 string external_path_list(string const & p)
 166 {
 167         return p;
 168 }
 169
 170
 171 string internal_path_list(string const & p)
 172 {
 173         return p;
 174 }
 175
 176
 177 string latex_path(string const & p)
 178 {
 179         return p;
 180 }
 181
 182
 183 string latex_path_list(string const & p)
 184 {
 185         return p;
 186 }
 187
 188
 189 bool is_valid_strftime(string const & p)
 190 {
 191         string::size_type pos = p.find_first_of('%');
 192         while (pos != string::npos) {
 193                 if (pos + 1 == string::npos)
 194                         break;
 195                 if (!containsOnly(p.substr(pos + 1, 1),
 196                         "aAbBcCdDeEFgGhHIjklmMnOpPrRsStTuUVwWxXyYzZ%+"))
 197                         return false;
 198                 if (pos + 2 == string::npos)
 199                       break;
 200                 pos = p.find_first_of('%', pos + 2);
 201         }
 202         return true;
 203 }
 204
 205
 206 char const * popen_read_mode()
 207 {
 208         return "r";
 209 }
 210
 211
 212 string const & nulldev()
 213 {
 214         static string const nulldev_ = "/dev/null";
 215         return nulldev_;
 216 }
 217
 218
 219 shell_type shell()
 220 {
 221         return UNIX;
 222 }
 223
 224
 225 char path_separator(path_type)
 226 {
 227         return ':';
 228 }
 229
 230
 231 void windows_style_tex_paths(bool)
 232 {}
 233
 234 bool canAutoOpenFile(string const & ext, auto_open_mode const mode)
 235 {
 236 #ifdef __APPLE__
 237 // Reference: http://developer.apple.com/documentation/Carbon/Reference/LaunchServicesReference/
 238         CFStringRef cfs_ext = CFStringCreateWithBytes(kCFAllocatorDefault,
 239                                         (UInt8 *) ext.c_str(), ext.length(),
 240                                         kCFStringEncodingISOLatin1, false);
 241         // this is what we would like to do but it seems that the
 242         // viewer for PDF is often quicktime...
 243         //LSRolesMask role = (mode == VIEW) ? kLSRolesViewer :  kLSRolesEditor;
 244         (void)mode;
 245         LSRolesMask role = kLSRolesAll;
 246         FSRef outAppRef;
 247         OSStatus status =
 248                 LSGetApplicationForInfo(kLSUnknownType, kLSUnknownCreator,
 249                                         cfs_ext, role, &outAppRef, NULL);
 250         CFRelease(cfs_ext);
 251
 252         return status != kLSApplicationNotFoundErr;
 253 #else
 254         // silence compiler warnings
 255         (void)ext;
 256         (void)mode;
 257
 258         // currently, no default viewer is tried for non-windows system
 259         // support for KDE/Gnome/Macintosh may be added later
 260         return false;
 261 #endif
 262 }
 263
 264
 265 bool autoOpenFile(string const & filename, auto_open_mode const mode,
 266                   string const & path)
 267 {
 268 #ifdef __APPLE__
 269 // Reference: http://developer.apple.com/documentation/Carbon/Reference/LaunchServicesReference/
 270         FSRef fileref;
 271         OSStatus status =
 272                 FSPathMakeRef((UInt8 *) filename.c_str(), &fileref, NULL);
 273         if (status != 0)
 274                 return false;
 275
 276         // this is what we would like to do but it seems that the
 277         // viewer for PDF is often quicktime...
 278         //LSRolesMask role = (mode == VIEW) ? kLSRolesViewer :  kLSRolesEditor;
 279         (void)mode;
 280         LSRolesMask role = kLSRolesAll;
 281         FSRef outAppRef;
 282
 283         status = LSGetApplicationForItem(&fileref, role, &outAppRef, NULL);
 284         if (status == kLSApplicationNotFoundErr)
 285                 return false;
 286
 287         string const texinputs = os::latex_path_list(
 288                         replaceCurdirPath(path, lyxrc.texinputs_prefix));
 289         string const oldval = getEnv("TEXINPUTS");
 290         string const newval = ".:" + texinputs + ":" + oldval;
 291         if (!path.empty() && !lyxrc.texinputs_prefix.empty())
 292                 setEnv("TEXINPUTS", newval);
 293
 294         LSLaunchFSRefSpec inLaunchSpec;
 295         inLaunchSpec.appRef = &outAppRef;
 296         inLaunchSpec.numDocs = 1;
 297         inLaunchSpec.itemRefs = &fileref;
 298         inLaunchSpec.passThruParams = NULL;
 299         inLaunchSpec.launchFlags = kLSLaunchDefaults;
 300         inLaunchSpec.asyncRefCon = NULL;
 301         status = LSOpenFromRefSpec(&inLaunchSpec, NULL);
 302
 303         if (!path.empty() && !lyxrc.texinputs_prefix.empty())
 304                 setEnv("TEXINPUTS", oldval);
 305
 306         return status != kLSApplicationNotFoundErr;
 307 #else
 308         // silence compiler warnings
 309         (void)filename;
 310         (void)mode;
 311         (void)path;
 312
 313         // currently, no default viewer is tried for non-windows system
 314         // support for KDE/Gnome/Macintosh may be added later
 315         return false;
 316 #endif
 317 }
 318
 319
 320 string real_path(string const & path)
 321 {
 322 #ifdef HAVE_DEF_PATH_MAX
 323         char rpath[PATH_MAX + 1];
 324         char * result = realpath(path.c_str(), rpath);
 325         return FileName::fromFilesystemEncoding(result ? rpath : path).absFileName();
 326 #else
 327         char * result = realpath(path.c_str(), NULL);
 328         string ret = FileName::fromFilesystemEncoding(result ? result : path).absFileName();
 329         free(result);
 330         return ret;
 331 #endif
 332 }
 333
 334 } // namespace os
 335 } // namespace support
 336 } // namespace lyx