]> git.lyx.org Git - lyx.git/blob - src/support/filetools.cpp
Fix build with GNU libstdc++ C++11 ABI
[lyx.git] / src / support / filetools.cpp
1 /**
2  * \file filetools.cpp
3  * This file is part of LyX, the document processor.
4  * Licence details can be found in the file COPYING.
5  *
6  * parts Copyright 1985, 1990, 1993 Free Software Foundation, Inc.
7  *
8  * \author Ivan Schreter
9  * \author Dirk Niggemann
10  * \author Asger Alstrup
11  * \author Lars Gullik Bjønnes
12  * \author Jean-Marc Lasgouttes
13  * \author Angus Leeming
14  * \author John Levon
15  * \author Herbert Voß
16  *
17  * Full author contact details are available in file CREDITS.
18  *
19  * General path-mangling functions
20  */
21
22 #include <config.h>
23
24 #include "LyXRC.h"
25
26 #include "support/filetools.h"
27
28 #include "support/debug.h"
29 #include "support/environment.h"
30 #include "support/gettext.h"
31 #include "support/lstrings.h"
32 #include "support/os.h"
33 #include "support/Messages.h"
34 #include "support/Package.h"
35 #include "support/PathChanger.h"
36 #include "support/Systemcall.h"
37 #include "support/qstring_helpers.h"
38
39 #include <QDir>
40 #include <QTemporaryFile>
41
42 #include "support/lassert.h"
43 #include "support/regex.h"
44
45 #include <fcntl.h>
46 #ifdef HAVE_MAGIC_H
47 #include <magic.h>
48 #endif
49 #ifdef HAVE_UNISTD_H
50 #include <unistd.h>
51 #endif
52
53 #include <cerrno>
54 #include <cstdlib>
55 #include <cstdio>
56
57 #include <utility>
58 #include <fstream>
59 #include <sstream>
60 #include <vector>
61
62 #if defined (_WIN32)
63 #include <io.h>
64 #include <windows.h>
65 #endif
66
67 using namespace std;
68
69 #define USE_QPROCESS
70
71 namespace lyx {
72 namespace support {
73
74 bool isLyXFileName(string const & filename)
75 {
76         return suffixIs(ascii_lowercase(filename), ".lyx");
77 }
78
79
80 bool isSGMLFileName(string const & filename)
81 {
82         return suffixIs(ascii_lowercase(filename), ".sgml");
83 }
84
85
86 bool isValidLaTeXFileName(string const & filename)
87 {
88         string const invalid_chars("#%\"");
89         return filename.find_first_of(invalid_chars) == string::npos;
90 }
91
92
93 bool isValidDVIFileName(string const & filename)
94 {
95         string const invalid_chars("${}()[]^");
96         return filename.find_first_of(invalid_chars) == string::npos;
97 }
98
99
100 bool isBinaryFile(FileName const & filename)
101 {
102         bool isbinary = false;
103         if (filename.empty() || !filename.exists())
104                 return isbinary;
105
106 #ifdef HAVE_MAGIC_H
107         magic_t magic_cookie = magic_open(MAGIC_MIME_ENCODING);
108         if (magic_cookie) {
109                 bool detected = true;
110                 if (magic_load(magic_cookie, NULL) != 0) {
111                         LYXERR(Debug::FILES, "isBinaryFile: "
112                                 "Could not load magic database - "
113                                 << magic_error(magic_cookie));
114                         detected = false;
115                 } else {
116                         char const *charset = magic_file(magic_cookie,
117                                         filename.toFilesystemEncoding().c_str());
118                         isbinary = contains(charset, "binary");
119                 }
120                 magic_close(magic_cookie);
121                 if (detected)
122                         return isbinary;
123         }
124 #endif
125         // Try by looking for binary chars at the beginning of the file.
126         // Note that this is formally not correct, since count_bin_chars
127         // expects utf8, and the passed string can be anything: plain text
128         // in any encoding, or really binary data. In practice it works,
129         // since QString::fromUtf8() drops invalid utf8 sequences, and
130         // while the exact number may not be correct, we still get a high
131         // number for truly binary files.
132
133         ifstream ifs(filename.toFilesystemEncoding().c_str());
134         if (!ifs)
135                 return isbinary;
136
137         // Maximum strings to read
138         int const max_count = 50;
139
140         // Maximum number of binary chars allowed
141         int const max_bin = 5;
142
143         int count = 0;
144         int binchars = 0;
145         string str;
146         while (count++ < max_count && !ifs.eof()) {
147                 getline(ifs, str);
148                 binchars += count_bin_chars(str);
149         }
150         return binchars > max_bin;
151 }
152
153
154 string const latex_path(string const & original_path,
155                 latex_path_extension extension,
156                 latex_path_dots dots)
157 {
158         // On cygwin, we may need windows or posix style paths.
159         string path = os::latex_path(original_path);
160         path = subst(path, "~", "\\string~");
161         if (path.find(' ') != string::npos) {
162                 // We can't use '"' because " is sometimes active (e.g. if
163                 // babel is loaded with the "german" option)
164                 if (extension == EXCLUDE_EXTENSION) {
165                         // changeExtension calls os::internal_path internally
166                         // so don't use it to remove the extension.
167                         string const ext = getExtension(path);
168                         string const base = ext.empty() ?
169                                 path :
170                                 path.substr(0, path.length() - ext.length() - 1);
171                         // changeExtension calls os::internal_path internally
172                         // so don't use it to re-add the extension.
173                         path = "\\string\"" + base + "\\string\"." + ext;
174                 } else {
175                         path = "\\string\"" + path + "\\string\"";
176                 }
177         }
178
179         if (dots != ESCAPE_DOTS)
180                 return path;
181
182         // Replace dots with the lyxdot macro, but only in the file name,
183         // not the directory part.
184         // addName etc call os::internal_path internally
185         // so don't use them for path manipulation
186         // The directory separator is always '/' for LaTeX.
187         string::size_type pos = path.rfind('/');
188         if (pos == string::npos)
189                 return subst(path, ".", "\\lyxdot ");
190         return path.substr(0, pos) + subst(path.substr(pos), ".", "\\lyxdot ");
191 }
192
193
194 // Substitutes spaces with underscores in filename (and path)
195 FileName const makeLatexName(FileName const & file)
196 {
197         string name = file.onlyFileName();
198         string const path = file.onlyPath().absFileName() + "/";
199
200         // ok so we scan through the string twice, but who cares.
201         // FIXME: in Unicode time this will break for sure! There is
202         // a non-latin world out there...
203         string const keep = "abcdefghijklmnopqrstuvwxyz"
204                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
205                 "@!'()*+,-./0123456789:;<=>?[]`|";
206
207         string::size_type pos = 0;
208         while ((pos = name.find_first_not_of(keep, pos)) != string::npos)
209                 name[pos++] = '_';
210
211         FileName latex_name(path + name);
212         latex_name.changeExtension(".tex");
213         return latex_name;
214 }
215
216
217 string const quoteName(string const & name, quote_style style)
218 {
219         switch(style) {
220         case quote_shell:
221                 // This does not work on native Windows for filenames
222                 // containing the following characters < > : " / \ | ? *
223                 // Moreover, it can't be made to work, as, according to
224                 // http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx
225                 // those are reserved characters, and thus are forbidden.
226                 // Please, also note that the command-line parser in
227                 // ForkedCall::generateChild cannot deal with filenames
228                 // containing " or ', therefore we don't pass user filenames
229                 // to child processes if possible. We store them in a python
230                 // script instead, where we don't have these limitations.
231 #ifndef USE_QPROCESS
232                 return (os::shell() == os::UNIX) ?
233                         '\'' + subst(name, "'", "\'\\\'\'") + '\'' :
234                         '"' + name + '"';
235 #else
236                 // According to the QProcess parser, a single double
237                 // quote is represented by three consecutive ones.
238                 // Here we simply escape the double quote and let our
239                 // simple parser in Systemcall.cpp do the substitution.
240                 return '"' + subst(name, "\"", "\\\"") + '"';
241 #endif
242         case quote_shell_filename:
243                 return quoteName(os::external_path(name), quote_shell);
244         case quote_python:
245                 return "\"" + subst(subst(name, "\\", "\\\\"), "\"", "\\\"")
246                      + "\"";
247         }
248         // shut up stupid compiler
249         return string();
250 }
251
252
253 #if 0
254 // Uses a string of paths separated by ";"s to find a file to open.
255 // Can't cope with pathnames with a ';' in them. Returns full path to file.
256 // If path entry begins with $$LyX/, use system_lyxdir
257 // If path entry begins with $$User/, use user_lyxdir
258 // Example: "$$User/doc;$$LyX/doc"
259 FileName const fileOpenSearch(string const & path, string const & name,
260                              string const & ext)
261 {
262         FileName real_file;
263         string path_element;
264         bool notfound = true;
265         string tmppath = split(path, path_element, ';');
266
267         while (notfound && !path_element.empty()) {
268                 path_element = os::internal_path(path_element);
269                 if (!suffixIs(path_element, '/'))
270                         path_element += '/';
271                 path_element = subst(path_element, "$$LyX",
272                                      package().system_support().absFileName());
273                 path_element = subst(path_element, "$$User",
274                                      package().user_support().absFileName());
275
276                 real_file = fileSearch(path_element, name, ext);
277
278                 if (real_file.empty()) {
279                         do {
280                                 tmppath = split(tmppath, path_element, ';');
281                         } while (!tmppath.empty() && path_element.empty());
282                 } else {
283                         notfound = false;
284                 }
285         }
286         return real_file;
287 }
288 #endif
289
290
291 // Returns the real name of file name in directory path, with optional
292 // extension ext.
293 FileName const fileSearch(string const & path, string const & name,
294                           string const & exts, search_mode mode)
295 {
296         // if `name' is an absolute path, we ignore the setting of `path'
297         // Expand Environmentvariables in 'name'
298         string const tmpname = replaceEnvironmentPath(name);
299         FileName fullname(makeAbsPath(tmpname, path));
300         // search first without extension, then with it.
301         if (fullname.isReadableFile())
302                 return fullname;
303         if (exts.empty())
304                 // We are done.
305                 return mode == may_not_exist ? fullname : FileName();
306         int n = 0;
307         string ext = token(exts, ',', n);
308         while (!ext.empty()) {
309                 // Only add the extension if it is not already the extension of
310                 // fullname.
311                 bool addext = getExtension(fullname.absFileName()) != ext;
312                 if (addext) {
313                         if (mode == check_hidpi) {
314                                 FileName fullname2x = FileName(addExtension(fullname.absFileName() + "@2x", ext));
315                                 if (fullname2x.isReadableFile())
316                                         return fullname2x;
317                         }
318                         fullname = FileName(addExtension(fullname.absFileName(), ext));
319                 }
320                 if (fullname.isReadableFile() || mode == may_not_exist)
321                         return fullname;
322                 if (addext)
323                         fullname.changeExtension("");
324                 ext = token(exts, ',', ++n);
325         }
326         return FileName();
327 }
328
329
330 // Search the file name.ext in the subdirectory dir of
331 //   1) user_lyxdir
332 //   2) build_lyxdir (if not empty)
333 //   3) system_lyxdir
334 FileName const libFileSearch(string const & dir, string const & name,
335                            string const & ext, search_mode mode)
336 {
337         FileName fullname = fileSearch(addPath(package().user_support().absFileName(), dir),
338                                      name, ext, mode);
339         if (!fullname.empty())
340                 return fullname;
341
342         if (!package().build_support().empty())
343                 fullname = fileSearch(addPath(package().build_support().absFileName(), dir),
344                                       name, ext, mode);
345         if (!fullname.empty())
346                 return fullname;
347
348         return fileSearch(addPath(package().system_support().absFileName(), dir),
349                                       name, ext, mode);
350 }
351
352
353 FileName const i18nLibFileSearch(string const & dir, string const & name,
354                   string const & ext)
355 {
356         /* The highest priority value is the `LANGUAGE' environment
357            variable. But we don't use the value if the currently
358            selected locale is the C locale. This is a GNU extension.
359
360            Otherwise, w use a trick to guess what support/gettext.has done:
361            each po file is able to tell us its name. (JMarc)
362         */
363
364         string lang = getGuiMessages().language();
365         string const language = getEnv("LANGUAGE");
366         if (!lang.empty() && !language.empty())
367                 lang = language;
368
369         string l;
370         lang = split(lang, l, ':');
371         while (!l.empty()) {
372                 FileName tmp;
373                 // First try with the full name
374                 tmp = libFileSearch(addPath(dir, l), name, ext);
375                 if (!tmp.empty())
376                         return tmp;
377
378                 // Then the name without country code
379                 string const shortl = token(l, '_', 0);
380                 if (shortl != l) {
381                         tmp = libFileSearch(addPath(dir, shortl), name, ext);
382                         if (!tmp.empty())
383                                 return tmp;
384                 }
385
386 #if 1
387                 // For compatibility, to be removed later (JMarc)
388                 tmp = libFileSearch(dir, token(l, '_', 0) + '_' + name,
389                                     ext);
390                 if (!tmp.empty()) {
391                         lyxerr << "i18nLibFileSearch: File `" << tmp
392                                << "' has been found by the old method" <<endl;
393                         return tmp;
394                 }
395 #endif
396                 lang = split(lang, l, ':');
397         }
398
399         return libFileSearch(dir, name, ext);
400 }
401
402
403 FileName const imageLibFileSearch(string & dir, string const & name,
404                   string const & ext, search_mode mode)
405 {
406         if (!lyx::lyxrc.icon_set.empty()) {
407                 string const imagedir = addPath(dir, lyx::lyxrc.icon_set);
408                 FileName const fn = libFileSearch(imagedir, name, ext, mode);
409                 if (fn.exists()) {
410                         dir = imagedir;
411                         return fn;
412                 }
413         }
414         return libFileSearch(dir, name, ext, mode);
415 }
416
417
418 string const commandPrep(string const & command_in)
419 {
420         static string const token_scriptpath = "$$s/";
421         string const python_call = "python -tt";
422
423         string command = command_in;
424         if (prefixIs(command_in, python_call))
425                 command = os::python() + command_in.substr(python_call.length());
426
427         // Find the starting position of "$$s/"
428         string::size_type const pos1 = command.find(token_scriptpath);
429         if (pos1 == string::npos)
430                 return command;
431         // Find the end of the "$$s/some_subdir/some_script" word within
432         // command. Assumes that the script name does not contain spaces.
433         string::size_type const start_script = pos1 + 4;
434         string::size_type const pos2 = command.find(' ', start_script);
435         string::size_type const size_script = pos2 == string::npos?
436                 (command.size() - start_script) : pos2 - start_script;
437
438         // Does this script file exist?
439         string const script =
440                 libFileSearch(".", command.substr(start_script, size_script)).absFileName();
441
442         if (script.empty()) {
443                 // Replace "$$s/" with ""
444                 command.erase(pos1, 4);
445         } else {
446                 quote_style style = quote_shell;
447                 if (prefixIs(command, os::python()))
448                         style = quote_python;
449
450                 // Replace "$$s/foo/some_script" with "<path to>/some_script".
451                 string::size_type const size_replace = size_script + 4;
452                 command.replace(pos1, size_replace, quoteName(script, style));
453         }
454
455         return command;
456 }
457
458
459 static string createTempFile(QString const & mask)
460 {
461         // FIXME: This is not safe. QTemporaryFile creates a file in open(),
462         //        but the file is deleted when qt_tmp goes out of scope.
463         //        Therefore the next call to createTempFile() may create the
464         //        same file again. To make this safe the QTemporaryFile object
465         //        needs to be kept for the whole life time of the temp file name.
466         //        This could be achieved by creating a class TempDir (like
467         //        TempFile, but using a currentlky non-existing
468         //        QTemporaryDirectory object).
469         QTemporaryFile qt_tmp(mask + ".XXXXXXXXXXXX");
470         if (qt_tmp.open()) {
471                 string const temp_file = fromqstr(qt_tmp.fileName());
472                 LYXERR(Debug::FILES, "Temporary file `" << temp_file << "' created.");
473                 return temp_file;
474         }
475         LYXERR(Debug::FILES, "Unable to create temporary file with following template: "
476                         << qt_tmp.fileTemplate());
477         return string();
478 }
479
480
481 static FileName createTmpDir(FileName const & tempdir, string const & mask)
482 {
483         LYXERR(Debug::FILES, "createTmpDir: tempdir=`" << tempdir << "'\n"
484                 << "createTmpDir:    mask=`" << mask << '\'');
485
486         QFileInfo tmp_fi(QDir(toqstr(tempdir.absFileName())), toqstr(mask));
487         FileName const tmpfl(createTempFile(tmp_fi.absoluteFilePath()));
488
489         if (tmpfl.empty() || !tmpfl.createDirectory(0700)) {
490                 LYXERR0("LyX could not create temporary directory in " << tempdir
491                         << "'");
492                 return FileName();
493         }
494
495         return tmpfl;
496 }
497
498
499 FileName const createLyXTmpDir(FileName const & deflt)
500 {
501         if (deflt.empty() || deflt == package().system_temp_dir())
502                 return createTmpDir(package().system_temp_dir(), "lyx_tmpdir");
503
504         if (deflt.createDirectory(0777))
505                 return deflt;
506
507         if (deflt.isDirWritable()) {
508                 // deflt could not be created because it
509                 // did exist already, so let's create our own
510                 // dir inside deflt.
511                 return createTmpDir(deflt, "lyx_tmpdir");
512         } else {
513                 // some other error occurred.
514                 return createTmpDir(package().system_temp_dir(), "lyx_tmpdir");
515         }
516 }
517
518
519 // Strip filename from path name
520 string const onlyPath(string const & filename)
521 {
522         // If empty filename, return empty
523         if (filename.empty())
524                 return filename;
525
526         // Find last / or start of filename
527         size_t j = filename.rfind('/');
528         return j == string::npos ? "./" : filename.substr(0, j + 1);
529 }
530
531
532 // Convert relative path into absolute path based on a basepath.
533 // If relpath is absolute, just use that.
534 // If basepath is empty, use CWD as base.
535 // Note that basePath can be a relative path, in the sense that it may
536 // not begin with "/" (e.g.), but it should NOT contain such constructs
537 // as "/../".
538 // FIXME It might be nice if the code didn't simply assume that.
539 FileName const makeAbsPath(string const & relPath, string const & basePath)
540 {
541         // checks for already absolute path
542         if (FileName::isAbsolute(relPath))
543                 return FileName(relPath);
544
545         // Copies given paths
546         string tempRel = os::internal_path(relPath);
547         // Since TempRel is NOT absolute, we can safely replace "//" with "/"
548         tempRel = subst(tempRel, "//", "/");
549
550         string tempBase;
551
552         if (FileName::isAbsolute(basePath))
553                 tempBase = basePath;
554         else
555                 tempBase = addPath(FileName::getcwd().absFileName(), basePath);
556
557         // Handle /./ at the end of the path
558         while (suffixIs(tempBase, "/./"))
559                 tempBase.erase(tempBase.length() - 2);
560
561         // processes relative path
562         string rTemp = tempRel;
563         string temp;
564
565         // Check for a leading "~"
566         // Split by first /
567         rTemp = split(rTemp, temp, '/');
568         if (temp == "~") {
569                 tempBase = Package::get_home_dir().absFileName();
570                 tempRel = rTemp;
571         }
572
573         rTemp = tempRel;
574         while (!rTemp.empty()) {
575                 // Split by next /
576                 rTemp = split(rTemp, temp, '/');
577
578                 if (temp == ".") continue;
579                 if (temp == "..") {
580                         // Remove one level of TempBase
581                         if (tempBase.length() <= 1) {
582                                 //this is supposed to be an absolute path, so...
583                                 tempBase = "/";
584                                 continue;
585                         }
586                         //erase a trailing slash if there is one
587                         if (suffixIs(tempBase, "/"))
588                                 tempBase.erase(tempBase.length() - 1, string::npos);
589
590                         string::size_type i = tempBase.length() - 1;
591                         while (i > 0 && tempBase[i] != '/')
592                                 --i;
593                         if (i > 0)
594                                 tempBase.erase(i, string::npos);
595                         else
596                                 tempBase = '/';
597                 } else if (temp.empty() && !rTemp.empty()) {
598                                 tempBase = os::current_root() + rTemp;
599                                 rTemp.erase();
600                 } else {
601                         // Add this piece to TempBase
602                         if (!suffixIs(tempBase, '/'))
603                                 tempBase += '/';
604                         tempBase += temp;
605                 }
606         }
607
608         // returns absolute path
609         return FileName(tempBase);
610 }
611
612
613 // Correctly append filename to the pathname.
614 // If pathname is '.', then don't use pathname.
615 // Chops any path of filename.
616 string const addName(string const & path, string const & fname)
617 {
618         string const basename = onlyFileName(fname);
619         string buf;
620
621         if (path != "." && path != "./" && !path.empty()) {
622                 buf = os::internal_path(path);
623                 if (!suffixIs(path, '/'))
624                         buf += '/';
625         }
626
627         return buf + basename;
628 }
629
630
631 // Strips path from filename
632 string const onlyFileName(string const & fname)
633 {
634         if (fname.empty())
635                 return fname;
636
637         string::size_type j = fname.rfind('/');
638         if (j == string::npos) // no '/' in fname
639                 return fname;
640
641         // Strip to basename
642         return fname.substr(j + 1);
643 }
644
645
646 // Create absolute path. If impossible, don't do anything
647 // Supports ./ and ~/. Later we can add support for ~logname/. (Asger)
648 string const expandPath(string const & path)
649 {
650         // checks for already absolute path
651         string rTemp = replaceEnvironmentPath(path);
652         if (FileName::isAbsolute(rTemp))
653                 return rTemp;
654
655         string temp;
656         string const copy = rTemp;
657
658         // Split by next /
659         rTemp = split(rTemp, temp, '/');
660
661         if (temp == ".")
662                 return FileName::getcwd().absFileName() + '/' + rTemp;
663
664         if (temp == "~")
665                 return Package::get_home_dir().absFileName() + '/' + rTemp;
666
667         if (temp == "..")
668                 return makeAbsPath(copy).absFileName();
669
670         // Don't know how to handle this
671         return copy;
672 }
673
674
675 // Search the string for ${VAR} and $VAR and replace VAR using getenv.
676 string const replaceEnvironmentPath(string const & path)
677 {
678         // ${VAR} is defined as
679         // $\{[A-Za-z_][A-Za-z_0-9]*\}
680         static string const envvar_br = "[$]\\{([A-Za-z_][A-Za-z_0-9]*)\\}";
681
682         // $VAR is defined as:
683         // $[A-Za-z_][A-Za-z_0-9]*
684         static string const envvar = "[$]([A-Za-z_][A-Za-z_0-9]*)";
685
686         static regex const envvar_br_re("(.*)" + envvar_br + "(.*)");
687         static regex const envvar_re("(.*)" + envvar + "(.*)");
688         string result = path;
689         while (1) {
690                 smatch what;
691                 if (!regex_match(result, what, envvar_br_re)) {
692                         if (!regex_match(result, what, envvar_re))
693                                 break;
694                 }
695                 string env_var = getEnv(what.str(2));
696                 result = what.str(1) + env_var + what.str(3);
697         }
698         return result;
699 }
700
701
702 // Return a command prefix for setting the environment of the TeX engine.
703 string latexEnvCmdPrefix(string const & path)
704 {
705         if (path.empty() || lyxrc.texinputs_prefix.empty())
706                 return string();
707
708         string const texinputs_prefix = os::latex_path_list(
709                         replaceCurdirPath(path, lyxrc.texinputs_prefix));
710         string const sep = string(1, os::path_separator(os::TEXENGINE));
711         string const texinputs = getEnv("TEXINPUTS");
712
713         if (os::shell() == os::UNIX)
714                 return "env TEXINPUTS=\"." + sep + texinputs_prefix
715                                           + sep + texinputs + "\" ";
716         else
717                 // NOTE: the dummy blank dir is necessary to force the
718                 //       QProcess parser to quote the argument (see bug 9453)
719                 return "cmd /d /c set \"TEXINPUTS=." + sep + " "
720                                                 + sep + texinputs_prefix
721                                                 + sep + texinputs + "\" & ";
722 }
723
724
725 // Replace current directory in all elements of a path list with a given path.
726 string const replaceCurdirPath(string const & path, string const & pathlist)
727 {
728         string const oldpathlist = replaceEnvironmentPath(pathlist);
729         char const sep = os::path_separator();
730         string newpathlist;
731
732         for (size_t i = 0, k = 0; i != string::npos; k = i) {
733                 i = oldpathlist.find(sep, i);
734                 string p = oldpathlist.substr(k, i - k);
735                 if (FileName::isAbsolute(p)) {
736                         newpathlist += p;
737                 } else if (i > k) {
738                         size_t offset = 0;
739                         if (p == ".") {
740                                 offset = 1;
741                         } else if (prefixIs(p, "./")) {
742                                 offset = 2;
743                                 while (p[offset] == '/')
744                                         ++offset;
745                         }
746                         newpathlist += addPath(path, p.substr(offset));
747                         if (suffixIs(p, "//"))
748                                 newpathlist += '/';
749                 }
750                 if (i != string::npos) {
751                         newpathlist += sep;
752                         // Stop here if the last element is empty
753                         if (++i == oldpathlist.length())
754                                 break;
755                 }
756         }
757         return newpathlist;
758 }
759
760
761 // Make relative path out of two absolute paths
762 docstring const makeRelPath(docstring const & abspath, docstring const & basepath)
763 // Makes relative path out of absolute path. If it is deeper than basepath,
764 // it's easy. If basepath and abspath share something (they are all deeper
765 // than some directory), it'll be rendered using ..'s. If they are completely
766 // different, then the absolute path will be used as relative path.
767 {
768         docstring::size_type const abslen = abspath.length();
769         docstring::size_type const baselen = basepath.length();
770
771         docstring::size_type i = os::common_path(abspath, basepath);
772
773         if (i == 0) {
774                 // actually no match - cannot make it relative
775                 return abspath;
776         }
777
778         // Count how many dirs there are in basepath above match
779         // and append as many '..''s into relpath
780         docstring buf;
781         docstring::size_type j = i;
782         while (j < baselen) {
783                 if (basepath[j] == '/') {
784                         if (j + 1 == baselen)
785                                 break;
786                         buf += "../";
787                 }
788                 ++j;
789         }
790
791         // Append relative stuff from common directory to abspath
792         if (abspath[i] == '/')
793                 ++i;
794         for (; i < abslen; ++i)
795                 buf += abspath[i];
796         // Remove trailing /
797         if (suffixIs(buf, '/'))
798                 buf.erase(buf.length() - 1);
799         // Substitute empty with .
800         if (buf.empty())
801                 buf = '.';
802         return buf;
803 }
804
805
806 // Append sub-directory(ies) to a path in an intelligent way
807 string const addPath(string const & path, string const & path_2)
808 {
809         string buf;
810         string const path2 = os::internal_path(path_2);
811
812         if (!path.empty() && path != "." && path != "./") {
813                 buf = os::internal_path(path);
814                 if (path[path.length() - 1] != '/')
815                         buf += '/';
816         }
817
818         if (!path2.empty()) {
819                 string::size_type const p2start = path2.find_first_not_of('/');
820                 string::size_type const p2end = path2.find_last_not_of('/');
821                 string const tmp = path2.substr(p2start, p2end - p2start + 1);
822                 buf += tmp + '/';
823         }
824         return buf;
825 }
826
827
828 string const changeExtension(string const & oldname, string const & extension)
829 {
830         string::size_type const last_slash = oldname.rfind('/');
831         string::size_type last_dot = oldname.rfind('.');
832         if (last_dot < last_slash && last_slash != string::npos)
833                 last_dot = string::npos;
834
835         string ext;
836         // Make sure the extension starts with a dot
837         if (!extension.empty() && extension[0] != '.')
838                 ext= '.' + extension;
839         else
840                 ext = extension;
841
842         return os::internal_path(oldname.substr(0, last_dot) + ext);
843 }
844
845
846 string const removeExtension(string const & name)
847 {
848         return changeExtension(name, string());
849 }
850
851
852 string const addExtension(string const & name, string const & extension)
853 {
854         if (!extension.empty() && extension[0] != '.')
855                 return name + '.' + extension;
856         return name + extension;
857 }
858
859
860 /// Return the extension of the file (not including the .)
861 string const getExtension(string const & name)
862 {
863         string::size_type const last_slash = name.rfind('/');
864         string::size_type const last_dot = name.rfind('.');
865         if (last_dot != string::npos &&
866             (last_slash == string::npos || last_dot > last_slash))
867                 return name.substr(last_dot + 1,
868                                    name.length() - (last_dot + 1));
869         else
870                 return string();
871 }
872
873
874 string const unzippedFileName(string const & zipped_file)
875 {
876         string const ext = getExtension(zipped_file);
877         if (ext == "gz" || ext == "z" || ext == "Z")
878                 return changeExtension(zipped_file, string());
879         else if (ext == "svgz")
880                 return changeExtension(zipped_file, "svg");
881         return onlyPath(zipped_file) + "unzipped_" + onlyFileName(zipped_file);
882 }
883
884
885 FileName const unzipFile(FileName const & zipped_file, string const & unzipped_file)
886 {
887         FileName const tempfile = FileName(unzipped_file.empty() ?
888                 unzippedFileName(zipped_file.toFilesystemEncoding()) :
889                 unzipped_file);
890         // Run gunzip
891         string const command = "gunzip -c " +
892                 zipped_file.toFilesystemEncoding() + " > " +
893                 tempfile.toFilesystemEncoding();
894         Systemcall one;
895         one.startscript(Systemcall::Wait, command);
896         // test that command was executed successfully (anon)
897         // yes, please do. (Lgb)
898         return tempfile;
899 }
900
901
902 docstring const makeDisplayPath(string const & path, unsigned int threshold)
903 {
904         string str = path;
905
906         // If file is from LyXDir, display it as if it were relative.
907         string const system = package().system_support().absFileName();
908         if (prefixIs(str, system) && str != system)
909                 return from_utf8("[" + str.erase(0, system.length()) + "]");
910
911         // replace /home/blah with ~/
912         string const home = Package::get_home_dir().absFileName();
913         if (!home.empty() && prefixIs(str, home))
914                 str = subst(str, home, "~");
915
916         if (str.length() <= threshold)
917                 return from_utf8(os::external_path(str));
918
919         string const prefix = ".../";
920         docstring dstr = from_utf8(str);
921         docstring temp;
922
923         while (dstr.length() > threshold)
924                 dstr = split(dstr, temp, '/');
925
926         // Did we shorten everything away?
927         if (dstr.empty()) {
928                 // Yes, filename itself is too long.
929                 // Pick the start and the end of the filename.
930                 dstr = from_utf8(onlyFileName(path));
931                 docstring const head = dstr.substr(0, threshold / 2 - 3);
932
933                 docstring::size_type len = dstr.length();
934                 docstring const tail =
935                         dstr.substr(len - threshold / 2 - 2, len - 1);
936                 dstr = head + from_ascii("...") + tail;
937         }
938
939         return from_utf8(os::external_path(prefix + to_utf8(dstr)));
940 }
941
942
943 #ifdef HAVE_READLINK
944 bool readLink(FileName const & file, FileName & link)
945 {
946         string const encoded = file.toFilesystemEncoding();
947 #ifdef HAVE_DEF_PATH_MAX
948         char linkbuffer[PATH_MAX + 1];
949         ssize_t const nRead = ::readlink(encoded.c_str(),
950                                      linkbuffer, sizeof(linkbuffer) - 1);
951         if (nRead <= 0)
952                 return false;
953         linkbuffer[nRead] = '\0'; // terminator
954 #else
955         vector<char> buf(1024);
956         int nRead = -1;
957
958         while (true) {
959                 nRead = ::readlink(encoded.c_str(), &buf[0], buf.size() - 1);
960                 if (nRead < 0) {
961                         return false;
962                 }
963                 if (static_cast<size_t>(nRead) < buf.size() - 1) {
964                         break;
965                 }
966                 buf.resize(buf.size() * 2);
967         }
968         buf[nRead] = '\0'; // terminator
969         const char * linkbuffer = &buf[0];
970 #endif
971         link = makeAbsPath(linkbuffer, onlyPath(file.absFileName()));
972         return true;
973 }
974 #else
975 bool readLink(FileName const &, FileName &)
976 {
977         return false;
978 }
979 #endif
980
981
982 cmd_ret const runCommand(string const & cmd)
983 {
984         // FIXME: replace all calls to RunCommand with ForkedCall
985         // (if the output is not needed) or the code in ISpell.cpp
986         // (if the output is needed).
987
988         // One question is if we should use popen or
989         // create our own popen based on fork, exec, pipe
990         // of course the best would be to have a
991         // pstream (process stream), with the
992         // variants ipstream, opstream
993
994 #if defined (_WIN32)
995         int fno;
996         STARTUPINFO startup;
997         PROCESS_INFORMATION process;
998         SECURITY_ATTRIBUTES security;
999         HANDLE in, out;
1000         FILE * inf = 0;
1001         bool err2out = false;
1002         string command;
1003         string const infile = trim(split(cmd, command, '<'), " \"");
1004         command = rtrim(command);
1005         if (suffixIs(command, "2>&1")) {
1006                 command = rtrim(command, "2>&1");
1007                 err2out = true;
1008         }
1009         string const cmdarg = "/d /c " + command;
1010         string const comspec = getEnv("COMSPEC");
1011
1012         security.nLength = sizeof(SECURITY_ATTRIBUTES);
1013         security.bInheritHandle = TRUE;
1014         security.lpSecurityDescriptor = NULL;
1015
1016         if (CreatePipe(&in, &out, &security, 0)) {
1017                 memset(&startup, 0, sizeof(STARTUPINFO));
1018                 memset(&process, 0, sizeof(PROCESS_INFORMATION));
1019
1020                 startup.cb = sizeof(STARTUPINFO);
1021                 startup.dwFlags = STARTF_USESTDHANDLES;
1022
1023                 startup.hStdError = err2out ? out : GetStdHandle(STD_ERROR_HANDLE);
1024                 startup.hStdInput = infile.empty()
1025                         ? GetStdHandle(STD_INPUT_HANDLE)
1026                         : CreateFile(infile.c_str(), GENERIC_READ,
1027                                 FILE_SHARE_READ, &security, OPEN_EXISTING,
1028                                 FILE_ATTRIBUTE_NORMAL, NULL);
1029                 startup.hStdOutput = out;
1030
1031                 if (startup.hStdInput != INVALID_HANDLE_VALUE &&
1032                         CreateProcess(comspec.c_str(), (LPTSTR)cmdarg.c_str(),
1033                                 &security, &security, TRUE, CREATE_NO_WINDOW,
1034                                 0, 0, &startup, &process)) {
1035
1036                         CloseHandle(process.hThread);
1037                         fno = _open_osfhandle((long)in, _O_RDONLY);
1038                         CloseHandle(out);
1039                         inf = _fdopen(fno, "r");
1040                 }
1041         }
1042 #elif defined (HAVE_POPEN)
1043         FILE * inf = ::popen(cmd.c_str(), os::popen_read_mode());
1044 #elif defined (HAVE__POPEN)
1045         FILE * inf = ::_popen(cmd.c_str(), os::popen_read_mode());
1046 #else
1047 #error No popen() function.
1048 #endif
1049
1050         // (Claus Hentschel) Check if popen was successful ;-)
1051         if (!inf) {
1052                 lyxerr << "RunCommand:: could not start child process" << endl;
1053                 return make_pair(-1, string());
1054         }
1055
1056         string ret;
1057         int c = fgetc(inf);
1058         while (c != EOF) {
1059                 ret += static_cast<char>(c);
1060                 c = fgetc(inf);
1061         }
1062
1063 #if defined (_WIN32)
1064         WaitForSingleObject(process.hProcess, INFINITE);
1065         if (!infile.empty())
1066                 CloseHandle(startup.hStdInput);
1067         CloseHandle(process.hProcess);
1068         int const pret = fclose(inf);
1069 #elif defined (HAVE_PCLOSE)
1070         int const pret = pclose(inf);
1071 #elif defined (HAVE__PCLOSE)
1072         int const pret = _pclose(inf);
1073 #else
1074 #error No pclose() function.
1075 #endif
1076
1077         if (pret == -1)
1078                 perror("RunCommand:: could not terminate child process");
1079
1080         return make_pair(pret, ret);
1081 }
1082
1083
1084 FileName const findtexfile(string const & fil, string const & /*format*/)
1085 {
1086         /* There is no problem to extend this function too use other
1087            methods to look for files. It could be setup to look
1088            in environment paths and also if wanted as a last resort
1089            to a recursive find. One of the easier extensions would
1090            perhaps be to use the LyX file lookup methods. But! I am
1091            going to implement this until I see some demand for it.
1092            Lgb
1093         */
1094
1095         // If the file can be found directly, we just return a
1096         // absolute path version of it.
1097         FileName const absfile(makeAbsPath(fil));
1098         if (absfile.exists())
1099                 return absfile;
1100
1101         // Now we try to find it using kpsewhich.
1102         // It seems from the kpsewhich manual page that it is safe to use
1103         // kpsewhich without --format: "When the --format option is not
1104         // given, the search path used when looking for a file is inferred
1105         // from the name given, by looking for a known extension. If no
1106         // known extension is found, the search path for TeX source files
1107         // is used."
1108         // However, we want to take advantage of the format sine almost all
1109         // the different formats has environment variables that can be used
1110         // to controll which paths to search. f.ex. bib looks in
1111         // BIBINPUTS and TEXBIB. Small list follows:
1112         // bib - BIBINPUTS, TEXBIB
1113         // bst - BSTINPUTS
1114         // graphic/figure - TEXPICTS, TEXINPUTS
1115         // ist - TEXINDEXSTYLE, INDEXSTYLE
1116         // pk - PROGRAMFONTS, PKFONTS, TEXPKS, GLYPHFONTS, TEXFONTS
1117         // tex - TEXINPUTS
1118         // tfm - TFMFONTS, TEXFONTS
1119         // This means that to use kpsewhich in the best possible way we
1120         // should help it by setting additional path in the approp. envir.var.
1121         string const kpsecmd = "kpsewhich " + fil;
1122
1123         cmd_ret const c = runCommand(kpsecmd);
1124
1125         LYXERR(Debug::LATEX, "kpse status = " << c.first << '\n'
1126                  << "kpse result = `" << rtrim(c.second, "\n\r") << '\'');
1127         if (c.first != -1)
1128                 return FileName(rtrim(to_utf8(from_filesystem8bit(c.second)), "\n\r"));
1129         else
1130                 return FileName();
1131 }
1132
1133
1134 int compare_timestamps(FileName const & file1, FileName const & file2)
1135 {
1136         // If the original is newer than the copy, then copy the original
1137         // to the new directory.
1138
1139         int cmp = 0;
1140         if (file1.exists() && file2.exists()) {
1141                 double const tmp = difftime(file1.lastModified(), file2.lastModified());
1142                 if (tmp != 0)
1143                         cmp = tmp > 0 ? 1 : -1;
1144
1145         } else if (file1.exists()) {
1146                 cmp = 1;
1147         } else if (file2.exists()) {
1148                 cmp = -1;
1149         }
1150
1151         return cmp;
1152 }
1153
1154
1155 bool prefs2prefs(FileName const & filename, FileName const & tempfile, bool lfuns)
1156 {
1157         FileName const script = libFileSearch("scripts", "prefs2prefs.py");
1158         if (script.empty()) {
1159                 LYXERR0("Could not find bind file conversion "
1160                                 "script prefs2prefs.py.");
1161                 return false;
1162         }
1163
1164         ostringstream command;
1165         command << os::python() << ' ' << quoteName(script.toFilesystemEncoding())
1166           << ' ' << (lfuns ? "-l" : "-p") << ' '
1167                 << quoteName(filename.toFilesystemEncoding())
1168                 << ' ' << quoteName(tempfile.toFilesystemEncoding());
1169         string const command_str = command.str();
1170
1171         LYXERR(Debug::FILES, "Running `" << command_str << '\'');
1172
1173         cmd_ret const ret = runCommand(command_str);
1174         if (ret.first != 0) {
1175                 LYXERR0("Could not run file conversion script prefs2prefs.py.");
1176                 return false;
1177         }
1178         return true;
1179 }
1180
1181
1182 bool configFileNeedsUpdate(string const & file)
1183 {
1184         // We cannot initialize configure_script directly because the package
1185         // is not initialized yet when static objects are constructed.
1186         static FileName configure_script;
1187         static bool firstrun = true;
1188         if (firstrun) {
1189                 configure_script =
1190                         FileName(addName(package().system_support().absFileName(),
1191                                 "configure.py"));
1192                 firstrun = false;
1193         }
1194
1195         FileName absfile =
1196                 FileName(addName(package().user_support().absFileName(), file));
1197         return !absfile.exists()
1198                 || configure_script.lastModified() > absfile.lastModified();
1199 }
1200
1201
1202 int fileLock(const char * lock_file)
1203 {
1204         int fd = -1;
1205 #if defined(HAVE_LOCKF)
1206         fd = open(lock_file, O_CREAT|O_APPEND|O_SYNC|O_RDWR, 0666);
1207         if (lockf(fd, F_LOCK, 0) != 0) {
1208                 close(fd);
1209                 return(-1);
1210         }
1211 #endif
1212         return(fd);
1213 }
1214
1215 void fileUnlock(int fd, const char * /* lock_file*/)
1216 {
1217 #if defined(HAVE_LOCKF)
1218         if (fd >= 0) {
1219                 if (lockf(fd, F_ULOCK, 0))
1220                         LYXERR0("Can't unlock the file.");
1221                 close(fd);
1222         }
1223 #endif
1224 }
1225
1226 } //namespace support
1227 } // namespace lyx