#include <config.h>
+#include "LyX.h"
#include "LyXRC.h"
#include "support/filetools.h"
+#include "support/convert.h"
#include "support/debug.h"
#include "support/environment.h"
#include "support/gettext.h"
#include "support/lstrings.h"
#include "support/os.h"
+#include "support/Messages.h"
#include "support/Package.h"
-#include "support/Path.h"
+#include "support/PathChanger.h"
#include "support/Systemcall.h"
#include "support/qstring_helpers.h"
+#include "support/TempFile.h"
#include <QDir>
#include "support/regex.h"
#include <fcntl.h>
+#ifdef HAVE_MAGIC_H
+#include <magic.h>
+#endif
+#ifdef HAVE_UNISTD_H
+#include <unistd.h>
+#endif
#include <cerrno>
+#include <climits>
#include <cstdlib>
#include <cstdio>
}
+bool isBinaryFile(FileName const & filename)
+{
+ bool isbinary = false;
+ if (filename.empty() || !filename.exists())
+ return isbinary;
+
+#ifdef HAVE_MAGIC_H
+ magic_t magic_cookie = magic_open(MAGIC_MIME_ENCODING);
+ if (magic_cookie) {
+ bool detected = true;
+ if (magic_load(magic_cookie, NULL) != 0) {
+ LYXERR(Debug::FILES, "isBinaryFile: "
+ "Could not load magic database - "
+ << magic_error(magic_cookie));
+ detected = false;
+ } else {
+ char const *charset = magic_file(magic_cookie,
+ filename.toFilesystemEncoding().c_str());
+ isbinary = contains(charset, "binary");
+ }
+ magic_close(magic_cookie);
+ if (detected)
+ return isbinary;
+ }
+#endif
+ // Try by looking for binary chars at the beginning of the file.
+ // Note that this is formally not correct, since count_bin_chars
+ // expects utf8, and the passed string can be anything: plain text
+ // in any encoding, or really binary data. In practice it works,
+ // since QString::fromUtf8() drops invalid utf8 sequences, and
+ // while the exact number may not be correct, we still get a high
+ // number for truly binary files.
+
+ ifstream ifs(filename.toFilesystemEncoding().c_str());
+ if (!ifs)
+ return isbinary;
+
+ // Maximum strings to read
+ int const max_count = 50;
+
+ // Maximum number of binary chars allowed
+ int const max_bin = 5;
+
+ int count = 0;
+ int binchars = 0;
+ string str;
+ while (count++ < max_count && !ifs.eof()) {
+ getline(ifs, str);
+ binchars += count_bin_chars(str);
+ }
+ return binchars > max_bin;
+}
+
+
string const latex_path(string const & original_path,
latex_path_extension extension,
latex_path_dots dots)
// simple parser in Systemcall.cpp do the substitution.
return '"' + subst(name, "\"", "\\\"") + '"';
#endif
+ case quote_shell_filename:
+ return quoteName(os::external_path(name), quote_shell);
case quote_python:
return "\"" + subst(subst(name, "\\", "\\\\"), "\"", "\\\"")
+ "\"";
// Returns the real name of file name in directory path, with optional
// extension ext.
FileName const fileSearch(string const & path, string const & name,
- string const & ext, search_mode mode)
+ string const & exts, search_mode mode)
{
// if `name' is an absolute path, we ignore the setting of `path'
// Expand Environmentvariables in 'name'
// search first without extension, then with it.
if (fullname.isReadableFile())
return fullname;
- if (ext.empty())
+ if (exts.empty())
// We are done.
return mode == may_not_exist ? fullname : FileName();
- // Only add the extension if it is not already the extension of
- // fullname.
- if (getExtension(fullname.absFileName()) != ext)
- fullname = FileName(addExtension(fullname.absFileName(), ext));
- if (fullname.isReadableFile() || mode == may_not_exist)
- return fullname;
+ int n = 0;
+ string ext = token(exts, ',', n);
+ while (!ext.empty()) {
+ // Only add the extension if it is not already the extension of
+ // fullname.
+ bool addext = getExtension(fullname.absFileName()) != ext;
+ if (addext) {
+ if (mode == check_hidpi) {
+ FileName fullname2x = FileName(addExtension(fullname.absFileName() + "@2x", ext));
+ if (fullname2x.isReadableFile())
+ return fullname2x;
+ }
+ fullname = FileName(addExtension(fullname.absFileName(), ext));
+ }
+ if (fullname.isReadableFile() || mode == may_not_exist)
+ return fullname;
+ if (addext)
+ fullname.changeExtension("");
+ ext = token(exts, ',', ++n);
+ }
return FileName();
}
// 2) build_lyxdir (if not empty)
// 3) system_lyxdir
FileName const libFileSearch(string const & dir, string const & name,
- string const & ext)
+ string const & ext, search_mode mode)
{
FileName fullname = fileSearch(addPath(package().user_support().absFileName(), dir),
- name, ext);
+ name, ext, mode);
if (!fullname.empty())
return fullname;
if (!package().build_support().empty())
fullname = fileSearch(addPath(package().build_support().absFileName(), dir),
- name, ext);
+ name, ext, mode);
if (!fullname.empty())
return fullname;
- return fileSearch(addPath(package().system_support().absFileName(), dir), name, ext);
+ return fileSearch(addPath(package().system_support().absFileName(), dir),
+ name, ext, mode);
}
FileName const i18nLibFileSearch(string const & dir, string const & name,
string const & ext)
{
- /* 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, w use a trick to guess what support/gettext.has done:
- each po file is able to tell us its name. (JMarc)
- */
-
- string lang = to_ascii(_(languageTestString()));
+ // if the LANGUAGE variable is set, use it as a fallback for searching for files.
+ string lang = getGuiMessages().language();
string const language = getEnv("LANGUAGE");
- if (!lang.empty() && !language.empty())
- lang = language;
+ if (!language.empty())
+ lang += ":" + language;
- string l;
- lang = split(lang, l, ':');
- while (!l.empty()) {
+ for (auto const & l : getVectorFromString(lang, ":")) {
FileName tmp;
// First try with the full name
- tmp = libFileSearch(addPath(dir, l), name, ext);
+ // `en' files are not in a subdirectory
+ if (l == "en")
+ tmp = libFileSearch(dir, name, ext);
+ else
+ tmp = libFileSearch(addPath(dir, l), name, ext);
if (!tmp.empty())
return tmp;
if (!tmp.empty())
return tmp;
}
-
-#if 1
- // For compatibility, to be removed later (JMarc)
- tmp = libFileSearch(dir, token(l, '_', 0) + '_' + name,
- ext);
- if (!tmp.empty()) {
- lyxerr << "i18nLibFileSearch: File `" << tmp
- << "' has been found by the old method" <<endl;
- return tmp;
- }
-#endif
- lang = split(lang, l, ':');
}
return libFileSearch(dir, name, ext);
FileName const imageLibFileSearch(string & dir, string const & name,
- string const & ext)
+ string const & ext, search_mode mode)
{
if (!lyx::lyxrc.icon_set.empty()) {
string const imagedir = addPath(dir, lyx::lyxrc.icon_set);
- FileName const fn = libFileSearch(imagedir, name, ext);
+ FileName const fn = libFileSearch(imagedir, name, ext, mode);
if (fn.exists()) {
dir = imagedir;
return fn;
}
}
- return libFileSearch(dir, name, ext);
+ return libFileSearch(dir, name, ext, mode);
}
-string const libScriptSearch(string const & command_in, quote_style style)
+string const commandPrep(string const & command_in)
{
static string const token_scriptpath = "$$s/";
+ string const python_call = "python -tt";
string command = command_in;
+ if (prefixIs(command_in, python_call))
+ command = os::python() + command_in.substr(python_call.length());
+
// Find the starting position of "$$s/"
string::size_type const pos1 = command.find(token_scriptpath);
if (pos1 == string::npos)
// Replace "$$s/" with ""
command.erase(pos1, 4);
} else {
+ quote_style style = quote_shell;
+ if (prefixIs(command, os::python()))
+ style = quote_python;
+
// 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, style));
}
+FileName const tempFileName(string const & mask, bool const dir)
+{
+ FileName tempfile = TempFile(mask).name();
+ // Since the QTemporaryFile object is destroyed at function return
+ // (which is what is intended here), the next call to this function
+ // may return the same file name again.
+ // Thus, in order to prevent race conditions, we track returned names
+ // and create our own unique names if QTemporaryFile returns a name again.
+ if (tmp_names_.find(tempfile.absFileName()) == tmp_names_.end()) {
+ tmp_names_.insert(tempfile.absFileName());
+ return tempfile;
+ }
+
+ // OK, we need another name. Simply append digits.
+ FileName tmp = tempfile;
+ string ext;
+ if (!dir) {
+ // Store and remove extensions
+ ext = "." + tempfile.extension();
+ tmp.changeExtension("");
+ }
+ for (int i = 1; i < INT_MAX ;++i) {
+ // Append digit to filename and re-add extension
+ string const new_fn =
+ tmp.absFileName() + convert<string>(i) + ext;
+ if (tmp_names_.find(new_fn) == tmp_names_.end()) {
+ tmp_names_.insert(new_fn);
+ tempfile.set(new_fn);
+ return tempfile;
+ }
+ }
+
+ // This should not happen!
+ LYXERR0("tempFileName(): Could not create unique temp file name!");
+ return tempfile;
+}
+
+
+void removeTempFile(FileName const & fn)
+{
+ if (!fn.exists())
+ return;
+
+ string const abs = fn.absFileName();
+ if (tmp_names_.find(abs) != tmp_names_.end())
+ tmp_names_.erase(abs);
+ fn.removeFile();
+}
+
+
static FileName createTmpDir(FileName const & tempdir, string const & mask)
{
LYXERR(Debug::FILES, "createTmpDir: tempdir=`" << tempdir << "'\n"
<< "createTmpDir: mask=`" << mask << '\'');
- FileName const tmpfl = FileName::tempName(tempdir, mask);
+ QFileInfo tmp_fi(QDir(toqstr(tempdir.absFileName())), toqstr(mask));
+ FileName const tmpfl =
+ tempFileName(fromqstr(tmp_fi.absoluteFilePath()) + ".XXXXXXXXXXXX", true);
if (tmpfl.empty() || !tmpfl.createDirectory(0700)) {
LYXERR0("LyX could not create temporary directory in " << tempdir
// dir inside deflt.
return createTmpDir(deflt, "lyx_tmpdir");
} else {
- // some other error occured.
+ // some other error occurred.
return createTmpDir(package().system_temp_dir(), "lyx_tmpdir");
}
}
}
-// 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 (FileName::isAbsolute(rTemp))
- return rTemp;
-
- string temp;
- string const copy = rTemp;
-
- // Split by next /
- rTemp = split(rTemp, temp, '/');
-
- if (temp == ".")
- return FileName::getcwd().absFileName() + '/' + rTemp;
-
- if (temp == "~")
- return Package::get_home_dir().absFileName() + '/' + rTemp;
-
- if (temp == "..")
- return makeAbsPath(copy).absFileName();
-
- // Don't know how to handle this
- return copy;
-}
-
-
// Search the string for ${VAR} and $VAR and replace VAR using getenv.
string const replaceEnvironmentPath(string const & path)
{
// $[A-Za-z_][A-Za-z_0-9]*
static string const envvar = "[$]([A-Za-z_][A-Za-z_0-9]*)";
- static regex envvar_br_re("(.*)" + envvar_br + "(.*)");
- static regex envvar_re("(.*)" + envvar + "(.*)");
- string result = path;
- while (1) {
- smatch what;
- if (!regex_match(result, what, envvar_br_re)) {
- if (!regex_match(result, what, envvar_re))
- break;
+ // Coverity thinks that the regex constructor can return an
+ // exception. We know that it is not true since our regex are
+ // hardcoded, but we have to protect against that nevertheless.
+ try {
+ static regex const envvar_br_re("(.*)" + envvar_br + "(.*)");
+ static regex const envvar_re("(.*)" + envvar + "(.*)");
+ string result = path;
+ while (1) {
+ smatch what;
+ if (!regex_match(result, what, envvar_br_re)) {
+ if (!regex_match(result, what, envvar_re))
+ break;
+ }
+ string env_var = getEnv(what.str(2));
+ result = what.str(1) + env_var + what.str(3);
}
- string env_var = getEnv(what.str(2));
- result = what.str(1) + env_var + what.str(3);
+ return result;
+ } catch (exception const & e) {
+ LYXERR0("Something is very wrong: " << e.what());
+ return path;
}
- return result;
}
// Return a command prefix for setting the environment of the TeX engine.
-string latexEnvCmdPrefix(string const & path)
+string latexEnvCmdPrefix(string const & path, string const & lpath)
{
- if (path.empty() || lyxrc.texinputs_prefix.empty())
+ bool use_lpath = !(lpath.empty() || lpath == "." || lpath == "./");
+
+ if (path.empty() || (lyxrc.texinputs_prefix.empty() && !use_lpath))
return string();
- string const texinputs_prefix = os::latex_path_list(
+ string texinputs_prefix = lyxrc.texinputs_prefix.empty() ? string()
+ : os::latex_path_list(
replaceCurdirPath(path, lyxrc.texinputs_prefix));
+ string const allother_prefix = os::latex_path_list(path);
string const sep = string(1, os::path_separator(os::TEXENGINE));
string const texinputs = getEnv("TEXINPUTS");
+ string const bibinputs = getEnv("BIBINPUTS");
+ string const bstinputs = getEnv("BSTINPUTS");
+ string const texfonts = getEnv("TEXFONTS");
+
+ if (use_lpath) {
+ string const abslpath = FileName::isAbsolute(lpath)
+ ? os::latex_path(lpath)
+ : os::latex_path(FileName(path + "/" + lpath).realPath());
+ if (texinputs_prefix.empty())
+ texinputs_prefix = abslpath;
+ else if (suffixIs(texinputs_prefix, sep))
+ texinputs_prefix.append(abslpath + sep);
+ else
+ texinputs_prefix.append(sep + abslpath);
+ }
if (os::shell() == os::UNIX)
return "env TEXINPUTS=\"." + sep + texinputs_prefix
- + sep + texinputs + "\" ";
+ + sep + texinputs + "\" "
+ + "BIBINPUTS=\"." + sep + allother_prefix
+ + sep + bibinputs + "\" "
+ + "BSTINPUTS=\"." + sep + allother_prefix
+ + sep + bstinputs + "\" "
+ + "TEXFONTS=\"." + sep + allother_prefix
+ + sep + texfonts + "\" ";
else
- return "cmd /d /c set TEXINPUTS=." + sep + texinputs_prefix
- + sep + texinputs + "&";
+ // NOTE: the dummy blank dirs are necessary to force the
+ // QProcess parser to quote the argument (see bug 9453)
+ return "cmd /d /c set \"TEXINPUTS=." + sep + " "
+ + sep + texinputs_prefix
+ + sep + texinputs + "\" & "
+ + "set \"BIBINPUTS=." + sep + " "
+ + sep + allother_prefix
+ + sep + bibinputs + "\" & "
+ + "set \"BSTINPUTS=." + sep + " "
+ + sep + allother_prefix
+ + sep + bstinputs + "\" & "
+ + "set \"TEXFONTS=." + sep + " "
+ + sep + allother_prefix
+ + sep + texfonts + "\" & ";
}
}
if (i != string::npos) {
newpathlist += sep;
- // Stop here if the last element is empty
+ // Stop here if the last element is empty
if (++i == oldpathlist.length())
break;
}
string const ext = getExtension(zipped_file);
if (ext == "gz" || ext == "z" || ext == "Z")
return changeExtension(zipped_file, string());
+ else if (ext == "svgz")
+ return changeExtension(zipped_file, "svg");
return onlyPath(zipped_file) + "unzipped_" + onlyFileName(zipped_file);
}
unzippedFileName(zipped_file.toFilesystemEncoding()) :
unzipped_file);
// Run gunzip
- string const command = "gunzip -c " +
- zipped_file.toFilesystemEncoding() + " > " +
- tempfile.toFilesystemEncoding();
+ 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 str = path;
+ // Recode URL encoded chars.
+ str = from_percent_encoding(str);
+
// If file is from LyXDir, display it as if it were relative.
string const system = package().system_support().absFileName();
if (prefixIs(str, system) && str != system)
if (dstr.empty()) {
// Yes, filename itself is too long.
// Pick the start and the end of the filename.
- dstr = from_utf8(onlyFileName(path));
- docstring const head = dstr.substr(0, threshold / 2 - 3);
-
- docstring::size_type len = dstr.length();
- docstring const tail =
- dstr.substr(len - threshold / 2 - 2, len - 1);
- dstr = head + from_ascii("...") + tail;
+ docstring fstr = from_utf8(onlyFileName(path));
+ dstr = fstr;
+ if (support::truncateWithEllipsis(dstr, threshold / 2))
+ dstr += fstr.substr(fstr.length() - threshold / 2 - 2,
+ docstring::npos);
}
return from_utf8(os::external_path(prefix + to_utf8(dstr)));
string const encoded = file.toFilesystemEncoding();
#ifdef HAVE_DEF_PATH_MAX
char linkbuffer[PATH_MAX + 1];
- int const nRead = ::readlink(encoded.c_str(),
+ ssize_t const nRead = ::readlink(encoded.c_str(),
linkbuffer, sizeof(linkbuffer) - 1);
if (nRead <= 0)
return false;
if (nRead < 0) {
return false;
}
- if (nRead < buf.size() - 1) {
+ if (static_cast<size_t>(nRead) < buf.size() - 1) {
break;
}
buf.resize(buf.size() * 2);
// pstream (process stream), with the
// variants ipstream, opstream
+ if (verbose)
+ lyxerr << "\nRunning: " << cmd << endl;
+ else
+ LYXERR(Debug::INFO,"Running: " << cmd);
+
#if defined (_WIN32)
- int fno;
STARTUPINFO startup;
PROCESS_INFORMATION process;
SECURITY_ATTRIBUTES security;
0, 0, &startup, &process)) {
CloseHandle(process.hThread);
- fno = _open_osfhandle((long)in, _O_RDONLY);
+ int fno = _open_osfhandle((intptr_t)in, _O_RDONLY);
CloseHandle(out);
inf = _fdopen(fno, "r");
}
#if defined (_WIN32)
WaitForSingleObject(process.hProcess, INFINITE);
+ DWORD pret;
+ if (!GetExitCodeProcess(process.hProcess, &pret))
+ pret = -1;
if (!infile.empty())
CloseHandle(startup.hStdInput);
CloseHandle(process.hProcess);
- int const pret = fclose(inf);
+ if (fclose(inf) != 0)
+ pret = -1;
#elif defined (HAVE_PCLOSE)
int const pret = pclose(inf);
#elif defined (HAVE__PCLOSE)
}
-FileName const findtexfile(string const & fil, string const & /*format*/)
+FileName const findtexfile(string const & fil, string const & /*format*/,
+ bool const onlykpse)
{
/* There is no problem to extend this function too use other
methods to look for files. It could be setup to look
// If the file can be found directly, we just return a
// absolute path version of it.
- FileName const absfile(makeAbsPath(fil));
- if (absfile.exists())
- return absfile;
+ if (!onlykpse) {
+ FileName const absfile(makeAbsPath(fil));
+ if (absfile.exists())
+ return absfile;
+ }
// Now we try to find it using kpsewhich.
// It seems from the kpsewhich manual page that it is safe to use
}
+bool configFileNeedsUpdate(string const & file)
+{
+ // We cannot initialize configure_script directly because the package
+ // is not initialized yet when static objects are constructed.
+ static FileName configure_script;
+ static bool firstrun = true;
+ if (firstrun) {
+ configure_script =
+ FileName(addName(package().system_support().absFileName(),
+ "configure.py"));
+ firstrun = false;
+ }
+
+ FileName absfile =
+ FileName(addName(package().user_support().absFileName(), file));
+ return !absfile.exists()
+ || configure_script.lastModified() > absfile.lastModified();
+}
+
+
+int fileLock(const char * lock_file)
+{
+ int fd = -1;
+#if defined(HAVE_LOCKF)
+ fd = open(lock_file, O_CREAT|O_APPEND|O_SYNC|O_RDWR, 0666);
+ if (fd == -1)
+ return -1;
+ if (lockf(fd, F_LOCK, 0) != 0) {
+ close(fd);
+ return -1;
+ }
+#endif
+ return fd;
+}
+
+
+void fileUnlock(int fd, const char * /* lock_file*/)
+{
+#if defined(HAVE_LOCKF)
+ if (fd >= 0) {
+ if (lockf(fd, F_ULOCK, 0))
+ LYXERR0("Can't unlock the file.");
+ close(fd);
+ }
+#endif
+}
+
} //namespace support
} // namespace lyx