mirror of
https://git.lyx.org/repos/lyx.git
synced 2024-09-22 07:57:22 +00:00
964 lines
22 KiB
C++
964 lines
22 KiB
C++
|
/*
|
||
|
filetools.C (former paths.C) - part of LyX project
|
||
|
General path-mangling functions
|
||
|
Copyright (C) 1996 Ivan Schreter
|
||
|
Parts Copyright (C) 1996 Dirk Niggemann
|
||
|
Parts Copyright (C) 1985, 1990, 1993 Free Software Foundation, Inc.
|
||
|
Parts Copyright (C) 1996 Asger Alstrup
|
||
|
|
||
|
See also filetools.H.
|
||
|
|
||
|
lyx-filetool.C : tools functions for file/path handling
|
||
|
this file is part of LyX, the High Level Word Processor
|
||
|
copyright (C) 1995-1996, Matthias Ettrich and the LyX Team
|
||
|
|
||
|
*/
|
||
|
|
||
|
#include <config.h>
|
||
|
|
||
|
#include <stdlib.h>
|
||
|
#include <ctype.h>
|
||
|
#include <errno.h> // I know it's OS/2 specific (SMiyata)
|
||
|
|
||
|
#ifdef __GNUG__
|
||
|
#pragma implementation "filetools.h"
|
||
|
#endif
|
||
|
|
||
|
#include "filetools.h"
|
||
|
#include "lyx_gui_misc.h"
|
||
|
#include "FileInfo.h"
|
||
|
#include "pathstack.h" // I know it's OS/2 specific (SMiyata)
|
||
|
#include "gettext.h"
|
||
|
|
||
|
// Which part of this is still necessary? (JMarc).
|
||
|
#if HAVE_DIRENT_H
|
||
|
# include <dirent.h>
|
||
|
# define NAMLEN(dirent) strlen((dirent)->d_name)
|
||
|
#else
|
||
|
# define dirent direct
|
||
|
# define NAMLEN(dirent) (dirent)->d_namlen
|
||
|
# if HAVE_SYS_NDIR_H
|
||
|
# include <sys/ndir.h>
|
||
|
# endif
|
||
|
# if HAVE_SYS_DIR_H
|
||
|
# include <sys/dir.h>
|
||
|
# endif
|
||
|
# if HAVE_NDIR_H
|
||
|
# include <ndir.h>
|
||
|
# endif
|
||
|
#endif
|
||
|
|
||
|
// $Id: filetools.C,v 1.1 1999/09/27 18:44:37 larsbj Exp $
|
||
|
|
||
|
#if !defined(lint) && !defined(WITH_WARNINGS)
|
||
|
static char vcid[] = "$Id: filetools.C,v 1.1 1999/09/27 18:44:37 larsbj Exp $";
|
||
|
#endif /* lint */
|
||
|
|
||
|
|
||
|
extern LString system_lyxdir;
|
||
|
extern LString build_lyxdir;
|
||
|
extern LString user_lyxdir;
|
||
|
extern LString system_tempdir;
|
||
|
|
||
|
|
||
|
bool IsLyXFilename(LString const & filename)
|
||
|
{
|
||
|
return filename.contains(".lyx");
|
||
|
}
|
||
|
|
||
|
|
||
|
bool IsSGMLFilename(LString const & filename)
|
||
|
{
|
||
|
return filename.contains(".sgml");
|
||
|
}
|
||
|
|
||
|
|
||
|
// Substitutes spaces with underscores in filename (and path)
|
||
|
LString SpaceLess(LString const & file)
|
||
|
{
|
||
|
LString name = OnlyFilename(file);
|
||
|
LString path = OnlyPath(file);
|
||
|
|
||
|
for (int i=0; i<name.length(); i++) {
|
||
|
name[i] &= 0x7f;
|
||
|
if (!isalnum(name[i]) && name[i] != '.')
|
||
|
name[i] = '_';
|
||
|
}
|
||
|
LString temp = AddName(path, name);
|
||
|
// Replace spaces with underscores, also in directory
|
||
|
// No!!! I checked it that it is not necessary.
|
||
|
// temp.subst(' ','_');
|
||
|
|
||
|
return temp;
|
||
|
}
|
||
|
|
||
|
|
||
|
/// Returns an unique name to be used as a temporary file.
|
||
|
LString TmpFileName(LString const & dir, LString const & mask)
|
||
|
{// With all these temporary variables, it should be safe enough :-) (JMarc)
|
||
|
LString tmpdir;
|
||
|
if (dir.empty())
|
||
|
tmpdir = system_tempdir;
|
||
|
else
|
||
|
tmpdir = dir;
|
||
|
LString tmpfl = AddName(tmpdir, mask);
|
||
|
|
||
|
// find a uniq postfix for the filename...
|
||
|
// using the pid, and...
|
||
|
tmpfl += int(getpid());
|
||
|
// a short string...
|
||
|
LString ret;
|
||
|
FileInfo fnfo;
|
||
|
for (int a='a'; a<= 'z'; a++)
|
||
|
for (int b='a'; b<= 'z'; b++)
|
||
|
for (int c='a'; c<= 'z'; c++) {
|
||
|
// if this is not enough I have no idea what
|
||
|
// to do.
|
||
|
ret = tmpfl + char(a) + char(b) + char(c);
|
||
|
// check if the file exist
|
||
|
if (!fnfo.newFile(ret).exist())
|
||
|
return ret;
|
||
|
}
|
||
|
lyxerr.print("Not able to find a uniq tmpfile name.");
|
||
|
return LString();
|
||
|
}
|
||
|
|
||
|
|
||
|
// Is a file readable ?
|
||
|
bool IsFileReadable (LString const & path)
|
||
|
{
|
||
|
FileInfo file(path);
|
||
|
if (file.isOK() && file.isRegular() && file.readable())
|
||
|
return true;
|
||
|
else
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Is a file read_only?
|
||
|
// return 1 read-write
|
||
|
// 0 read_only
|
||
|
// -1 error (doesn't exist, no access, anything else)
|
||
|
int IsFileWriteable (LString const & path)
|
||
|
{
|
||
|
FilePtr fp(path, FilePtr::update);
|
||
|
if (!fp()) {
|
||
|
if ((errno == EACCES) || (errno == EROFS)) {
|
||
|
//fp = FilePtr(path, FilePtr::read);
|
||
|
fp.reopen(path, FilePtr::read);
|
||
|
if (fp()) {
|
||
|
return 0;
|
||
|
}
|
||
|
}
|
||
|
return -1;
|
||
|
}
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
|
||
|
//returns 1: dir writeable
|
||
|
// 0: not writeable
|
||
|
// -1: error- couldn't find out
|
||
|
int IsDirWriteable (LString const & path)
|
||
|
{
|
||
|
LString tmpfl = TmpFileName(path);
|
||
|
|
||
|
if (tmpfl.empty()) {
|
||
|
WriteFSAlert(_("LyX Internal Error!"),
|
||
|
_("Could not test if directory is writeable"));
|
||
|
return -1;
|
||
|
} else {
|
||
|
FilePtr fp(tmpfl, FilePtr::truncate);
|
||
|
if (!fp()) {
|
||
|
if (errno == EACCES) {
|
||
|
return 0;
|
||
|
} else {
|
||
|
WriteFSAlert(_("LyX Internal Error!"),
|
||
|
_("Cannot open directory test file"));
|
||
|
return -1;
|
||
|
}
|
||
|
}
|
||
|
}
|
||
|
if (remove (tmpfl.c_str())) {
|
||
|
WriteFSAlert(_("LyX Internal Error!"),
|
||
|
_("Created test file but cannot remove it?"));
|
||
|
return -1;
|
||
|
}
|
||
|
return 1;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Uses a string of paths separated by ";"s to find a file to open.
|
||
|
// Can't cope with pathnames with a ';' in them. Returns full path to file.
|
||
|
// If path entry begins with $$LyX/, use system_lyxdir
|
||
|
// If path entry begins with $$User/, use user_lyxdir
|
||
|
// Example: "$$User/doc;$$LyX/doc"
|
||
|
LString FileOpenSearch (LString const & path, LString const & name,
|
||
|
LString const & ext)
|
||
|
{
|
||
|
LString real_file, path_element;
|
||
|
LString tmppath = path;
|
||
|
bool notfound = true;
|
||
|
|
||
|
tmppath.split(path_element, ';');
|
||
|
|
||
|
while (notfound && !path_element.empty()) {
|
||
|
path_element = CleanupPath(path_element);
|
||
|
if (!path_element.suffixIs('/'))
|
||
|
path_element+='/';
|
||
|
path_element.subst("$$LyX",system_lyxdir);
|
||
|
path_element.subst("$$User",user_lyxdir);
|
||
|
|
||
|
real_file = FileSearch(path_element, name, ext);
|
||
|
|
||
|
if (real_file.empty()) {
|
||
|
tmppath.split(path_element, ';');
|
||
|
} else {
|
||
|
notfound = false;
|
||
|
}
|
||
|
}
|
||
|
#ifdef __EMX__
|
||
|
if (ext.empty() && notfound) {
|
||
|
real_file = FileOpenSearch(path, name, "exe");
|
||
|
if (notfound) real_file = FileOpenSearch(path, name, "cmd");
|
||
|
}
|
||
|
#endif
|
||
|
return real_file;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Returns the real name of file name in directory path, with optional
|
||
|
// extension ext.
|
||
|
LString FileSearch(LString const & path, LString const & name,
|
||
|
LString const & ext)
|
||
|
{
|
||
|
LString fullname;
|
||
|
LString tmp;
|
||
|
|
||
|
// if `name' is an absolute path, we ignore the setting of `path'
|
||
|
// Expand Environmentvariables in 'name'
|
||
|
LString tmpname = ReplaceEnvironmentPath(name);
|
||
|
fullname = MakeAbsPath(tmpname,path);
|
||
|
|
||
|
// search first without extension, then with it.
|
||
|
if (IsFileReadable(fullname))
|
||
|
return fullname;
|
||
|
else if(ext.empty())
|
||
|
return LString();
|
||
|
else { // Is it not more reasonable to use ChangeExtension()? (SMiyata)
|
||
|
fullname += '.';
|
||
|
fullname += ext;
|
||
|
if (IsFileReadable(fullname))
|
||
|
return fullname;
|
||
|
else
|
||
|
return LString();
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// Search the file name.ext in the subdirectory dir of
|
||
|
// 1) user_lyxdir
|
||
|
// 2) build_lyxdir (if not empty)
|
||
|
// 3) system_lyxdir
|
||
|
LString LibFileSearch(LString const & dir, LString const & name,
|
||
|
LString const & ext)
|
||
|
{
|
||
|
LString 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 (!fullname.empty())
|
||
|
return fullname;
|
||
|
|
||
|
return FileSearch(AddPath(system_lyxdir,dir), name, ext);
|
||
|
}
|
||
|
|
||
|
LString i18nLibFileSearch(LString const & dir, LString const & name,
|
||
|
LString const & ext)
|
||
|
{
|
||
|
LString lang = LString(getenv("LANG")).token('_',0);
|
||
|
|
||
|
if (lang.empty())
|
||
|
return LibFileSearch(dir, name, ext);
|
||
|
else {
|
||
|
LString tmp = LibFileSearch(dir, lang + '_' + name,
|
||
|
ext);
|
||
|
if (!tmp.empty())
|
||
|
return tmp;
|
||
|
else
|
||
|
return LibFileSearch(dir, name, ext);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
static
|
||
|
int DeleteAllFilesInDir (LString const & path)
|
||
|
{
|
||
|
DIR * dir;
|
||
|
struct dirent *de;
|
||
|
dir = opendir(path.c_str());
|
||
|
if (!dir) {
|
||
|
WriteFSAlert (_("Error! Cannot open directory:"), path);
|
||
|
return -1;
|
||
|
}
|
||
|
while ((de = readdir(dir))) {
|
||
|
LString temp = de->d_name;
|
||
|
if (temp=="." || temp=="..")
|
||
|
continue;
|
||
|
LString unlinkpath = AddName (path, temp);
|
||
|
|
||
|
lyxerr.debug("Deleting file: " + unlinkpath);
|
||
|
|
||
|
if (remove (unlinkpath.c_str()))
|
||
|
WriteFSAlert (_("Error! Could not remove file:"),
|
||
|
unlinkpath);
|
||
|
}
|
||
|
closedir (dir);
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
static
|
||
|
LString CreateTmpDir (LString const & tempdir, LString const & mask)
|
||
|
{
|
||
|
LString tmpfl = TmpFileName(tempdir, mask);
|
||
|
|
||
|
if ((tmpfl.empty()) || mkdir (tmpfl.c_str(), 0777)) {
|
||
|
WriteFSAlert(_("Error! Couldn't create temporary directory:"),
|
||
|
tempdir);
|
||
|
return LString();
|
||
|
}
|
||
|
return MakeAbsPath(tmpfl);
|
||
|
}
|
||
|
|
||
|
|
||
|
static
|
||
|
int DestroyTmpDir (LString const & tmpdir, bool Allfiles)
|
||
|
{
|
||
|
if ((Allfiles) && (DeleteAllFilesInDir (tmpdir))) return -1;
|
||
|
if (rmdir(tmpdir.c_str())) {
|
||
|
#ifdef __EMX__
|
||
|
if (errno == EBUSY) {
|
||
|
chdir(user_lyxdir.c_str()); // They are in the same drive.
|
||
|
if (!rmdir(tmpdir.c_str())) return 0;
|
||
|
}
|
||
|
#endif
|
||
|
WriteFSAlert(_("Error! Couldn't delete temporary directory:"),
|
||
|
tmpdir);
|
||
|
return -1;
|
||
|
}
|
||
|
return 0;
|
||
|
}
|
||
|
|
||
|
|
||
|
LString CreateBufferTmpDir (LString const & pathfor)
|
||
|
{
|
||
|
return CreateTmpDir (pathfor, "lyx_bufrtmp");
|
||
|
}
|
||
|
|
||
|
|
||
|
int DestroyBufferTmpDir (LString const & tmpdir)
|
||
|
{
|
||
|
return DestroyTmpDir (tmpdir, true);
|
||
|
}
|
||
|
|
||
|
|
||
|
LString CreateLyXTmpDir (LString const & deflt)
|
||
|
{
|
||
|
LString t;
|
||
|
|
||
|
if ((!deflt.empty()) && (deflt!="/tmp")) {
|
||
|
if (mkdir (deflt.c_str(), 0777)) {
|
||
|
#ifdef __EMX__
|
||
|
PathPush(user_lyxdir);
|
||
|
#endif
|
||
|
t = CreateTmpDir (deflt.c_str(), "lyx_tmp");
|
||
|
#ifdef __EMX__
|
||
|
PathPop();
|
||
|
#endif
|
||
|
return t;
|
||
|
} else
|
||
|
return deflt;
|
||
|
} else {
|
||
|
#ifdef __EMX__
|
||
|
PathPush(user_lyxdir);
|
||
|
#endif
|
||
|
t = CreateTmpDir ("/tmp", "lyx_tmp");
|
||
|
#ifdef __EMX__
|
||
|
PathPop();
|
||
|
#endif
|
||
|
return t;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
int DestroyLyXTmpDir (LString const & tmpdir)
|
||
|
{
|
||
|
return DestroyTmpDir (tmpdir, false); // Why false?
|
||
|
}
|
||
|
|
||
|
|
||
|
// Creates directory. Returns true if succesfull
|
||
|
bool createDirectory(LString const & path, int permission)
|
||
|
{
|
||
|
LString temp = CleanupPath(path);
|
||
|
|
||
|
// Cut off trailing /s
|
||
|
temp.strip('/');
|
||
|
|
||
|
if (temp.empty()) {
|
||
|
WriteAlert(_("Internal error!"),
|
||
|
_("Call to createDirectory with invalid name"));
|
||
|
return false;
|
||
|
}
|
||
|
|
||
|
if (mkdir(temp.c_str(), permission)) {
|
||
|
WriteFSAlert (_("Error! Couldn't create directory:"), temp);
|
||
|
return false;
|
||
|
}
|
||
|
return true;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Returns current working directory
|
||
|
LString GetCWD ()
|
||
|
{
|
||
|
int n = 256; // Assume path is less than 256 chars
|
||
|
char * err;
|
||
|
char * tbuf = new char [n];
|
||
|
LString result;
|
||
|
|
||
|
// Safe. Hopefully all getcwds behave this way!
|
||
|
while (((err = getcwd (tbuf, n)) == NULL) && (errno == ERANGE)) {
|
||
|
// Buffer too small, double the buffersize and try again
|
||
|
delete[] tbuf;
|
||
|
n = 2*n;
|
||
|
tbuf = new char [n];
|
||
|
}
|
||
|
|
||
|
if (err) result = tbuf;
|
||
|
delete[] tbuf;
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Strip filename from path name
|
||
|
LString OnlyPath(LString const &Filename)
|
||
|
{
|
||
|
// If empty filename, return empty
|
||
|
if (Filename.empty()) return Filename;
|
||
|
|
||
|
// Find last / or start of filename
|
||
|
int j = Filename.length() - 1;
|
||
|
LString temp = CleanupPath(Filename);
|
||
|
for (; j > 0 && temp[j] != '/'; j--);
|
||
|
|
||
|
if (temp[j] != '/')
|
||
|
return "./";
|
||
|
else {
|
||
|
// Strip to pathname
|
||
|
return temp.substring(0, j);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
|
||
|
// 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.
|
||
|
LString MakeAbsPath(LString const &RelPath, LString const &BasePath)
|
||
|
{
|
||
|
// checks for already absolute path
|
||
|
if (AbsolutePath(RelPath))
|
||
|
#ifdef __EMX__
|
||
|
if(RelPath[0]!='/' || RelPath[0]!='\\')
|
||
|
#endif
|
||
|
return RelPath;
|
||
|
|
||
|
// Copies given paths
|
||
|
LString TempRel = CleanupPath(RelPath);
|
||
|
|
||
|
LString TempBase;
|
||
|
|
||
|
if (!BasePath.empty()) {
|
||
|
#ifndef __EMX__
|
||
|
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 = GetCWD(); //safer_getcwd();
|
||
|
#ifdef __EMX__
|
||
|
if (AbsolutePath(TempRel))
|
||
|
return TempBase.substring(0,1) + TempRel;
|
||
|
#endif
|
||
|
|
||
|
// Handle /./ at the end of the path
|
||
|
while(TempBase.suffixIs("/./"))
|
||
|
TempBase.substring(0,TempBase.length()-3);
|
||
|
|
||
|
// processes relative path
|
||
|
LString RTemp = TempRel;
|
||
|
LString Temp;
|
||
|
|
||
|
while (!RTemp.empty()) {
|
||
|
// Split by next /
|
||
|
RTemp.split(Temp, '/');
|
||
|
|
||
|
if (Temp==".") continue;
|
||
|
if (Temp=="..") {
|
||
|
// Remove one level of TempBase
|
||
|
int i = TempBase.length()-2;
|
||
|
#ifndef __EMX__
|
||
|
if (i<0) i=0;
|
||
|
while (i>0 && TempBase[i] != '/') i--;
|
||
|
if (i>0)
|
||
|
#else
|
||
|
if (i<2) i=2;
|
||
|
while (i>2 && TempBase[i] != '/') i--;
|
||
|
if (i>2)
|
||
|
#endif
|
||
|
TempBase.substring(0, i);
|
||
|
else
|
||
|
TempBase += '/';
|
||
|
} else {
|
||
|
// Add this piece to TempBase
|
||
|
if (!TempBase.suffixIs('/'))
|
||
|
TempBase += '/';
|
||
|
TempBase += Temp;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// returns absolute path
|
||
|
return TempBase;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Correctly append filename to the pathname.
|
||
|
// If pathname is '.', then don't use pathname.
|
||
|
// Chops any path of filename.
|
||
|
LString AddName(LString const &Path, LString const &FileName)
|
||
|
{
|
||
|
// Get basename
|
||
|
LString Basename = OnlyFilename(FileName);
|
||
|
|
||
|
LString buf;
|
||
|
|
||
|
if (Path != "." && Path != "./" && !Path.empty()) {
|
||
|
buf = CleanupPath(Path);
|
||
|
if (!Path.suffixIs('/'))
|
||
|
buf += '/';
|
||
|
}
|
||
|
|
||
|
return buf + Basename;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Strips path from filename
|
||
|
LString OnlyFilename(LString const &Filename)
|
||
|
{
|
||
|
// If empty filename, return empty
|
||
|
if (Filename.empty()) return Filename;
|
||
|
|
||
|
int j;
|
||
|
// Find last / or start of filename
|
||
|
LString temp = CleanupPath(Filename);
|
||
|
for (j=Filename.length()-1; temp[j] != '/' && j>0; j--);
|
||
|
|
||
|
// Skip potential /
|
||
|
if (j!=0) j++;
|
||
|
|
||
|
// Strip to basename
|
||
|
return temp.substring(j, temp.length()-1);
|
||
|
}
|
||
|
|
||
|
|
||
|
// Is a filename/path absolute?
|
||
|
bool AbsolutePath(LString const &path)
|
||
|
{
|
||
|
#ifndef __EMX__
|
||
|
return (!path.empty() && path[0]=='/');
|
||
|
#else
|
||
|
return (!path.empty() && (path[0]=='/' || (isalpha((unsigned char) path[0]) && path[1]==':')));
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
|
||
|
// Create absolute path. If impossible, don't do anything
|
||
|
// Supports ./ and ~/. Later we can add support for ~logname/. (Asger)
|
||
|
LString ExpandPath(LString const &path)
|
||
|
{
|
||
|
// checks for already absolute path
|
||
|
LString RTemp = ReplaceEnvironmentPath(path);
|
||
|
if (AbsolutePath(RTemp))
|
||
|
return RTemp;
|
||
|
|
||
|
LString Temp;
|
||
|
LString copy(RTemp);
|
||
|
|
||
|
// Split by next /
|
||
|
RTemp.split(Temp, '/');
|
||
|
|
||
|
if (Temp==".") {
|
||
|
return GetCWD() + '/' + RTemp;
|
||
|
} else if (Temp=="~") {
|
||
|
return getEnvPath("HOME") + '/' + RTemp;
|
||
|
} else if (Temp=="..") {
|
||
|
return MakeAbsPath(copy);
|
||
|
} else
|
||
|
// Don't know how to handle this
|
||
|
return copy;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Normalize a path
|
||
|
// Constracts path/../path
|
||
|
// Can't handle "../../" or "/../" (Asger)
|
||
|
LString NormalizePath(LString const &path)
|
||
|
{
|
||
|
LString TempBase;
|
||
|
LString RTemp;
|
||
|
LString Temp;
|
||
|
|
||
|
if (AbsolutePath(path))
|
||
|
RTemp = path;
|
||
|
else
|
||
|
// Make implicit current directory explicit
|
||
|
RTemp = "./" +path;
|
||
|
|
||
|
while (!RTemp.empty()) {
|
||
|
// Split by next /
|
||
|
RTemp.split(Temp, '/');
|
||
|
|
||
|
if (Temp==".") {
|
||
|
TempBase = "./";
|
||
|
} else if (Temp=="..") {
|
||
|
// Remove one level of TempBase
|
||
|
int i = TempBase.length()-2;
|
||
|
while (i>0 && TempBase[i] != '/')
|
||
|
i--;
|
||
|
if (i>=0 && TempBase[i] == '/')
|
||
|
TempBase.substring(0, i);
|
||
|
else
|
||
|
TempBase = "../";
|
||
|
} else {
|
||
|
TempBase += Temp + '/';
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// returns absolute path
|
||
|
return TempBase;
|
||
|
}
|
||
|
|
||
|
LString CleanupPath(LString const &path)
|
||
|
{
|
||
|
#ifdef __EMX__ /* SMiyata: This should fix searchpath bug. */
|
||
|
LString temppath(path);
|
||
|
temppath.subst('\\', '/');
|
||
|
temppath.subst("//", "/");
|
||
|
temppath.lowercase();
|
||
|
return temppath;
|
||
|
#else // On unix, nothing to do
|
||
|
return path;
|
||
|
#endif
|
||
|
}
|
||
|
|
||
|
|
||
|
//
|
||
|
// 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]*} '}'
|
||
|
//
|
||
|
|
||
|
LString ReplaceEnvironmentPath(LString const &path)
|
||
|
{
|
||
|
//
|
||
|
// CompareChar: Environmentvariables 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
|
||
|
//
|
||
|
const char CompareChar = '$';
|
||
|
const char FirstChar = '{';
|
||
|
const char EndChar = '}';
|
||
|
const char UnderscoreChar = '_';
|
||
|
const LString EndString(EndChar);
|
||
|
const LString FirstString(FirstChar);
|
||
|
const LString CompareString(CompareChar);
|
||
|
const LString RegExp("*}*"); // Exist EndChar inside a String?
|
||
|
|
||
|
if (path.empty()) return path; // nothing to do.
|
||
|
|
||
|
// first: Search for a '$' - Sign.
|
||
|
LString copy(path);
|
||
|
LString result1(copy); // for split-calls
|
||
|
LString result0 = copy.split(result1, CompareChar);
|
||
|
while (!result0.empty()) {
|
||
|
LString copy1(result0); // contains String after $
|
||
|
|
||
|
// Check, if there is an EndChar inside original String.
|
||
|
|
||
|
if (!copy1.regexMatch(RegExp)) {
|
||
|
// No EndChar inside. So we are finished
|
||
|
result1 += CompareString + result0;
|
||
|
result0 = LString();
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
LString res1;
|
||
|
LString res0 = copy1.split(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
|
||
|
const char *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"
|
||
|
const char *cp1 = res1_contents+1;
|
||
|
bool result = isalpha((unsigned char) *cp1) || (*cp1 == UnderscoreChar);
|
||
|
++cp1;
|
||
|
while (*cp1 && result) {
|
||
|
result = isalnum((unsigned char) *cp1) ||
|
||
|
(*cp1 == UnderscoreChar);
|
||
|
++cp1;
|
||
|
}
|
||
|
|
||
|
if (!result) {
|
||
|
// no correct variable name
|
||
|
result1 += CompareString + res1 + EndString;
|
||
|
result0 = res0.split(res1, CompareChar);
|
||
|
result1 += res1;
|
||
|
continue;
|
||
|
}
|
||
|
|
||
|
char *env = getenv(res1_contents+1);
|
||
|
if (env) {
|
||
|
// Congratulations. Environmentvariable found
|
||
|
result1 += env;
|
||
|
} else {
|
||
|
result1 += CompareString + res1 + EndString;
|
||
|
}
|
||
|
// Next $-Sign?
|
||
|
result0 = res0.split(res1, CompareChar);
|
||
|
result1 += res1;
|
||
|
}
|
||
|
return result1;
|
||
|
} // ReplaceEnvironmentPath
|
||
|
|
||
|
|
||
|
// Make relative path out of two absolute paths
|
||
|
LString MakeRelPath(LString const & abspath0, LString const & basepath0)
|
||
|
// 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.
|
||
|
LString abspath = CleanupPath(abspath0);
|
||
|
LString basepath = CleanupPath(basepath0);
|
||
|
if (abspath.empty())
|
||
|
return "<unknown_path>";
|
||
|
|
||
|
const int abslen = abspath.length();
|
||
|
const int baselen = basepath.length();
|
||
|
|
||
|
// Find first different character
|
||
|
int 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;
|
||
|
}
|
||
|
|
||
|
if (i == 0) {
|
||
|
// actually no match - cannot make it relative
|
||
|
return abspath;
|
||
|
}
|
||
|
|
||
|
// Count how many dirs there are in basepath above match
|
||
|
// and append as many '..''s into relpath
|
||
|
LString buf;
|
||
|
int j = i;
|
||
|
while (j < baselen) {
|
||
|
if (basepath[j] == '/') {
|
||
|
if (j+1 == baselen) break;
|
||
|
buf += "../";
|
||
|
}
|
||
|
++j;
|
||
|
}
|
||
|
|
||
|
// Append relative stuff from common directory to abspath
|
||
|
if (abspath[i] == '/') ++i;
|
||
|
for (; i<abslen; ++i)
|
||
|
buf += abspath[i];
|
||
|
// Remove trailing /
|
||
|
if (buf.suffixIs('/'))
|
||
|
buf.substring(0,buf.length()-2);
|
||
|
// Substitute empty with .
|
||
|
if (buf.empty())
|
||
|
buf = '.';
|
||
|
return buf;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Append sub-directory(ies) to a path in an intelligent way
|
||
|
LString AddPath(LString const & path, LString const & path_2)
|
||
|
{
|
||
|
LString buf;
|
||
|
LString path2 = CleanupPath(path_2);
|
||
|
|
||
|
if (!path.empty() && path != "." && path != "./") {
|
||
|
buf = CleanupPath(path);
|
||
|
if (!path.suffixIs('/'))
|
||
|
buf += '/';
|
||
|
}
|
||
|
|
||
|
if (!path2.empty()){
|
||
|
int p2start = 0;
|
||
|
while (path2[p2start] == '/') p2start++;
|
||
|
|
||
|
int p2end = path2.length()-1;
|
||
|
while (path2[p2end] == '/') p2end--;
|
||
|
|
||
|
LString tmp = path2;
|
||
|
tmp.substring(p2start,p2end);
|
||
|
buf += tmp + '/';
|
||
|
}
|
||
|
return buf;
|
||
|
}
|
||
|
|
||
|
|
||
|
/*
|
||
|
Change extension of oldname to extension.
|
||
|
Strips path off if no_path == true.
|
||
|
If no extension on oldname, just appends.
|
||
|
*/
|
||
|
LString ChangeExtension(LString const & origname, LString const & extension,
|
||
|
bool no_path)
|
||
|
{
|
||
|
LString oldname = CleanupPath(origname);
|
||
|
int n = oldname.length()-1;
|
||
|
int dot;
|
||
|
|
||
|
// Make sure the extension includes the dot, if not empty
|
||
|
LString ext;
|
||
|
if (!extension.empty() && extension[0] != '.')
|
||
|
ext = "." + extension;
|
||
|
else
|
||
|
ext = extension;
|
||
|
|
||
|
// Go back to the first dot not crossing any /
|
||
|
for (dot=n; dot>=0 && oldname[dot]!='.' && oldname[dot]!='/'; dot--);
|
||
|
|
||
|
if (dot==-1 || oldname[dot]!='.')
|
||
|
// If no extension was found, we use the end of the string
|
||
|
dot = n;
|
||
|
else
|
||
|
// Remove the dot, because the new extension includes it
|
||
|
dot--;
|
||
|
|
||
|
// "path" points to last / or 0 if path is wanted
|
||
|
int path = 0;
|
||
|
if (no_path) {
|
||
|
for (path=dot; path && oldname[path]!='/';path--);
|
||
|
if (oldname[path]=='/')
|
||
|
path++;
|
||
|
} else
|
||
|
path = 0;
|
||
|
|
||
|
LString result = oldname;
|
||
|
result.substring(path,dot);
|
||
|
if (!ext.empty())
|
||
|
result += ext;
|
||
|
return result;
|
||
|
}
|
||
|
|
||
|
|
||
|
// Creates a nice compact path for displaying
|
||
|
LString MakeDisplayPath (LString const & path, int threshold)
|
||
|
{
|
||
|
const int l1 = path.length();
|
||
|
|
||
|
// First, we try a relative path compared to home
|
||
|
LString home = getEnvPath("HOME");
|
||
|
LString relhome = MakeRelPath(path, home);
|
||
|
|
||
|
int l2 = relhome.length();
|
||
|
|
||
|
LString prefix;
|
||
|
|
||
|
// If we backup from home or don't have a relative path,
|
||
|
// this try is no good
|
||
|
if (relhome.prefixIs("../") || AbsolutePath(relhome)) {
|
||
|
// relative path was no good, just use the original path
|
||
|
relhome = path;
|
||
|
l2 = l1;
|
||
|
} else {
|
||
|
prefix = "~/";
|
||
|
}
|
||
|
|
||
|
// Is the path too long?
|
||
|
if (l2 > threshold) {
|
||
|
// Yes, shortend it
|
||
|
prefix += ".../";
|
||
|
|
||
|
LString temp;
|
||
|
|
||
|
while (relhome.length()>threshold)
|
||
|
relhome.split(temp, '/');
|
||
|
|
||
|
// Did we shortend everything away?
|
||
|
if (relhome.empty()) {
|
||
|
// Yes, filename in itself is too long.
|
||
|
// Pick the start and the end of the filename.
|
||
|
relhome = OnlyFilename(path);
|
||
|
LString head = relhome;
|
||
|
head.substring(0, threshold/2 - 3);
|
||
|
|
||
|
LString tail = relhome;
|
||
|
l2 = tail.length();
|
||
|
tail.substring(l2 - threshold/2 -2, l2 - 1);
|
||
|
|
||
|
relhome = head + "..." + tail;
|
||
|
}
|
||
|
}
|
||
|
return prefix + relhome;
|
||
|
}
|
||
|
|
||
|
bool LyXReadLink(LString const & File, LString & Link)
|
||
|
{
|
||
|
char LinkBuffer[512];
|
||
|
// Should be PATH_MAX but that needs autconf support
|
||
|
int nRead;
|
||
|
nRead = readlink(File.c_str(), LinkBuffer,sizeof(LinkBuffer)-1);
|
||
|
if (nRead <= 0)
|
||
|
return false;
|
||
|
LinkBuffer[nRead] = 0;
|
||
|
Link = LinkBuffer;
|
||
|
return true;
|
||
|
}
|