* \author Ivan Schreter
* \author Dirk Niggemann
* \author Asger Alstrup
- * \author Lars Gullik Bjønnes
+ * \author Lars Gullik Bjønnes
* \author Jean-Marc Lasgouttes
* \author Angus Leeming
* \author John Levon
- * \author Herbert Voß
+ * \author Herbert Voß
*
* Full author contact details are available in file CREDITS.
*
#include <config.h>
-#include "support/convert.h"
-#include "support/environment.h"
+#include "LyXRC.h"
+
#include "support/filetools.h"
+
+#include "support/debug.h"
+#include "support/environment.h"
+#include "support/gettext.h"
#include "support/lstrings.h"
-#include "support/lyxlib.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"
-// FIXME Interface violation
-#include "gettext.h"
-#include "debug.h"
+#include <QDir>
+#include <QTemporaryFile>
-#include <boost/assert.hpp>
-#include <boost/filesystem/operations.hpp>
-#include <boost/regex.hpp>
+#include "support/lassert.h"
+#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 <cstdlib>
#include <utility>
#include <fstream>
#include <sstream>
+#include <vector>
+
+#if defined (_WIN32)
+#include <io.h>
+#include <windows.h>
+#endif
-using std::endl;
-using std::getline;
-using std::make_pair;
-using std::string;
-using std::ifstream;
-using std::ostringstream;
-using std::vector;
-using std::pair;
+using namespace std;
-namespace fs = boost::filesystem;
+#define USE_QPROCESS
namespace lyx {
namespace support {
-bool isLyXFilename(string const & filename)
+bool isLyXFileName(string const & filename)
{
return suffixIs(ascii_lowercase(filename), ".lyx");
}
-bool isSGMLFilename(string const & filename)
+bool isSGMLFileName(string const & filename)
{
return suffixIs(ascii_lowercase(filename), ".sgml");
}
-bool isValidLaTeXFilename(string const & filename)
+bool isValidLaTeXFileName(string const & filename)
{
- string const invalid_chars("#$%{}()[]\"^");
+ string const invalid_chars("#%\"");
return filename.find_first_of(invalid_chars) == string::npos;
}
+bool isValidDVIFileName(string const & filename)
+{
+ string const invalid_chars("${}()[]^");
+ return filename.find_first_of(invalid_chars) == string::npos;
+}
+
+
+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)
// We can't use '"' because " is sometimes active (e.g. if
// babel is loaded with the "german" option)
if (extension == EXCLUDE_EXTENSION) {
- // ChangeExtension calls os::internal_path internally
+ // changeExtension calls os::internal_path internally
// so don't use it to remove the extension.
string const ext = getExtension(path);
string const base = ext.empty() ?
path :
path.substr(0, path.length() - ext.length() - 1);
- // ChangeExtension calls os::internal_path internally
+ // changeExtension calls os::internal_path internally
// so don't use it to re-add the extension.
path = "\\string\"" + base + "\\string\"." + ext;
} else {
}
}
- return dots == ESCAPE_DOTS ? subst(path, ".", "\\lyxdot ") : path;
+ if (dots != ESCAPE_DOTS)
+ return path;
+
+ // Replace dots with the lyxdot macro, but only in the file name,
+ // not the directory part.
+ // addName etc call os::internal_path internally
+ // so don't use them for path manipulation
+ // The directory separator is always '/' for LaTeX.
+ string::size_type pos = path.rfind('/');
+ if (pos == string::npos)
+ return subst(path, ".", "\\lyxdot ");
+ return path.substr(0, pos) + subst(path.substr(pos), ".", "\\lyxdot ");
}
// Substitutes spaces with underscores in filename (and path)
-string const makeLatexName(string const & file)
+FileName const makeLatexName(FileName const & file)
{
- string name = onlyFilename(file);
- string const path = onlyPath(file);
+ string name = file.onlyFileName();
+ string const path = file.onlyPath().absFileName() + "/";
// ok so we scan through the string twice, but who cares.
+ // FIXME: in Unicode time this will break for sure! There is
+ // a non-latin world out there...
string const keep = "abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"@!'()*+,-./0123456789:;<=>?[]`|";
while ((pos = name.find_first_not_of(keep, pos)) != string::npos)
name[pos++] = '_';
- return addName(path, name);
+ FileName latex_name(path + name);
+ latex_name.changeExtension(".tex");
+ return latex_name;
}
{
switch(style) {
case quote_shell:
- // This does not work for filenames containing " (windows)
- // or ' (all other OSes). This can't be changed easily, since
- // we would need to adapt the command line parser in
- // Forkedcall::generateChild. Therefore we don't pass user
- // filenames to child processes if possible. We store them in
- // a python script instead, where we don't have these
- // limitations.
+ // This does not work on native Windows for filenames
+ // containing the following characters < > : " / \ | ? *
+ // Moreover, it can't be made to work, as, according to
+ // http://msdn.microsoft.com/en-us/library/aa365247(VS.85).aspx
+ // those are reserved characters, and thus are forbidden.
+ // Please, also note that the command-line parser in
+ // ForkedCall::generateChild cannot deal with filenames
+ // containing " or ', therefore we don't pass user filenames
+ // to child processes if possible. We store them in a python
+ // script instead, where we don't have these limitations.
+#ifndef USE_QPROCESS
return (os::shell() == os::UNIX) ?
- '\'' + name + '\'':
+ '\'' + subst(name, "'", "\'\\\'\'") + '\'' :
'"' + name + '"';
+#else
+ // According to the QProcess parser, a single double
+ // quote is represented by three consecutive ones.
+ // Here we simply escape the double quote and let our
+ // 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, "\\", "\\\\"), "\"", "\\\"")
+ "\"";
if (!suffixIs(path_element, '/'))
path_element += '/';
path_element = subst(path_element, "$$LyX",
- package().system_support().absFilename());
+ package().system_support().absFileName());
path_element = subst(path_element, "$$User",
- package().user_support().absFilename());
+ package().user_support().absFileName());
real_file = fileSearch(path_element, name, ext);
#endif
-/// Returns a vector of all files in directory dir having extension ext.
-vector<FileName> const dirList(FileName const & dir, string const & ext)
-{
- // EXCEPTIONS FIXME. Rewrite needed when we turn on exceptions. (Lgb)
- vector<FileName> dirlist;
-
- if (!(dir.exists() && dir.isDirectory())) {
- LYXERR(Debug::FILES)
- << "Directory \"" << dir
- << "\" does not exist to DirList." << endl;
- return dirlist;
- }
-
- string extension;
- if (!ext.empty() && ext[0] != '.')
- extension += '.';
- extension += ext;
-
- string const encoded_dir = dir.toFilesystemEncoding();
- fs::directory_iterator dit(encoded_dir);
- fs::directory_iterator end;
- for (; dit != end; ++dit) {
- string const & fil = dit->leaf();
- if (suffixIs(fil, extension))
- dirlist.push_back(FileName::fromFilesystemEncoding(
- encoded_dir + '/' + fil));
- }
- return dirlist;
-}
-
-
// 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 tmpname = replaceEnvironmentPath(name);
FileName fullname(makeAbsPath(tmpname, path));
// search first without extension, then with it.
- if (fullname.isReadable())
+ if (fullname.isReadableFile())
return fullname;
if (ext.empty())
// We are done.
- return mode == allow_unreadable ? fullname : FileName();
+ 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.isReadable() || mode == allow_unreadable)
+ if (getExtension(fullname.absFileName()) != ext) {
+ 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;
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);
+ FileName fullname = fileSearch(addPath(package().user_support().absFileName(), dir),
+ name, ext, mode);
if (!fullname.empty())
return fullname;
if (!package().build_support().empty())
- fullname = fileSearch(addPath(package().build_support().absFilename(), dir),
- name, ext);
+ fullname = fileSearch(addPath(package().build_support().absFileName(), dir),
+ 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);
}
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 gettext has done:
+ 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(_("[[Replace with the code of your language]]"));
+ string lang = getGuiMessages().language();
string const language = getEnv("LANGUAGE");
if (!lang.empty() && !language.empty())
lang = language;
}
-string const libScriptSearch(string const & command_in, quote_style style)
+FileName const imageLibFileSearch(string & dir, string const & name,
+ 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, mode);
+ if (fn.exists()) {
+ dir = imagedir;
+ return fn;
+ }
+ }
+ return libFileSearch(dir, name, ext, mode);
+}
+
+
+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)
// Does this script file exist?
string const script =
- libFileSearch(".", command.substr(start_script, size_script)).absFilename();
+ libFileSearch(".", command.substr(start_script, size_script)).absFileName();
if (script.empty()) {
// 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));
}
-static FileName createTmpDir(FileName const & tempdir, string const & mask)
+static string createTempFile(QString const & mask)
{
- LYXERR(Debug::FILES)
- << "createTmpDir: tempdir=`" << tempdir << "'\n"
- << "createTmpDir: mask=`" << mask << '\'' << endl;
-
- FileName 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)
- unlink(tmpfl);
-
- if (tmpfl.empty() || mkdir(tmpfl, 0700)) {
- lyxerr << "LyX could not create the temporary directory '"
- << tmpfl << "'" << endl;
- return FileName();
+ // FIXME: This is not safe. QTemporaryFile creates a file in open(),
+ // but the file is deleted when qt_tmp goes out of scope.
+ // Therefore the next call to createTempFile() may create the
+ // same file again. To make this safe the QTemporaryFile object
+ // needs to be kept for the whole life time of the temp file name.
+ // This could be achieved by creating a class TempDir (like
+ // TempFile, but using a currentlky non-existing
+ // QTemporaryDirectory object).
+ QTemporaryFile qt_tmp(mask + ".XXXXXXXXXXXX");
+ if (qt_tmp.open()) {
+ string const temp_file = fromqstr(qt_tmp.fileName());
+ LYXERR(Debug::FILES, "Temporary file `" << temp_file << "' created.");
+ return temp_file;
}
-
- return tmpfl;
+ LYXERR(Debug::FILES, "Unable to create temporary file with following template: "
+ << qt_tmp.fileTemplate());
+ return string();
}
-string const createBufferTmpDir()
+
+static FileName createTmpDir(FileName const & tempdir, string const & mask)
{
- static int count;
- // 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 =
- package().temp_dir().absFilename() + "/lyx_tmpbuf" +
- convert<string>(count++);
+ LYXERR(Debug::FILES, "createTmpDir: tempdir=`" << tempdir << "'\n"
+ << "createTmpDir: mask=`" << mask << '\'');
- if (mkdir(FileName(tmpfl), 0777)) {
- lyxerr << "LyX could not create the temporary directory '"
- << tmpfl << "'" << endl;
- return string();
+ QFileInfo tmp_fi(QDir(toqstr(tempdir.absFileName())), toqstr(mask));
+ FileName const tmpfl(createTempFile(tmp_fi.absoluteFilePath()));
+
+ if (tmpfl.empty() || !tmpfl.createDirectory(0700)) {
+ LYXERR0("LyX could not create temporary directory in " << tempdir
+ << "'");
+ return FileName();
}
+
return tmpfl;
}
FileName const createLyXTmpDir(FileName const & deflt)
{
- if (deflt.empty() || deflt.absFilename() == "/tmp")
- return createTmpDir(FileName("/tmp"), "lyx_tmpdir");
+ if (deflt.empty() || deflt == package().system_temp_dir())
+ return createTmpDir(package().system_temp_dir(), "lyx_tmpdir");
- if (!mkdir(deflt, 0777))
+ if (deflt.createDirectory(0777))
return deflt;
if (deflt.isDirWritable()) {
return createTmpDir(deflt, "lyx_tmpdir");
} else {
// some other error occured.
- return createTmpDir(FileName("/tmp"), "lyx_tmpdir");
+ return createTmpDir(package().system_temp_dir(), "lyx_tmpdir");
}
}
// 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.
+// Note that basePath can be a relative path, in the sense that it may
+// not begin with "/" (e.g.), but it should NOT contain such constructs
+// as "/../".
+// FIXME It might be nice if the code didn't simply assume that.
FileName const makeAbsPath(string const & relPath, string const & basePath)
{
// checks for already absolute path
- if (os::is_absolute_path(relPath))
+ if (FileName::isAbsolute(relPath))
return FileName(relPath);
// Copies given paths
string tempBase;
- if (os::is_absolute_path(basePath))
+ if (FileName::isAbsolute(basePath))
tempBase = basePath;
else
- tempBase = addPath(getcwd().absFilename(), basePath);
+ tempBase = addPath(FileName::getcwd().absFileName(), basePath);
// Handle /./ at the end of the path
while (suffixIs(tempBase, "/./"))
string rTemp = tempRel;
string temp;
+ // Check for a leading "~"
+ // Split by first /
+ rTemp = split(rTemp, temp, '/');
+ if (temp == "~") {
+ tempBase = Package::get_home_dir().absFileName();
+ tempRel = rTemp;
+ }
+
+ rTemp = tempRel;
while (!rTemp.empty()) {
// Split by next /
rTemp = split(rTemp, temp, '/');
if (temp == ".") continue;
if (temp == "..") {
// Remove one level of TempBase
- string::difference_type i = tempBase.length() - 2;
- if (i < 0)
- i = 0;
+ if (tempBase.length() <= 1) {
+ //this is supposed to be an absolute path, so...
+ tempBase = "/";
+ continue;
+ }
+ //erase a trailing slash if there is one
+ if (suffixIs(tempBase, "/"))
+ tempBase.erase(tempBase.length() - 1, string::npos);
+
+ string::size_type i = tempBase.length() - 1;
while (i > 0 && tempBase[i] != '/')
--i;
if (i > 0)
tempBase.erase(i, string::npos);
else
- tempBase += '/';
+ tempBase = '/';
} else if (temp.empty() && !rTemp.empty()) {
tempBase = os::current_root() + rTemp;
rTemp.erase();
}
// returns absolute path
- return FileName(os::internal_path(tempBase));
+ return FileName(tempBase);
}
// Chops any path of filename.
string const addName(string const & path, string const & fname)
{
- string const basename = onlyFilename(fname);
+ string const basename = onlyFileName(fname);
string buf;
if (path != "." && path != "./" && !path.empty()) {
// Strips path from filename
-string const onlyFilename(string const & fname)
+string const onlyFileName(string const & fname)
{
if (fname.empty())
return fname;
}
-/// Returns true is path is absolute
-bool absolutePath(string const & path)
-{
- 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 (os::is_absolute_path(rTemp))
+ if (FileName::isAbsolute(rTemp))
return rTemp;
string temp;
rTemp = split(rTemp, temp, '/');
if (temp == ".")
- return getcwd().absFilename() + '/' + rTemp;
+ return FileName::getcwd().absFileName() + '/' + rTemp;
if (temp == "~")
- return package().home_dir().absFilename() + '/' + rTemp;
+ return Package::get_home_dir().absFileName() + '/' + rTemp;
if (temp == "..")
- return makeAbsPath(copy).absFilename();
+ return makeAbsPath(copy).absFileName();
// Don't know how to handle this
return copy;
}
-// 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)
-{
- // Normalize paths like /foo//bar ==> /foo/bar
- static boost::regex regex("/{2,}");
- string const tmppath = boost::regex_merge(path, regex, "/");
-
- fs::path const npath = fs::path(tmppath, fs::no_check).normalize();
-
- if (!npath.is_complete())
- return "./" + npath.string() + '/';
-
- return npath.string() + '/';
-}
-
-
// Search the string for ${VAR} and $VAR and replace VAR using getenv.
string const replaceEnvironmentPath(string const & path)
{
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]*\}
+ // $[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;
-
+ static regex const envvar_br_re("(.*)" + envvar_br + "(.*)");
+ static regex const envvar_re("(.*)" + envvar + "(.*)");
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)
+ smatch what;
+ if (!regex_match(result, what, envvar_br_re)) {
+ if (!regex_match(result, what, envvar_re))
break;
}
- result = what.str(1) + getEnv(what.str(2)) + what.str(3);
+ string env_var = getEnv(what.str(2));
+ result = what.str(1) + env_var + what.str(3);
}
return result;
}
+// Return a command prefix for setting the environment of the TeX engine.
+string latexEnvCmdPrefix(string const & path)
+{
+ if (path.empty() || lyxrc.texinputs_prefix.empty())
+ return string();
+
+ string const texinputs_prefix = os::latex_path_list(
+ replaceCurdirPath(path, lyxrc.texinputs_prefix));
+ string const sep = string(1, os::path_separator(os::TEXENGINE));
+ string const texinputs = getEnv("TEXINPUTS");
+
+ if (os::shell() == os::UNIX)
+ return "env TEXINPUTS=\"." + sep + texinputs_prefix
+ + sep + texinputs + "\" ";
+ else
+#ifndef USE_QPROCESS
+ return "cmd /d /c set \"TEXINPUTS=."
+ + sep + texinputs_prefix
+ + sep + texinputs + "\"&";
+#else
+ return "cmd /d /c set \"\"\"TEXINPUTS=."
+ + sep + texinputs_prefix
+ + sep + texinputs + "\"\"\"&";
+#endif
+}
+
+
+// Replace current directory in all elements of a path list with a given path.
+string const replaceCurdirPath(string const & path, string const & pathlist)
+{
+ string const oldpathlist = replaceEnvironmentPath(pathlist);
+ char const sep = os::path_separator();
+ string newpathlist;
+
+ for (size_t i = 0, k = 0; i != string::npos; k = i) {
+ i = oldpathlist.find(sep, i);
+ string p = oldpathlist.substr(k, i - k);
+ if (FileName::isAbsolute(p)) {
+ newpathlist += p;
+ } else if (i > k) {
+ size_t offset = 0;
+ if (p == ".") {
+ offset = 1;
+ } else if (prefixIs(p, "./")) {
+ offset = 2;
+ while (p[offset] == '/')
+ ++offset;
+ }
+ newpathlist += addPath(path, p.substr(offset));
+ if (suffixIs(p, "//"))
+ newpathlist += '/';
+ }
+ if (i != string::npos) {
+ newpathlist += sep;
+ // Stop here if the last element is empty
+ if (++i == oldpathlist.length())
+ break;
+ }
+ }
+ return newpathlist;
+}
+
+
// Make relative path out of two absolute paths
docstring const makeRelPath(docstring const & abspath, docstring const & basepath)
// Makes relative path out of absolute path. If it is deeper than basepath,
string const ext = getExtension(zipped_file);
if (ext == "gz" || ext == "z" || ext == "Z")
return changeExtension(zipped_file, string());
- return "unzipped_" + zipped_file;
+ return onlyPath(zipped_file) + "unzipped_" + onlyFileName(zipped_file);
}
string str = path;
// If file is from LyXDir, display it as if it were relative.
- string const system = package().system_support().absFilename();
+ string const system = package().system_support().absFileName();
if (prefixIs(str, system) && str != system)
return from_utf8("[" + str.erase(0, system.length()) + "]");
// replace /home/blah with ~/
- string const home = package().home_dir().absFilename();
+ string const home = Package::get_home_dir().absFileName();
if (!home.empty() && prefixIs(str, home))
str = subst(str, home, "~");
return from_utf8(os::external_path(str));
string const prefix = ".../";
- string temp;
+ docstring dstr = from_utf8(str);
+ docstring temp;
- while (str.length() > threshold)
- str = split(str, temp, '/');
+ while (dstr.length() > threshold)
+ dstr = split(dstr, temp, '/');
// Did we shorten everything away?
- if (str.empty()) {
+ if (dstr.empty()) {
// Yes, filename itself is too long.
// Pick the start and the end of the filename.
- str = onlyFilename(path);
- string const head = str.substr(0, threshold / 2 - 3);
+ dstr = from_utf8(onlyFileName(path));
+ docstring const head = dstr.substr(0, threshold / 2 - 3);
- string::size_type len = str.length();
- string const tail =
- str.substr(len - threshold / 2 - 2, len - 1);
- str = head + "..." + tail;
+ docstring::size_type len = dstr.length();
+ docstring const tail =
+ dstr.substr(len - threshold / 2 - 2, len - 1);
+ dstr = head + from_ascii("...") + tail;
}
- return from_utf8(os::external_path(prefix + str));
+ return from_utf8(os::external_path(prefix + to_utf8(dstr)));
}
+#ifdef HAVE_READLINK
bool readLink(FileName const & file, FileName & link)
{
-#ifdef HAVE_READLINK
- char linkbuffer[512];
- // Should be PATH_MAX but that needs autconf support
string const encoded = file.toFilesystemEncoding();
- int const nRead = ::readlink(encoded.c_str(),
+#ifdef HAVE_DEF_PATH_MAX
+ char linkbuffer[PATH_MAX + 1];
+ ssize_t const nRead = ::readlink(encoded.c_str(),
linkbuffer, sizeof(linkbuffer) - 1);
if (nRead <= 0)
return false;
linkbuffer[nRead] = '\0'; // terminator
- link = makeAbsPath(linkbuffer, onlyPath(file.absFilename()));
+#else
+ vector<char> buf(1024);
+ int nRead = -1;
+
+ while (true) {
+ nRead = ::readlink(encoded.c_str(), &buf[0], buf.size() - 1);
+ if (nRead < 0) {
+ return false;
+ }
+ if (static_cast<size_t>(nRead) < buf.size() - 1) {
+ break;
+ }
+ buf.resize(buf.size() * 2);
+ }
+ buf[nRead] = '\0'; // terminator
+ const char * linkbuffer = &buf[0];
+#endif
+ link = makeAbsPath(linkbuffer, onlyPath(file.absFileName()));
return true;
+}
#else
+bool readLink(FileName const &, FileName &)
+{
return false;
-#endif
}
+#endif
cmd_ret const runCommand(string const & cmd)
// pstream (process stream), with the
// variants ipstream, opstream
-#if defined (HAVE_POPEN)
+#if defined (_WIN32)
+ int fno;
+ STARTUPINFO startup;
+ PROCESS_INFORMATION process;
+ SECURITY_ATTRIBUTES security;
+ HANDLE in, out;
+ FILE * inf = 0;
+ bool err2out = false;
+ string command;
+ string const infile = trim(split(cmd, command, '<'), " \"");
+ command = rtrim(command);
+ if (suffixIs(command, "2>&1")) {
+ command = rtrim(command, "2>&1");
+ err2out = true;
+ }
+ string const cmdarg = "/d /c " + command;
+ string const comspec = getEnv("COMSPEC");
+
+ security.nLength = sizeof(SECURITY_ATTRIBUTES);
+ security.bInheritHandle = TRUE;
+ security.lpSecurityDescriptor = NULL;
+
+ if (CreatePipe(&in, &out, &security, 0)) {
+ memset(&startup, 0, sizeof(STARTUPINFO));
+ memset(&process, 0, sizeof(PROCESS_INFORMATION));
+
+ startup.cb = sizeof(STARTUPINFO);
+ startup.dwFlags = STARTF_USESTDHANDLES;
+
+ startup.hStdError = err2out ? out : GetStdHandle(STD_ERROR_HANDLE);
+ startup.hStdInput = infile.empty()
+ ? GetStdHandle(STD_INPUT_HANDLE)
+ : CreateFile(infile.c_str(), GENERIC_READ,
+ FILE_SHARE_READ, &security, OPEN_EXISTING,
+ FILE_ATTRIBUTE_NORMAL, NULL);
+ startup.hStdOutput = out;
+
+ if (startup.hStdInput != INVALID_HANDLE_VALUE &&
+ CreateProcess(comspec.c_str(), (LPTSTR)cmdarg.c_str(),
+ &security, &security, TRUE, CREATE_NO_WINDOW,
+ 0, 0, &startup, &process)) {
+
+ CloseHandle(process.hThread);
+ fno = _open_osfhandle((long)in, _O_RDONLY);
+ CloseHandle(out);
+ inf = _fdopen(fno, "r");
+ }
+ }
+#elif defined (HAVE_POPEN)
FILE * inf = ::popen(cmd.c_str(), os::popen_read_mode());
#elif defined (HAVE__POPEN)
FILE * inf = ::_popen(cmd.c_str(), os::popen_read_mode());
#error No popen() function.
#endif
- // (Claus Hentschel) Check if popen was succesful ;-)
+ // (Claus Hentschel) Check if popen was successful ;-)
if (!inf) {
lyxerr << "RunCommand:: could not start child process" << endl;
return make_pair(-1, string());
c = fgetc(inf);
}
-#if defined (HAVE_PCLOSE)
+#if defined (_WIN32)
+ WaitForSingleObject(process.hProcess, INFINITE);
+ if (!infile.empty())
+ CloseHandle(startup.hStdInput);
+ CloseHandle(process.hProcess);
+ int const pret = fclose(inf);
+#elif defined (HAVE_PCLOSE)
int const pret = pclose(inf);
#elif defined (HAVE__PCLOSE)
int const pret = _pclose(inf);
if (absfile.exists())
return absfile;
- // No we try to find it using kpsewhich.
+ // Now we try to find it using kpsewhich.
// 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
cmd_ret const c = runCommand(kpsecmd);
- LYXERR(Debug::LATEX) << "kpse status = " << c.first << '\n'
- << "kpse result = `" << rtrim(c.second, "\n\r")
- << '\'' << endl;
+ LYXERR(Debug::LATEX, "kpse status = " << c.first << '\n'
+ << "kpse result = `" << rtrim(c.second, "\n\r") << '\'');
if (c.first != -1)
- return FileName(os::internal_path(rtrim(to_utf8(from_filesystem8bit(c.second)),
- "\n\r")));
+ return FileName(rtrim(to_utf8(from_filesystem8bit(c.second)), "\n\r"));
else
return FileName();
}
-void removeAutosaveFile(string const & filename)
-{
- string a = onlyPath(filename);
- a += '#';
- a += onlyFilename(filename);
- a += '#';
- FileName const autosave(a);
- if (autosave.exists())
- unlink(autosave);
-}
-
-
-void readBB_lyxerrMessage(FileName const & file, bool & zipped,
- string const & message)
-{
- LYXERR(Debug::GRAPHICS) << "[readBB_from_PSFile] "
- << message << std::endl;
- // FIXME: Why is this func deleting a file? (Lgb)
- if (zipped)
- unlink(file);
-}
-
-
-string const readBB_from_PSFile(FileName const & file)
-{
- // in a (e)ps-file it's an entry like %%BoundingBox:23 45 321 345
- // It seems that every command in the header has an own line,
- // getline() should work for all files.
- // On the other hand some plot programs write the bb at the
- // end of the file. Than we have in the header:
- // %%BoundingBox: (atend)
- // In this case we must check the end.
- bool zipped = file.isZippedFile();
- FileName const file_ = zipped ? unzipFile(file) : file;
- string const format = file_.guessFormatFromContents();
-
- if (format != "eps" && format != "ps") {
- readBB_lyxerrMessage(file_, zipped,"no(e)ps-format");
- return string();
- }
-
- static boost::regex bbox_re(
- "^%%BoundingBox:\\s*([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)\\s+([[:digit:]]+)");
- std::ifstream is(file_.toFilesystemEncoding().c_str());
- while (is) {
- string s;
- getline(is,s);
- boost::smatch what;
- if (regex_match(s, what, bbox_re)) {
- // Our callers expect the tokens in the string
- // separated by single spaces.
- // FIXME: change return type from string to something
- // sensible
- ostringstream os;
- os << what.str(1) << ' ' << what.str(2) << ' '
- << what.str(3) << ' ' << what.str(4);
- string const bb = os.str();
- readBB_lyxerrMessage(file_, zipped, bb);
- return bb;
- }
- }
- readBB_lyxerrMessage(file_, zipped, "no bb found");
- return string();
-}
-
-
int compare_timestamps(FileName const & file1, FileName const & file2)
{
// If the original is newer than the copy, then copy the original
return cmp;
}
+
+bool prefs2prefs(FileName const & filename, FileName const & tempfile, bool lfuns)
+{
+ FileName const script = libFileSearch("scripts", "prefs2prefs.py");
+ if (script.empty()) {
+ LYXERR0("Could not find bind file conversion "
+ "script prefs2prefs.py.");
+ return false;
+ }
+
+ ostringstream command;
+ command << os::python() << ' ' << quoteName(script.toFilesystemEncoding())
+ << ' ' << (lfuns ? "-l" : "-p") << ' '
+ << quoteName(filename.toFilesystemEncoding())
+ << ' ' << quoteName(tempfile.toFilesystemEncoding());
+ string const command_str = command.str();
+
+ LYXERR(Debug::FILES, "Running `" << command_str << '\'');
+
+ cmd_ret const ret = runCommand(command_str);
+ if (ret.first != 0) {
+ LYXERR0("Could not run file conversion script prefs2prefs.py.");
+ return false;
+ }
+ return true;
+}
+
+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 (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
projects / lyx.git / blobdiff