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
#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 "FileInfo.h"
#include "support/path.h" // I know it's OS/2 specific (SMiyata)
-#include "support/syscall.h"
#include "gettext.h"
#include "lyxlib.h"
+#include "os.h"
// Which part of this is still necessary? (JMarc).
#if HAVE_DIRENT_H
using std::ifstream;
using std::vector;
-#if 0
-using std::getenv;
-using std::isalpha;
-using std::isalnum;
-using std::popen;
-#endif
-
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 const QuoteName(string const & name)
{
- // CHECK Add proper emx support here!
-#ifndef __EMX__
- return "\'" + name + "\'";
-#else
- return name;
-#endif
+ return (os::shell() == os::UNIX) ?
+ "\'" + name + "\'":
+ "\"" + name + "\"";
}
int IsFileWriteable (string const & path)
{
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
}
-//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 const tmpfl(lyx::tempName(path)); //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 {
- FileInfo fi(path);
- if (fi.writable()) return 1;
- return 0;
- }
+ if (tmpfl.empty())
+ return false;
+
+ lyx::unlink(tmpfl);
+ return 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);
{
// This is a non-error checking C/system implementation
string extension(ext);
- if (extension[0] != '.')
+ 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 (prefixIs(fil, extension)) {
+ if (suffixIs(fil, extension)) {
dirlist.push_back(fil);
}
}
vector<string> dirlist;
directory_iterator dit("dir");
while (dit != directory_iterator()) {
- string fil = (*dit).filename;
+ string fil = dit->filename;
if (prefixIs(fil, extension)) {
dirlist.push_back(fil);
}
// Expand Environmentvariables in 'name'
string const tmpname = ReplaceEnvironmentPath(name);
string fullname = MakeAbsPath(tmpname, path);
-
// search first without extension, then with it.
if (IsFileReadable(fullname))
return fullname;
i18nLibFileSearch(string const & dir, string const & name,
string const & ext)
{
- string const 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);
#ifndef __EMX__
string const pathlist = subst(GetEnv(name), ':', ';');
#else
- string const pathlist = subst(GetEnv(name), '\\', '/');
+ string const pathlist = os::slashify_path(GetEnv(name));
#endif
return strip(pathlist, ';');
}
}
-static
+namespace {
+
int DeleteAllFilesInDir (string const & path)
{
// I have decided that we will be using parts from the boost
continue;
string const unlinkpath = AddName (path, temp);
- lyxerr.debug() << "Deleting file: " << unlinkpath << endl;
+ lyxerr[Debug::FILES] << "Deleting file: " << unlinkpath
+ << endl;
bool deleted = true;
if (FileInfo(unlinkpath).isDir())
}
-static
string const CreateTmpDir(string const & tempdir, string const & mask)
{
lyxerr[Debug::FILES]
// safe because of the gap between unlink and mkdir. (Lgb)
lyx::unlink(tmpfl.c_str());
- if (tmpfl.empty() || lyx::mkdir(tmpfl, 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)
{
#ifdef __EMX__
return -1;
}
return 0;
-}
+}
+
+} // namespace anon
string const CreateBufferTmpDir(string const & pathfor)
{
- return CreateTmpDir(pathfor, "lyx_tmpbuf");
+ 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;
}
// 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!"),
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 = lyx::getcwd(); //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);
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);
}
string buf;
if (path != "." && path != "./" && !path.empty()) {
- buf = CleanupPath(path);
+ buf = os::slashify_path(path);
if (!suffixIs(path, '/'))
buf += '/';
}
}
-// Strips filename from path
-string const BasePath(string const & fname)
-{
- if (fname.empty())
- return fname;
-
- string::size_type j = fname.rfind('/');
- if (j == string::npos) // no '/' in fname
- return string();
-
- // Strip to basename
- return fname.substr(0,j + 1);
-}
-
-
-// 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 const ExpandPath(string const & path)
{
// checks for already absolute path
string RTemp(ReplaceEnvironmentPath(path));
- if (AbsolutePath(RTemp))
+ if (os::is_absolute_path(RTemp))
return RTemp;
string Temp;
string RTemp;
string Temp;
- if (AbsolutePath(path))
+ if (os::is_absolute_path(path))
RTemp = path;
else
// Make implicit current directory explicit
}
-string const CleanupPath(string const & path)
-{
-#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
-}
-
-
string const GetFileContents(string const & fname)
{
FileInfo finfo(fname);
if (finfo.exist()) {
ifstream ifs(fname.c_str());
- std::ostringstream ofs;
+ ostringstream ofs;
if (ifs && ofs) {
ofs << ifs.rdbuf();
ifs.close();
// Make relative path out of two absolute paths
-string const 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 const abspath = CleanupPath(abspath0);
- string const basepath = CleanupPath(basepath0);
- if (abspath.empty())
- return "<unknown_path>";
-
string::size_type const abslen = abspath.length();
string::size_type const baselen = basepath.length();
-
- // Find first different character
- string::size_type 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
string const AddPath(string const & path, string const & path_2)
{
string buf;
- string const 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 += '/';
}
else
ext = extension;
- return CleanupPath(oldname.substr(0, last_dot) + ext);
+ return os::slashify_path(oldname.substr(0, last_dot) + ext);
}
// 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;
}
+namespace {
+
typedef pair<int, string> cmdret;
-static
+
cmdret const do_popen(string const & cmd)
{
// One question is if we should use popen or
return make_pair(pret, ret);
}
+} // namespace anon
+
string const
findtexfile(string const & fil, string const & /*format*/)
lyxerr[Debug::LATEX] << "kpse status = " << c.first << "\n"
<< "kpse result = `" << strip(c.second, '\n')
<< "'" << endl;
- return c.first != -1 ? strip(c.second, '\n') : string();
+ if (c.first != -1)
+ return os::internal_path(strip(strip(c.second, '\n'), '\r'));
+ else
+ return string();
}
}
}
}
-
-
-bool WriteableDir(string const & name, string & errorMessage)
-{
- errorMessage.erase();
-
- if (!AbsolutePath(name)) {
- errorMessage = N_("The absolute path is required.");
- return false;
- }
-
- FileInfo const tp(name);
- if (!tp.isDir()) {
- errorMessage = N_("Directory does not exist.");
- return false;
- }
-
- if (!tp.writable()) {
- errorMessage = N_("Cannot write to this directory.");
- return false;
- }
-
- return true;
-}
-
-
-bool ReadableDir(string const & name, string & errorMessage)
-{
- errorMessage.erase();
-
- if (!AbsolutePath(name)) {
- errorMessage = N_("The absolute path is required.");
- return false;
- }
-
- FileInfo const tp(name);
- if (!tp.isDir()) {
- errorMessage = N_("Directory does not exist.");
- return false;
- }
-
- if (!tp.readable()) {
- errorMessage = N_("Cannot read this directory.");
- return false;
- }
-
- return true;
-}
-
-
-bool WriteableFile(string const & name, string & errorMessage)
-{
- // A writeable file is either:
- // * An existing file to which we have write access, or
- // * A file that doesn't yet exist but that would exist in a writeable
- // directory.
-
- errorMessage.erase();
-
- if (name.empty()) {
- errorMessage = N_("No file input.");
- return false;
- }
-
- string const dir = OnlyPath(name);
- if (!AbsolutePath(dir)) {
- errorMessage = N_("The absolute path is required.");
- return false;
- }
-
- FileInfo d(name);
- if (!d.isDir()) {
- d.newFile(dir);
- }
-
- if (!d.isDir()) {
- errorMessage = N_("Directory does not exist.");
- return false;
- }
-
- if (!d.writable()) {
- errorMessage = N_("Cannot write to this directory.");
- return false;
- }
-
- FileInfo f(name);
- if (dir == name || f.isDir()) {
- errorMessage = N_("A file is required, not a directory.");
- return false;
- }
-
- if (f.exist() && !f.writable()) {
- errorMessage = N_("Cannot write to this file.");
- return false;
- }
-
- return true;
-}
-
-
-bool ReadableFile(string const & name, string & errorMessage)
-{
- errorMessage.erase();
-
- if (name.empty()) {
- errorMessage = N_("No file input.");
- return false;
- }
-
- string const dir = OnlyPath(name);
- if (!AbsolutePath(dir)) {
- errorMessage = N_("The absolute path is required.");
- return false;
- }
-
- FileInfo d(name);
- if (!d.isDir()) {
- d.newFile(dir);
- }
-
- if (!d.isDir()) {
- errorMessage = N_("Directory does not exist.");
- return false;
- }
-
- if (!d.readable()) {
- errorMessage = N_("Cannot read from this directory.");
- return false;
- }
-
- FileInfo f(name);
- if (dir == name || f.isDir()) {
- errorMessage = N_("A file is required, not a directory.");
- return false;
- }
-
- if (!f.exist()) {
- errorMessage = N_("File does not exist.");
- return false;
- }
-
- if (!f.readable()) {
- errorMessage = N_("Cannot read from this file.");
- return false;
- }
-
- return true;
-}