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 "support/lassert.h"
  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 == may_not_exist ? 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 == may_not_exist)
 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         string const tmp_dir = tempdir.absFilename() + "/" + mask;
 325         FileName const tmpfl = FileName::tempName(tmp_dir);
 326
 327         if (tmpfl.empty() || !tmpfl.createDirectory(0700)) {
 328                 LYXERR0("LyX could not create the temporary directory '" << tmp_dir
 329                         << "'");
 330                 return FileName();
 331         }
 332
 333         return tmpfl;
 334 }
 335
 336
 337 FileName const createLyXTmpDir(FileName const & deflt)
 338 {
 339         if (deflt.empty() || deflt == package().system_temp_dir())
 340                 return createTmpDir(package().system_temp_dir(), "lyx_tmpdir");
 341
 342         if (deflt.createDirectory(0777))
 343                 return deflt;
 344
 345         if (deflt.isDirWritable()) {
 346                 // deflt could not be created because it
 347                 // did exist already, so let's create our own
 348                 // dir inside deflt.
 349                 return createTmpDir(deflt, "lyx_tmpdir");
 350         } else {
 351                 // some other error occured.
 352                 return createTmpDir(package().system_temp_dir(), "lyx_tmpdir");
 353         }
 354 }
 355
 356
 357 // Strip filename from path name
 358 string const onlyPath(string const & filename)
 359 {
 360         // If empty filename, return empty
 361         if (filename.empty())
 362                 return filename;
 363
 364         // Find last / or start of filename
 365         size_t j = filename.rfind('/');
 366         return j == string::npos ? "./" : filename.substr(0, j + 1);
 367 }
 368
 369
 370 // Convert relative path into absolute path based on a basepath.
 371 // If relpath is absolute, just use that.
 372 // If basepath is empty, use CWD as base.
 373 // Note that basePath can be a relative path, in the sense that it may
 374 // not begin with "/" (e.g.), but it should NOT contain such constructs
 375 // as "/../".
 376 // FIXME It might be nice if the code didn't simply assume that.
 377 FileName const makeAbsPath(string const & relPath, string const & basePath)
 378 {
 379         FileName relative_path(relPath);
 380         // checks for already absolute path
 381         if (relative_path.isAbsolute())
 382                 return relative_path;
 383
 384         // Copies given paths
 385         string tempRel = os::internal_path(relPath);
 386         // Since TempRel is NOT absolute, we can safely replace "//" with "/"
 387         tempRel = subst(tempRel, "//", "/");
 388
 389         string tempBase;
 390
 391         FileName base_path(basePath);
 392         if (base_path.isAbsolute())
 393                 tempBase = basePath;
 394         else
 395                 tempBase = addPath(FileName::getcwd().absFilename(), basePath);
 396
 397         // Handle /./ at the end of the path
 398         while (suffixIs(tempBase, "/./"))
 399                 tempBase.erase(tempBase.length() - 2);
 400
 401         // processes relative path
 402         string rTemp = tempRel;
 403         string temp;
 404
 405         // Check for a leading "~"
 406         // Split by first /
 407         rTemp = split(rTemp, temp, '/');
 408         if (temp == "~") {
 409                 tempBase = package().home_dir().absFilename();
 410                 tempRel = rTemp;
 411         }
 412
 413         rTemp = tempRel;
 414         while (!rTemp.empty()) {
 415                 // Split by next /
 416                 rTemp = split(rTemp, temp, '/');
 417
 418                 if (temp == ".") continue;
 419                 if (temp == "..") {
 420                         // Remove one level of TempBase
 421                         if (tempBase.length() <= 1) {
 422                                 //this is supposed to be an absolute path, so...
 423                                 tempBase = "/";
 424                                 continue;
 425                         }
 426                         //erase a trailing slash if there is one
 427                         if (suffixIs(tempBase, "/"))
 428                                 tempBase.erase(tempBase.length() - 1, string::npos);
 429
 430                         string::size_type i = tempBase.length() - 1;
 431                         while (i > 0 && tempBase[i] != '/')
 432                                 --i;
 433                         if (i > 0)
 434                                 tempBase.erase(i, string::npos);
 435                         else
 436                                 tempBase = '/';
 437                 } else if (temp.empty() && !rTemp.empty()) {
 438                                 tempBase = os::current_root() + rTemp;
 439                                 rTemp.erase();
 440                 } else {
 441                         // Add this piece to TempBase
 442                         if (!suffixIs(tempBase, '/'))
 443                                 tempBase += '/';
 444                         tempBase += temp;
 445                 }
 446         }
 447
 448         // returns absolute path
 449         return FileName(tempBase);
 450 }
 451
 452
 453 // Correctly append filename to the pathname.
 454 // If pathname is '.', then don't use pathname.
 455 // Chops any path of filename.
 456 string const addName(string const & path, string const & fname)
 457 {
 458         string const basename = onlyFilename(fname);
 459         string buf;
 460
 461         if (path != "." && path != "./" && !path.empty()) {
 462                 buf = os::internal_path(path);
 463                 if (!suffixIs(path, '/'))
 464                         buf += '/';
 465         }
 466
 467         return buf + basename;
 468 }
 469
 470
 471 // Strips path from filename
 472 string const onlyFilename(string const & fname)
 473 {
 474         if (fname.empty())
 475                 return fname;
 476
 477         string::size_type j = fname.rfind('/');
 478         if (j == string::npos) // no '/' in fname
 479                 return fname;
 480
 481         // Strip to basename
 482         return fname.substr(j + 1);
 483 }
 484
 485
 486 // Create absolute path. If impossible, don't do anything
 487 // Supports ./ and ~/. Later we can add support for ~logname/. (Asger)
 488 string const expandPath(string const & path)
 489 {
 490         // checks for already absolute path
 491         string rTemp = replaceEnvironmentPath(path);
 492         FileName abs_path(rTemp);
 493         if (abs_path.isAbsolute())
 494                 return rTemp;
 495
 496         string temp;
 497         string const copy = rTemp;
 498
 499         // Split by next /
 500         rTemp = split(rTemp, temp, '/');
 501
 502         if (temp == ".")
 503                 return FileName::getcwd().absFilename() + '/' + rTemp;
 504
 505         if (temp == "~")
 506                 return package().home_dir().absFilename() + '/' + rTemp;
 507
 508         if (temp == "..")
 509                 return makeAbsPath(copy).absFilename();
 510
 511         // Don't know how to handle this
 512         return copy;
 513 }
 514
 515
 516 // Search the string for ${VAR} and $VAR and replace VAR using getenv.
 517 string const replaceEnvironmentPath(string const & path)
 518 {
 519         // ${VAR} is defined as
 520         // $\{[A-Za-z_][A-Za-z_0-9]*\}
 521         static string const envvar_br = "[$]\\{([A-Za-z_][A-Za-z_0-9]*)\\}";
 522
 523         // $VAR is defined as:
 524         // $\{[A-Za-z_][A-Za-z_0-9]*\}
 525         static string const envvar = "[$]([A-Za-z_][A-Za-z_0-9]*)";
 526
 527         static boost::regex envvar_br_re("(.*)" + envvar_br + "(.*)");
 528         static boost::regex envvar_re("(.*)" + envvar + "(.*)");
 529         boost::smatch what;
 530
 531         string result = path;
 532         while (1) {
 533                 regex_match(result, what, envvar_br_re);
 534                 if (!what[0].matched) {
 535                         regex_match(result, what, envvar_re);
 536                         if (!what[0].matched)
 537                                 break;
 538                 }
 539                 result = what.str(1) + getEnv(what.str(2)) + what.str(3);
 540         }
 541         return result;
 542 }
 543
 544
 545 // Make relative path out of two absolute paths
 546 docstring const makeRelPath(docstring const & abspath, docstring const & basepath)
 547 // Makes relative path out of absolute path. If it is deeper than basepath,
 548 // it's easy. If basepath and abspath share something (they are all deeper
 549 // than some directory), it'll be rendered using ..'s. If they are completely
 550 // different, then the absolute path will be used as relative path.
 551 {
 552         docstring::size_type const abslen = abspath.length();
 553         docstring::size_type const baselen = basepath.length();
 554
 555         docstring::size_type i = os::common_path(abspath, basepath);
 556
 557         if (i == 0) {
 558                 // actually no match - cannot make it relative
 559                 return abspath;
 560         }
 561
 562         // Count how many dirs there are in basepath above match
 563         // and append as many '..''s into relpath
 564         docstring buf;
 565         docstring::size_type j = i;
 566         while (j < baselen) {
 567                 if (basepath[j] == '/') {
 568                         if (j + 1 == baselen)
 569                                 break;
 570                         buf += "../";
 571                 }
 572                 ++j;
 573         }
 574
 575         // Append relative stuff from common directory to abspath
 576         if (abspath[i] == '/')
 577                 ++i;
 578         for (; i < abslen; ++i)
 579                 buf += abspath[i];
 580         // Remove trailing /
 581         if (suffixIs(buf, '/'))
 582                 buf.erase(buf.length() - 1);
 583         // Substitute empty with .
 584         if (buf.empty())
 585                 buf = '.';
 586         return buf;
 587 }
 588
 589
 590 // Append sub-directory(ies) to a path in an intelligent way
 591 string const addPath(string const & path, string const & path_2)
 592 {
 593         string buf;
 594         string const path2 = os::internal_path(path_2);
 595
 596         if (!path.empty() && path != "." && path != "./") {
 597                 buf = os::internal_path(path);
 598                 if (path[path.length() - 1] != '/')
 599                         buf += '/';
 600         }
 601
 602         if (!path2.empty()) {
 603                 string::size_type const p2start = path2.find_first_not_of('/');
 604                 string::size_type const p2end = path2.find_last_not_of('/');
 605                 string const tmp = path2.substr(p2start, p2end - p2start + 1);
 606                 buf += tmp + '/';
 607         }
 608         return buf;
 609 }
 610
 611
 612 string const changeExtension(string const & oldname, string const & extension)
 613 {
 614         string::size_type const last_slash = oldname.rfind('/');
 615         string::size_type last_dot = oldname.rfind('.');
 616         if (last_dot < last_slash && last_slash != string::npos)
 617                 last_dot = string::npos;
 618
 619         string ext;
 620         // Make sure the extension starts with a dot
 621         if (!extension.empty() && extension[0] != '.')
 622                 ext= '.' + extension;
 623         else
 624                 ext = extension;
 625
 626         return os::internal_path(oldname.substr(0, last_dot) + ext);
 627 }
 628
 629
 630 string const removeExtension(string const & name)
 631 {
 632         return changeExtension(name, string());
 633 }
 634
 635
 636 string const addExtension(string const & name, string const & extension)
 637 {
 638         if (!extension.empty() && extension[0] != '.')
 639                 return name + '.' + extension;
 640         return name + extension;
 641 }
 642
 643
 644 /// Return the extension of the file (not including the .)
 645 string const getExtension(string const & name)
 646 {
 647         string::size_type const last_slash = name.rfind('/');
 648         string::size_type const last_dot = name.rfind('.');
 649         if (last_dot != string::npos &&
 650             (last_slash == string::npos || last_dot > last_slash))
 651                 return name.substr(last_dot + 1,
 652                                    name.length() - (last_dot + 1));
 653         else
 654                 return string();
 655 }
 656
 657
 658 string const unzippedFileName(string const & zipped_file)
 659 {
 660         string const ext = getExtension(zipped_file);
 661         if (ext == "gz" || ext == "z" || ext == "Z")
 662                 return changeExtension(zipped_file, string());
 663         return onlyPath(zipped_file) + "unzipped_" + onlyFilename(zipped_file);
 664 }
 665
 666
 667 FileName const unzipFile(FileName const & zipped_file, string const & unzipped_file)
 668 {
 669         FileName const tempfile = FileName(unzipped_file.empty() ?
 670                 unzippedFileName(zipped_file.toFilesystemEncoding()) :
 671                 unzipped_file);
 672         // Run gunzip
 673         string const command = "gunzip -c " +
 674                 zipped_file.toFilesystemEncoding() + " > " +
 675                 tempfile.toFilesystemEncoding();
 676         Systemcall one;
 677         one.startscript(Systemcall::Wait, command);
 678         // test that command was executed successfully (anon)
 679         // yes, please do. (Lgb)
 680         return tempfile;
 681 }
 682
 683
 684 docstring const makeDisplayPath(string const & path, unsigned int threshold)
 685 {
 686         string str = path;
 687
 688         // If file is from LyXDir, display it as if it were relative.
 689         string const system = package().system_support().absFilename();
 690         if (prefixIs(str, system) && str != system)
 691                 return from_utf8("[" + str.erase(0, system.length()) + "]");
 692
 693         // replace /home/blah with ~/
 694         string const home = package().home_dir().absFilename();
 695         if (!home.empty() && prefixIs(str, home))
 696                 str = subst(str, home, "~");
 697
 698         if (str.length() <= threshold)
 699                 return from_utf8(os::external_path(str));
 700
 701         string const prefix = ".../";
 702         string temp;
 703
 704         while (str.length() > threshold)
 705                 str = split(str, temp, '/');
 706
 707         // Did we shorten everything away?
 708         if (str.empty()) {
 709                 // Yes, filename itself is too long.
 710                 // Pick the start and the end of the filename.
 711                 str = onlyFilename(path);
 712                 string const head = str.substr(0, threshold / 2 - 3);
 713
 714                 string::size_type len = str.length();
 715                 string const tail =
 716                         str.substr(len - threshold / 2 - 2, len - 1);
 717                 str = head + "..." + tail;
 718         }
 719
 720         return from_utf8(os::external_path(prefix + str));
 721 }
 722
 723
 724 bool readLink(FileName const & file, FileName & link)
 725 {
 726 #ifdef HAVE_READLINK
 727         char linkbuffer[512];
 728         // Should be PATH_MAX but that needs autconf support
 729         string const encoded = file.toFilesystemEncoding();
 730         int const nRead = ::readlink(encoded.c_str(),
 731                                      linkbuffer, sizeof(linkbuffer) - 1);
 732         if (nRead <= 0)
 733                 return false;
 734         linkbuffer[nRead] = '\0'; // terminator
 735         link = makeAbsPath(linkbuffer, onlyPath(file.absFilename()));
 736         return true;
 737 #else
 738         return false;
 739 #endif
 740 }
 741
 742
 743 cmd_ret const runCommand(string const & cmd)
 744 {
 745         // FIXME: replace all calls to RunCommand with ForkedCall
 746         // (if the output is not needed) or the code in ISpell.cpp
 747         // (if the output is needed).
 748
 749         // One question is if we should use popen or
 750         // create our own popen based on fork, exec, pipe
 751         // of course the best would be to have a
 752         // pstream (process stream), with the
 753         // variants ipstream, opstream
 754
 755 #if defined (HAVE_POPEN)
 756         FILE * inf = ::popen(cmd.c_str(), os::popen_read_mode());
 757 #elif defined (HAVE__POPEN)
 758         FILE * inf = ::_popen(cmd.c_str(), os::popen_read_mode());
 759 #else
 760 #error No popen() function.
 761 #endif
 762
 763         // (Claus Hentschel) Check if popen was succesful ;-)
 764         if (!inf) {
 765                 lyxerr << "RunCommand:: could not start child process" << endl;
 766                 return make_pair(-1, string());
 767         }
 768
 769         string ret;
 770         int c = fgetc(inf);
 771         while (c != EOF) {
 772                 ret += static_cast<char>(c);
 773                 c = fgetc(inf);
 774         }
 775
 776 #if defined (HAVE_PCLOSE)
 777         int const pret = pclose(inf);
 778 #elif defined (HAVE__PCLOSE)
 779         int const pret = _pclose(inf);
 780 #else
 781 #error No pclose() function.
 782 #endif
 783
 784         if (pret == -1)
 785                 perror("RunCommand:: could not terminate child process");
 786
 787         return make_pair(pret, ret);
 788 }
 789
 790
 791 FileName const findtexfile(string const & fil, string const & /*format*/)
 792 {
 793         /* There is no problem to extend this function too use other
 794            methods to look for files. It could be setup to look
 795            in environment paths and also if wanted as a last resort
 796            to a recursive find. One of the easier extensions would
 797            perhaps be to use the LyX file lookup methods. But! I am
 798            going to implement this until I see some demand for it.
 799            Lgb
 800         */
 801
 802         // If the file can be found directly, we just return a
 803         // absolute path version of it.
 804         FileName const absfile(makeAbsPath(fil));
 805         if (absfile.exists())
 806                 return absfile;
 807
 808         // Now we try to find it using kpsewhich.
 809         // It seems from the kpsewhich manual page that it is safe to use
 810         // kpsewhich without --format: "When the --format option is not
 811         // given, the search path used when looking for a file is inferred
 812         // from the name given, by looking for a known extension. If no
 813         // known extension is found, the search path for TeX source files
 814         // is used."
 815         // However, we want to take advantage of the format sine almost all
 816         // the different formats has environment variables that can be used
 817         // to controll which paths to search. f.ex. bib looks in
 818         // BIBINPUTS and TEXBIB. Small list follows:
 819         // bib - BIBINPUTS, TEXBIB
 820         // bst - BSTINPUTS
 821         // graphic/figure - TEXPICTS, TEXINPUTS
 822         // ist - TEXINDEXSTYLE, INDEXSTYLE
 823         // pk - PROGRAMFONTS, PKFONTS, TEXPKS, GLYPHFONTS, TEXFONTS
 824         // tex - TEXINPUTS
 825         // tfm - TFMFONTS, TEXFONTS
 826         // This means that to use kpsewhich in the best possible way we
 827         // should help it by setting additional path in the approp. envir.var.
 828         string const kpsecmd = "kpsewhich " + fil;
 829
 830         cmd_ret const c = runCommand(kpsecmd);
 831
 832         LYXERR(Debug::LATEX, "kpse status = " << c.first << '\n'
 833                  << "kpse result = `" << rtrim(c.second, "\n\r") << '\'');
 834         if (c.first != -1)
 835                 return FileName(rtrim(to_utf8(from_filesystem8bit(c.second)), "\n\r"));
 836         else
 837                 return FileName();
 838 }
 839
 840
 841 void removeAutosaveFile(string const & filename)
 842 {
 843         string a = onlyPath(filename);
 844         a += '#';
 845         a += onlyFilename(filename);
 846         a += '#';
 847         FileName const autosave(a);
 848         if (autosave.exists())
 849                 autosave.removeFile();
 850 }
 851
 852
 853 void readBB_lyxerrMessage(FileName const & file, bool & zipped,
 854         string const & message)
 855 {
 856         LYXERR(Debug::GRAPHICS, "[readBB_from_PSFile] " << message);
 857         // FIXME: Why is this func deleting a file? (Lgb)
 858         if (zipped)
 859                 file.removeFile();
 860 }
 861
 862
 863 string const readBB_from_PSFile(FileName const & file)
 864 {
 865         // in a (e)ps-file it's an entry like %%BoundingBox:23 45 321 345
 866         // It seems that every command in the header has an own line,
 867         // getline() should work for all files.
 868         // On the other hand some plot programs write the bb at the
 869         // end of the file. Than we have in the header:
 870         // %%BoundingBox: (atend)
 871         // In this case we must check the end.
 872         bool zipped = file.isZippedFile();
 873         FileName const file_ = zipped ? unzipFile(file) : file;
 874         string const format = file_.guessFormatFromContents();
 875
 876         if (format != "eps" && format != "ps") {
 877                 readBB_lyxerrMessage(file_, zipped,"no(e)ps-format");
 878                 return string();
 879         }
 880
 881         static boost::regex bbox_re(
 882                 "^%%BoundingBox:\\s*([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)");
 883         ifstream is(file_.toFilesystemEncoding().c_str());
 884         while (is) {
 885                 string s;
 886                 getline(is,s);
 887                 boost::smatch what;
 888                 if (regex_match(s, what, bbox_re)) {
 889                         // Our callers expect the tokens in the string
 890                         // separated by single spaces.
 891                         // FIXME: change return type from string to something
 892                         // sensible
 893                         ostringstream os;
 894                         os << what.str(1) << ' ' << what.str(2) << ' '
 895                            << what.str(3) << ' ' << what.str(4);
 896                         string const bb = os.str();
 897                         readBB_lyxerrMessage(file_, zipped, bb);
 898                         return bb;
 899                 }
 900         }
 901         readBB_lyxerrMessage(file_, zipped, "no bb found");
 902         return string();
 903 }
 904
 905
 906 int compare_timestamps(FileName const & file1, FileName const & file2)
 907 {
 908         // If the original is newer than the copy, then copy the original
 909         // to the new directory.
 910
 911         int cmp = 0;
 912         if (file1.exists() && file2.exists()) {
 913                 double const tmp = difftime(file1.lastModified(), file2.lastModified());
 914                 if (tmp != 0)
 915                         cmp = tmp > 0 ? 1 : -1;
 916
 917         } else if (file1.exists()) {
 918                 cmp = 1;
 919         } else if (file2.exists()) {
 920                 cmp = -1;
 921         }
 922
 923         return cmp;
 924 }
 925
 926
 927 } //namespace support
 928 } // namespace lyx