-/*
- filetools.C (former paths.C) - part of LyX project
- General path-mangling functions
- Copyright 1996 Ivan Schreter
- Parts Copyright 1996 Dirk Niggemann
- Parts Copyright 1985, 1990, 1993 Free Software Foundation, Inc.
- Parts Copyright 1996 Asger Alstrup
-
- See also filetools.h.
-
- lyx-filetool.C : tools functions for file/path handling
- this file is part of LyX, the High Level Word Processor
- Copyright 1995-1996, Matthias Ettrich and the LyX Team
-
-*/
+/**
+ * \file filetools.C
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * parts Copyright 1985, 1990, 1993 Free Software Foundation, Inc.
+ *
+ * \author Ivan Schreter
+ * \author Dirk Niggemann
+ * \author Asger Alstrup
+ * \author Lars Gullik Bjønnes
+ * \author Jean-Marc Lasgouttes
+ * \author Angus Leeming
+ * \author John Levon
+ * \author Herbert Voss
+ *
+ * This file is part of LyX, the document processor.
+ * Licence details can be found in the file COPYING.
+ *
+ * General path-mangling functions
+ */
#include <config.h>
-#include <cctype>
+#include "debug.h"
+#include "support/tostr.h"
+#include "support/systemcall.h"
+#include "support/LAssert.h"
-#include <utility>
-#include <fstream>
+#include "filetools.h"
+#include "lstrings.h"
+#include "FileInfo.h"
+#include "path.h"
+#include "path_defines.h"
+#include "gettext.h"
+#include "lyxlib.h"
+#include "os.h"
#include "Lsstream.h"
-#ifdef __GNUG__
-#pragma implementation "filetools.h"
-#endif
-
+#include <boost/cregex.hpp>
+#include <cctype>
#include <cstdlib>
#include <cstdio>
#include <fcntl.h>
#include <cerrno>
-#include "debug.h"
-#include "support/lstrings.h"
-#include "support/systemcall.h"
-#include "filetools.h"
-#include "LSubstring.h"
-#include "frontends/Alert.h"
-#include "FileInfo.h"
-#include "support/path.h" // I know it's OS/2 specific (SMiyata)
-#include "gettext.h"
-#include "lyxlib.h"
-#include "os.h"
+#include <utility>
+#include <fstream>
+
// Which part of this is still necessary? (JMarc).
#if HAVE_DIRENT_H
# endif
#endif
+#ifndef CXX_GLOBAL_CSTD
+using std::fgetc;
+using std::isalpha;
+using std::isalnum;
+#endif
+
using std::make_pair;
using std::pair;
using std::endl;
using std::ifstream;
using std::vector;
+using std::getline;
-extern string system_lyxdir;
-extern string build_lyxdir;
-extern string user_lyxdir;
-extern string system_tempdir;
-extern string system_packageList;
+namespace lyx {
+namespace support {
bool IsLyXFilename(string const & filename)
{
- return suffixIs(lowercase(filename), ".lyx");
+ return suffixIs(ascii_lowercase(filename), ".lyx");
}
bool IsSGMLFilename(string const & filename)
{
- return suffixIs(lowercase(filename), ".sgml");
+ return suffixIs(ascii_lowercase(filename), ".sgml");
}
string const QuoteName(string const & name)
{
return (os::shell() == os::UNIX) ?
- "\'" + name + "\'":
- "\"" + name + "\"";
+ '\'' + name + '\'':
+ '"' + name + '"';
}
// Is a file readable ?
-bool IsFileReadable (string const & path)
+bool IsFileReadable(string const & path)
{
FileInfo file(path);
- if (file.isOK() && file.isRegular() && file.readable())
- return true;
- else
- return false;
+ return file.isOK() && file.isRegular() && file.readable();
}
// return 1 read-write
// 0 read_only
// -1 error (doesn't exist, no access, anything else)
-int IsFileWriteable (string const & path)
+int IsFileWriteable(string const & path)
{
FileInfo fi(path);
//returns true: dir writeable
// false: not writeable
-bool IsDirWriteable (string const & path)
+bool IsDirWriteable(string const & path)
{
lyxerr[Debug::FILES] << "IsDirWriteable: " << path << endl;
- string const tmpfl(lyx::tempName(path, "lyxwritetest"));
+ string const tmpfl(tempName(path, "lyxwritetest"));
if (tmpfl.empty())
return false;
- lyx::unlink(tmpfl);
+ unlink(tmpfl);
return true;
}
// If path entry begins with $$LyX/, use system_lyxdir
// If path entry begins with $$User/, use user_lyxdir
// Example: "$$User/doc;$$LyX/doc"
-string const FileOpenSearch (string const & path, string const & name,
+string const FileOpenSearch(string const & path, string const & name,
string const & ext)
{
- string real_file, path_element;
+ string real_file;
+ string path_element;
bool notfound = true;
string tmppath = split(path, path_element, ';');
path_element = os::slashify_path(path_element);
if (!suffixIs(path_element, '/'))
path_element+= '/';
- path_element = subst(path_element, "$$LyX", system_lyxdir);
- path_element = subst(path_element, "$$User", user_lyxdir);
+ path_element = subst(path_element, "$$LyX", system_lyxdir());
+ path_element = subst(path_element, "$$User", user_lyxdir());
real_file = FileSearch(path_element, name, ext);
vector<string> const DirList(string const & dir, string const & ext)
{
// This is a non-error checking C/system implementation
- string extension(ext);
- if (!extension.empty() && extension[0] != '.')
- extension.insert(0, ".");
+ string extension;
+ if (!ext.empty() && ext[0] != '.')
+ extension += '.';
+ extension += ext;
+
vector<string> dirlist;
DIR * dirp = ::opendir(dir.c_str());
if (!dirp) {
*/
/* A C++ implementaion will look like this:
string extension(ext);
- if (extension[0] != '.') extension.insert(0, ".");
+ if (extension[0] != '.') extension.insert(0, 1, '.');
vector<string> dirlist;
directory_iterator dit("dir");
while (dit != directory_iterator()) {
string const LibFileSearch(string const & dir, string const & name,
string const & ext)
{
- string fullname = FileSearch(AddPath(user_lyxdir, dir), name, ext);
+ string fullname = FileSearch(AddPath(user_lyxdir(), dir), name, ext);
if (!fullname.empty())
return fullname;
- if (!build_lyxdir.empty())
- fullname = FileSearch(AddPath(build_lyxdir, dir), name, ext);
+ if (!build_lyxdir().empty())
+ fullname = FileSearch(AddPath(build_lyxdir(), dir), name, ext);
if (!fullname.empty())
return fullname;
- return FileSearch(AddPath(system_lyxdir, dir), name, ext);
+ return FileSearch(AddPath(system_lyxdir(), dir), name, ext);
}
}
-string const LibScriptSearch(string const & command)
+string const LibScriptSearch(string const & command_in)
{
- string script;
- string args = command;
- split(args, script, ' ');
- script = LibFileSearch("scripts", script);
- if (script.empty())
+ string const token_scriptpath("$$s/");
+
+ string command = command_in;
+ // Find the starting position of "$$s/"
+ string::size_type const pos1 = command.find(token_scriptpath);
+ if (pos1 == string::npos)
return command;
- else if (args.empty())
- return script;
- else
- return script + ' ' + args;
+ // Find the end of the "$$s/some_script" word within command
+ string::size_type const start_script = pos1 + 4;
+ string::size_type const pos2 = command.find(' ', start_script);
+ string::size_type const size_script = pos2 == string::npos?
+ (command.size() - start_script) : pos2 - start_script;
+
+ // Does this script file exist?
+ string const script =
+ LibFileSearch("scripts", command.substr(start_script, size_script));
+
+ if (script.empty()) {
+ // Replace "$$s/" with ""
+ command.erase(pos1, 4);
+ } else {
+ // Replace "$$s/some_script" with "$LYX_SCRIPT_PATH/some_script"
+ string::size_type const size_replace = size_script + 4;
+ command.replace(pos1, size_replace, script);
+ }
+
+ return command;
}
#else
string const pathlist = os::slashify_path(GetEnv(name));
#endif
- return strip(pathlist, ';');
-}
-
-
-bool PutEnv(string const & envstr)
-{
- // CHECK Look at and fix this.
- // f.ex. what about error checking?
-
-#if HAVE_PUTENV
- // this leaks, but what can we do about it?
- // Is doing a getenv() and a free() of the older value
- // a good idea? (JMarc)
- // Actually we don't have to leak...calling putenv like this
- // should be enough: ... and this is obviously not enough if putenv
- // does not make a copy of the string. It is also not very wise to
- // put a string on the free store. If we have to leak we should do it
- // like this:
- char * leaker = new char[envstr.length() + 1];
- envstr.copy(leaker, envstr.length());
- leaker[envstr.length()] = '\0';
- int const retval = lyx::putenv(leaker);
-
- // If putenv does not make a copy of the char const * this
- // is very dangerous. OTOH if it does take a copy this is the
- // best solution.
- // The only implementation of putenv that I have seen does not
- // allocate memory. _And_ after testing the putenv in glibc it
- // seems that we need to make a copy of the string contents.
- // I will enable the above.
- //int retval = lyx::putenv(envstr.c_str());
-#else
-#ifdef HAVE_SETENV
- string varname;
- string const str = envstr.split(varname,'=');
- int const retval = ::setenv(varname.c_str(), str.c_str(), true);
-#else
- // No environment setting function. Can this happen?
- int const retval = 1; //return an error condition.
-#endif
-#endif
- return retval == 0;
-}
-
-
-bool PutEnvPath(string const & envstr)
-{
- return PutEnv(envstr);
+ return rtrim(pathlist, ";");
}
namespace {
-int DeleteAllFilesInDir (string const & path)
+int DeleteAllFilesInDir(string const & path)
{
// I have decided that we will be using parts from the boost
// library. Check out http://www.boost.org/
// directory_iterator dit(path);
// directory_iterator dend;
// if (dit == dend) {
- // Alert::err_alert(_("Error! Cannot open directory:"), path);
// return -1;
// }
// for (; dit != dend; ++dit) {
// if (filename == "." || filename == "..")
// continue;
// string unlinkpath(AddName(path, filename));
- // if (lyx::unlink(unlinkpath))
- // Alert::err_alert(_("Error! Could not remove file:"),
- // unlinkpath);
+ // lyx::unlink(unlinkpath);
// }
// return 0;
DIR * dir = ::opendir(path.c_str());
- if (!dir) {
- Alert::err_alert (_("Error! Cannot open directory:"), path);
+ if (!dir)
return -1;
- }
+
struct dirent * de;
int return_value = 0;
while ((de = readdir(dir))) {
FileInfo fi(unlinkpath);
if (fi.isOK() && fi.isDir())
deleted = (DeleteAllFilesInDir(unlinkpath) == 0);
- deleted &= (lyx::unlink(unlinkpath) == 0);
- if (!deleted) {
- Alert::err_alert(_("Error! Could not remove file:"),
- unlinkpath);
+ deleted &= (unlink(unlinkpath) == 0);
+ if (!deleted)
return_value = -1;
- }
}
closedir(dir);
return return_value;
{
lyxerr[Debug::FILES]
<< "CreateTmpDir: tempdir=`" << tempdir << "'\n"
- << "CreateTmpDir: mask=`" << mask << "'" << endl;
+ << "CreateTmpDir: mask=`" << mask << '\'' << endl;
- string const tmpfl(lyx::tempName(tempdir, mask));
+ string const tmpfl(tempName(tempdir, mask));
// lyx::tempName actually creates a file to make sure that it
// stays unique. So we have to delete it before we can create
// a dir with the same name. Note also that we are not thread
// safe because of the gap between unlink and mkdir. (Lgb)
- lyx::unlink(tmpfl.c_str());
+ unlink(tmpfl);
- if (tmpfl.empty() || lyx::mkdir(tmpfl, 0700)) {
- Alert::err_alert(_("Error! Couldn't create temporary directory:"),
- tempdir);
+ if (tmpfl.empty() || mkdir(tmpfl, 0700))
return string();
- }
+
return MakeAbsPath(tmpfl);
}
+} // namespace anon
+
-int DestroyTmpDir(string const & tmpdir, bool Allfiles)
+int destroyDir(string const & tmpdir)
{
#ifdef __EMX__
- Path p(user_lyxdir);
+ Path p(user_lyxdir());
#endif
- if (Allfiles && DeleteAllFilesInDir(tmpdir)) {
+ if (DeleteAllFilesInDir(tmpdir))
return -1;
- }
- if (lyx::rmdir(tmpdir)) {
- Alert::err_alert(_("Error! Couldn't delete temporary directory:"),
- tmpdir);
+
+ if (rmdir(tmpdir))
return -1;
- }
+
return 0;
}
-} // namespace anon
-
string const CreateBufferTmpDir(string const & pathfor)
{
// In fact I wrote this code to circumvent a problematic behaviour (bug?)
// of EMX mkstemp().
string const tmpfl = tmpdir + "/lyx_tmpbuf" + tostr(count++);
- if (lyx::mkdir(tmpfl, 0777)) {
- Alert::err_alert(_("Error! Couldn't create temporary directory:"),
- tmpdir);
+ if (mkdir(tmpfl, 0777)) {
return string();
}
return tmpfl;
}
-int DestroyBufferTmpDir(string const & tmpdir)
-{
- return DestroyTmpDir(tmpdir, true);
-}
-
-
string const CreateLyXTmpDir(string const & deflt)
{
if ((!deflt.empty()) && (deflt != "/tmp")) {
- if (lyx::mkdir(deflt, 0777)) {
+ if (mkdir(deflt, 0777)) {
#ifdef __EMX__
- Path p(user_lyxdir);
+ Path p(user_lyxdir());
#endif
return CreateTmpDir(deflt, "lyx_tmpdir");
} else
return deflt;
} else {
#ifdef __EMX__
- Path p(user_lyxdir);
+ Path p(user_lyxdir());
#endif
return CreateTmpDir("/tmp", "lyx_tmpdir");
}
}
-int DestroyLyXTmpDir(string const & tmpdir)
-{
- return DestroyTmpDir (tmpdir, false); // Why false?
-}
-
-
-// Creates directory. Returns true if succesfull
bool createDirectory(string const & path, int permission)
{
- string temp(strip(os::slashify_path(path), '/'));
+ string temp(rtrim(os::slashify_path(path), "/"));
- if (temp.empty()) {
- Alert::alert(_("Internal error!"),
- _("Call to createDirectory with invalid name"));
- return false;
- }
+ Assert(!temp.empty());
- if (lyx::mkdir(temp, permission)) {
- Alert::err_alert (_("Error! Couldn't create directory:"), temp);
+ if (mkdir(temp, permission))
return false;
- }
+
return true;
}
if (os::is_absolute_path(BasePath))
TempBase = BasePath;
else
- TempBase = AddPath(lyx::getcwd(), BasePath);
+ TempBase = AddPath(getcwd(), BasePath);
// Handle /./ at the end of the path
while (suffixIs(TempBase, "/./"))
RTemp = split(RTemp, Temp, '/');
if (Temp == ".") {
- return lyx::getcwd() /*GetCWD()*/ + '/' + RTemp;
+ return getcwd() + '/' + RTemp;
}
if (Temp == "~") {
return GetEnvPath("HOME") + '/' + RTemp;
// Normalize a path
// Constracts path/../path
// Can't handle "../../" or "/../" (Asger)
+// Also converts paths like /foo//bar ==> /foo/bar
string const NormalizePath(string const & path)
{
string TempBase;
// Make implicit current directory explicit
RTemp = "./" +path;
+ // Normalise paths like /foo//bar ==> /foo/bar
+ boost::RegEx regex("/{2,}");
+ RTemp = STRCONV(regex.Merge(STRCONV(RTemp), "/"));
+
while (!RTemp.empty()) {
// Split by next /
RTemp = split(RTemp, Temp, '/');
if (ifs && ofs) {
ofs << ifs.rdbuf();
ifs.close();
- return ofs.str().c_str();
+ return STRCONV(ofs.str());
}
}
- lyxerr << "LyX was not able to read file '" << fname << "'" << endl;
+ lyxerr << "LyX was not able to read file '" << fname << '\'' << endl;
return string();
}
string const ReplaceEnvironmentPath(string const & path)
{
-//
-// CompareChar: Environmentvariables starts with this character
-// PathChar: Next path component start with this character
-// while CompareChar found do:
-// Split String with PathChar
-// Search Environmentvariable
-// if found: Replace Strings
-//
+ //
+ // CompareChar: Environment variables starts with this character
+ // PathChar: Next path component start with this character
+ // while CompareChar found do:
+ // Split String with PathChar
+ // Search Environmentvariable
+ // if found: Replace Strings
+ //
char const CompareChar = '$';
char const FirstChar = '{';
char const EndChar = '}';
result1 += res1;
}
return result1;
-} // ReplaceEnvironmentPath
+}
// Make relative path out of two absolute paths
string ext;
// Make sure the extension starts with a dot
if (!extension.empty() && extension[0] != '.')
- ext= "." + extension;
+ ext= '.' + extension;
else
ext = extension;
// AGR Grace...
// BMP BM...
// EPS %!PS-Adobe-3.0 EPSF...
+// FIG #FIG...
// FITS ...BITPIX...
// GIF GIF...
// JPG JFIF
// ...static char *...
// XWD \000\000\000\151 (0x00006900) decimal 105
//
-// GZIP \037\213\010\010... http://www.ietf.org/rfc/rfc1952.txt
+// GZIP \037\213 http://www.ietf.org/rfc/rfc1952.txt
// ZIP PK... http://www.halyava.ru/document/ind_arch.htm
-// Z \037\177 UNIX compress
+// Z \037\235 UNIX compress
/// return the "extension" which belongs to the contents.
/// for no knowing contents return the extension. Without
if (filename.empty() || !IsFileReadable(filename))
return string();
+
ifstream ifs(filename.c_str());
if (!ifs)
// Couldn't open file...
return string();
// gnuzip
- string const gzipStamp = "\037\213\010\010";
+ string const gzipStamp = "\037\213";
// PKZIP
string const zipStamp = "PK";
// compress
- string const compressStamp = "\037\177";
+ string const compressStamp = "\037\235";
// Maximum strings to read
int const max_count = 50;
break;
}
- std::getline(ifs, str);
- lyxerr[Debug::GRAPHICS] << "Scanstring: " << str << endl;
-
+ getline(ifs, str);
string const stamp = str.substr(0,2);
if (firstLine && str.size() >= 2) {
// at first we check for a zipped file, because this
} else if (prefixIs(str,"%TGIF")) {
format = "tgif";
+ } else if (prefixIs(str,"#FIG")) {
+ format = "fig";
+
} else if (prefixIs(str,"GIF")) {
format = "gif";
format = "xwd";
}
}
-
+
firstLine = false;
}
}
if (!format.empty()) {
- lyxerr[Debug::GRAPHICS]
- << "Recognised Fileformat: " << format << endl;
- return format;
+ lyxerr[Debug::GRAPHICS]
+ << "Recognised Fileformat: " << format << endl;
+ return format;
}
string const ext(GetExtension(filename));
string const unzipFile(string const & zipped_file)
{
string const file = ChangeExtension(zipped_file, string());
- string const tempfile = lyx::tempName(string(), file);
+ string const tempfile = tempName(string(), file);
// Run gunzip
string const command = "gunzip -c " + zipped_file + " > " + tempfile;
Systemcall one;
}
-// Creates a nice compact path for displaying
-string const
-MakeDisplayPath (string const & path, unsigned int threshold)
+string const MakeDisplayPath(string const & path, unsigned int threshold)
{
- string::size_type const l1 = path.length();
+ string str = path;
- // First, we try a relative path compared to home
string const home(GetEnvPath("HOME"));
- string relhome = MakeRelPath(path, home);
-
- string::size_type l2 = relhome.length();
-
- string prefix;
- // If we backup from home or don't have a relative path,
- // this try is no good
- if (prefixIs(relhome, "../") || os::is_absolute_path(relhome)) {
- // relative path was no good, just use the original path
- relhome = path;
- l2 = l1;
- } else {
- prefix = "~/";
- }
+ // replace /home/blah with ~/
+ if (prefixIs(str, home))
+ str = subst(str, home, "~");
- // Is the path too long?
- if (l2 > threshold) {
- // Yes, shortend it
- prefix += ".../";
+ if (str.length() <= threshold)
+ return str;
- string temp;
+ string const prefix = ".../";
+ string temp;
- while (relhome.length() > threshold)
- relhome = split(relhome, temp, '/');
+ while (str.length() > threshold)
+ str = split(str, temp, '/');
- // Did we shortend everything away?
- if (relhome.empty()) {
- // Yes, filename in itself is too long.
- // Pick the start and the end of the filename.
- relhome = OnlyFilename(path);
- string const head = relhome.substr(0, threshold/2 - 3);
+ // Did we shorten everything away?
+ if (str.empty()) {
+ // Yes, filename itself is too long.
+ // Pick the start and the end of the filename.
+ str = OnlyFilename(path);
+ string const head = str.substr(0, threshold / 2 - 3);
- l2 = relhome.length();
- string const tail =
- relhome.substr(l2 - threshold/2 - 2, l2 - 1);
- relhome = head + "..." + tail;
- }
+ string::size_type len = str.length();
+ string const tail =
+ str.substr(len - threshold / 2 - 2, len - 1);
+ str = head + "..." + tail;
}
- return prefix + relhome;
+
+ return prefix + str;
}
-bool LyXReadLink(string const & File, string & Link)
+bool LyXReadLink(string const & file, string & link, bool resolve)
{
- char LinkBuffer[512];
+ char linkbuffer[512];
// Should be PATH_MAX but that needs autconf support
- int const nRead = ::readlink(File.c_str(),
- LinkBuffer, sizeof(LinkBuffer) - 1);
+ int const nRead = ::readlink(file.c_str(),
+ linkbuffer, sizeof(linkbuffer) - 1);
if (nRead <= 0)
return false;
- LinkBuffer[nRead] = '\0'; // terminator
- Link = LinkBuffer;
+ linkbuffer[nRead] = '\0'; // terminator
+ if (resolve)
+ link = MakeAbsPath(linkbuffer, OnlyPath(file));
+ else
+ link = linkbuffer;
return true;
}
-namespace {
-
-typedef pair<int, string> cmdret;
-
-cmdret const do_popen(string const & cmd)
+cmd_ret const RunCommand(string const & cmd)
{
// One question is if we should use popen or
// create our own popen based on fork, exec, pipe
// pstream (process stream), with the
// variants ipstream, opstream
- FILE * inf = ::popen(cmd.c_str(), os::read_mode());
+ FILE * inf = ::popen(cmd.c_str(), os::popen_read_mode());
// (Claus Hentschel) Check if popen was succesful ;-)
if (!inf)
return make_pair(pret, ret);
}
-} // namespace anon
-
string const findtexfile(string const & fil, string const & /*format*/)
{
// should help it by setting additional path in the approp. envir.var.
string const kpsecmd = "kpsewhich " + fil;
- cmdret const c = do_popen(kpsecmd);
+ cmd_ret const c = RunCommand(kpsecmd);
- lyxerr[Debug::LATEX] << "kpse status = " << c.first << "\n"
- << "kpse result = `" << strip(c.second, '\n')
- << "'" << endl;
+ lyxerr[Debug::LATEX] << "kpse status = " << c.first << '\n'
+ << "kpse result = `" << rtrim(c.second, "\n")
+ << '\'' << endl;
if (c.first != -1)
- return os::internal_path(strip(strip(c.second, '\n'), '\r'));
+ return os::internal_path(rtrim(c.second, "\n\r"));
else
return string();
}
a += OnlyFilename(filename);
a += '#';
FileInfo const fileinfo(a);
- if (fileinfo.exist()) {
- if (lyx::unlink(a) != 0) {
- Alert::err_alert(_("Could not delete auto-save file!"), a);
- }
- }
+ if (fileinfo.exist())
+ unlink(a);
+}
+
+
+void readBB_lyxerrMessage(string const & file, bool & zipped,
+ string const & message)
+{
+ lyxerr[Debug::GRAPHICS] << "[readBB_from_PSFile] "
+ << message << std::endl;
+#warning Why is this func deleting a file? (Lgb)
+ if (zipped)
+ unlink(file);
}
// end of the file. Than we have in the header:
// %%BoundingBox: (atend)
// In this case we must check the end.
- string const file_ = zippedFile(file) ?
+ bool zipped = zippedFile(file);
+ string const file_ = zipped ?
string(unzipFile(file)) : string(file);
string const format = getExtFromContents(file_);
- if (format != "eps" && format != "ps")
+
+ if (format != "eps" && format != "ps") {
+ readBB_lyxerrMessage(file_, zipped,"no(e)ps-format");
return string();
+ }
std::ifstream is(file_.c_str());
while (is) {
string s;
- std::getline(is,s);
- if (contains(s,"%%BoundingBox:") && !contains(s,"atend"))
- return (frontStrip(s.substr(14)));
+ getline(is,s);
+ if (contains(s,"%%BoundingBox:") && !contains(s,"atend")) {
+ string const bb = ltrim(s.substr(14));
+ readBB_lyxerrMessage(file_, zipped, bb);
+ return bb;
+ }
}
+ readBB_lyxerrMessage(file_, zipped, "no bb found");
return string();
}
+
+string const copyFileToDir(string const & path, string const & file_in)
+{
+ Assert(AbsolutePath(path));
+
+ // First, make the file path relative to path.
+ string file_out = MakeRelPath(path, NormalizePath(file_in));
+ file_out = os::slashify_path(file_out);
+
+ // Now generate a unique filename.
+ // Remove the extension.
+ file_out = ChangeExtension(file_out, string());
+ // Replace '/' in the file name with '_'
+ file_out = subst(file_out, "/", "_");
+ // Replace '.' in the file name with '_'
+ file_out = subst(file_out, ".", "_");
+ // Append a unique ID
+// static int id;
+// file_out += '_' + tostr(id++);
+ // Add the extension back on
+ file_out = ChangeExtension(file_out, GetExtension(file_in));
+ // Put this file in the buffer's temp dir
+ file_out = MakeAbsPath(file_out, path);
+
+ // If the original is newer than the copy, then copy the original
+ // to the new directory.
+ FileInfo fi(file_in);
+ FileInfo fi2(file_out);
+
+ bool success = true;
+ if (fi.exist()) {
+ if (!fi2.exist() ||
+ difftime(fi.getModificationTime(),
+ fi2.getModificationTime()) >= 0)
+ success = copy(file_in, file_out);
+ }
+
+ return success ? file_out : string();
+}
+
+} //namespace support
+} // namespace lyx