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         FileName const tmpfl = FileName::tempName(tempdir, mask);
 325
 326         if (tmpfl.empty() || !tmpfl.createDirectory(0700)) {
 327                 LYXERR0("LyX could not create temporary directory in " << tempdir
 328                         << "'");
 329                 return FileName();
 330         }
 331
 332         return tmpfl;
 333 }
 334
 335
 336 FileName const createLyXTmpDir(FileName const & deflt)
 337 {
 338         if (deflt.empty() || deflt == package().system_temp_dir())
 339                 return createTmpDir(package().system_temp_dir(), "lyx_tmpdir");
 340
 341         if (deflt.createDirectory(0777))
 342                 return deflt;
 343
 344         if (deflt.isDirWritable()) {
 345                 // deflt could not be created because it
 346                 // did exist already, so let's create our own
 347                 // dir inside deflt.
 348                 return createTmpDir(deflt, "lyx_tmpdir");
 349         } else {
 350                 // some other error occured.
 351                 return createTmpDir(package().system_temp_dir(), "lyx_tmpdir");
 352         }
 353 }
 354
 355
 356 // Strip filename from path name
 357 string const onlyPath(string const & filename)
 358 {
 359         // If empty filename, return empty
 360         if (filename.empty())
 361                 return filename;
 362
 363         // Find last / or start of filename
 364         size_t j = filename.rfind('/');
 365         return j == string::npos ? "./" : filename.substr(0, j + 1);
 366 }
 367
 368
 369 // Convert relative path into absolute path based on a basepath.
 370 // If relpath is absolute, just use that.
 371 // If basepath is empty, use CWD as base.
 372 // Note that basePath can be a relative path, in the sense that it may
 373 // not begin with "/" (e.g.), but it should NOT contain such constructs
 374 // as "/../".
 375 // FIXME It might be nice if the code didn't simply assume that.
 376 FileName const makeAbsPath(string const & relPath, string const & basePath)
 377 {
 378         // checks for already absolute path
 379         if (FileName::isAbsolute(relPath))
 380                 return FileName(relPath);
 381
 382         // Copies given paths
 383         string tempRel = os::internal_path(relPath);
 384         // Since TempRel is NOT absolute, we can safely replace "//" with "/"
 385         tempRel = subst(tempRel, "//", "/");
 386
 387         string tempBase;
 388
 389         if (FileName::isAbsolute(basePath))
 390                 tempBase = basePath;
 391         else
 392                 tempBase = addPath(FileName::getcwd().absFilename(), basePath);
 393
 394         // Handle /./ at the end of the path
 395         while (suffixIs(tempBase, "/./"))
 396                 tempBase.erase(tempBase.length() - 2);
 397
 398         // processes relative path
 399         string rTemp = tempRel;
 400         string temp;
 401
 402         // Check for a leading "~"
 403         // Split by first /
 404         rTemp = split(rTemp, temp, '/');
 405         if (temp == "~") {
 406                 tempBase = package().home_dir().absFilename();
 407                 tempRel = rTemp;
 408         }
 409
 410         rTemp = tempRel;
 411         while (!rTemp.empty()) {
 412                 // Split by next /
 413                 rTemp = split(rTemp, temp, '/');
 414
 415                 if (temp == ".") continue;
 416                 if (temp == "..") {
 417                         // Remove one level of TempBase
 418                         if (tempBase.length() <= 1) {
 419                                 //this is supposed to be an absolute path, so...
 420                                 tempBase = "/";
 421                                 continue;
 422                         }
 423                         //erase a trailing slash if there is one
 424                         if (suffixIs(tempBase, "/"))
 425                                 tempBase.erase(tempBase.length() - 1, string::npos);
 426
 427                         string::size_type i = tempBase.length() - 1;
 428                         while (i > 0 && tempBase[i] != '/')
 429                                 --i;
 430                         if (i > 0)
 431                                 tempBase.erase(i, string::npos);
 432                         else
 433                                 tempBase = '/';
 434                 } else if (temp.empty() && !rTemp.empty()) {
 435                                 tempBase = os::current_root() + rTemp;
 436                                 rTemp.erase();
 437                 } else {
 438                         // Add this piece to TempBase
 439                         if (!suffixIs(tempBase, '/'))
 440                                 tempBase += '/';
 441                         tempBase += temp;
 442                 }
 443         }
 444
 445         // returns absolute path
 446         return FileName(tempBase);
 447 }
 448
 449
 450 // Correctly append filename to the pathname.
 451 // If pathname is '.', then don't use pathname.
 452 // Chops any path of filename.
 453 string const addName(string const & path, string const & fname)
 454 {
 455         string const basename = onlyFilename(fname);
 456         string buf;
 457
 458         if (path != "." && path != "./" && !path.empty()) {
 459                 buf = os::internal_path(path);
 460                 if (!suffixIs(path, '/'))
 461                         buf += '/';
 462         }
 463
 464         return buf + basename;
 465 }
 466
 467
 468 // Strips path from filename
 469 string const onlyFilename(string const & fname)
 470 {
 471         if (fname.empty())
 472                 return fname;
 473
 474         string::size_type j = fname.rfind('/');
 475         if (j == string::npos) // no '/' in fname
 476                 return fname;
 477
 478         // Strip to basename
 479         return fname.substr(j + 1);
 480 }
 481
 482
 483 // Create absolute path. If impossible, don't do anything
 484 // Supports ./ and ~/. Later we can add support for ~logname/. (Asger)
 485 string const expandPath(string const & path)
 486 {
 487         // checks for already absolute path
 488         string rTemp = replaceEnvironmentPath(path);
 489         if (FileName::isAbsolute(rTemp))
 490                 return rTemp;
 491
 492         string temp;
 493         string const copy = rTemp;
 494
 495         // Split by next /
 496         rTemp = split(rTemp, temp, '/');
 497
 498         if (temp == ".")
 499                 return FileName::getcwd().absFilename() + '/' + rTemp;
 500
 501         if (temp == "~")
 502                 return package().home_dir().absFilename() + '/' + rTemp;
 503
 504         if (temp == "..")
 505                 return makeAbsPath(copy).absFilename();
 506
 507         // Don't know how to handle this
 508         return copy;
 509 }
 510
 511
 512 // Search the string for ${VAR} and $VAR and replace VAR using getenv.
 513 string const replaceEnvironmentPath(string const & path)
 514 {
 515         // ${VAR} is defined as
 516         // $\{[A-Za-z_][A-Za-z_0-9]*\}
 517         static string const envvar_br = "[$]\\{([A-Za-z_][A-Za-z_0-9]*)\\}";
 518
 519         // $VAR is defined as:
 520         // $\{[A-Za-z_][A-Za-z_0-9]*\}
 521         static string const envvar = "[$]([A-Za-z_][A-Za-z_0-9]*)";
 522
 523         static boost::regex envvar_br_re("(.*)" + envvar_br + "(.*)");
 524         static boost::regex envvar_re("(.*)" + envvar + "(.*)");
 525         boost::smatch what;
 526         string result;
 527         string remaining = path;
 528         while (1) {
 529                 regex_match(remaining, what, envvar_br_re);
 530                 if (!what[0].matched) {
 531                         regex_match(remaining, what, envvar_re);
 532                         if (!what[0].matched) {
 533                                 result += remaining;
 534                                 break;
 535                         }
 536                 }
 537                 string env_var = getEnv(what.str(2));
 538                 if (!env_var.empty())
 539                         result += what.str(1) + env_var;
 540                 else
 541                         result += what.str(1) + "$" + what.str(2);
 542                 remaining = 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 onlyPath(zipped_file) + "unzipped_" + onlyFilename(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         // Now 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 readBB_lyxerrMessage(FileName const & file, bool & zipped,
 845         string const & message)
 846 {
 847         LYXERR(Debug::GRAPHICS, "[readBB_from_PSFile] " << message);
 848         // FIXME: Why is this func deleting a file? (Lgb)
 849         if (zipped)
 850                 file.removeFile();
 851 }
 852
 853
 854 string const readBB_from_PSFile(FileName const & file)
 855 {
 856         // in a (e)ps-file it's an entry like %%BoundingBox:23 45 321 345
 857         // It seems that every command in the header has an own line,
 858         // getline() should work for all files.
 859         // On the other hand some plot programs write the bb at the
 860         // end of the file. Than we have in the header:
 861         // %%BoundingBox: (atend)
 862         // In this case we must check the end.
 863         bool zipped = file.isZippedFile();
 864         FileName const file_ = zipped ? unzipFile(file) : file;
 865         string const format = file_.guessFormatFromContents();
 866
 867         if (format != "eps" && format != "ps") {
 868                 readBB_lyxerrMessage(file_, zipped,"no(e)ps-format");
 869                 return string();
 870         }
 871
 872         static boost::regex bbox_re(
 873                 "^%%BoundingBox:\\s*([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)");
 874         ifstream is(file_.toFilesystemEncoding().c_str());
 875         while (is) {
 876                 string s;
 877                 getline(is,s);
 878                 boost::smatch what;
 879                 if (regex_match(s, what, bbox_re)) {
 880                         // Our callers expect the tokens in the string
 881                         // separated by single spaces.
 882                         // FIXME: change return type from string to something
 883                         // sensible
 884                         ostringstream os;
 885                         os << what.str(1) << ' ' << what.str(2) << ' '
 886                            << what.str(3) << ' ' << what.str(4);
 887                         string const bb = os.str();
 888                         readBB_lyxerrMessage(file_, zipped, bb);
 889                         return bb;
 890                 }
 891         }
 892         readBB_lyxerrMessage(file_, zipped, "no bb found");
 893         return string();
 894 }
 895
 896
 897 int compare_timestamps(FileName const & file1, FileName const & file2)
 898 {
 899         // If the original is newer than the copy, then copy the original
 900         // to the new directory.
 901
 902         int cmp = 0;
 903         if (file1.exists() && file2.exists()) {
 904                 double const tmp = difftime(file1.lastModified(), file2.lastModified());
 905                 if (tmp != 0)
 906                         cmp = tmp > 0 ? 1 : -1;
 907
 908         } else if (file1.exists()) {
 909                 cmp = 1;
 910         } else if (file2.exists()) {
 911                 cmp = -1;
 912         }
 913
 914         return cmp;
 915 }
 916
 917
 918 } //namespace support
 919 } // namespace lyx