* \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
+ * Full author contact details are available in file CREDITS.
*
* General path-mangling functions
*/
#include "debug.h"
#include "support/tostr.h"
#include "support/systemcall.h"
-#include "support/LAssert.h"
#include "filetools.h"
+#include "format.h"
#include "lstrings.h"
#include "FileInfo.h"
-#include "support/path.h" // I know it's OS/2 specific (SMiyata)
+#include "forkedcontr.h"
+#include "path.h"
+#include "path_defines.h"
#include "gettext.h"
#include "lyxlib.h"
#include "os.h"
-#include "Lsstream.h"
+#include <boost/assert.hpp>
+#include <boost/regex.hpp>
+
+#include <fcntl.h>
#include <cctype>
#include <cstdlib>
#include <cstdio>
-#include <fcntl.h>
#include <cerrno>
#include <utility>
#include <fstream>
+#include <sstream>
// Which part of this is still necessary? (JMarc).
#ifndef CXX_GLOBAL_CSTD
using std::fgetc;
-using std::isalpha;
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;
-using std::getline;
-extern string system_lyxdir;
-extern string build_lyxdir;
-extern string user_lyxdir;
+namespace lyx {
+namespace support {
bool IsLyXFilename(string const & filename)
{
{
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;
}
path_element = os::slashify_path(path_element);
if (!suffixIs(path_element, '/'))
path_element+= '/';
- path_element = subst(path_element, "$$LyX", system_lyxdir);
- path_element = subst(path_element, "$$User", user_lyxdir);
+ path_element = subst(path_element, "$$LyX", system_lyxdir());
+ path_element = subst(path_element, "$$User", user_lyxdir());
real_file = FileSearch(path_element, name, ext);
string const LibFileSearch(string const & dir, string const & name,
string const & ext)
{
- string fullname = FileSearch(AddPath(user_lyxdir, dir), name, ext);
+ string fullname = FileSearch(AddPath(user_lyxdir(), dir), name, ext);
if (!fullname.empty())
return fullname;
- if (!build_lyxdir.empty())
- fullname = FileSearch(AddPath(build_lyxdir, dir), name, ext);
+ if (!build_lyxdir().empty())
+ fullname = FileSearch(AddPath(build_lyxdir(), dir), name, ext);
if (!fullname.empty())
return fullname;
- return FileSearch(AddPath(system_lyxdir, dir), name, ext);
+ return FileSearch(AddPath(system_lyxdir(), dir), name, ext);
}
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");
+ if (lang.empty())
+ lang = "C";
}
}
- lang = token(lang, '_', 0);
+ string const language = GetEnv("LANGUAGE");
+ if (lang != "C" && lang != "POSIX" && !language.empty())
+ lang = language;
- if (lang.empty() || lang == "C")
- return LibFileSearch(dir, name, ext);
- else {
- string const tmp = LibFileSearch(dir, lang + '_' + name,
+ 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, ':');
}
+
+ return LibFileSearch(dir, name, ext);
}
} else {
// Replace "$$s/some_script" with "$LYX_SCRIPT_PATH/some_script"
string::size_type const size_replace = size_script + 4;
- command.replace(pos1, size_replace, script);
+ command.replace(pos1, size_replace, QuoteName(script));
}
return command;
bool deleted = true;
FileInfo fi(unlinkpath);
- if (fi.isOK() && fi.isDir())
+ if (fi.isOK() && fi.isDir()) {
deleted = (DeleteAllFilesInDir(unlinkpath) == 0);
- deleted &= (lyx::unlink(unlinkpath) == 0);
+ deleted &= (rmdir(unlinkpath) == 0);
+ } else
+ deleted &= (unlink(unlinkpath) == 0);
if (!deleted)
return_value = -1;
}
}
-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;
+ << "createTmpDir: tempdir=`" << tempdir << "'\n"
+ << "createTmpDir: mask=`" << mask << '\'' << endl;
- string const tmpfl(lyx::tempName(tempdir, mask));
+ string const tmpfl(tempName(tempdir, mask));
// lyx::tempName actually creates a file to make sure that it
// stays unique. So we have to delete it before we can create
// a dir with the same name. Note also that we are not thread
// safe because of the gap between unlink and mkdir. (Lgb)
- lyx::unlink(tmpfl.c_str());
+ unlink(tmpfl);
- if (tmpfl.empty() || lyx::mkdir(tmpfl, 0700))
+ if (tmpfl.empty() || mkdir(tmpfl, 0700)) {
+ lyxerr << "LyX could not create the temporary directory '"
+ << tmpfl << "'" << endl;
return string();
+ }
return MakeAbsPath(tmpfl);
}
int destroyDir(string const & tmpdir)
{
#ifdef __EMX__
- Path p(user_lyxdir);
+ Path p(user_lyxdir());
#endif
if (DeleteAllFilesInDir(tmpdir))
return -1;
- if (lyx::rmdir(tmpdir))
+ if (rmdir(tmpdir))
return -1;
return 0;
}
-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)) {
+ string const tmpfl = os::getTmpDir() + "/lyx_tmpbuf" + tostr(count++);
+ if (mkdir(tmpfl, 0777)) {
+ lyxerr << "LyX could not create the temporary directory '"
+ << tmpfl << "'" << endl;
return string();
}
return tmpfl;
}
-string const CreateLyXTmpDir(string const & deflt)
+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)) {
+ if (IsDirWriteable(deflt))
+ // 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
+ // some other error occured.
#ifdef __EMX__
- Path p(user_lyxdir);
+ Path p(user_lyxdir());
#endif
- return CreateTmpDir(deflt, "lyx_tmpdir");
+ return createTmpDir("/tmp", "lyx_tmpdir");
} else
return deflt;
} else {
#ifdef __EMX__
- Path p(user_lyxdir);
+ Path p(user_lyxdir());
#endif
- return CreateTmpDir("/tmp", "lyx_tmpdir");
+ return createTmpDir("/tmp", "lyx_tmpdir");
}
}
{
string temp(rtrim(os::slashify_path(path), "/"));
- lyx::Assert(!temp.empty());
+ BOOST_ASSERT(!temp.empty());
- if (lyx::mkdir(temp, permission))
+ if (mkdir(temp, permission))
return false;
return true;
if (os::is_absolute_path(BasePath))
TempBase = BasePath;
else
- TempBase = AddPath(lyx::getcwd(), BasePath);
+ TempBase = AddPath(getcwd(), BasePath);
// Handle /./ at the end of the path
while (suffixIs(TempBase, "/./"))
RTemp = split(RTemp, Temp, '/');
if (Temp == ".") {
- return lyx::getcwd() /*GetCWD()*/ + '/' + RTemp;
+ return getcwd() + '/' + RTemp;
}
if (Temp == "~") {
return GetEnvPath("HOME") + '/' + RTemp;
// Normalize a path
// Constracts path/../path
// Can't handle "../../" or "/../" (Asger)
+// Also converts paths like /foo//bar ==> /foo/bar
string const NormalizePath(string const & path)
{
string TempBase;
// Make implicit current directory explicit
RTemp = "./" +path;
+ // Normalise paths like /foo//bar ==> /foo/bar
+ boost::RegEx regex("/{2,}");
+ RTemp = regex.Merge(RTemp, "/");
+
while (!RTemp.empty()) {
// Split by next /
RTemp = split(RTemp, Temp, '/');
if (ifs && ofs) {
ofs << ifs.rdbuf();
ifs.close();
- return STRCONV(ofs.str());
+ return ofs.str();
}
}
lyxerr << "LyX was not able to read file '" << fname << '\'' << endl;
}
-//
-// 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: Environment variables starts with this character
- // PathChar: Next path component start with this character
- // while CompareChar found do:
- // Split String with PathChar
- // Search Environmentvariable
- // if found: Replace Strings
- //
- char const CompareChar = '$';
- char const FirstChar = '{';
- char const EndChar = '}';
- 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;
+ result = what.str(1) + GetEnv(what.str(2)) + what.str(3);
}
- return result1;
+ return result;
}
return string();
}
+
+namespace {
+
+class FormatExtensionsEqual : public std::unary_function<Format, bool> {
+public:
+ FormatExtensionsEqual(string const & extension)
+ : extension_(extension) {}
+ bool operator()(Format const & f) const
+ {
+ return f.extension() == extension_;
+ }
+private:
+ string extension_;
+};
+
+} // namespace anon
+
+
// the different filetypes and what they contain in one of the first lines
// (dots are any characters). (Herbert 20020131)
// AGR Grace...
// ...static char *...
// XWD \000\000\000\151 (0x00006900) decimal 105
//
-// GZIP \037\213\010\010... http://www.ietf.org/rfc/rfc1952.txt
+// GZIP \037\213 http://www.ietf.org/rfc/rfc1952.txt
// ZIP PK... http://www.halyava.ru/document/ind_arch.htm
-// Z \037\177 UNIX compress
+// Z \037\235 UNIX compress
/// return the "extension" which belongs to the contents.
/// for no knowing contents return the extension. Without
/// an extension and unknown contents we return "user"
-string const getExtFromContents(string const & filename)
+string const getFormatFromContents(string const & filename)
{
// paranoia check
if (filename.empty() || !IsFileReadable(filename))
return string();
// gnuzip
- string const gzipStamp = "\037\213\010\010";
+ string const gzipStamp = "\037\213";
// PKZIP
string const zipStamp = "PK";
// compress
- string const compressStamp = "\037\177";
+ string const compressStamp = "\037\235";
// Maximum strings to read
int const max_count = 50;
while ((count++ < max_count) && format.empty()) {
if (ifs.eof()) {
lyxerr[Debug::GRAPHICS]
- << "filetools(getExtFromContents)\n"
+ << "filetools(getFormatFromContents)\n"
<< "\tFile type not recognised before EOF!"
<< endl;
break;
string const ext(GetExtension(filename));
lyxerr[Debug::GRAPHICS]
- << "filetools(getExtFromContents)\n"
- << "\tCouldn't find a known Type!\n";
+ << "filetools(getFormatFromContents)\n"
+ << "\tCouldn't find a known format!\n";
if (!ext.empty()) {
- lyxerr[Debug::GRAPHICS]
- << "\twill take the file extension -> "
- << ext << endl;
- return ext;
- } else {
- lyxerr[Debug::GRAPHICS]
- << "\twill use ext or a \"user\" defined format" << endl;
- return "user";
+ // this is ambigous if two formats have the same extension,
+ // but better than nothing
+ Formats::const_iterator cit =
+ find_if(formats.begin(), formats.end(),
+ FormatExtensionsEqual(ext));
+ if (cit != formats.end()) {
+ lyxerr[Debug::GRAPHICS]
+ << "\twill guess format from file extension: "
+ << ext << " -> " << cit->name() << endl;
+ return cit->name();
+ }
}
+ lyxerr[Debug::GRAPHICS]
+ << "\twill use a \"user\" defined format" << endl;
+ return "user";
}
/// 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 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 file = ChangeExtension(zipped_file, string());
- string const tempfile = lyx::tempName(string(), file);
+ string const tempfile = unzipped_file.empty() ?
+ unzippedFileName(zipped_file) : unzipped_file;
// Run gunzip
string const command = "gunzip -c " + zipped_file + " > " + tempfile;
Systemcall one;
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
+ 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);
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);
}
a += '#';
FileInfo const fileinfo(a);
if (fileinfo.exist())
- lyx::unlink(a);
+ unlink(a);
}
{
lyxerr[Debug::GRAPHICS] << "[readBB_from_PSFile] "
<< message << std::endl;
+#ifdef WITH_WARNINGS
+#warning Why is this func deleting a file? (Lgb)
+#endif
if (zipped)
- lyx::unlink(file);
+ unlink(file);
}
bool zipped = zippedFile(file);
string const file_ = zipped ?
string(unzipFile(file)) : string(file);
- string const format = getExtFromContents(file_);
+ string const format = getFormatFromContents(file_);
if (format != "eps" && format != "ps") {
readBB_lyxerrMessage(file_, zipped,"no(e)ps-format");
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.
+ FileInfo f1(file1);
+ FileInfo f2(file2);
+
+ int cmp = 0;
+ if (f1.exist() && f2.exist()) {
+ double const tmp = difftime(f1.getModificationTime(),
+ f2.getModificationTime());
+ if (tmp != 0)
+ cmp = tmp > 0 ? 1 : -1;
+
+ } else if (f1.exist()) {
+ cmp = 1;
+ } else if (f2.exist()) {
+ cmp = -1;
+ }
+
+ return cmp;
+}
+
+} //namespace support
+} // namespace lyx
projects / lyx.git / blobdiff