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