#include <config.h>
-#include "debug.h"
#include "support/tostr.h"
#include "support/systemcall.h"
-
-#include "filetools.h"
-#include "lstrings.h"
-#include "FileInfo.h"
-#include "path.h"
-#include "path_defines.h"
+#include "support/filetools.h"
+#include "support/lstrings.h"
+#include "support/FileInfo.h"
+#include "support/forkedcontr.h"
+#include "support/path.h"
+#include "support/path_defines.h"
+#include "support/lyxlib.h"
+#include "support/os.h"
+
+// FIXME Interface violation
#include "gettext.h"
-#include "lyxlib.h"
-#include "os.h"
-
-#include "support/std_sstream.h"
+#include "debug.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).
string tmppath = split(path, path_element, ';');
while (notfound && !path_element.empty()) {
- path_element = os::slashify_path(path_element);
+ path_element = os::internal_path(path_element);
if (!suffixIs(path_element, '/'))
path_element+= '/';
path_element = subst(path_element, "$$LyX", system_lyxdir());
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'. On some systems
- this can be done by the `setlocale' function itself. */
+ looking to `LC_ALL', `LC_xxx', and `LANG'. */
-#if defined HAVE_SETLOCALE && defined HAVE_LC_MESSAGES && defined HAVE_LOCALE_NULL
- lang = setlocale(LC_MESSAGES, NULL);
-#else
string lang = GetEnv("LC_ALL");
if (lang.empty()) {
lang = GetEnv("LC_MESSAGES");
lang = "C";
}
}
-#endif
string const language = GetEnv("LANGUAGE");
- if (lang != "C" && !language.empty())
+ if (lang != "C" && lang != "POSIX" && !language.empty())
lang = language;
- lang = token(lang, '_', 0);
-
- 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;
#ifndef __EMX__
string const pathlist = subst(GetEnv(name), ':', ';');
#else
- string const pathlist = os::slashify_path(GetEnv(name));
+ string const pathlist = os::internal_path(GetEnv(name));
#endif
return rtrim(pathlist, ";");
}
bool deleted = true;
FileInfo fi(unlinkpath);
- if (fi.isOK() && fi.isDir())
+ if (fi.isOK() && fi.isDir()) {
deleted = (DeleteAllFilesInDir(unlinkpath) == 0);
- deleted &= (unlink(unlinkpath) == 0);
+ deleted &= (rmdir(unlinkpath) == 0);
+ } else
+ deleted &= (unlink(unlinkpath) == 0);
if (!deleted)
return_value = -1;
}
// 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 = os::getTmpDir() + "/lyx_tmpbuf" + tostr(count++);
+ string const tmpfl = os::getTmpDir() + "/lyx_tmpbuf" + convert<string>(count++);
if (mkdir(tmpfl, 0777)) {
lyxerr << "LyX could not create the temporary directory '"
<< tmpfl << "'" << endl;
bool createDirectory(string const & path, int permission)
{
- string temp(rtrim(os::slashify_path(path), "/"));
+ string temp(rtrim(os::internal_path(path), "/"));
BOOST_ASSERT(!temp.empty());
return RelPath;
// Copies given paths
- string TempRel(os::slashify_path(RelPath));
+ string TempRel(os::internal_path(RelPath));
// Since TempRel is NOT absolute, we can safely replace "//" with "/"
TempRel = subst(TempRel, "//", "/");
}
// returns absolute path
- return os::slashify_path(TempBase);
+ return os::internal_path(TempBase);
}
string buf;
if (path != "." && path != "./" && !path.empty()) {
- buf = os::slashify_path(path);
+ buf = os::internal_path(path);
if (!suffixIs(path, '/'))
buf += '/';
}
return getcwd() + '/' + RTemp;
}
if (Temp == "~") {
- return GetEnvPath("HOME") + '/' + RTemp;
+ return os::homepath() + '/' + RTemp;
}
if (Temp == "..") {
return MakeAbsPath(copy);
string const AddPath(string const & path, string const & path_2)
{
string buf;
- string const path2 = os::slashify_path(path_2);
+ string const path2 = os::internal_path(path_2);
if (!path.empty() && path != "." && path != "./") {
- buf = os::slashify_path(path);
+ buf = os::internal_path(path);
if (path[path.length() - 1] != '/')
buf += '/';
}
else
ext = extension;
- return os::slashify_path(oldname.substr(0, last_dot) + ext);
+ return os::internal_path(oldname.substr(0, last_dot) + ext);
}
return string();
}
+
// the different filetypes and what they contain in one of the first lines
// (dots are any characters). (Herbert 20020131)
// AGR Grace...
// ZIP PK... http://www.halyava.ru/document/ind_arch.htm
// 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();
-
ifstream ifs(filename.c_str());
if (!ifs)
// Couldn't open file...
int const max_count = 50;
int count = 0;
- string str, format;
+ string str;
+ string format;
bool firstLine = true;
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;
return format;
}
- string const ext(GetExtension(filename));
lyxerr[Debug::GRAPHICS]
- << "filetools(getExtFromContents)\n"
- << "\tCouldn't find a known Type!\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";
- }
+ << "filetools(getFormatFromContents)\n"
+ << "\tCouldn't find a known format!\n";
+ return string();
}
/// check for zipped file
bool zippedFile(string const & name)
{
- string const type = getExtFromContents(name);
+ string const type = getFormatFromContents(name);
if (contains("gzip zip compress", type) && !type.empty())
return true;
return false;
{
string str = path;
- string const home(GetEnvPath("HOME"));
+ string const home(os::homepath());
// replace /home/blah with ~/
if (prefixIs(str, home))
bool LyXReadLink(string const & file, string & link, bool resolve)
{
+#ifdef HAVE_READLINK
char linkbuffer[512];
// Should be PATH_MAX but that needs autconf support
int const nRead = ::readlink(file.c_str(),
else
link = linkbuffer;
return true;
+#else
+ return false;
+#endif
}
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);
}
{
lyxerr[Debug::GRAPHICS] << "[readBB_from_PSFile] "
<< message << std::endl;
+#ifdef WITH_WARNINGS
#warning Why is this func deleting a file? (Lgb)
+#endif
if (zipped)
unlink(file);
}
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");