Parts Copyright 1985, 1990, 1993 Free Software Foundation, Inc.
Parts Copyright 1996 Asger Alstrup
- See also filetools.H.
+ See also filetools.h.
lyx-filetool.C : tools functions for file/path handling
this file is part of LyX, the High Level Word Processor
#include <config.h>
#include <cctype>
+
#include <utility>
-using std::make_pair;
-using std::pair;
+#include <fstream>
+
+#include "Lsstream.h"
#ifdef __GNUG__
#pragma implementation "filetools.h"
#endif
+#include <cstdlib>
+#include <fcntl.h>
+#include <cerrno>
+#include "debug.h"
+#include "support/lstrings.h"
+
#include "filetools.h"
#include "LSubstring.h"
#include "lyx_gui_misc.h"
#include "support/path.h" // I know it's OS/2 specific (SMiyata)
#include "gettext.h"
#include "lyxlib.h"
+#include "os.h"
// Which part of this is still necessary? (JMarc).
#if HAVE_DIRENT_H
# endif
#endif
+using std::make_pair;
+using std::pair;
+using std::endl;
+using std::ifstream;
+using std::vector;
+
extern string system_lyxdir;
extern string build_lyxdir;
extern string user_lyxdir;
bool IsLyXFilename(string const & filename)
{
- return contains(filename, ".lyx");
+ return suffixIs(lowercase(filename), ".lyx");
}
bool IsSGMLFilename(string const & filename)
{
- return contains(filename, ".sgml");
+ return suffixIs(lowercase(filename), ".sgml");
}
// Substitutes spaces with underscores in filename (and path)
-string MakeLatexName(string const & file)
+string const MakeLatexName(string const & file)
{
string name = OnlyFilename(file);
- string path = OnlyPath(file);
+ string const path = OnlyPath(file);
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 keep("abcdefghijklmnopqrstuvwxyz"
+ string const keep("abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"@!\"'()*+,-./0123456789:;<=>?[]`|");
return AddName(path, name);
}
+
// Substitutes spaces with underscores in filename (and path)
-string QuoteName(string const & name)
+string const QuoteName(string const & name)
{
-#ifdef WITH_WARNINGS
-#warning Add proper emx support here!
-#endif
- string qname = name;
- while (qname.find("'") != string::npos)
- LSubstring(qname, "'") = "\\'";
- return '\'' + qname + '\'';
-}
-
-
-/// Returns an unique name to be used as a temporary file.
-string TmpFileName(string const & dir, string const & mask)
-{// With all these temporary variables, it should be safe enough :-) (JMarc)
- string tmpdir;
- if (dir.empty())
- tmpdir = system_tempdir;
- else
- tmpdir = dir;
- string tmpfl = AddName(tmpdir, mask);
-
- // find a uniq postfix for the filename...
- // using the pid, and...
- tmpfl += tostr(getpid());
- // a short string...
- string ret;
- FileInfo fnfo;
- for (int a = 'a'; a <= 'z'; ++a)
- for (int b = 'a'; b <= 'z'; ++b)
- for (int c = 'a'; c <= 'z'; ++c) {
- // if this is not enough I have no idea what
- // to do.
- ret = tmpfl + char(a) + char(b) + char(c);
- // check if the file exist
- if (!fnfo.newFile(ret).exist())
- return ret;
- }
- lyxerr << "Not able to find a uniq tmpfile name." << endl;
- return string();
+ return (os::shell() == os::UNIX) ?
+ "\'" + name + "\'":
+ "\"" + name + "\"";
}
// -1 error (doesn't exist, no access, anything else)
int IsFileWriteable (string const & path)
{
- FilePtr fp(path, FilePtr::update);
- if (!fp()) {
- if ((errno == EACCES) || (errno == EROFS)) {
- fp.reopen(path, FilePtr::read);
- if (fp()) {
- return 0;
- }
- }
- return -1;
- }
- return 1;
+ FileInfo fi(path);
+ //lyxerr << "fi : " << fi << endl;
+ //lyxerr << "fi.exists" << fi.exist() << endl;
+ if (fi.access(FileInfo::wperm|FileInfo::rperm)) // read-write
+ return 1;
+ if (fi.readable()) // read-only
+ return 0;
+ return -1; // everything else.
}
-//returns 1: dir writeable
-// 0: not writeable
-// -1: error- couldn't find out
-int IsDirWriteable (string const & path)
+//returns true: dir writeable
+// false: not writeable
+bool IsDirWriteable (string const & path)
{
- string tmpfl = TmpFileName(path);
+ lyxerr[Debug::FILES] << "IsDirWriteable: " << path << endl;
+
+ string const tmpfl(lyx::tempName(path, "lyxwritetest"));
- if (tmpfl.empty()) {
- WriteFSAlert(_("LyX Internal Error!"),
- _("Could not test if directory is writeable"));
- return -1;
- } else {
- FilePtr fp(tmpfl, FilePtr::truncate);
- if (!fp()) {
- if (errno == EACCES) {
- return 0;
- } else {
- WriteFSAlert(_("LyX Internal Error!"),
- _("Cannot open directory test file"));
- return -1;
- }
- }
- }
- if (remove(tmpfl.c_str())) {
- WriteFSAlert(_("LyX Internal Error!"),
- _("Created test file but cannot remove it?"));
- return -1;
- }
- return 1;
+ if (tmpfl.empty())
+ return false;
+
+ lyx::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 FileOpenSearch (string const & path, string const & name,
- string const & ext)
+string const FileOpenSearch (string const & path, string const & name,
+ string const & ext)
{
string real_file, path_element;
bool notfound = true;
string tmppath = split(path, path_element, ';');
while (notfound && !path_element.empty()) {
- path_element = CleanupPath(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);
real_file = FileSearch(path_element, name, ext);
-
+
if (real_file.empty()) {
- do {
- tmppath = split(tmppath, path_element, ';');
- } while(!tmppath.empty() && path_element.empty());
+ do {
+ tmppath = split(tmppath, path_element, ';');
+ } while(!tmppath.empty() && path_element.empty());
} else {
- notfound = false;
+ notfound = false;
}
}
#ifdef __EMX__
}
+/// 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, ".");
+ vector<string> dirlist;
+ DIR * dirp = ::opendir(dir.c_str());
+ dirent * dire;
+ while ((dire = ::readdir(dirp))) {
+ string const fil = dire->d_name;
+ 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 FileSearch(string const & path, string const & name,
- string const & 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'
// Expand Environmentvariables in 'name'
- string tmpname = ReplaceEnvironmentPath(name);
+ string const tmpname = ReplaceEnvironmentPath(name);
string fullname = MakeAbsPath(tmpname, path);
-
// search first without extension, then with it.
if (IsFileReadable(fullname))
return fullname;
// 1) user_lyxdir
// 2) build_lyxdir (if not empty)
// 3) system_lyxdir
-string LibFileSearch(string const & dir, string const & name,
- string const & ext)
+string const LibFileSearch(string const & dir, string const & name,
+ string const & 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 (!fullname.empty())
return fullname;
-
+
return FileSearch(AddPath(system_lyxdir, dir), name, ext);
}
-string i18nLibFileSearch(string const & dir, string const & name,
- string const & ext)
+string const
+i18nLibFileSearch(string const & dir, string const & name,
+ string const & ext)
{
- string lang = token(string(GetEnv("LANG")), '_', 0);
-
+ // this comment is 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. */
+
+ string const lc_all = GetEnv("LC_ALL");
+ string lang = GetEnv("LANGUAGE");
+ if (lang.empty() || lc_all == "C") {
+ lang = lc_all;
+ if (lang.empty()) {
+ lang = GetEnv("LANG");
+ }
+ }
+
+ lang = token(lang, '_', 0);
+
if (lang.empty() || lang == "C")
return LibFileSearch(dir, name, ext);
else {
- string tmp = LibFileSearch(dir, lang + '_' + name,
- ext);
+ string const tmp = LibFileSearch(dir, lang + '_' + name,
+ ext);
if (!tmp.empty())
return tmp;
else
}
-string GetEnv(string const & envname)
+string const GetEnv(string const & envname)
{
// f.ex. what about error checking?
char const * const ch = getenv(envname.c_str());
- string envstr = !ch ? "" : ch;
+ string const envstr = !ch ? "" : ch;
return envstr;
}
-string GetEnvPath(string const & name)
+string const GetEnvPath(string const & name)
{
#ifndef __EMX__
- string pathlist = subst(GetEnv(name), ':', ';');
+ string const pathlist = subst(GetEnv(name), ':', ';');
#else
- string pathlist = subst(GetEnv(name), '\\', '/');
+ string const pathlist = os::slashify_path(GetEnv(name));
#endif
return strip(pathlist, ';');
}
bool PutEnv(string const & envstr)
{
-#ifdef WITH_WARNINGS
-#warning Look at and fix this.
-#endif
+ // 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)
- int retval = putenv((new string(envstr))->c_str());
+ // 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 str = envstr.split(varname,'=');
- int retval = setenv(varname.c_str(), str.c_str(), true);
+ 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;
}
-static
+namespace {
+
int DeleteAllFilesInDir (string const & path)
{
- DIR * dir = opendir(path.c_str());
+ // 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) {
+ // WriteFSAlert(_("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))
+ // WriteFSAlert(_("Error! Could not remove file:"),
+ // unlinkpath);
+ // }
+ // return 0;
+ DIR * dir = ::opendir(path.c_str());
if (!dir) {
WriteFSAlert (_("Error! Cannot open directory:"), path);
return -1;
}
struct dirent * de;
+ int return_value = 0;
while ((de = readdir(dir))) {
- string temp = de->d_name;
+ string const temp = de->d_name;
if (temp == "." || temp == "..")
continue;
- string unlinkpath = AddName (path, temp);
+ string const unlinkpath = AddName (path, temp);
- lyxerr.debug() << "Deleting file: " << unlinkpath << endl;
+ lyxerr[Debug::FILES] << "Deleting file: " << unlinkpath
+ << endl;
- if (remove(unlinkpath.c_str()))
+ bool deleted = true;
+ if (FileInfo(unlinkpath).isDir())
+ deleted = (DeleteAllFilesInDir(unlinkpath) == 0);
+ deleted &= (lyx::unlink(unlinkpath) == 0);
+ if (!deleted) {
WriteFSAlert (_("Error! Could not remove file:"),
unlinkpath);
+ return_value = -1;
+ }
}
closedir(dir);
- return 0;
+ return return_value;
}
-static
-string CreateTmpDir (string const & tempdir, string const & mask)
+string const CreateTmpDir(string const & tempdir, string const & mask)
{
- string tmpfl = TmpFileName(tempdir, mask);
+ lyxerr[Debug::FILES]
+ << "CreateTmpDir: tempdir=`" << tempdir << "'\n"
+ << "CreateTmpDir: mask=`" << mask << "'" << endl;
+
+ string const tmpfl(lyx::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()) || mkdir (tmpfl.c_str(), 0777)) {
+ if (tmpfl.empty() || lyx::mkdir(tmpfl, 0700)) {
WriteFSAlert(_("Error! Couldn't create temporary directory:"),
tempdir);
return string();
}
-static
-int DestroyTmpDir (string const & tmpdir, bool Allfiles)
+int DestroyTmpDir(string const & tmpdir, bool Allfiles)
{
#ifdef __EMX__
Path p(user_lyxdir);
#endif
if (Allfiles && DeleteAllFilesInDir(tmpdir)) return -1;
- if (rmdir(tmpdir.c_str())) {
+ if (lyx::rmdir(tmpdir)) {
WriteFSAlert(_("Error! Couldn't delete temporary directory:"),
tmpdir);
return -1;
}
return 0;
-}
+}
+} // namespace anon
-string CreateBufferTmpDir (string const & pathfor)
+
+string const CreateBufferTmpDir(string const & pathfor)
{
- return CreateTmpDir(pathfor, "lyx_bufrtmp");
+ 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)) {
+ WriteFSAlert(_("Error! Couldn't create temporary directory:"),
+ tmpdir);
+ return string();
+ }
+ return tmpfl;
}
-int DestroyBufferTmpDir (string const & tmpdir)
+int DestroyBufferTmpDir(string const & tmpdir)
{
return DestroyTmpDir(tmpdir, true);
}
-string CreateLyXTmpDir (string const & deflt)
+string const CreateLyXTmpDir(string const & deflt)
{
if ((!deflt.empty()) && (deflt != "/tmp")) {
- if (mkdir(deflt.c_str(), 0777)) {
+ if (lyx::mkdir(deflt, 0777)) {
#ifdef __EMX__
Path p(user_lyxdir);
#endif
- string t = CreateTmpDir (deflt.c_str(), "lyx_tmp");
+ string const t(CreateTmpDir(deflt, "lyx_tmpdir"));
return t;
} else
return deflt;
#ifdef __EMX__
Path p(user_lyxdir);
#endif
- string t = CreateTmpDir ("/tmp", "lyx_tmp");
+ string const t(CreateTmpDir("/tmp", "lyx_tmpdir"));
return t;
}
}
-int DestroyLyXTmpDir (string const & 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(CleanupPath(path), '/');
+ string temp(strip(os::slashify_path(path), '/'));
if (temp.empty()) {
WriteAlert(_("Internal error!"),
return false;
}
- if (mkdir(temp.c_str(), permission)) {
+ if (lyx::mkdir(temp, permission)) {
WriteFSAlert (_("Error! Couldn't create directory:"), temp);
return false;
}
}
-// Returns current working directory
-string GetCWD ()
-{
- int n = 256; // Assume path is less than 256 chars
- char * err;
- char * tbuf = new char[n];
-
- // Safe. Hopefully all getcwds behave this way!
- while (((err = lyx::getcwd (tbuf, n)) == 0) && (errno == ERANGE)) {
- // Buffer too small, double the buffersize and try again
- delete[] tbuf;
- n = 2 * n;
- tbuf = new char[n];
- }
-
- string result;
- if (err) result = tbuf;
- delete[] tbuf;
- return result;
-}
-
-
// Strip filename from path name
-string OnlyPath(string const & Filename)
+string const OnlyPath(string const & Filename)
{
// If empty filename, return empty
if (Filename.empty()) return Filename;
// 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 MakeAbsPath(string const & RelPath, string const & BasePath)
+string const MakeAbsPath(string const & RelPath, string const & BasePath)
{
// checks for already absolute path
- if (AbsolutePath(RelPath))
-#ifdef __EMX__
- if(RelPath[0]!= '/' && RelPath[0]!= '\\')
-#endif
+ if (os::is_absolute_path(RelPath))
return RelPath;
// Copies given paths
- string TempRel = CleanupPath(RelPath);
+ string TempRel(os::slashify_path(RelPath));
+ // Since TempRel is NOT absolute, we can safely replace "//" with "/"
+ TempRel = subst(TempRel, "//", "/");
string TempBase;
- if (!BasePath.empty()) {
-#ifndef __EMX__
+ if (os::is_absolute_path(BasePath))
TempBase = BasePath;
-#else
- char * with_drive = new char[_MAX_PATH];
- _abspath(with_drive, BasePath.c_str(), _MAX_PATH);
- TempBase = with_drive;
- delete[] with_drive;
-#endif
- } else
- TempBase = GetCWD();
-#ifdef __EMX__
- if (AbsolutePath(TempRel))
- return TempBase.substr(0, 2) + TempRel;
-#endif
-
+ else
+ TempBase = AddPath(lyx::getcwd(), BasePath);
+
// Handle /./ at the end of the path
while(suffixIs(TempBase, "/./"))
TempBase.erase(TempBase.length() - 2);
// processes relative path
- string RTemp = TempRel;
+ string RTemp(TempRel);
string Temp;
while (!RTemp.empty()) {
if (Temp == ".") continue;
if (Temp == "..") {
// Remove one level of TempBase
- int i = TempBase.length() - 2;
+ string::difference_type i = TempBase.length() - 2;
#ifndef __EMX__
if (i < 0) i = 0;
while (i > 0 && TempBase[i] != '/') --i;
TempBase.erase(i, string::npos);
else
TempBase += '/';
+ } else if (Temp.empty() && !RTemp.empty()) {
+ TempBase = os::current_root() + RTemp;
+ RTemp.erase();
} else {
// Add this piece to TempBase
if (!suffixIs(TempBase, '/'))
}
// returns absolute path
- return TempBase;
+ return os::slashify_path(TempBase);
}
// Correctly append filename to the pathname.
// If pathname is '.', then don't use pathname.
// Chops any path of filename.
-string AddName(string const & path, string const & fname)
+string const AddName(string const & path, string const & fname)
{
// Get basename
- string basename = OnlyFilename(fname);
+ string const basename(OnlyFilename(fname));
string buf;
if (path != "." && path != "./" && !path.empty()) {
- buf = CleanupPath(path);
+ buf = os::slashify_path(path);
if (!suffixIs(path, '/'))
buf += '/';
}
// Strips path from filename
-string OnlyFilename(string const & fname)
+string const OnlyFilename(string const & fname)
{
if (fname.empty())
return fname;
}
-// Is a filename/path absolute?
+/// Returns true is path is absolute
bool AbsolutePath(string const & path)
{
-#ifndef __EMX__
- return (!path.empty() && path[0] == '/');
-#else
- return (!path.empty() && (path[0] == '/' || (isalpha(static_cast<unsigned char>(path[0])) && path.length()>1 && path[1] == ':')));
-#endif
+ 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 ExpandPath(string const & path)
+string const ExpandPath(string const & path)
{
// checks for already absolute path
- string RTemp = ReplaceEnvironmentPath(path);
- if (AbsolutePath(RTemp))
+ string RTemp(ReplaceEnvironmentPath(path));
+ if (os::is_absolute_path(RTemp))
return RTemp;
string Temp;
- string copy(RTemp);
+ string const copy(RTemp);
// Split by next /
- RTemp= split(RTemp, Temp, '/');
+ RTemp = split(RTemp, Temp, '/');
if (Temp == ".") {
- return GetCWD() + '/' + RTemp;
+ return lyx::getcwd() /*GetCWD()*/ + '/' + RTemp;
} else if (Temp == "~") {
return GetEnvPath("HOME") + '/' + RTemp;
} else if (Temp == "..") {
// Normalize a path
// Constracts path/../path
// Can't handle "../../" or "/../" (Asger)
-string NormalizePath(string const & path)
+string const NormalizePath(string const & path)
{
string TempBase;
string RTemp;
string Temp;
- if (AbsolutePath(path))
+ if (os::is_absolute_path(path))
RTemp = path;
else
// Make implicit current directory explicit
TempBase = "./";
} else if (Temp == "..") {
// Remove one level of TempBase
- int i = TempBase.length() - 2;
+ string::difference_type i = TempBase.length() - 2;
while (i > 0 && TempBase[i] != '/')
--i;
if (i >= 0 && TempBase[i] == '/')
return TempBase;
}
-string CleanupPath(string const & path)
+
+string const GetFileContents(string const & fname)
{
-#ifdef __EMX__ /* SMiyata: This should fix searchpath bug. */
- string temppath = subst(path, '\\', '/');
- temppath = subst(temppath, "//", "/");
- return lowercase(temppath);
-#else // On unix, nothing to do
- return path;
-#endif
+ FileInfo finfo(fname);
+ if (finfo.exist()) {
+ ifstream ifs(fname.c_str());
+ ostringstream ofs;
+ if (ifs && ofs) {
+ ofs << ifs.rdbuf();
+ ifs.close();
+ return ofs.str().c_str();
+ }
+ }
+ lyxerr << "LyX was not able to read file '" << fname << "'" << endl;
+ return string();
}
// variable := '$' '{' [A-Za-z_]{[A-Za-z_0-9]*} '}'
//
-string ReplaceEnvironmentPath(string const & path)
+string const ReplaceEnvironmentPath(string const & path)
{
//
// CompareChar: Environmentvariables starts with this character
if (!regexMatch(copy1, RegExp)) {
// No EndChar inside. So we are finished
result1 += CompareString + result0;
- result0.clear();
+ result0.erase();
continue;
}
continue;
}
- string env = GetEnv(res1_contents+1);
+ string env(GetEnv(res1_contents + 1));
if (!env.empty()) {
// Congratulations. Environmentvariable found
result1 += env;
// Make relative path out of two absolute paths
-string MakeRelPath(string const & abspath0, string const & basepath0)
+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
// different, then the absolute path will be used as relative path.
{
- // This is a hack. It should probaly be done in another way. Lgb.
- string abspath = CleanupPath(abspath0);
- string basepath = CleanupPath(basepath0);
- if (abspath.empty())
- return "<unknown_path>";
+ string::size_type const abslen = abspath.length();
+ string::size_type const baselen = basepath.length();
- const int abslen = abspath.length();
- const int baselen = basepath.length();
-
- // Find first different character
- int i = 0;
- while (i < abslen && i < baselen && abspath[i] == basepath[i]) ++i;
-
- // Go back to last /
- if (i < abslen && i < baselen
- || (i<abslen && abspath[i] != '/' && i == baselen)
- || (i<baselen && basepath[i] != '/' && i == abslen))
- {
- if (i) --i; // here was the last match
- while (i && abspath[i] != '/') --i;
- }
+ string::size_type i = os::common_path(abspath, basepath);
if (i == 0) {
// actually no match - cannot make it relative
// Count how many dirs there are in basepath above match
// and append as many '..''s into relpath
string buf;
- int j = i;
+ string::size_type j = i;
while (j < baselen) {
if (basepath[j] == '/') {
- if (j+1 == baselen) break;
+ if (j + 1 == baselen) break;
buf += "../";
}
++j;
// Append sub-directory(ies) to a path in an intelligent way
-string AddPath(string const & path, string const & path_2)
+string const AddPath(string const & path, string const & path_2)
{
string buf;
- string path2 = CleanupPath(path_2);
+ string const path2 = os::slashify_path(path_2);
if (!path.empty() && path != "." && path != "./") {
- buf = CleanupPath(path);
+ buf = os::slashify_path(path);
if (path[path.length() - 1] != '/')
buf += '/';
}
- if (!path2.empty()){
- int p2start = path2.find_first_not_of('/');
-
- int p2end = path2.find_last_not_of('/');
-
- string tmp = path2.substr(p2start, p2end - p2start + 1);
+ if (!path2.empty()) {
+ 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 + '/';
}
return buf;
Strips path off if no_path == true.
If no extension on oldname, just appends.
*/
-string ChangeExtension(string const & oldname, string const & extension,
- bool no_path)
+string const
+ChangeExtension(string const & oldname, string const & extension)
{
- string::size_type last_slash = oldname.rfind('/');
- string::size_type last_dot;
- if (last_slash != string::npos)
- last_dot = oldname.find('.', last_slash);
- else
- last_dot = oldname.rfind('.');
-
+ string::size_type const last_slash = oldname.rfind('/');
+ 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;
- string ret_str;
- if (no_path && last_slash != string::npos) {
- ++last_slash; // step it
- ret_str = oldname.substr(last_slash,
- last_dot - last_slash) + ext;
- } else
- ret_str = oldname.substr(0, last_dot) + ext;
- return CleanupPath(ret_str);
+
+ return os::slashify_path(oldname.substr(0, last_dot) + ext);
+}
+
+
+/// Return the extension of the file (not including the .)
+string const GetExtension(string const & name)
+{
+ string::size_type const last_slash = name.rfind('/');
+ string::size_type const last_dot = name.rfind('.');
+ if (last_dot != string::npos &&
+ (last_slash == string::npos || last_dot > last_slash))
+ return name.substr(last_dot + 1,
+ name.length() - (last_dot + 1));
+ else
+ return string();
}
// Creates a nice compact path for displaying
-string MakeDisplayPath (string const & path, unsigned int threshold)
+string const
+MakeDisplayPath (string const & path, unsigned int threshold)
{
- const int l1 = path.length();
+ string::size_type const l1 = path.length();
// First, we try a relative path compared to home
- string home = GetEnvPath("HOME");
+ string const home(GetEnvPath("HOME"));
string relhome = MakeRelPath(path, home);
- unsigned int l2 = relhome.length();
+ 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, "../") || AbsolutePath(relhome)) {
+ if (prefixIs(relhome, "../") || os::is_absolute_path(relhome)) {
// relative path was no good, just use the original path
relhome = path;
l2 = l1;
// Yes, filename in itself is too long.
// Pick the start and the end of the filename.
relhome = OnlyFilename(path);
- string head = relhome.substr(0, threshold/2 - 3);
+ string const head = relhome.substr(0, threshold/2 - 3);
l2 = relhome.length();
- string tail =
+ string const tail =
relhome.substr(l2 - threshold/2 - 2, l2 - 1);
relhome = head + "..." + tail;
}
{
char LinkBuffer[512];
// Should be PATH_MAX but that needs autconf support
- int 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;
+ LinkBuffer[nRead] = '\0'; // terminator
Link = LinkBuffer;
return true;
}
+namespace {
+
typedef pair<int, string> cmdret;
-static cmdret do_popen(string const & cmd)
+
+cmdret const do_popen(string const & cmd)
{
// 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 and
- FILE * inf = popen(cmd.c_str(), "r");
+ // variants ipstream, opstream
+ FILE * inf = ::popen(cmd.c_str(), "r");
string ret;
int c = fgetc(inf);
while (c != EOF) {
ret += static_cast<char>(c);
c = fgetc(inf);
}
- int pret = pclose(inf);
+ int const pret = pclose(inf);
return make_pair(pret, ret);
}
+} // namespace anon
-string findtexfile(string const & fil, string const & format)
+
+string const
+findtexfile(string const & fil, string const & /*format*/)
{
/* There is no problem to extend this function too use other
methods to look for files. It could be setup to look
Lgb
*/
- // If fil is a file with absolute path we just return it
- if (AbsolutePath(fil)) return fil;
-
- // Check in the current dir.
- if (FileInfo(OnlyFilename(fil)).exist())
- return OnlyFilename(fil);
-
+ // If the file can be found directly, we just return a
+ // absolute path version of it.
+ if (FileInfo(fil).exist())
+ return MakeAbsPath(fil);
+
// No we try to find it using kpsewhich.
- string kpsecmd = "kpsewhich --format= " + format + " " + OnlyFilename(fil);
- cmdret c = do_popen(kpsecmd);
+ // 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
+ // from the name given, by looking for a known extension. If no
+ // known extension is found, the search path for TeX source files
+ // is used."
+ // However, we want to take advantage of the format sine almost all
+ // the different formats has environment variables that can be used
+ // to controll which paths to search. f.ex. bib looks in
+ // BIBINPUTS and TEXBIB. Small list follows:
+ // bib - BIBINPUTS, TEXBIB
+ // bst - BSTINPUTS
+ // graphic/figure - TEXPICTS, TEXINPUTS
+ // ist - TEXINDEXSTYLE, INDEXSTYLE
+ // pk - PROGRAMFONTS, PKFONTS, TEXPKS, GLYPHFONTS, TEXFONTS
+ // tex - TEXINPUTS
+ // tfm - TFMFONTS, TEXFONTS
+ // This means that to use kpsewhich in the best possible way we
+ // should help it by setting additional path in the approp. envir.var.
+ string const kpsecmd = "kpsewhich " + fil;
+
+ cmdret const c = do_popen(kpsecmd);
- lyxerr << "kpse status = " << c.first << "\n"
- << "kpse result = `" << strip(c.second, '\n') << "'" << endl;
- return c.first != -1 ? strip(c.second, '\n') : string();
+ 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'));
+ else
+ return string();
+}
+
+
+void removeAutosaveFile(string const & filename)
+{
+ string a = OnlyPath(filename);
+ a += '#';
+ a += OnlyFilename(filename);
+ a += '#';
+ FileInfo const fileinfo(a);
+ if (fileinfo.exist()) {
+ if (lyx::unlink(a) != 0) {
+ WriteFSAlert(_("Could not delete auto-save file!"), a);
+ }
+ }
}