#include <config.h>
#include "support/convert.h"
-#include "support/systemcall.h"
+#include "support/environment.h"
#include "support/filetools.h"
+#include "support/fs_extras.h"
#include "support/lstrings.h"
-#include "support/FileInfo.h"
-#include "support/forkedcontr.h"
-#include "support/package.h"
-#include "support/path.h"
#include "support/lyxlib.h"
#include "support/os.h"
+#include "support/package.h"
+#include "support/path.h"
+#include "support/systemcall.h"
// FIXME Interface violation
#include "gettext.h"
#include "debug.h"
#include <boost/assert.hpp>
+#include <boost/filesystem/operations.hpp>
#include <boost/regex.hpp>
-#include <boost/tokenizer.hpp>
#include <fcntl.h>
#include <cctype>
+#include <cerrno>
#include <cstdlib>
#include <cstdio>
-#include <cerrno>
#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
-#endif
-
#ifndef CXX_GLOBAL_CSTD
using std::fgetc;
using std::isalnum;
using std::ostringstream;
using std::vector;
+namespace fs = boost::filesystem;
namespace lyx {
namespace support {
-bool IsLyXFilename(string const & filename)
+bool isLyXFilename(string const & filename)
{
return suffixIs(ascii_lowercase(filename), ".lyx");
}
-bool IsSGMLFilename(string const & filename)
+bool isSGMLFilename(string const & filename)
{
return suffixIs(ascii_lowercase(filename), ".sgml");
}
+string const latex_path(string const & original_path,
+ latex_path_extension extension,
+ latex_path_dots dots)
+{
+ // On cygwin, we may need windows or posix style paths.
+ string path = os::latex_path(original_path);
+ path = subst(path, "~", "\\string~");
+ if (path.find(' ') != string::npos) {
+ // We can't use '"' because " is sometimes active (e.g. if
+ // babel is loaded with the "german" option)
+ if (extension == EXCLUDE_EXTENSION) {
+ // ChangeExtension calls os::internal_path internally
+ // so don't use it to remove the extension.
+ string const ext = getExtension(path);
+ string const base = ext.empty() ?
+ path :
+ path.substr(0, path.length() - ext.length() - 1);
+ // ChangeExtension calls os::internal_path internally
+ // so don't use it to re-add the extension.
+ path = "\\string\"" + base + "\\string\"." + ext;
+ } else {
+ path = "\\string\"" + path + "\\string\"";
+ }
+ }
+
+ return dots == ESCAPE_DOTS ? subst(path, ".", "\\lyxdot ") : path;
+}
+
+
// Substitutes spaces with underscores in filename (and path)
-string const MakeLatexName(string const & file)
+string const makeLatexName(string const & file)
{
- string name = OnlyFilename(file);
- string const path = OnlyPath(file);
+ string name = onlyFilename(file);
+ string const path = onlyPath(file);
- for (string::size_type i = 0; i < name.length(); ++i) {
+ for (string::size_type i = 0; i < name.length(); ++i)
name[i] &= 0x7f; // set 8th bit to 0
- };
// ok so we scan through the string twice, but who cares.
- string const keep("abcdefghijklmnopqrstuvwxyz"
+ string const keep = "abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
- "@!\"'()*+,-./0123456789:;<=>?[]`|");
+ "@!\"'()*+,-./0123456789:;<=>?[]`|";
string::size_type pos = 0;
- while ((pos = name.find_first_not_of(keep, pos)) != string::npos) {
+ while ((pos = name.find_first_not_of(keep, pos)) != string::npos)
name[pos++] = '_';
- }
- return AddName(path, name);
-}
-
-// Substitutes spaces with underscores in filename (and path)
-string const QuoteName(string const & name)
-{
- return (os::shell() == os::UNIX) ?
- '\'' + name + '\'':
- '"' + name + '"';
+ return addName(path, name);
}
-// Is a file readable ?
-bool IsFileReadable(string const & path)
+string const quoteName(string const & name, quote_style style)
{
- FileInfo file(path);
- return file.isOK() && file.isRegular() && file.readable();
+ switch(style) {
+ case quote_shell:
+ // This does not work for filenames containing " (windows)
+ // or ' (all other OSes). This can't be changed easily, since
+ // we would need to adapt the command line parser in
+ // Forkedcall::generateChild. Therefore we don't pass user
+ // filenames to child processes if possible. We store them in
+ // a python script instead, where we don't have these
+ // limitations.
+ return (os::shell() == os::UNIX) ?
+ '\'' + name + '\'':
+ '"' + name + '"';
+ case quote_python:
+ return "\"" + subst(subst(name, "\\", "\\\\"), "\"", "\\\"")
+ + "\"";
+ }
+ // shut up stupid compiler
+ return string();
}
-// 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)
+bool isFileReadable(FileName const & filename)
{
- 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.
+ std::string const path = filename.toFilesystemEncoding();
+ 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;
+ lyxerr[Debug::FILES] << "isDirWriteable: " << path << endl;
- string const tmpfl(tempName(path, "lyxwritetest"));
+ string const tmpfl = tempName(path, "lyxwritetest");
if (tmpfl.empty())
return false;
- unlink(tmpfl);
+ unlink(FileName(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,
+FileName const fileOpenSearch(string const & path, string const & name,
string const & ext)
{
- string real_file;
+ FileName real_file;
string path_element;
bool notfound = true;
string tmppath = split(path, path_element, ';');
while (notfound && !path_element.empty()) {
path_element = os::internal_path(path_element);
if (!suffixIs(path_element, '/'))
- path_element+= '/';
+ path_element += '/';
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);
+ real_file = fileSearch(path_element, name, ext);
if (real_file.empty()) {
do {
notfound = false;
}
}
-#ifdef __EMX__
- if (ext.empty() && notfound) {
- real_file = FileOpenSearch(path, name, "exe");
- if (notfound) real_file = FileOpenSearch(path, name, "cmd");
- }
-#endif
return real_file;
}
/// Returns a vector of all files in directory dir having extension ext.
-vector<string> const DirList(string const & dir, string const & ext)
+vector<string> const dirList(string const & dir, string const & ext)
{
- // This is a non-error checking C/system implementation
- string extension;
- if (!ext.empty() && ext[0] != '.')
- extension += '.';
- extension += ext;
-
+ // EXCEPTIONS FIXME. Rewrite needed when we turn on exceptions. (Lgb)
vector<string> dirlist;
- DIR * dirp = ::opendir(dir.c_str());
- if (!dirp) {
+
+ 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, 1, '.');
- 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,
+FileName const fileSearch(string const & path, string const & name,
string const & ext)
{
// if `name' is an absolute path, we ignore the setting of `path'
// Expand Environmentvariables in 'name'
- string const tmpname = ReplaceEnvironmentPath(name);
- string fullname = MakeAbsPath(tmpname, path);
+ string const tmpname = replaceEnvironmentPath(name);
+ FileName fullname(makeAbsPath(tmpname, path));
// search first without extension, then with it.
- if (IsFileReadable(fullname))
+ if (isFileReadable(fullname))
return fullname;
- 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
- return string();
- }
+ if (ext.empty())
+ return FileName();
+ fullname = FileName(changeExtension(fullname.absFilename(), ext));
+ return isFileReadable(fullname) ? fullname : FileName();
}
// 1) user_lyxdir
// 2) build_lyxdir (if not empty)
// 3) system_lyxdir
-string const LibFileSearch(string const & dir, string const & name,
+FileName const libFileSearch(string const & dir, string const & name,
string const & ext)
{
- string fullname = FileSearch(AddPath(package().user_support(), dir),
+ FileName fullname = fileSearch(addPath(package().user_support(), dir),
name, ext);
if (!fullname.empty())
return fullname;
if (!package().build_support().empty())
- fullname = FileSearch(AddPath(package().build_support(), dir),
+ fullname = fileSearch(addPath(package().build_support(), dir),
name, ext);
if (!fullname.empty())
return fullname;
- return FileSearch(AddPath(package().system_support(), dir), name, ext);
+ return fileSearch(addPath(package().system_support(), dir), name, ext);
}
-string const
-i18nLibFileSearch(string const & dir, string const & name,
+FileName const i18nLibFileSearch(string const & dir, string const & name,
string const & ext)
{
// the following comments are from intl/dcigettext.c. We try
/* [Otherwise] We have to proceed with the POSIX methods of
looking to `LC_ALL', `LC_xxx', and `LANG'. */
- string lang = GetEnv("LC_ALL");
+ string lang = getEnv("LC_ALL");
if (lang.empty()) {
- lang = GetEnv("LC_MESSAGES");
+ lang = getEnv("LC_MESSAGES");
if (lang.empty()) {
- lang = GetEnv("LANG");
+ lang = getEnv("LANG");
if (lang.empty())
lang = "C";
}
}
- string const language = GetEnv("LANGUAGE");
+ 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,
+ FileName const tmp = libFileSearch(dir,
token(l, '_', 0) + '_' + name,
ext);
if (!tmp.empty())
lang = split(lang, l, ':');
}
- return LibFileSearch(dir, name, ext);
+ return libFileSearch(dir, name, ext);
}
-string const LibScriptSearch(string const & command_in)
+string const libScriptSearch(string const & command_in, quote_style style)
{
- string const token_scriptpath("$$s/");
+ static 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_script" word within 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("scripts", command.substr(start_script, size_script));
+ string const script =
+ libFileSearch(".", command.substr(start_script, size_script)).absFilename();
if (script.empty()) {
// Replace "$$s/" with ""
command.erase(pos1, 4);
} else {
- // Replace "$$s/some_script" with "$LYX_SCRIPT_PATH/some_script"
+ // 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));
+ command.replace(pos1, size_replace, quoteName(script, style));
}
return command;
}
-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;
-}
-
-
-vector<string> const getEnvPath(string const & name)
-{
- typedef boost::char_separator<char> Separator;
- typedef boost::tokenizer<Separator> Tokenizer;
-
- string const env_var = GetEnv(name);
- Separator const separator(string(1, os::path_separator()).c_str());
- Tokenizer const tokens(env_var, separator);
- Tokenizer::const_iterator it = tokens.begin();
- Tokenizer::const_iterator const end = tokens.end();
-
- std::vector<string> vars;
- for (; it != end; ++it)
- vars.push_back(os::internal_path(*it));
-
- return vars;
-}
-
-
-void setEnvPath(string const & name, vector<string> const & env)
-{
- char const separator(os::path_separator());
- std::ostringstream ss;
- vector<string>::const_iterator it = env.begin();
- vector<string>::const_iterator const end = env.end();
- for (; it != end; ++it) {
- if (ss.tellp() > 0)
- ss << separator;
- ss << os::external_path(*it);
- }
- putEnv(name + "=" + ss.str());
-}
-
-
-bool putEnv(string const & envstr)
-{
- // CHECK Look at and fix this.
- // f.ex. what about error checking?
-
-#if defined (HAVE_SETENV)
- string name;
- string const value = split(envstr, name, '=');
- int const retval = ::setenv(name.c_str(), value.c_str(), true);
-#elif defined (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 = ::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
- // No environment setting function. Can this happen?
- int const retval = 1; //return an error condition.
-#endif
- return retval == 0;
-}
-
-
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) {
- // return -1;
- // }
- // for (; dit != dend; ++dit) {
- // string filename(*dit);
- // if (filename == "." || filename == "..")
- // continue;
- // string unlinkpath(AddName(path, filename));
- // lyx::unlink(unlinkpath);
- // }
- // return 0;
- DIR * dir = ::opendir(path.c_str());
- if (!dir)
- 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 &= (rmdir(unlinkpath) == 0);
- } else
- deleted &= (unlink(unlinkpath) == 0);
- if (!deleted)
- return_value = -1;
- }
- closedir(dir);
- return return_value;
-}
-
-
-string const createTmpDir(string const & tempdir, string const & mask)
+FileName const createTmpDir(FileName const & tempdir, string const & mask)
{
lyxerr[Debug::FILES]
<< "createTmpDir: tempdir=`" << tempdir << "'\n"
<< "createTmpDir: mask=`" << mask << '\'' << endl;
- string const tmpfl(tempName(tempdir, mask));
+ string const tmpfl = tempName(tempdir.absFilename(), 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)
- unlink(tmpfl);
+ unlink(FileName(tmpfl));
- if (tmpfl.empty() || mkdir(tmpfl, 0700)) {
+ if (tmpfl.empty() || mkdir(FileName(tmpfl), 0700)) {
lyxerr << "LyX could not create the temporary directory '"
<< tmpfl << "'" << endl;
- return string();
+ return FileName();
}
- return MakeAbsPath(tmpfl);
+ return FileName(tmpfl);
}
} // namespace anon
-int destroyDir(string const & tmpdir)
+bool destroyDir(string const & tmpdir)
{
-#ifdef __EMX__
- Path p(user_lyxdir());
-#endif
- if (DeleteAllFilesInDir(tmpdir))
- return -1;
-
- if (rmdir(tmpdir))
- return -1;
-
- return 0;
+ try {
+ return fs::remove_all(tmpdir) > 0;
+ } catch (fs::filesystem_error const & fe){
+ lyxerr << "Could not delete " << tmpdir << ". (" << fe.what() << ")" << std::endl;
+ return false;
+ }
}
package().temp_dir() + "/lyx_tmpbuf" +
convert<string>(count++);
- if (mkdir(tmpfl, 0777)) {
+ if (mkdir(FileName(tmpfl), 0777)) {
lyxerr << "LyX could not create the temporary directory '"
<< tmpfl << "'" << endl;
return string();
}
-string const createLyXTmpDir(string const & deflt)
+FileName const createLyXTmpDir(FileName const & deflt)
{
- if (!deflt.empty() && deflt != "/tmp") {
+ if (!deflt.empty() && deflt.absFilename() != "/tmp") {
if (mkdir(deflt, 0777)) {
- if (IsDirWriteable(deflt))
+ if (isDirWriteable(deflt.absFilename())) {
// deflt could not be created because it
// did exist already, so let's create our own
// dir inside deflt.
-#ifdef __EMX__
- Path p(user_lyxdir());
-#endif
return createTmpDir(deflt, "lyx_tmpdir");
- else
+ } else {
// some other error occured.
-#ifdef __EMX__
- Path p(user_lyxdir());
-#endif
- return createTmpDir("/tmp", "lyx_tmpdir");
+ return createTmpDir(FileName("/tmp"), "lyx_tmpdir");
+ }
} else
return deflt;
} else {
-#ifdef __EMX__
- Path p(user_lyxdir());
-#endif
- return createTmpDir("/tmp", "lyx_tmpdir");
+ return createTmpDir(FileName("/tmp"), "lyx_tmpdir");
}
}
bool createDirectory(string const & path, int permission)
{
- string temp(rtrim(os::internal_path(path), "/"));
-
+ string temp = rtrim(os::internal_path(path), "/");
BOOST_ASSERT(!temp.empty());
-
- if (mkdir(temp, permission))
- return false;
-
- return true;
+ return mkdir(FileName(temp), permission) == 0;
}
// Strip filename from path name
-string const OnlyPath(string const & Filename)
+string const onlyPath(string const & filename)
{
// If empty filename, return empty
- if (Filename.empty()) return Filename;
+ if (filename.empty())
+ return filename;
// Find last / or start of filename
- string::size_type j = Filename.rfind('/');
- if (j == string::npos)
- return "./";
- return Filename.substr(0, j + 1);
+ string::size_type j = filename.rfind('/');
+ return j == string::npos ? "./" : filename.substr(0, j + 1);
}
// Convert relative path into absolute path based on a basepath.
// If relpath is absolute, just use that.
// If basepath is empty, use CWD as base.
-string const MakeAbsPath(string const & RelPath, string const & BasePath)
+string const makeAbsPath(string const & relPath, string const & basePath)
{
// checks for already absolute path
- if (os::is_absolute_path(RelPath))
- return RelPath;
+ if (os::is_absolute_path(relPath))
+ return relPath;
// Copies given paths
- string TempRel(os::internal_path(RelPath));
+ string tempRel = os::internal_path(relPath);
// Since TempRel is NOT absolute, we can safely replace "//" with "/"
- TempRel = subst(TempRel, "//", "/");
+ tempRel = subst(tempRel, "//", "/");
- string TempBase;
+ string tempBase;
- if (os::is_absolute_path(BasePath))
- TempBase = BasePath;
+ if (os::is_absolute_path(basePath))
+ tempBase = basePath;
else
- TempBase = AddPath(getcwd(), BasePath);
+ tempBase = addPath(getcwd(), basePath);
// Handle /./ at the end of the path
- while (suffixIs(TempBase, "/./"))
- TempBase.erase(TempBase.length() - 2);
+ while (suffixIs(tempBase, "/./"))
+ tempBase.erase(tempBase.length() - 2);
// processes relative path
- string RTemp(TempRel);
- string Temp;
+ string rTemp = tempRel;
+ string temp;
- while (!RTemp.empty()) {
+ while (!rTemp.empty()) {
// Split by next /
- RTemp = split(RTemp, Temp, '/');
+ rTemp = split(rTemp, temp, '/');
- if (Temp == ".") continue;
- if (Temp == "..") {
+ if (temp == ".") continue;
+ if (temp == "..") {
// Remove one level of TempBase
- string::difference_type i = TempBase.length() - 2;
-#ifndef __EMX__
- if (i < 0) i = 0;
- while (i > 0 && TempBase[i] != '/') --i;
+ string::difference_type i = tempBase.length() - 2;
+ if (i < 0)
+ i = 0;
+ while (i > 0 && tempBase[i] != '/')
+ --i;
if (i > 0)
-#else
- if (i < 2) i = 2;
- while (i > 2 && TempBase[i] != '/') --i;
- if (i > 2)
-#endif
- TempBase.erase(i, string::npos);
+ tempBase.erase(i, string::npos);
else
- TempBase += '/';
- } else if (Temp.empty() && !RTemp.empty()) {
- TempBase = os::current_root() + RTemp;
- RTemp.erase();
+ tempBase += '/';
+ } else if (temp.empty() && !rTemp.empty()) {
+ tempBase = os::current_root() + rTemp;
+ rTemp.erase();
} else {
// Add this piece to TempBase
- if (!suffixIs(TempBase, '/'))
- TempBase += '/';
- TempBase += Temp;
+ if (!suffixIs(tempBase, '/'))
+ tempBase += '/';
+ tempBase += temp;
}
}
// returns absolute path
- return os::internal_path(TempBase);
+ return os::internal_path(tempBase);
}
// Correctly append filename to the pathname.
// If pathname is '.', then don't use pathname.
// Chops any path of filename.
-string const AddName(string const & path, string const & fname)
+string const addName(string const & path, string const & fname)
{
- // Get basename
- string const basename(OnlyFilename(fname));
-
+ string const basename = onlyFilename(fname);
string buf;
if (path != "." && path != "./" && !path.empty()) {
// Strips path from filename
-string const OnlyFilename(string const & fname)
+string const onlyFilename(string const & fname)
{
if (fname.empty())
return fname;
/// Returns true is path is absolute
-bool AbsolutePath(string const & path)
+bool absolutePath(string const & path)
{
return os::is_absolute_path(path);
}
-
// Create absolute path. If impossible, don't do anything
// Supports ./ and ~/. Later we can add support for ~logname/. (Asger)
-string const ExpandPath(string const & path)
+string const expandPath(string const & path)
{
// checks for already absolute path
- string RTemp(ReplaceEnvironmentPath(path));
- if (os::is_absolute_path(RTemp))
- return RTemp;
+ string rTemp = replaceEnvironmentPath(path);
+ if (os::is_absolute_path(rTemp))
+ return rTemp;
- string Temp;
- string const copy(RTemp);
+ string temp;
+ string const copy = rTemp;
// Split by next /
- RTemp = split(RTemp, Temp, '/');
+ rTemp = split(rTemp, temp, '/');
+
+ if (temp == ".")
+ return getcwd() + '/' + rTemp;
+
+ if (temp == "~")
+ return package().home_dir() + '/' + rTemp;
+
+ if (temp == "..")
+ return makeAbsPath(copy);
- if (Temp == ".") {
- return getcwd() + '/' + RTemp;
- }
- if (Temp == "~") {
- return package().home_dir() + '/' + RTemp;
- }
- if (Temp == "..") {
- return MakeAbsPath(copy);
- }
// Don't know how to handle this
return copy;
}
-// Normalize a path
-// Constracts path/../path
+// 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 const normalizePath(string const & path)
{
- string TempBase;
- string RTemp;
- string Temp;
+ // Normalize paths like /foo//bar ==> /foo/bar
+ static boost::regex regex("/{2,}");
+ string const tmppath = boost::regex_merge(path, regex, "/");
- if (os::is_absolute_path(path))
- RTemp = path;
- else
- // Make implicit current directory explicit
- RTemp = "./" +path;
+ fs::path const npath = fs::path(tmppath, fs::no_check).normalize();
- // Normalise paths like /foo//bar ==> /foo/bar
- boost::RegEx regex("/{2,}");
- RTemp = regex.Merge(RTemp, "/");
+ if (!npath.is_complete())
+ return "./" + npath.string() + '/';
- while (!RTemp.empty()) {
- // Split by next /
- RTemp = split(RTemp, Temp, '/');
-
- if (Temp == ".") {
- TempBase = "./";
- } else if (Temp == "..") {
- // Remove one level of TempBase
- string::difference_type i = TempBase.length() - 2;
- while (i > 0 && TempBase[i] != '/')
- --i;
- if (i >= 0 && TempBase[i] == '/')
- TempBase.erase(i + 1, string::npos);
- else
- TempBase = "../";
- } else {
- TempBase += Temp + '/';
- }
- }
-
- // returns absolute path
- return TempBase;
+ return npath.string() + '/';
}
-string const GetFileContents(string const & fname)
+string const getFileContents(FileName const & fname)
{
- FileInfo finfo(fname);
- if (finfo.exist()) {
- ifstream ifs(fname.c_str());
+ string const encodedname = fname.toFilesystemEncoding();
+ if (fs::exists(encodedname)) {
+ ifstream ifs(encodedname.c_str());
ostringstream ofs;
if (ifs && ofs) {
ofs << ifs.rdbuf();
// Search the string for ${VAR} and $VAR and replace VAR using getenv.
-string const ReplaceEnvironmentPath(string const & path)
+string const replaceEnvironmentPath(string const & path)
{
// ${VAR} is defined as
// $\{[A-Za-z_][A-Za-z_0-9]*\}
if (!what[0].matched)
break;
}
- result = what.str(1) + GetEnv(what.str(2)) + what.str(3);
+ result = what.str(1) + getEnv(what.str(2)) + what.str(3);
}
return result;
}
// Make relative path out of two absolute paths
-string const MakeRelPath(string const & abspath, string const & basepath)
+string const makeRelPath(string const & abspath, string const & basepath)
// Makes relative path out of absolute path. If it is deeper than basepath,
// it's easy. If basepath and abspath share something (they are all deeper
// than some directory), it'll be rendered using ..'s. If they are completely
// Append sub-directory(ies) to a path in an intelligent way
-string const AddPath(string const & path, string const & path_2)
+string const addPath(string const & path, string const & path_2)
{
string buf;
string const path2 = os::internal_path(path_2);
Strips path off if no_path == true.
If no extension on oldname, just appends.
*/
-string const ChangeExtension(string const & oldname, string const & extension)
+string const changeExtension(string const & oldname, string const & extension)
{
string::size_type const last_slash = oldname.rfind('/');
string::size_type last_dot = oldname.rfind('.');
}
+string const removeExtension(string const & name)
+{
+ return changeExtension(name, string());
+}
+
+
/// Return the extension of the file (not including the .)
-string const GetExtension(string const & name)
+string const getExtension(string const & name)
{
string::size_type const last_slash = name.rfind('/');
string::size_type const last_dot = name.rfind('.');
// ZIP PK... http://www.halyava.ru/document/ind_arch.htm
// Z \037\235 UNIX compress
-string const getFormatFromContents(string const & filename)
+string const getFormatFromContents(FileName const & filename)
{
// paranoia check
- if (filename.empty() || !IsFileReadable(filename))
+ if (filename.empty() || !isFileReadable(filename))
return string();
- ifstream ifs(filename.c_str());
+ ifstream ifs(filename.toFilesystemEncoding().c_str());
if (!ifs)
// Couldn't open file...
return string();
// gnuzip
- string const gzipStamp = "\037\213";
+ static string const gzipStamp = "\037\213";
// PKZIP
- string const zipStamp = "PK";
+ static string const zipStamp = "PK";
// compress
- string const compressStamp = "\037\235";
+ static string const compressStamp = "\037\235";
// Maximum strings to read
int const max_count = 50;
}
getline(ifs, str);
- string const stamp = str.substr(0,2);
+ 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!
/// check for zipped file
-bool zippedFile(string const & name)
+bool zippedFile(FileName const & name)
{
string const type = getFormatFromContents(name);
if (contains("gzip zip compress", type) && !type.empty())
string const unzippedFileName(string const & zipped_file)
{
- string const ext = GetExtension(zipped_file);
+ string const ext = getExtension(zipped_file);
if (ext == "gz" || ext == "z" || ext == "Z")
- return ChangeExtension(zipped_file, string());
+ return changeExtension(zipped_file, string());
return "unzipped_" + zipped_file;
}
-string const unzipFile(string const & zipped_file, string const & unzipped_file)
+FileName const unzipFile(FileName const & zipped_file, string const & unzipped_file)
{
- string const tempfile = unzipped_file.empty() ?
- unzippedFileName(zipped_file) : unzipped_file;
+ FileName const tempfile = FileName(unzipped_file.empty() ?
+ unzippedFileName(zipped_file.toFilesystemEncoding()) :
+ unzipped_file);
// Run gunzip
- string const command = "gunzip -c " + zipped_file + " > " + tempfile;
+ string const command = "gunzip -c " +
+ zipped_file.toFilesystemEncoding() + " > " +
+ tempfile.toFilesystemEncoding();
Systemcall one;
one.startscript(Systemcall::Wait, command);
// test that command was executed successfully (anon)
}
-string const MakeDisplayPath(string const & path, unsigned int threshold)
+docstring const makeDisplayPath(string const & path, unsigned int threshold)
{
string str = path;
-
- string const home(package().home_dir());
+ string const home = package().home_dir();
// replace /home/blah with ~/
- if (prefixIs(str, home))
+ if (!home.empty() && prefixIs(str, home))
str = subst(str, home, "~");
if (str.length() <= threshold)
- return str;
+ return lyx::from_utf8(os::external_path(str));
string const prefix = ".../";
string temp;
if (str.empty()) {
// Yes, filename itself is too long.
// Pick the start and the end of the filename.
- str = OnlyFilename(path);
+ str = onlyFilename(path);
string const head = str.substr(0, threshold / 2 - 3);
string::size_type len = str.length();
str = head + "..." + tail;
}
- return prefix + str;
+ return lyx::from_utf8(os::external_path(prefix + str));
}
-bool LyXReadLink(string const & file, string & link, bool resolve)
+bool readLink(string const & file, string & link, bool resolve)
{
#ifdef HAVE_READLINK
char linkbuffer[512];
return false;
linkbuffer[nRead] = '\0'; // terminator
if (resolve)
- link = MakeAbsPath(linkbuffer, OnlyPath(file));
+ link = makeAbsPath(linkbuffer, onlyPath(file));
else
link = linkbuffer;
return true;
}
-cmd_ret const RunCommand(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
// pstream (process stream), with the
// variants ipstream, opstream
- sigset_t newMask, oldMask;
- sigemptyset(&oldMask);
- sigemptyset(&newMask);
- sigaddset(&newMask, SIGCHLD);
-
- // Block the SIGCHLD signal.
- sigprocmask(SIG_BLOCK, &newMask, &oldMask);
-
+#if defined (HAVE_POPEN)
FILE * inf = ::popen(cmd.c_str(), os::popen_read_mode());
+#elif defined (HAVE__POPEN)
+ FILE * inf = ::_popen(cmd.c_str(), os::popen_read_mode());
+#else
+#error No popen() function.
+#endif
// (Claus Hentschel) Check if popen was succesful ;-)
if (!inf) {
- return make_pair(-1, string());
lyxerr << "RunCommand:: could not start child process" << endl;
- }
+ return make_pair(-1, string());
+ }
string ret;
int c = fgetc(inf);
ret += static_cast<char>(c);
c = fgetc(inf);
}
+
+#if defined (HAVE_PCLOSE)
int const pret = pclose(inf);
+#elif defined (HAVE__PCLOSE)
+ int const pret = _pclose(inf);
+#else
+#error No pclose() function.
+#endif
+
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);
}
// If the file can be found directly, we just return a
// absolute path version of it.
- if (FileInfo(fil).exist())
- return MakeAbsPath(fil);
+ if (fs::exists(fil))
+ return makeAbsPath(fil);
// No we try to find it using kpsewhich.
// It seems from the kpsewhich manual page that it is safe to use
// should help it by setting additional path in the approp. envir.var.
string const kpsecmd = "kpsewhich " + fil;
- cmd_ret const c = RunCommand(kpsecmd);
+ cmd_ret const c = runCommand(kpsecmd);
lyxerr[Debug::LATEX] << "kpse status = " << c.first << '\n'
<< "kpse result = `" << rtrim(c.second, "\n")
void removeAutosaveFile(string const & filename)
{
- string a = OnlyPath(filename);
+ string a = onlyPath(filename);
a += '#';
- a += OnlyFilename(filename);
+ a += onlyFilename(filename);
a += '#';
- FileInfo const fileinfo(a);
- if (fileinfo.exist())
- unlink(a);
+ FileName const autosave(a);
+ if (fs::exists(autosave.toFilesystemEncoding()))
+ unlink(autosave);
}
-void readBB_lyxerrMessage(string const & file, bool & zipped,
+void readBB_lyxerrMessage(FileName const & file, bool & zipped,
string const & message)
{
lyxerr[Debug::GRAPHICS] << "[readBB_from_PSFile] "
}
-string const readBB_from_PSFile(string const & file)
+string const readBB_from_PSFile(FileName 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,
// %%BoundingBox: (atend)
// In this case we must check the end.
bool zipped = zippedFile(file);
- string const file_ = zipped ?
- string(unzipFile(file)) : string(file);
+ FileName const file_ = zipped ? unzipFile(file) : file;
string const format = getFormatFromContents(file_);
if (format != "eps" && format != "ps") {
return string();
}
- std::ifstream is(file_.c_str());
+ static boost::regex bbox_re(
+ "^%%BoundingBox:\\s*([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)");
+ std::ifstream is(file_.toFilesystemEncoding().c_str());
while (is) {
string s;
getline(is,s);
- if (contains(s,"%%BoundingBox:") && !contains(s,"atend")) {
- string const bb = ltrim(s.substr(14));
+ boost::smatch what;
+ if (regex_match(s, what, bbox_re)) {
+ // Our callers expect the tokens in the string
+ // separated by single spaces.
+ // FIXME: change return type from string to something
+ // sensible
+ ostringstream os;
+ os << what.str(1) << ' ' << what.str(2) << ' '
+ << what.str(3) << ' ' << what.str(4);
+ string const bb = os.str();
readBB_lyxerrMessage(file_, zipped, bb);
return bb;
}
}
-int compare_timestamps(string const & file1, string const & file2)
+int compare_timestamps(FileName const & filename1, FileName const & filename2)
{
- BOOST_ASSERT(AbsolutePath(file1) && AbsolutePath(file2));
-
// If the original is newer than the copy, then copy the original
// to the new directory.
- FileInfo f1(file1);
- FileInfo f2(file2);
+ string const file1 = filename1.toFilesystemEncoding();
+ string const file2 = filename2.toFilesystemEncoding();
int cmp = 0;
- if (f1.exist() && f2.exist()) {
- double const tmp = difftime(f1.getModificationTime(),
- f2.getModificationTime());
+ 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 (f1.exist()) {
+ } else if (fs::exists(file1)) {
cmp = 1;
- } else if (f2.exist()) {
+ } else if (fs::exists(file2)) {
cmp = -1;
}