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 /// Returns true is path is absolute
 490 bool absolutePath(string const & path)
 491 {
 492         return FileName(path).isAbsolute();
 493 }
 494
 495
 496 // Create absolute path. If impossible, don't do anything
 497 // Supports ./ and ~/. Later we can add support for ~logname/. (Asger)
 498 string const expandPath(string const & path)
 499 {
 500         // checks for already absolute path
 501         string rTemp = replaceEnvironmentPath(path);
 502         FileName abs_path(rTemp);
 503         if (abs_path.isAbsolute())
 504                 return rTemp;
 505
 506         string temp;
 507         string const copy = rTemp;
 508
 509         // Split by next /
 510         rTemp = split(rTemp, temp, '/');
 511
 512         if (temp == ".")
 513                 return FileName::getcwd().absFilename() + '/' + rTemp;
 514
 515         if (temp == "~")
 516                 return package().home_dir().absFilename() + '/' + rTemp;
 517
 518         if (temp == "..")
 519                 return makeAbsPath(copy).absFilename();
 520
 521         // Don't know how to handle this
 522         return copy;
 523 }
 524
 525
 526 // Search the string for ${VAR} and $VAR and replace VAR using getenv.
 527 string const replaceEnvironmentPath(string const & path)
 528 {
 529         // ${VAR} is defined as
 530         // $\{[A-Za-z_][A-Za-z_0-9]*\}
 531         static string const envvar_br = "[$]\\{([A-Za-z_][A-Za-z_0-9]*)\\}";
 532
 533         // $VAR is defined as:
 534         // $\{[A-Za-z_][A-Za-z_0-9]*\}
 535         static string const envvar = "[$]([A-Za-z_][A-Za-z_0-9]*)";
 536
 537         static boost::regex envvar_br_re("(.*)" + envvar_br + "(.*)");
 538         static boost::regex envvar_re("(.*)" + envvar + "(.*)");
 539         boost::smatch what;
 540
 541         string result = path;
 542         while (1) {
 543                 regex_match(result, what, envvar_br_re);
 544                 if (!what[0].matched) {
 545                         regex_match(result, what, envvar_re);
 546                         if (!what[0].matched)
 547                                 break;
 548                 }
 549                 result = what.str(1) + getEnv(what.str(2)) + what.str(3);
 550         }
 551         return result;
 552 }
 553
 554
 555 // Make relative path out of two absolute paths
 556 docstring const makeRelPath(docstring const & abspath, docstring const & basepath)
 557 // Makes relative path out of absolute path. If it is deeper than basepath,
 558 // it's easy. If basepath and abspath share something (they are all deeper
 559 // than some directory), it'll be rendered using ..'s. If they are completely
 560 // different, then the absolute path will be used as relative path.
 561 {
 562         docstring::size_type const abslen = abspath.length();
 563         docstring::size_type const baselen = basepath.length();
 564
 565         docstring::size_type i = os::common_path(abspath, basepath);
 566
 567         if (i == 0) {
 568                 // actually no match - cannot make it relative
 569                 return abspath;
 570         }
 571
 572         // Count how many dirs there are in basepath above match
 573         // and append as many '..''s into relpath
 574         docstring buf;
 575         docstring::size_type j = i;
 576         while (j < baselen) {
 577                 if (basepath[j] == '/') {
 578                         if (j + 1 == baselen)
 579                                 break;
 580                         buf += "../";
 581                 }
 582                 ++j;
 583         }
 584
 585         // Append relative stuff from common directory to abspath
 586         if (abspath[i] == '/')
 587                 ++i;
 588         for (; i < abslen; ++i)
 589                 buf += abspath[i];
 590         // Remove trailing /
 591         if (suffixIs(buf, '/'))
 592                 buf.erase(buf.length() - 1);
 593         // Substitute empty with .
 594         if (buf.empty())
 595                 buf = '.';
 596         return buf;
 597 }
 598
 599
 600 // Append sub-directory(ies) to a path in an intelligent way
 601 string const addPath(string const & path, string const & path_2)
 602 {
 603         string buf;
 604         string const path2 = os::internal_path(path_2);
 605
 606         if (!path.empty() && path != "." && path != "./") {
 607                 buf = os::internal_path(path);
 608                 if (path[path.length() - 1] != '/')
 609                         buf += '/';
 610         }
 611
 612         if (!path2.empty()) {
 613                 string::size_type const p2start = path2.find_first_not_of('/');
 614                 string::size_type const p2end = path2.find_last_not_of('/');
 615                 string const tmp = path2.substr(p2start, p2end - p2start + 1);
 616                 buf += tmp + '/';
 617         }
 618         return buf;
 619 }
 620
 621
 622 string const changeExtension(string const & oldname, string const & extension)
 623 {
 624         string::size_type const last_slash = oldname.rfind('/');
 625         string::size_type last_dot = oldname.rfind('.');
 626         if (last_dot < last_slash && last_slash != string::npos)
 627                 last_dot = string::npos;
 628
 629         string ext;
 630         // Make sure the extension starts with a dot
 631         if (!extension.empty() && extension[0] != '.')
 632                 ext= '.' + extension;
 633         else
 634                 ext = extension;
 635
 636         return os::internal_path(oldname.substr(0, last_dot) + ext);
 637 }
 638
 639
 640 string const removeExtension(string const & name)
 641 {
 642         return changeExtension(name, string());
 643 }
 644
 645
 646 string const addExtension(string const & name, string const & extension)
 647 {
 648         if (!extension.empty() && extension[0] != '.')
 649                 return name + '.' + extension;
 650         return name + extension;
 651 }
 652
 653
 654 /// Return the extension of the file (not including the .)
 655 string const getExtension(string const & name)
 656 {
 657         string::size_type const last_slash = name.rfind('/');
 658         string::size_type const last_dot = name.rfind('.');
 659         if (last_dot != string::npos &&
 660             (last_slash == string::npos || last_dot > last_slash))
 661                 return name.substr(last_dot + 1,
 662                                    name.length() - (last_dot + 1));
 663         else
 664                 return string();
 665 }
 666
 667
 668 string const unzippedFileName(string const & zipped_file)
 669 {
 670         string const ext = getExtension(zipped_file);
 671         if (ext == "gz" || ext == "z" || ext == "Z")
 672                 return changeExtension(zipped_file, string());
 673         return "unzipped_" + zipped_file;
 674 }
 675
 676
 677 FileName const unzipFile(FileName const & zipped_file, string const & unzipped_file)
 678 {
 679         FileName const tempfile = FileName(unzipped_file.empty() ?
 680                 unzippedFileName(zipped_file.toFilesystemEncoding()) :
 681                 unzipped_file);
 682         // Run gunzip
 683         string const command = "gunzip -c " +
 684                 zipped_file.toFilesystemEncoding() + " > " +
 685                 tempfile.toFilesystemEncoding();
 686         Systemcall one;
 687         one.startscript(Systemcall::Wait, command);
 688         // test that command was executed successfully (anon)
 689         // yes, please do. (Lgb)
 690         return tempfile;
 691 }
 692
 693
 694 docstring const makeDisplayPath(string const & path, unsigned int threshold)
 695 {
 696         string str = path;
 697
 698         // If file is from LyXDir, display it as if it were relative.
 699         string const system = package().system_support().absFilename();
 700         if (prefixIs(str, system) && str != system)
 701                 return from_utf8("[" + str.erase(0, system.length()) + "]");
 702
 703         // replace /home/blah with ~/
 704         string const home = package().home_dir().absFilename();
 705         if (!home.empty() && prefixIs(str, home))
 706                 str = subst(str, home, "~");
 707
 708         if (str.length() <= threshold)
 709                 return from_utf8(os::external_path(str));
 710
 711         string const prefix = ".../";
 712         string temp;
 713
 714         while (str.length() > threshold)
 715                 str = split(str, temp, '/');
 716
 717         // Did we shorten everything away?
 718         if (str.empty()) {
 719                 // Yes, filename itself is too long.
 720                 // Pick the start and the end of the filename.
 721                 str = onlyFilename(path);
 722                 string const head = str.substr(0, threshold / 2 - 3);
 723
 724                 string::size_type len = str.length();
 725                 string const tail =
 726                         str.substr(len - threshold / 2 - 2, len - 1);
 727                 str = head + "..." + tail;
 728         }
 729
 730         return from_utf8(os::external_path(prefix + str));
 731 }
 732
 733
 734 bool readLink(FileName const & file, FileName & link)
 735 {
 736 #ifdef HAVE_READLINK
 737         char linkbuffer[512];
 738         // Should be PATH_MAX but that needs autconf support
 739         string const encoded = file.toFilesystemEncoding();
 740         int const nRead = ::readlink(encoded.c_str(),
 741                                      linkbuffer, sizeof(linkbuffer) - 1);
 742         if (nRead <= 0)
 743                 return false;
 744         linkbuffer[nRead] = '\0'; // terminator
 745         link = makeAbsPath(linkbuffer, onlyPath(file.absFilename()));
 746         return true;
 747 #else
 748         return false;
 749 #endif
 750 }
 751
 752
 753 cmd_ret const runCommand(string const & cmd)
 754 {
 755         // FIXME: replace all calls to RunCommand with ForkedCall
 756         // (if the output is not needed) or the code in ISpell.cpp
 757         // (if the output is needed).
 758
 759         // One question is if we should use popen or
 760         // create our own popen based on fork, exec, pipe
 761         // of course the best would be to have a
 762         // pstream (process stream), with the
 763         // variants ipstream, opstream
 764
 765 #if defined (HAVE_POPEN)
 766         FILE * inf = ::popen(cmd.c_str(), os::popen_read_mode());
 767 #elif defined (HAVE__POPEN)
 768         FILE * inf = ::_popen(cmd.c_str(), os::popen_read_mode());
 769 #else
 770 #error No popen() function.
 771 #endif
 772
 773         // (Claus Hentschel) Check if popen was succesful ;-)
 774         if (!inf) {
 775                 lyxerr << "RunCommand:: could not start child process" << endl;
 776                 return make_pair(-1, string());
 777         }
 778
 779         string ret;
 780         int c = fgetc(inf);
 781         while (c != EOF) {
 782                 ret += static_cast<char>(c);
 783                 c = fgetc(inf);
 784         }
 785
 786 #if defined (HAVE_PCLOSE)
 787         int const pret = pclose(inf);
 788 #elif defined (HAVE__PCLOSE)
 789         int const pret = _pclose(inf);
 790 #else
 791 #error No pclose() function.
 792 #endif
 793
 794         if (pret == -1)
 795                 perror("RunCommand:: could not terminate child process");
 796
 797         return make_pair(pret, ret);
 798 }
 799
 800
 801 FileName const findtexfile(string const & fil, string const & /*format*/)
 802 {
 803         /* There is no problem to extend this function too use other
 804            methods to look for files. It could be setup to look
 805            in environment paths and also if wanted as a last resort
 806            to a recursive find. One of the easier extensions would
 807            perhaps be to use the LyX file lookup methods. But! I am
 808            going to implement this until I see some demand for it.
 809            Lgb
 810         */
 811
 812         // If the file can be found directly, we just return a
 813         // absolute path version of it.
 814         FileName const absfile(makeAbsPath(fil));
 815         if (absfile.exists())
 816                 return absfile;
 817
 818         // No we try to find it using kpsewhich.
 819         // It seems from the kpsewhich manual page that it is safe to use
 820         // kpsewhich without --format: "When the --format option is not
 821         // given, the search path used when looking for a file is inferred
 822         // from the name given, by looking for a known extension. If no
 823         // known extension is found, the search path for TeX source files
 824         // is used."
 825         // However, we want to take advantage of the format sine almost all
 826         // the different formats has environment variables that can be used
 827         // to controll which paths to search. f.ex. bib looks in
 828         // BIBINPUTS and TEXBIB. Small list follows:
 829         // bib - BIBINPUTS, TEXBIB
 830         // bst - BSTINPUTS
 831         // graphic/figure - TEXPICTS, TEXINPUTS
 832         // ist - TEXINDEXSTYLE, INDEXSTYLE
 833         // pk - PROGRAMFONTS, PKFONTS, TEXPKS, GLYPHFONTS, TEXFONTS
 834         // tex - TEXINPUTS
 835         // tfm - TFMFONTS, TEXFONTS
 836         // This means that to use kpsewhich in the best possible way we
 837         // should help it by setting additional path in the approp. envir.var.
 838         string const kpsecmd = "kpsewhich " + fil;
 839
 840         cmd_ret const c = runCommand(kpsecmd);
 841
 842         LYXERR(Debug::LATEX, "kpse status = " << c.first << '\n'
 843                  << "kpse result = `" << rtrim(c.second, "\n\r") << '\'');
 844         if (c.first != -1)
 845                 return FileName(rtrim(to_utf8(from_filesystem8bit(c.second)), "\n\r"));
 846         else
 847                 return FileName();
 848 }
 849
 850
 851 void removeAutosaveFile(string const & filename)
 852 {
 853         string a = onlyPath(filename);
 854         a += '#';
 855         a += onlyFilename(filename);
 856         a += '#';
 857         FileName const autosave(a);
 858         if (autosave.exists())
 859                 autosave.removeFile();
 860 }
 861
 862
 863 void readBB_lyxerrMessage(FileName const & file, bool & zipped,
 864         string const & message)
 865 {
 866         LYXERR(Debug::GRAPHICS, "[readBB_from_PSFile] " << message);
 867         // FIXME: Why is this func deleting a file? (Lgb)
 868         if (zipped)
 869                 file.removeFile();
 870 }
 871
 872
 873 string const readBB_from_PSFile(FileName const & file)
 874 {
 875         // in a (e)ps-file it's an entry like %%BoundingBox:23 45 321 345
 876         // It seems that every command in the header has an own line,
 877         // getline() should work for all files.
 878         // On the other hand some plot programs write the bb at the
 879         // end of the file. Than we have in the header:
 880         // %%BoundingBox: (atend)
 881         // In this case we must check the end.
 882         bool zipped = file.isZippedFile();
 883         FileName const file_ = zipped ? unzipFile(file) : file;
 884         string const format = file_.guessFormatFromContents();
 885
 886         if (format != "eps" && format != "ps") {
 887                 readBB_lyxerrMessage(file_, zipped,"no(e)ps-format");
 888                 return string();
 889         }
 890
 891         static boost::regex bbox_re(
 892                 "^%%BoundingBox:\\s*([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)");
 893         ifstream is(file_.toFilesystemEncoding().c_str());
 894         while (is) {
 895                 string s;
 896                 getline(is,s);
 897                 boost::smatch what;
 898                 if (regex_match(s, what, bbox_re)) {
 899                         // Our callers expect the tokens in the string
 900                         // separated by single spaces.
 901                         // FIXME: change return type from string to something
 902                         // sensible
 903                         ostringstream os;
 904                         os << what.str(1) << ' ' << what.str(2) << ' '
 905                            << what.str(3) << ' ' << what.str(4);
 906                         string const bb = os.str();
 907                         readBB_lyxerrMessage(file_, zipped, bb);
 908                         return bb;
 909                 }
 910         }
 911         readBB_lyxerrMessage(file_, zipped, "no bb found");
 912         return string();
 913 }
 914
 915
 916 int compare_timestamps(FileName const & file1, FileName const & file2)
 917 {
 918         // If the original is newer than the copy, then copy the original
 919         // to the new directory.
 920
 921         int cmp = 0;
 922         if (file1.exists() && file2.exists()) {
 923                 double const tmp = difftime(file1.lastModified(), file2.lastModified());
 924                 if (tmp != 0)
 925                         cmp = tmp > 0 ? 1 : -1;
 926
 927         } else if (file1.exists()) {
 928                 cmp = 1;
 929         } else if (file2.exists()) {
 930                 cmp = -1;
 931         }
 932
 933         return cmp;
 934 }
 935
 936
 937 } //namespace support
 938 } // namespace lyx