-/*
- 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 Voß
+ *
+ * Full author contact details are available in file CREDITS.
+ *
+ * General path-mangling functions
+ */
#include <config.h>
-#include <cctype>
+#include "support/convert.h"
+#include "support/environment.h"
+#include "support/filetools.h"
+#include "support/forkedcontr.h"
+#include "support/fs_extras.h"
+#include "support/lstrings.h"
+#include "support/lyxlib.h"
+#include "support/os.h"
+#include "support/package.h"
+#include "support/path.h"
+#include "support/systemcall.h"
-#include <utility>
-#include <fstream>
+// FIXME Interface violation
+#include "gettext.h"
+#include "debug.h"
-#include "Lsstream.h"
+#include <boost/assert.hpp>
+#include <boost/filesystem/operations.hpp>
+#include <boost/regex.hpp>
-#ifdef __GNUG__
-#pragma implementation "filetools.h"
-#endif
+#include <fcntl.h>
+#include <cctype>
#include <cstdlib>
-#include <cstdio>
-#include <fcntl.h>
+#include <cstdio>
#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>
+#include <sstream>
-// Which part of this is still necessary? (JMarc).
-#if HAVE_DIRENT_H
-# include <dirent.h>
-# define NAMLEN(dirent) strlen((dirent)->d_name)
-#else
-# define dirent direct
-# define NAMLEN(dirent) (dirent)->d_namlen
-# if HAVE_SYS_NDIR_H
-# include <sys/ndir.h>
-# endif
-# if HAVE_SYS_DIR_H
-# include <sys/dir.h>
-# endif
-# if HAVE_NDIR_H
-# include <ndir.h>
-# endif
+#ifndef CXX_GLOBAL_CSTD
+using std::fgetc;
+using std::isalnum;
+using std::isalpha;
#endif
-using std::make_pair;
-using std::pair;
using std::endl;
+using std::getline;
+using std::make_pair;
+using std::string;
using std::ifstream;
+using std::ostringstream;
using std::vector;
-extern string system_lyxdir;
-extern string build_lyxdir;
-extern string user_lyxdir;
-extern string system_tempdir;
-extern string system_packageList;
+namespace fs = boost::filesystem;
+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 name = OnlyFilename(file);
string const path = OnlyPath(file);
-
+
for (string::size_type i = 0; i < name.length(); ++i) {
name[i] &= 0x7f; // set 8th bit to 0
};
string const keep("abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"@!\"'()*+,-./0123456789:;<=>?[]`|");
-
+
string::size_type pos = 0;
while ((pos = name.find_first_not_of(keep, pos)) != string::npos) {
name[pos++] = '_';
}
-// Substitutes spaces with underscores in filename (and path)
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;
-}
-
-
-// Is a file read_only?
-// return 1 read-write
-// 0 read_only
-// -1 error (doesn't exist, no access, anything else)
-int IsFileWriteable (string const & path)
-{
- FileInfo fi(path);
-
- if (fi.access(FileInfo::wperm|FileInfo::rperm)) // read-write
- return 1;
- if (fi.readable()) // read-only
- return 0;
- return -1; // everything else.
+ return fs::exists(path) && !fs::is_directory(path) && fs::is_readable(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, ';');
-
+
while (notfound && !path_element.empty()) {
- path_element = os::slashify_path(path_element);
+ path_element = os::internal_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",
+ package().system_support());
+ path_element = subst(path_element, "$$User",
+ package().user_support());
+
real_file = FileSearch(path_element, name, ext);
-
+
if (real_file.empty()) {
do {
tmppath = split(tmppath, path_element, ';');
/// Returns a vector of all files in directory dir having extension 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, ".");
+ // EXCEPTIONS FIXME. Rewrite needed when we turn on exceptions. (Lgb)
vector<string> dirlist;
- DIR * dirp = ::opendir(dir.c_str());
- if (!dirp) {
- lyxerr[Debug::FILES]
+
+ if (!(fs::exists(dir) && fs::is_directory(dir))) {
+ lyxerr[Debug::FILES]
<< "Directory \"" << dir
<< "\" does not exist to DirList." << endl;
return dirlist;
}
-
- dirent * dire;
- while ((dire = ::readdir(dirp))) {
- string const fil = dire->d_name;
+
+ string extension;
+ if (!ext.empty() && ext[0] != '.')
+ extension += '.';
+ extension += ext;
+
+ fs::directory_iterator dit(dir);
+ fs::directory_iterator end;
+ for (; dit != end; ++dit) {
+ string const & fil = dit->leaf();
if (suffixIs(fil, extension)) {
dirlist.push_back(fil);
}
}
- ::closedir(dirp);
return dirlist;
- /* I would have prefered to take a vector<string>& as parameter so
- that we could avoid the copy of the vector when returning.
- Then we would use:
- dirlist.swap(argvec);
- to avoid the copy. (Lgb)
- */
- /* A C++ implementaion will look like this:
- string extension(ext);
- if (extension[0] != '.') extension.insert(0, ".");
- vector<string> dirlist;
- directory_iterator dit("dir");
- while (dit != directory_iterator()) {
- string fil = dit->filename;
- if (prefixIs(fil, extension)) {
- dirlist.push_back(fil);
- }
- ++dit;
- }
- dirlist.swap(argvec);
- return;
- */
}
// Returns the real name of file name in directory path, with optional
-// extension ext.
-string const FileSearch(string const & path, string const & name,
+// extension ext.
+string const FileSearch(string const & path, string const & name,
string const & ext)
{
// if `name' is an absolute path, we ignore the setting of `path'
// search first without extension, then with it.
if (IsFileReadable(fullname))
return fullname;
- else if (ext.empty())
+ else if (ext.empty())
return string();
else { // Is it not more reasonable to use ChangeExtension()? (SMiyata)
fullname += '.';
fullname += ext;
if (IsFileReadable(fullname))
return fullname;
- else
+ else
return string();
}
}
// 1) user_lyxdir
// 2) build_lyxdir (if not empty)
// 3) system_lyxdir
-string const LibFileSearch(string const & dir, string const & name,
+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(package().user_support(), dir),
+ name, ext);
if (!fullname.empty())
return fullname;
-
- if (!build_lyxdir.empty())
- fullname = FileSearch(AddPath(build_lyxdir, dir), name, ext);
+
+ if (!package().build_support().empty())
+ fullname = FileSearch(AddPath(package().build_support(), dir),
+ name, ext);
if (!fullname.empty())
return fullname;
-
- return FileSearch(AddPath(system_lyxdir, dir), name, ext);
+
+ return FileSearch(AddPath(package().system_support(), dir), name, ext);
}
string const
-i18nLibFileSearch(string const & dir, string const & name,
+i18nLibFileSearch(string const & dir, string const & name,
string const & ext)
{
- // this comment is from intl/dcigettext.c. We try to mimick this
- // behaviour here.
+ // the following comments are from intl/dcigettext.c. We try
+ // to mimick this behaviour here.
/* The highest priority value is the `LANGUAGE' environment
variable. But we don't use the value if the currently
selected locale is the C locale. This is a GNU extension. */
+ /* [Otherwise] We have to proceed with the POSIX methods of
+ looking to `LC_ALL', `LC_xxx', and `LANG'. */
- string const lc_all = GetEnv("LC_ALL");
- string lang = GetEnv("LANGUAGE");
- if (lang.empty() || lc_all == "C") {
- lang = lc_all;
+ string lang = getEnv("LC_ALL");
+ if (lang.empty()) {
+ lang = getEnv("LC_MESSAGES");
if (lang.empty()) {
- lang = GetEnv("LANG");
+ lang = getEnv("LANG");
+ if (lang.empty())
+ lang = "C";
}
}
-
- lang = token(lang, '_', 0);
-
- if (lang.empty() || lang == "C")
- return LibFileSearch(dir, name, ext);
- else {
- string const tmp = LibFileSearch(dir, lang + '_' + name,
+
+ string const language = getEnv("LANGUAGE");
+ if (lang != "C" && lang != "POSIX" && !language.empty())
+ lang = language;
+
+ string l;
+ lang = split(lang, l, ':');
+ while (!l.empty() && l != "C" && l != "POSIX") {
+ string const tmp = LibFileSearch(dir,
+ token(l, '_', 0) + '_' + name,
ext);
if (!tmp.empty())
return tmp;
- else
- return LibFileSearch(dir, name, ext);
+ lang = split(lang, l, ':');
}
-}
-
-string const GetEnv(string const & envname)
-{
- // f.ex. what about error checking?
- char const * const ch = getenv(envname.c_str());
- string const envstr = !ch ? "" : ch;
- return envstr;
+ return LibFileSearch(dir, name, ext);
}
-string const GetEnvPath(string const & name)
+string const LibScriptSearch(string const & command_in)
{
-#ifndef __EMX__
- string const pathlist = subst(GetEnv(name), ':', ';');
-#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;
-}
-
+ 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;
+ // Find the end of the "$$s/some_subdir/some_script" word within
+ // command. Assumes that the script name does not contain spaces.
+ 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(".", command.substr(start_script, size_script));
+
+ if (script.empty()) {
+ // Replace "$$s/" with ""
+ command.erase(pos1, 4);
+ } else {
+ // Replace "$$s/foo/some_script" with "<path to>/some_script".
+ string::size_type const size_replace = size_script + 4;
+ command.replace(pos1, size_replace, QuoteName(script));
+ }
-bool PutEnvPath(string const & envstr)
-{
- return PutEnv(envstr);
+ return command;
}
namespace {
-int DeleteAllFilesInDir (string const & path)
-{
- // I have decided that we will be using parts from the boost
- // library. Check out http://www.boost.org/
- // For directory access we will then use the directory_iterator.
- // Then the code will be something like:
- // directory_iterator dit(path);
- // directory_iterator dend;
- // if (dit == dend) {
- // Alert::err_alert(_("Error! Cannot open directory:"), path);
- // return -1;
- // }
- // for (; dit != dend; ++dit) {
- // string filename(*dit);
- // if (filename == "." || filename == "..")
- // continue;
- // string unlinkpath(AddName(path, filename));
- // if (lyx::unlink(unlinkpath))
- // Alert::err_alert(_("Error! Could not remove file:"),
- // unlinkpath);
- // }
- // return 0;
- DIR * dir = ::opendir(path.c_str());
- if (!dir) {
- Alert::err_alert (_("Error! Cannot open directory:"), path);
- return -1;
- }
- struct dirent * de;
- int return_value = 0;
- while ((de = readdir(dir))) {
- string const temp = de->d_name;
- if (temp == "." || temp == "..")
- continue;
- string const unlinkpath = AddName (path, temp);
-
- lyxerr[Debug::FILES] << "Deleting file: " << unlinkpath
- << endl;
-
- bool deleted = true;
- 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);
- return_value = -1;
- }
- }
- closedir(dir);
- return return_value;
-}
-
-
-string const CreateTmpDir(string const & tempdir, string const & mask)
+string const createTmpDir(string const & tempdir, string const & mask)
{
lyxerr[Debug::FILES]
- << "CreateTmpDir: tempdir=`" << tempdir << "'\n"
- << "CreateTmpDir: mask=`" << mask << "'" << endl;
-
- string const tmpfl(lyx::tempName(tempdir, mask));
+ << "createTmpDir: tempdir=`" << tempdir << "'\n"
+ << "createTmpDir: mask=`" << mask << '\'' << endl;
+
+ 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());
-
- if (tmpfl.empty() || lyx::mkdir(tmpfl, 0700)) {
- Alert::err_alert(_("Error! Couldn't create temporary directory:"),
- tempdir);
+ unlink(tmpfl);
+
+ if (tmpfl.empty() || mkdir(tmpfl, 0700)) {
+ lyxerr << "LyX could not create the temporary directory '"
+ << tmpfl << "'" << endl;
return string();
}
+
return MakeAbsPath(tmpfl);
}
+} // namespace anon
-int DestroyTmpDir(string const & tmpdir, bool Allfiles)
+
+bool destroyDir(string const & tmpdir)
{
+
#ifdef __EMX__
- Path p(user_lyxdir);
+ Path p(user_lyxdir());
#endif
- if (Allfiles && DeleteAllFilesInDir(tmpdir)) {
- return -1;
- }
- if (lyx::rmdir(tmpdir)) {
- Alert::err_alert(_("Error! Couldn't delete temporary directory:"),
- tmpdir);
- return -1;
- }
- return 0;
+ return fs::remove_all(tmpdir) > 0;
}
-} // namespace anon
-
-string const CreateBufferTmpDir(string const & pathfor)
+string const createBufferTmpDir()
{
static int count;
- static string const tmpdir(pathfor.empty() ? os::getTmpDir() : pathfor);
// We are in our own directory. Why bother to mangle name?
- // 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);
+ // In fact I wrote this code to circumvent a problematic behaviour
+ // (bug?) of EMX mkstemp().
+ string const tmpfl =
+ package().temp_dir() + "/lyx_tmpbuf" +
+ convert<string>(count++);
+
+ if (mkdir(tmpfl, 0777)) {
+ lyxerr << "LyX could not create the temporary directory '"
+ << tmpfl << "'" << endl;
return string();
}
return tmpfl;
}
-int DestroyBufferTmpDir(string const & tmpdir)
+string const createLyXTmpDir(string const & deflt)
{
- return DestroyTmpDir(tmpdir, true);
-}
-
-
-string const CreateLyXTmpDir(string const & deflt)
-{
- if ((!deflt.empty()) && (deflt != "/tmp")) {
- if (lyx::mkdir(deflt, 0777)) {
+ if (!deflt.empty() && deflt != "/tmp") {
+ if (mkdir(deflt, 0777)) {
#ifdef __EMX__
- Path p(user_lyxdir);
+ Path p(package().user_support());
#endif
- return CreateTmpDir(deflt, "lyx_tmpdir");
+ if (IsDirWriteable(deflt)) {
+ // deflt could not be created because it
+ // did exist already, so let's create our own
+ // dir inside deflt.
+ return createTmpDir(deflt, "lyx_tmpdir");
+ } else {
+ // some other error occured.
+ return createTmpDir("/tmp", "lyx_tmpdir");
+ }
} else
return deflt;
} else {
#ifdef __EMX__
- Path p(user_lyxdir);
+ Path p(package().user_support());
#endif
- return CreateTmpDir("/tmp", "lyx_tmpdir");
+ 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::internal_path(path), "/"));
- if (temp.empty()) {
- Alert::alert(_("Internal error!"),
- _("Call to createDirectory with invalid name"));
- return false;
- }
+ BOOST_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;
}
return RelPath;
// Copies given paths
- string TempRel(os::slashify_path(RelPath));
+ string TempRel(os::internal_path(RelPath));
// Since TempRel is NOT absolute, we can safely replace "//" with "/"
TempRel = subst(TempRel, "//", "/");
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, "/./"))
TempBase.erase(TempBase.length() - 2);
while (!RTemp.empty()) {
// Split by next /
RTemp = split(RTemp, Temp, '/');
-
+
if (Temp == ".") continue;
if (Temp == "..") {
// Remove one level of TempBase
}
// returns absolute path
- return os::slashify_path(TempBase);
+ return os::internal_path(TempBase);
}
string buf;
if (path != "." && path != "./" && !path.empty()) {
- buf = os::slashify_path(path);
+ buf = os::internal_path(path);
if (!suffixIs(path, '/'))
buf += '/';
}
RTemp = split(RTemp, Temp, '/');
if (Temp == ".") {
- return lyx::getcwd() /*GetCWD()*/ + '/' + RTemp;
+ return getcwd() + '/' + RTemp;
}
if (Temp == "~") {
- return GetEnvPath("HOME") + '/' + RTemp;
+ return package().home_dir() + '/' + RTemp;
}
if (Temp == "..") {
return MakeAbsPath(copy);
// 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 = regex.Merge(RTemp, "/");
+
while (!RTemp.empty()) {
// Split by next /
RTemp = split(RTemp, Temp, '/');
-
+
if (Temp == ".") {
TempBase = "./";
} else if (Temp == "..") {
}
// returns absolute path
- return TempBase;
+ return TempBase;
}
string const GetFileContents(string const & fname)
{
- FileInfo finfo(fname);
- if (finfo.exist()) {
+ if (fs::exists(fname)) {
ifstream ifs(fname.c_str());
ostringstream ofs;
if (ifs && ofs) {
ofs << ifs.rdbuf();
ifs.close();
- return ofs.str().c_str();
+ return ofs.str();
}
}
- lyxerr << "LyX was not able to read file '" << fname << "'" << endl;
+ lyxerr << "LyX was not able to read file '" << fname << '\'' << endl;
return string();
}
-//
-// Search ${...} as Variable-Name inside the string and replace it with
-// the denoted environmentvariable
-// Allow Variables according to
-// variable := '$' '{' [A-Za-z_]{[A-Za-z_0-9]*} '}'
-//
-
+// Search the string for ${VAR} and $VAR and replace VAR using getenv.
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
-//
- char const CompareChar = '$';
- char const FirstChar = '{';
- char const EndChar = '}';
- char const UnderscoreChar = '_';
- string EndString; EndString += EndChar;
- string FirstString; FirstString += FirstChar;
- string CompareString; CompareString += CompareChar;
- string const RegExp("*}*"); // Exist EndChar inside a String?
-
-// first: Search for a '$' - Sign.
- //string copy(path);
- string result1; //(copy); // for split-calls
- string result0 = split(path, result1, CompareChar);
- while (!result0.empty()) {
- string copy1(result0); // contains String after $
-
- // Check, if there is an EndChar inside original String.
-
- if (!regexMatch(copy1, RegExp)) {
- // No EndChar inside. So we are finished
- result1 += CompareString + result0;
- result0.erase();
- continue;
- }
-
- string res1;
- string res0 = split(copy1, res1, EndChar);
- // Now res1 holds the environmentvariable
- // First, check, if Contents is ok.
- if (res1.empty()) { // No environmentvariable. Continue Loop.
- result1 += CompareString + FirstString;
- result0 = res0;
- continue;
- }
- // check contents of res1
- char const * res1_contents = res1.c_str();
- if (*res1_contents != FirstChar) {
- // Again No Environmentvariable
- result1 += CompareString;
- result0 = res0;
- }
-
- // Check for variable names
- // Situation ${} is detected as "No Environmentvariable"
- char const * cp1 = res1_contents + 1;
- bool result = isalpha(*cp1) || (*cp1 == UnderscoreChar);
- ++cp1;
- while (*cp1 && result) {
- result = isalnum(*cp1) ||
- (*cp1 == UnderscoreChar);
- ++cp1;
- }
-
- if (!result) {
- // no correct variable name
- result1 += CompareString + res1 + EndString;
- result0 = split(res0, res1, CompareChar);
- result1 += res1;
- continue;
- }
-
- string env(GetEnv(res1_contents + 1));
- if (!env.empty()) {
- // Congratulations. Environmentvariable found
- result1 += env;
- } else {
- result1 += CompareString + res1 + EndString;
+ // ${VAR} is defined as
+ // $\{[A-Za-z_][A-Za-z_0-9]*\}
+ static string const envvar_br = "[$]\\{([A-Za-z_][A-Za-z_0-9]*)\\}";
+
+ // $VAR is defined as:
+ // $\{[A-Za-z_][A-Za-z_0-9]*\}
+ static string const envvar = "[$]([A-Za-z_][A-Za-z_0-9]*)";
+
+ static boost::regex envvar_br_re("(.*)" + envvar_br + "(.*)");
+ static boost::regex envvar_re("(.*)" + envvar + "(.*)");
+ boost::smatch what;
+
+ string result = path;
+ while (1) {
+ regex_match(result, what, envvar_br_re);
+ if (!what[0].matched) {
+ regex_match(result, what, envvar_re);
+ if (!what[0].matched)
+ break;
}
- // Next $-Sign?
- result0 = split(res0, res1, CompareChar);
- result1 += res1;
- }
- return result1;
-} // ReplaceEnvironmentPath
+ result = what.str(1) + getEnv(what.str(2)) + what.str(3);
+ }
+ return result;
+}
// Make relative path out of two absolute paths
string const AddPath(string const & path, string const & path_2)
{
string buf;
- string const path2 = os::slashify_path(path_2);
+ string const path2 = os::internal_path(path_2);
if (!path.empty() && path != "." && path != "./") {
- buf = os::slashify_path(path);
+ buf = os::internal_path(path);
if (path[path.length() - 1] != '/')
buf += '/';
}
if (!path2.empty()) {
- string::size_type const p2start = path2.find_first_not_of('/');
+ string::size_type const p2start = path2.find_first_not_of('/');
string::size_type const p2end = path2.find_last_not_of('/');
string const tmp = path2.substr(p2start, p2end - p2start + 1);
buf += tmp + '/';
}
-/*
+/*
Change extension of oldname to extension.
Strips path off if no_path == true.
If no extension on oldname, just appends.
string::size_type last_dot = oldname.rfind('.');
if (last_dot < last_slash && last_slash != string::npos)
last_dot = string::npos;
-
+
string ext;
// Make sure the extension starts with a dot
if (!extension.empty() && extension[0] != '.')
- ext= "." + extension;
+ ext= '.' + extension;
else
ext = extension;
- return os::slashify_path(oldname.substr(0, last_dot) + ext);
+ return os::internal_path(oldname.substr(0, last_dot) + ext);
}
return string();
}
+
// the different filetypes and what they contain in one of the first lines
-// (dots are any characters). (Herbert 20020131)
+// (dots are any characters). (Herbert 20020131)
// AGR Grace...
// BMP BM...
// EPS %!PS-Adobe-3.0 EPSF...
+// FIG #FIG...
// FITS ...BITPIX...
// GIF GIF...
// JPG JFIF
// PDF %PDF-...
// PNG .PNG...
-// PBM P1... or P4 (B/W)
+// PBM P1... or P4 (B/W)
// PGM P2... or P5 (Grayscale)
-// PPM P3... or P6 (color)
+// PPM P3... or P6 (color)
// PS %!PS-Adobe-2.0 or 1.0, no "EPSF"!
// SGI \001\332... (decimal 474)
// TGIF %TGIF...
// TIFF II... or MM...
-// XBM ... static char ...
-// XPM /* XPM */
-// XWD \000\000\000\151 (0x00006900)
+// XBM ..._bits[]...
+// XPM /* XPM */ sometimes missing (f.ex. tgif-export)
+// ...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
-
-/// return the "extension" which belongs to the contents
-/// for no knowing contents return the extension. Without
-/// an extension and unknown contents we return "user"
-string const getExtFromContents(string const & filename) {
- if (filename.empty() || !IsFileReadable(filename))
- return string(); // paranoia check
+// Z \037\235 UNIX compress
+
+string const getFormatFromContents(string const & filename)
+{
+ // paranoia check
+ if (filename.empty() || !IsFileReadable(filename))
+ return string();
+
ifstream ifs(filename.c_str());
- if (!ifs)
- return string(); // Couldn't open file...
- string const gzipStamp = "\037\213\010\010"; // gnuzip
- string const zipStamp = "PK"; // PKZIP
- string const compressStamp = "\037\177"; // compress
- int const max_count = 50; // Maximum strings to read
- int count = 0; // Counter of attempts.
+ if (!ifs)
+ // Couldn't open file...
+ return string();
+
+ // gnuzip
+ string const gzipStamp = "\037\213";
+
+ // PKZIP
+ string const zipStamp = "PK";
+
+ // compress
+ string const compressStamp = "\037\235";
+
+ // Maximum strings to read
+ int const max_count = 50;
+ int count = 0;
+
string str;
+ string format;
bool firstLine = true;
- for (; count < max_count; ++count) {
+ while ((count++ < max_count) && format.empty()) {
if (ifs.eof()) {
- lyxerr[Debug::GRAPHICS] << "filetools(getExtFromContents)\n"
- "\tEnd of file reached and it wasn't found a known Type!" << endl;
+ lyxerr[Debug::GRAPHICS]
+ << "filetools(getFormatFromContents)\n"
+ << "\tFile type not recognised before EOF!"
+ << endl;
break;
}
- ifs >> str;
- if (firstLine) {
- // at first we check for a zipped file, because this information
- // is saved in the first bytes of the file!
- // also some graphic formats which save the information
- // in the first line, too.
- if (str.substr(0,4) == gzipStamp)
- return "gzip";
- string const stamp = str.substr(0,2);
- if (stamp == zipStamp)
- return "zip";
- else if (stamp == compressStamp)
- return "compress";
- // the graphics part
- else if (stamp == "BM")
- return "bmp";
- else if (str.at(0) == 'P') { // PBM family
- switch (str.at(1)) {
- case '1':
- case '4':
- return "pbm";
-
- case '2':
- case '5':
- return "pgm";
-
- case '3':
- case '6':
- return "ppm";
+
+ 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
+ // information is saved in the first bytes of the file!
+ // also some graphic formats which save the information
+ // in the first line, too.
+ if (prefixIs(str, gzipStamp)) {
+ format = "gzip";
+
+ } else if (stamp == zipStamp) {
+ format = "zip";
+
+ } else if (stamp == compressStamp) {
+ format = "compress";
+
+ // the graphics part
+ } else if (stamp == "BM") {
+ format = "bmp";
+
+ } else if (stamp == "\001\332") {
+ format = "sgi";
+
+ // PBM family
+ // Don't need to use str.at(0), str.at(1) because
+ // we already know that str.size() >= 2
+ } else if (str[0] == 'P') {
+ switch (str[1]) {
+ case '1':
+ case '4':
+ format = "pbm";
+ break;
+ case '2':
+ case '5':
+ format = "pgm";
+ break;
+ case '3':
+ case '6':
+ format = "ppm";
+ }
+ break;
+
+ } else if ((stamp == "II") || (stamp == "MM")) {
+ format = "tiff";
+
+ } else if (prefixIs(str,"%TGIF")) {
+ format = "tgif";
+
+ } else if (prefixIs(str,"#FIG")) {
+ format = "fig";
+
+ } else if (prefixIs(str,"GIF")) {
+ format = "gif";
+
+ } else if (str.size() > 3) {
+ int const c = ((str[0] << 24) & (str[1] << 16) &
+ (str[2] << 8) & str[3]);
+ if (c == 105) {
+ format = "xwd";
+ }
}
- }
- if (stamp == "\001\332")
- return "sgi";
- else if ((stamp == "II") || (stamp == "MM"))
- return "tiff";
- else if (str.substr(0,3) == "GIF")
- return "gif";
-// else if ((str.at(3) == 'i') && (str.at(0) == '\000') &&
-// (str.at(1) == '\000') && (str.at(2) == '\000'))
-// return "xwd";
- firstLine = false;
+
+ firstLine = false;
}
- if (contains(str,"EPSF")) // dummy, if we have wrong file
- return "eps"; // description like "%!PS-Adobe-2.0EPSF"
- else if (contains(str,"TGIF"))
- return "tgif";
+
+ if (!format.empty())
+ break;
+ else if (contains(str,"EPSF"))
+ // dummy, if we have wrong file description like
+ // %!PS-Adobe-2.0EPSF"
+ format = "eps";
+
else if (contains(str,"Grace"))
- return "agr";
+ format = "agr";
+
else if (contains(str,"JFIF"))
- return "jpg";
+ format = "jpg";
+
else if (contains(str,"%PDF"))
- return "pdf";
+ format = "pdf";
+
else if (contains(str,"PNG"))
- return "png";
- else if (contains(str,"%!PS-Adobe")) { // eps or ps
- ifs >> str;
- if (contains(str,"EPSF"))
- return "eps";
- else
- return "ps";
- } else if (contains(str,"static char"))
- return "xbm";
- else if (contains(str,"XPM"))
- return "xpm";
+ format = "png";
+
+ else if (contains(str,"%!PS-Adobe")) {
+ // eps or ps
+ ifs >> str;
+ if (contains(str,"EPSF"))
+ format = "eps";
+ else
+ format = "ps";
+ }
+
+ else if (contains(str,"_bits[]"))
+ format = "xbm";
+
+ else if (contains(str,"XPM") || contains(str, "static char *"))
+ format = "xpm";
+
else if (contains(str,"BITPIX"))
- return "fits";
+ format = "fits";
}
- lyxerr[Debug::GRAPHICS] << "filetools(getExtFromContents)\n"
- "\tCouldn't find a known Type!"
- "\twill use ext or a \"user\" defined format" << endl;
- string const ext(GetExtension(filename));
- if (!ext.empty())
- return ext;
- return "user";
+
+ if (!format.empty()) {
+ lyxerr[Debug::GRAPHICS]
+ << "Recognised Fileformat: " << format << endl;
+ return format;
+ }
+
+ lyxerr[Debug::GRAPHICS]
+ << "filetools(getFormatFromContents)\n"
+ << "\tCouldn't find a known format!\n";
+ return string();
}
/// check for zipped file
bool zippedFile(string const & name)
{
- string const type = getExtFromContents(name);
+ string const type = getFormatFromContents(name);
if (contains("gzip zip compress", type) && !type.empty())
return true;
return false;
}
-string const unzipFile(string const & zipped_file)
+string const unzippedFileName(string const & zipped_file)
{
- string const file = ChangeExtension(zipped_file, string());
- string const tempfile = lyx::tempName(string(), file);
+ string const ext = GetExtension(zipped_file);
+ if (ext == "gz" || ext == "z" || ext == "Z")
+ return ChangeExtension(zipped_file, string());
+ return "unzipped_" + zipped_file;
+}
+
+
+string const unzipFile(string const & zipped_file, string const & unzipped_file)
+{
+ string const tempfile = unzipped_file.empty() ?
+ unzippedFileName(zipped_file) : unzipped_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 const home(package().home_dir());
- string::size_type l2 = relhome.length();
+ // replace /home/blah with ~/
+ if (prefixIs(str, home))
+ str = subst(str, home, "~");
- string prefix;
+ if (str.length() <= threshold)
+ return str;
- // 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 = "~/";
- }
+ string const prefix = ".../";
+ string temp;
- // Is the path too long?
- if (l2 > threshold) {
- // Yes, shortend it
- prefix += ".../";
-
- string temp;
-
- while (relhome.length() > threshold)
- relhome = split(relhome, 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);
-
- l2 = relhome.length();
- string const tail =
- relhome.substr(l2 - threshold/2 - 2, l2 - 1);
- relhome = head + "..." + tail;
- }
+ while (str.length() > threshold)
+ str = split(str, temp, '/');
+
+ // 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);
+
+ 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];
+#ifdef HAVE_READLINK
+ 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;
+#else
+ return false;
+#endif
}
-namespace {
-
-typedef pair<int, string> cmdret;
-
-cmdret const do_popen(string const & cmd)
+cmd_ret const RunCommand(string const & cmd)
{
+ // FIXME: replace all calls to RunCommand with ForkedCall
+ // (if the output is not needed) or the code in ispell.C
+ // (if the output is needed).
+
// One question is if we should use popen or
// create our own popen based on fork, exec, pipe
// of course the best would be to have a
// pstream (process stream), with the
// variants ipstream, opstream
- FILE * inf = ::popen(cmd.c_str(), os::read_mode());
+ sigset_t newMask, oldMask;
+ sigemptyset(&oldMask);
+ sigemptyset(&newMask);
+ sigaddset(&newMask, SIGCHLD);
+
+ // Block the SIGCHLD signal.
+ sigprocmask(SIG_BLOCK, &newMask, &oldMask);
+
+ FILE * inf = ::popen(cmd.c_str(), os::popen_read_mode());
// (Claus Hentschel) Check if popen was succesful ;-)
- if (!inf)
+ if (!inf) {
return make_pair(-1, string());
-
+ lyxerr << "RunCommand:: could not start child process" << endl;
+ }
+
string ret;
int c = fgetc(inf);
while (c != EOF) {
c = fgetc(inf);
}
int const pret = pclose(inf);
+ if (pret == -1)
+ perror("RunCommand:: could not terminate child process");
+
+ // Unblock the SIGCHLD signal and restore the old mask.
+ sigprocmask(SIG_SETMASK, &oldMask, 0);
+
return make_pair(pret, ret);
}
-} // namespace anon
-
string const findtexfile(string const & fil, string const & /*format*/)
{
going to implement this until I see some demand for it.
Lgb
*/
-
+
// If the file can be found directly, we just return a
- // absolute path version of it.
- if (FileInfo(fil).exist())
+ // absolute path version of it.
+ if (fs::exists(fil))
return MakeAbsPath(fil);
- // No we try to find it using kpsewhich.
+ // No we try to find it using kpsewhich.
// It seems from the kpsewhich manual page that it is safe to use
// kpsewhich without --format: "When the --format option is not
// given, the search path used when looking for a file is inferred
// 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;
- if (c.first != -1)
- return os::internal_path(strip(strip(c.second, '\n'), '\r'));
+ lyxerr[Debug::LATEX] << "kpse status = " << c.first << '\n'
+ << "kpse result = `" << rtrim(c.second, "\n")
+ << '\'' << endl;
+ if (c.first != -1)
+ return os::internal_path(rtrim(c.second, "\n\r"));
else
return string();
}
a += '#';
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 (fs::exists(a))
+ unlink(a);
+}
+
+
+void readBB_lyxerrMessage(string const & file, bool & zipped,
+ string const & message)
+{
+ lyxerr[Debug::GRAPHICS] << "[readBB_from_PSFile] "
+ << message << std::endl;
+#ifdef WITH_WARNINGS
+#warning Why is this func deleting a file? (Lgb)
+#endif
+ if (zipped)
+ unlink(file);
+}
+
+
+string const readBB_from_PSFile(string const & file)
+{
+ // in a (e)ps-file it's an entry like %%BoundingBox:23 45 321 345
+ // It seems that every command in the header has an own line,
+ // getline() should work for all files.
+ // On the other hand some plot programs write the bb at the
+ // end of the file. Than we have in the header:
+ // %%BoundingBox: (atend)
+ // In this case we must check the end.
+ bool zipped = zippedFile(file);
+ string const file_ = zipped ?
+ string(unzipFile(file)) : string(file);
+ string const format = getFormatFromContents(file_);
+
+ 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;
+ 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();
}
+int compare_timestamps(string const & file1, string const & file2)
+{
+ BOOST_ASSERT(AbsolutePath(file1) && AbsolutePath(file2));
+
+ // If the original is newer than the copy, then copy the original
+ // to the new directory.
+
+ int cmp = 0;
+ if (fs::exists(file1) && fs::exists(file2)) {
+ double const tmp = difftime(fs::last_write_time(file1),
+ fs::last_write_time(file2));
+ if (tmp != 0)
+ cmp = tmp > 0 ? 1 : -1;
+
+ } else if (fs::exists(file1)) {
+ cmp = 1;
+ } else if (fs::exists(file2)) {
+ cmp = -1;
+ }
+
+ return cmp;
+}
+
+} //namespace support
+} // namespace lyx