]> git.lyx.org Git - lyx.git/blob - src/support/filetools.cpp
a7cf272e6ba3cce252bd6b368cbf1c7c18e8774b
[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 "support/filetools.h"
25
26 #include "support/convert.h"
27 #include "support/debug.h"
28 #include "support/environment.h"
29 #include "support/gettext.h"
30 #include "support/lstrings.h"
31 #include "support/os.h"
32 #include "support/Package.h"
33 #include "support/Path.h"
34 #include "support/Systemcall.h"
35 #include "support/qstring_helpers.h"
36
37 #include <QDir>
38
39 #include <boost/assert.hpp>
40 #include <boost/regex.hpp>
41
42 #include <fcntl.h>
43
44 #include <cerrno>
45 #include <cstdlib>
46 #include <cstdio>
47
48 #include <utility>
49 #include <fstream>
50 #include <sstream>
51
52 using namespace std;
53
54 namespace lyx {
55 namespace support {
56
57 bool isLyXFilename(string const & filename)
58 {
59         return suffixIs(ascii_lowercase(filename), ".lyx");
60 }
61
62
63 bool isSGMLFilename(string const & filename)
64 {
65         return suffixIs(ascii_lowercase(filename), ".sgml");
66 }
67
68
69 bool isValidLaTeXFilename(string const & filename)
70 {
71         string const invalid_chars("#$%{}()[]\"^");
72         return filename.find_first_of(invalid_chars) == string::npos;
73 }
74
75
76 string const latex_path(string const & original_path,
77                 latex_path_extension extension,
78                 latex_path_dots dots)
79 {
80         // On cygwin, we may need windows or posix style paths.
81         string path = os::latex_path(original_path);
82         path = subst(path, "~", "\\string~");
83         if (path.find(' ') != string::npos) {
84                 // We can't use '"' because " is sometimes active (e.g. if
85                 // babel is loaded with the "german" option)
86                 if (extension == EXCLUDE_EXTENSION) {
87                         // ChangeExtension calls os::internal_path internally
88                         // so don't use it to remove the extension.
89                         string const ext = getExtension(path);
90                         string const base = ext.empty() ?
91                                 path :
92                                 path.substr(0, path.length() - ext.length() - 1);
93                         // ChangeExtension calls os::internal_path internally
94                         // so don't use it to re-add the extension.
95                         path = "\\string\"" + base + "\\string\"." + ext;
96                 } else {
97                         path = "\\string\"" + path + "\\string\"";
98                 }
99         }
100
101         return dots == ESCAPE_DOTS ? subst(path, ".", "\\lyxdot ") : path;
102 }
103
104
105 // Substitutes spaces with underscores in filename (and path)
106 FileName const makeLatexName(FileName const & file)
107 {
108         string name = file.onlyFileName();
109         string const path = file.onlyPath().absFilename() + "/";
110
111         // ok so we scan through the string twice, but who cares.
112         // FIXME: in Unicode time this will break for sure! There is
113         // a non-latin world out there...
114         string const keep = "abcdefghijklmnopqrstuvwxyz"
115                 "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
116                 "@!'()*+,-./0123456789:;<=>?[]`|";
117
118         string::size_type pos = 0;
119         while ((pos = name.find_first_not_of(keep, pos)) != string::npos)
120                 name[pos++] = '_';
121
122         FileName latex_name(path + name);
123         latex_name.changeExtension(".tex");
124         return latex_name;
125 }
126
127
128 string const quoteName(string const & name, quote_style style)
129 {
130         switch(style) {
131         case quote_shell:
132                 // This does not work for filenames containing " (windows)
133                 // or ' (all other OSes). This can't be changed easily, since
134                 // we would need to adapt the command line parser in
135                 // Forkedcall::generateChild. Therefore we don't pass user
136                 // filenames to child processes if possible. We store them in
137                 // a python script instead, where we don't have these
138                 // limitations.
139                 return (os::shell() == os::UNIX) ?
140                         '\'' + name + '\'':
141                         '"' + name + '"';
142         case quote_python:
143                 return "\"" + subst(subst(name, "\\", "\\\\"), "\"", "\\\"")
144                      + "\"";
145         }
146         // shut up stupid compiler
147         return string();
148 }
149
150
151 #if 0
152 // Uses a string of paths separated by ";"s to find a file to open.
153 // Can't cope with pathnames with a ';' in them. Returns full path to file.
154 // If path entry begins with $$LyX/, use system_lyxdir
155 // If path entry begins with $$User/, use user_lyxdir
156 // Example: "$$User/doc;$$LyX/doc"
157 FileName const fileOpenSearch(string const & path, string const & name,
158                              string const & ext)
159 {
160         FileName real_file;
161         string path_element;
162         bool notfound = true;
163         string tmppath = split(path, path_element, ';');
164
165         while (notfound && !path_element.empty()) {
166                 path_element = os::internal_path(path_element);
167                 if (!suffixIs(path_element, '/'))
168                         path_element += '/';
169                 path_element = subst(path_element, "$$LyX",
170                                      package().system_support().absFilename());
171                 path_element = subst(path_element, "$$User",
172                                      package().user_support().absFilename());
173
174                 real_file = fileSearch(path_element, name, ext);
175
176                 if (real_file.empty()) {
177                         do {
178                                 tmppath = split(tmppath, path_element, ';');
179                         } while (!tmppath.empty() && path_element.empty());
180                 } else {
181                         notfound = false;
182                 }
183         }
184         return real_file;
185 }
186 #endif
187
188
189 // Returns the real name of file name in directory path, with optional
190 // extension ext.
191 FileName const fileSearch(string const & path, string const & name,
192                           string const & ext, search_mode mode)
193 {
194         // if `name' is an absolute path, we ignore the setting of `path'
195         // Expand Environmentvariables in 'name'
196         string const tmpname = replaceEnvironmentPath(name);
197         FileName fullname(makeAbsPath(tmpname, path));
198         // search first without extension, then with it.
199         if (fullname.isReadableFile())
200                 return fullname;
201         if (ext.empty())
202                 // We are done.
203                 return mode == allow_unreadable ? fullname : FileName();
204         // Only add the extension if it is not already the extension of
205         // fullname.
206         if (getExtension(fullname.absFilename()) != ext)
207                 fullname = FileName(addExtension(fullname.absFilename(), ext));
208         if (fullname.isReadableFile() || mode == allow_unreadable)
209                 return fullname;
210         return FileName();
211 }
212
213
214 // Search the file name.ext in the subdirectory dir of
215 //   1) user_lyxdir
216 //   2) build_lyxdir (if not empty)
217 //   3) system_lyxdir
218 FileName const libFileSearch(string const & dir, string const & name,
219                            string const & ext)
220 {
221         FileName fullname = fileSearch(addPath(package().user_support().absFilename(), dir),
222                                      name, ext);
223         if (!fullname.empty())
224                 return fullname;
225
226         if (!package().build_support().empty())
227                 fullname = fileSearch(addPath(package().build_support().absFilename(), dir),
228                                       name, ext);
229         if (!fullname.empty())
230                 return fullname;
231
232         return fileSearch(addPath(package().system_support().absFilename(), dir), name, ext);
233 }
234
235
236 FileName const i18nLibFileSearch(string const & dir, string const & name,
237                   string const & ext)
238 {
239         /* The highest priority value is the `LANGUAGE' environment
240            variable. But we don't use the value if the currently
241            selected locale is the C locale. This is a GNU extension.
242
243            Otherwise, w use a trick to guess what support/gettext.has done:
244            each po file is able to tell us its name. (JMarc)
245         */
246
247         string lang = to_ascii(_("[[Replace with the code of your language]]"));
248         string const language = getEnv("LANGUAGE");
249         if (!lang.empty() && !language.empty())
250                 lang = language;
251
252         string l;
253         lang = split(lang, l, ':');
254         while (!l.empty()) {
255                 FileName tmp;
256                 // First try with the full name
257                 tmp = libFileSearch(addPath(dir, l), name, ext);
258                 if (!tmp.empty())
259                         return tmp;
260
261                 // Then the name without country code
262                 string const shortl = token(l, '_', 0);
263                 if (shortl != l) {
264                         tmp = libFileSearch(addPath(dir, shortl), name, ext);
265                         if (!tmp.empty())
266                                 return tmp;
267                 }
268
269 #if 1
270                 // For compatibility, to be removed later (JMarc)
271                 tmp = libFileSearch(dir, token(l, '_', 0) + '_' + name,
272                                     ext);
273                 if (!tmp.empty()) {
274                         lyxerr << "i18nLibFileSearch: File `" << tmp
275                                << "' has been found by the old method" <<endl;
276                         return tmp;
277                 }
278 #endif
279                 lang = split(lang, l, ':');
280         }
281
282         return libFileSearch(dir, name, ext);
283 }
284
285
286 string const libScriptSearch(string const & command_in, quote_style style)
287 {
288         static string const token_scriptpath = "$$s/";
289
290         string command = command_in;
291         // Find the starting position of "$$s/"
292         string::size_type const pos1 = command.find(token_scriptpath);
293         if (pos1 == string::npos)
294                 return command;
295         // Find the end of the "$$s/some_subdir/some_script" word within
296         // command. Assumes that the script name does not contain spaces.
297         string::size_type const start_script = pos1 + 4;
298         string::size_type const pos2 = command.find(' ', start_script);
299         string::size_type const size_script = pos2 == string::npos?
300                 (command.size() - start_script) : pos2 - start_script;
301
302         // Does this script file exist?
303         string const script =
304                 libFileSearch(".", command.substr(start_script, size_script)).absFilename();
305
306         if (script.empty()) {
307                 // Replace "$$s/" with ""
308                 command.erase(pos1, 4);
309         } else {
310                 // Replace "$$s/foo/some_script" with "<path to>/some_script".
311                 string::size_type const size_replace = size_script + 4;
312                 command.replace(pos1, size_replace, quoteName(script, style));
313         }
314
315         return command;
316 }
317
318
319 static FileName createTmpDir(FileName const & tempdir, string const & mask)
320 {
321         LYXERR(Debug::FILES, "createTmpDir: tempdir=`" << tempdir << "'\n"
322                 << "createTmpDir:    mask=`" << mask << '\'');
323
324         FileName const tmpfl = FileName::tempName(tempdir.absFilename()
325                 + "/" + mask);
326         // FileName::tempName actually creates a file to make sure that it
327         // stays unique. So we have to delete it before we can create
328         // a dir with the same name. Note also that we are not thread
329         // safe because of the gap between unlink and mkdir. (Lgb)
330         tmpfl.removeFile();
331
332         if (tmpfl.empty() || !tmpfl.createDirectory(0700)) {
333                 lyxerr << "LyX could not create the temporary directory '"
334                        << tmpfl << "'" << endl;
335                 return FileName();
336         }
337
338         return tmpfl;
339 }
340
341 string const createBufferTmpDir()
342 {
343         static int count;
344         // We are in our own directory.  Why bother to mangle name?
345         // In fact I wrote this code to circumvent a problematic behaviour
346         // (bug?) of EMX mkstemp().
347         string const tmpfl =
348                 package().temp_dir().absFilename() + "/lyx_tmpbuf" +
349                 convert<string>(count++);
350
351         if (!FileName(tmpfl).createDirectory(0777)) {
352                 lyxerr << "LyX could not create the temporary directory '"
353                        << tmpfl << "'" << endl;
354                 return string();
355         }
356         return tmpfl;
357 }
358
359
360 FileName const createLyXTmpDir(FileName const & deflt)
361 {
362         if (deflt.empty() || deflt.absFilename() == "/tmp")
363                 return createTmpDir(FileName("/tmp"), "lyx_tmpdir");
364
365         if (deflt.createDirectory(0777)) 
366                 return deflt;
367
368         if (deflt.isDirWritable()) {
369                 // deflt could not be created because it
370                 // did exist already, so let's create our own
371                 // dir inside deflt.
372                 return createTmpDir(deflt, "lyx_tmpdir");
373         } else {
374                 // some other error occured.
375                 return createTmpDir(FileName("/tmp"), "lyx_tmpdir");
376         }
377 }
378
379
380 // Strip filename from path name
381 string const onlyPath(string const & filename)
382 {
383         // If empty filename, return empty
384         if (filename.empty())
385                 return filename;
386
387         // Find last / or start of filename
388         size_t j = filename.rfind('/');
389         return j == string::npos ? "./" : filename.substr(0, j + 1);
390 }
391
392
393 // Convert relative path into absolute path based on a basepath.
394 // If relpath is absolute, just use that.
395 // If basepath is empty, use CWD as base.
396 FileName const makeAbsPath(string const & relPath, string const & basePath)
397 {
398         FileName relative_path(relPath);
399         // checks for already absolute path
400         if (relative_path.isAbsolute())
401                 return relative_path;
402
403         // Copies given paths
404         string tempRel = os::internal_path(relPath);
405         // Since TempRel is NOT absolute, we can safely replace "//" with "/"
406         tempRel = subst(tempRel, "//", "/");
407
408         string tempBase;
409
410         FileName base_path(basePath);
411         if (base_path.isAbsolute())
412                 tempBase = basePath;
413         else
414                 tempBase = addPath(FileName::getcwd().absFilename(), basePath);
415
416         // Handle /./ at the end of the path
417         while (suffixIs(tempBase, "/./"))
418                 tempBase.erase(tempBase.length() - 2);
419
420         // processes relative path
421         string rTemp = tempRel;
422         string temp;
423
424         while (!rTemp.empty()) {
425                 // Split by next /
426                 rTemp = split(rTemp, temp, '/');
427
428                 if (temp == ".") continue;
429                 if (temp == "..") {
430                         // Remove one level of TempBase
431                         string::difference_type i = tempBase.length() - 2;
432                         if (i < 0)
433                                 i = 0;
434                         while (i > 0 && tempBase[i] != '/')
435                                 --i;
436                         if (i > 0)
437                                 tempBase.erase(i, string::npos);
438                         else
439                                 tempBase += '/';
440                 } else if (temp.empty() && !rTemp.empty()) {
441                                 tempBase = os::current_root() + rTemp;
442                                 rTemp.erase();
443                 } else {
444                         // Add this piece to TempBase
445                         if (!suffixIs(tempBase, '/'))
446                                 tempBase += '/';
447                         tempBase += temp;
448                 }
449         }
450
451         // returns absolute path
452         return FileName(tempBase);
453 }
454
455
456 // Correctly append filename to the pathname.
457 // If pathname is '.', then don't use pathname.
458 // Chops any path of filename.
459 string const addName(string const & path, string const & fname)
460 {
461         string const basename = onlyFilename(fname);
462         string buf;
463
464         if (path != "." && path != "./" && !path.empty()) {
465                 buf = os::internal_path(path);
466                 if (!suffixIs(path, '/'))
467                         buf += '/';
468         }
469
470         return buf + basename;
471 }
472
473
474 // Strips path from filename
475 string const onlyFilename(string const & fname)
476 {
477         if (fname.empty())
478                 return fname;
479
480         string::size_type j = fname.rfind('/');
481         if (j == string::npos) // no '/' in fname
482                 return fname;
483
484         // Strip to basename
485         return fname.substr(j + 1);
486 }
487
488
489 // Create absolute path. If impossible, don't do anything
490 // Supports ./ and ~/. Later we can add support for ~logname/. (Asger)
491 string const expandPath(string const & path)
492 {
493         // checks for already absolute path
494         string rTemp = replaceEnvironmentPath(path);
495         FileName abs_path(rTemp);
496         if (abs_path.isAbsolute())
497                 return rTemp;
498
499         string temp;
500         string const copy = rTemp;
501
502         // Split by next /
503         rTemp = split(rTemp, temp, '/');
504
505         if (temp == ".")
506                 return FileName::getcwd().absFilename() + '/' + rTemp;
507
508         if (temp == "~")
509                 return package().home_dir().absFilename() + '/' + rTemp;
510
511         if (temp == "..")
512                 return makeAbsPath(copy).absFilename();
513
514         // Don't know how to handle this
515         return copy;
516 }
517
518
519 // Search the string for ${VAR} and $VAR and replace VAR using getenv.
520 string const replaceEnvironmentPath(string const & path)
521 {
522         // ${VAR} is defined as
523         // $\{[A-Za-z_][A-Za-z_0-9]*\}
524         static string const envvar_br = "[$]\\{([A-Za-z_][A-Za-z_0-9]*)\\}";
525
526         // $VAR is defined as:
527         // $\{[A-Za-z_][A-Za-z_0-9]*\}
528         static string const envvar = "[$]([A-Za-z_][A-Za-z_0-9]*)";
529
530         static boost::regex envvar_br_re("(.*)" + envvar_br + "(.*)");
531         static boost::regex envvar_re("(.*)" + envvar + "(.*)");
532         boost::smatch what;
533
534         string result = path;
535         while (1) {
536                 regex_match(result, what, envvar_br_re);
537                 if (!what[0].matched) {
538                         regex_match(result, what, envvar_re);
539                         if (!what[0].matched)
540                                 break;
541                 }
542                 result = what.str(1) + getEnv(what.str(2)) + what.str(3);
543         }
544         return result;
545 }
546
547
548 // Make relative path out of two absolute paths
549 docstring const makeRelPath(docstring const & abspath, docstring const & basepath)
550 // Makes relative path out of absolute path. If it is deeper than basepath,
551 // it's easy. If basepath and abspath share something (they are all deeper
552 // than some directory), it'll be rendered using ..'s. If they are completely
553 // different, then the absolute path will be used as relative path.
554 {
555         docstring::size_type const abslen = abspath.length();
556         docstring::size_type const baselen = basepath.length();
557
558         docstring::size_type i = os::common_path(abspath, basepath);
559
560         if (i == 0) {
561                 // actually no match - cannot make it relative
562                 return abspath;
563         }
564
565         // Count how many dirs there are in basepath above match
566         // and append as many '..''s into relpath
567         docstring buf;
568         docstring::size_type j = i;
569         while (j < baselen) {
570                 if (basepath[j] == '/') {
571                         if (j + 1 == baselen)
572                                 break;
573                         buf += "../";
574                 }
575                 ++j;
576         }
577
578         // Append relative stuff from common directory to abspath
579         if (abspath[i] == '/')
580                 ++i;
581         for (; i < abslen; ++i)
582                 buf += abspath[i];
583         // Remove trailing /
584         if (suffixIs(buf, '/'))
585                 buf.erase(buf.length() - 1);
586         // Substitute empty with .
587         if (buf.empty())
588                 buf = '.';
589         return buf;
590 }
591
592
593 // Append sub-directory(ies) to a path in an intelligent way
594 string const addPath(string const & path, string const & path_2)
595 {
596         string buf;
597         string const path2 = os::internal_path(path_2);
598
599         if (!path.empty() && path != "." && path != "./") {
600                 buf = os::internal_path(path);
601                 if (path[path.length() - 1] != '/')
602                         buf += '/';
603         }
604
605         if (!path2.empty()) {
606                 string::size_type const p2start = path2.find_first_not_of('/');
607                 string::size_type const p2end = path2.find_last_not_of('/');
608                 string const tmp = path2.substr(p2start, p2end - p2start + 1);
609                 buf += tmp + '/';
610         }
611         return buf;
612 }
613
614
615 string const changeExtension(string const & oldname, string const & extension)
616 {
617         string::size_type const last_slash = oldname.rfind('/');
618         string::size_type last_dot = oldname.rfind('.');
619         if (last_dot < last_slash && last_slash != string::npos)
620                 last_dot = string::npos;
621
622         string ext;
623         // Make sure the extension starts with a dot
624         if (!extension.empty() && extension[0] != '.')
625                 ext= '.' + extension;
626         else
627                 ext = extension;
628
629         return os::internal_path(oldname.substr(0, last_dot) + ext);
630 }
631
632
633 string const removeExtension(string const & name)
634 {
635         return changeExtension(name, string());
636 }
637
638
639 string const addExtension(string const & name, string const & extension)
640 {
641         if (!extension.empty() && extension[0] != '.')
642                 return name + '.' + extension;
643         return name + extension;
644 }
645
646
647 /// Return the extension of the file (not including the .)
648 string const getExtension(string const & name)
649 {
650         string::size_type const last_slash = name.rfind('/');
651         string::size_type const last_dot = name.rfind('.');
652         if (last_dot != string::npos &&
653             (last_slash == string::npos || last_dot > last_slash))
654                 return name.substr(last_dot + 1,
655                                    name.length() - (last_dot + 1));
656         else
657                 return string();
658 }
659
660
661 string const unzippedFileName(string const & zipped_file)
662 {
663         string const ext = getExtension(zipped_file);
664         if (ext == "gz" || ext == "z" || ext == "Z")
665                 return changeExtension(zipped_file, string());
666         return "unzipped_" + zipped_file;
667 }
668
669
670 FileName const unzipFile(FileName const & zipped_file, string const & unzipped_file)
671 {
672         FileName const tempfile = FileName(unzipped_file.empty() ?
673                 unzippedFileName(zipped_file.toFilesystemEncoding()) :
674                 unzipped_file);
675         // Run gunzip
676         string const command = "gunzip -c " +
677                 zipped_file.toFilesystemEncoding() + " > " +
678                 tempfile.toFilesystemEncoding();
679         Systemcall one;
680         one.startscript(Systemcall::Wait, command);
681         // test that command was executed successfully (anon)
682         // yes, please do. (Lgb)
683         return tempfile;
684 }
685
686
687 docstring const makeDisplayPath(string const & path, unsigned int threshold)
688 {
689         string str = path;
690
691         // If file is from LyXDir, display it as if it were relative.
692         string const system = package().system_support().absFilename();
693         if (prefixIs(str, system) && str != system)
694                 return from_utf8("[" + str.erase(0, system.length()) + "]");
695
696         // replace /home/blah with ~/
697         string const home = package().home_dir().absFilename();
698         if (!home.empty() && prefixIs(str, home))
699                 str = subst(str, home, "~");
700
701         if (str.length() <= threshold)
702                 return from_utf8(os::external_path(str));
703
704         string const prefix = ".../";
705         string temp;
706
707         while (str.length() > threshold)
708                 str = split(str, temp, '/');
709
710         // Did we shorten everything away?
711         if (str.empty()) {
712                 // Yes, filename itself is too long.
713                 // Pick the start and the end of the filename.
714                 str = onlyFilename(path);
715                 string const head = str.substr(0, threshold / 2 - 3);
716
717                 string::size_type len = str.length();
718                 string const tail =
719                         str.substr(len - threshold / 2 - 2, len - 1);
720                 str = head + "..." + tail;
721         }
722
723         return from_utf8(os::external_path(prefix + str));
724 }
725
726
727 bool readLink(FileName const & file, FileName & link)
728 {
729 #ifdef HAVE_READLINK
730         char linkbuffer[512];
731         // Should be PATH_MAX but that needs autconf support
732         string const encoded = file.toFilesystemEncoding();
733         int const nRead = ::readlink(encoded.c_str(),
734                                      linkbuffer, sizeof(linkbuffer) - 1);
735         if (nRead <= 0)
736                 return false;
737         linkbuffer[nRead] = '\0'; // terminator
738         link = makeAbsPath(linkbuffer, onlyPath(file.absFilename()));
739         return true;
740 #else
741         return false;
742 #endif
743 }
744
745
746 cmd_ret const runCommand(string const & cmd)
747 {
748         // FIXME: replace all calls to RunCommand with ForkedCall
749         // (if the output is not needed) or the code in ISpell.cpp
750         // (if the output is needed).
751
752         // One question is if we should use popen or
753         // create our own popen based on fork, exec, pipe
754         // of course the best would be to have a
755         // pstream (process stream), with the
756         // variants ipstream, opstream
757
758 #if defined (HAVE_POPEN)
759         FILE * inf = ::popen(cmd.c_str(), os::popen_read_mode());
760 #elif defined (HAVE__POPEN)
761         FILE * inf = ::_popen(cmd.c_str(), os::popen_read_mode());
762 #else
763 #error No popen() function.
764 #endif
765
766         // (Claus Hentschel) Check if popen was succesful ;-)
767         if (!inf) {
768                 lyxerr << "RunCommand:: could not start child process" << endl;
769                 return make_pair(-1, string());
770         }
771
772         string ret;
773         int c = fgetc(inf);
774         while (c != EOF) {
775                 ret += static_cast<char>(c);
776                 c = fgetc(inf);
777         }
778
779 #if defined (HAVE_PCLOSE)
780         int const pret = pclose(inf);
781 #elif defined (HAVE__PCLOSE)
782         int const pret = _pclose(inf);
783 #else
784 #error No pclose() function.
785 #endif
786
787         if (pret == -1)
788                 perror("RunCommand:: could not terminate child process");
789
790         return make_pair(pret, ret);
791 }
792
793
794 FileName const findtexfile(string const & fil, string const & /*format*/)
795 {
796         /* There is no problem to extend this function too use other
797            methods to look for files. It could be setup to look
798            in environment paths and also if wanted as a last resort
799            to a recursive find. One of the easier extensions would
800            perhaps be to use the LyX file lookup methods. But! I am
801            going to implement this until I see some demand for it.
802            Lgb
803         */
804
805         // If the file can be found directly, we just return a
806         // absolute path version of it.
807         FileName const absfile(makeAbsPath(fil));
808         if (absfile.exists())
809                 return absfile;
810
811         // No we try to find it using kpsewhich.
812         // It seems from the kpsewhich manual page that it is safe to use
813         // kpsewhich without --format: "When the --format option is not
814         // given, the search path used when looking for a file is inferred
815         // from the name given, by looking for a known extension. If no
816         // known extension is found, the search path for TeX source files
817         // is used."
818         // However, we want to take advantage of the format sine almost all
819         // the different formats has environment variables that can be used
820         // to controll which paths to search. f.ex. bib looks in
821         // BIBINPUTS and TEXBIB. Small list follows:
822         // bib - BIBINPUTS, TEXBIB
823         // bst - BSTINPUTS
824         // graphic/figure - TEXPICTS, TEXINPUTS
825         // ist - TEXINDEXSTYLE, INDEXSTYLE
826         // pk - PROGRAMFONTS, PKFONTS, TEXPKS, GLYPHFONTS, TEXFONTS
827         // tex - TEXINPUTS
828         // tfm - TFMFONTS, TEXFONTS
829         // This means that to use kpsewhich in the best possible way we
830         // should help it by setting additional path in the approp. envir.var.
831         string const kpsecmd = "kpsewhich " + fil;
832
833         cmd_ret const c = runCommand(kpsecmd);
834
835         LYXERR(Debug::LATEX, "kpse status = " << c.first << '\n'
836                  << "kpse result = `" << rtrim(c.second, "\n\r") << '\'');
837         if (c.first != -1)
838                 return FileName(rtrim(to_utf8(from_filesystem8bit(c.second)), "\n\r"));
839         else
840                 return FileName();
841 }
842
843
844 void removeAutosaveFile(string const & filename)
845 {
846         string a = onlyPath(filename);
847         a += '#';
848         a += onlyFilename(filename);
849         a += '#';
850         FileName const autosave(a);
851         if (autosave.exists())
852                 autosave.removeFile();
853 }
854
855
856 void readBB_lyxerrMessage(FileName const & file, bool & zipped,
857         string const & message)
858 {
859         LYXERR(Debug::GRAPHICS, "[readBB_from_PSFile] " << message);
860         // FIXME: Why is this func deleting a file? (Lgb)
861         if (zipped)
862                 file.removeFile();
863 }
864
865
866 string const readBB_from_PSFile(FileName const & file)
867 {
868         // in a (e)ps-file it's an entry like %%BoundingBox:23 45 321 345
869         // It seems that every command in the header has an own line,
870         // getline() should work for all files.
871         // On the other hand some plot programs write the bb at the
872         // end of the file. Than we have in the header:
873         // %%BoundingBox: (atend)
874         // In this case we must check the end.
875         bool zipped = file.isZippedFile();
876         FileName const file_ = zipped ? unzipFile(file) : file;
877         string const format = file_.guessFormatFromContents();
878
879         if (format != "eps" && format != "ps") {
880                 readBB_lyxerrMessage(file_, zipped,"no(e)ps-format");
881                 return string();
882         }
883
884         static boost::regex bbox_re(
885                 "^%%BoundingBox:\\s*([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)");
886         ifstream is(file_.toFilesystemEncoding().c_str());
887         while (is) {
888                 string s;
889                 getline(is,s);
890                 boost::smatch what;
891                 if (regex_match(s, what, bbox_re)) {
892                         // Our callers expect the tokens in the string
893                         // separated by single spaces.
894                         // FIXME: change return type from string to something
895                         // sensible
896                         ostringstream os;
897                         os << what.str(1) << ' ' << what.str(2) << ' '
898                            << what.str(3) << ' ' << what.str(4);
899                         string const bb = os.str();
900                         readBB_lyxerrMessage(file_, zipped, bb);
901                         return bb;
902                 }
903         }
904         readBB_lyxerrMessage(file_, zipped, "no bb found");
905         return string();
906 }
907
908
909 int compare_timestamps(FileName const & file1, FileName const & file2)
910 {
911         // If the original is newer than the copy, then copy the original
912         // to the new directory.
913
914         int cmp = 0;
915         if (file1.exists() && file2.exists()) {
916                 double const tmp = difftime(file1.lastModified(), file2.lastModified());
917                 if (tmp != 0)
918                         cmp = tmp > 0 ? 1 : -1;
919
920         } else if (file1.exists()) {
921                 cmp = 1;
922         } else if (file2.exists()) {
923                 cmp = -1;
924         }
925
926         return cmp;
927 }
928
929
930 } //namespace support
931 } // namespace lyx