home *** CD-ROM | disk | FTP | other *** search
/ Dream 52 / Amiga_Dream_52.iso / Linux / Divers / lyx-0.13.2.tar.gz / lyx-0.13.2.tar / lyx-0.13.2 / src / filetools.C < prev    next >
C/C++ Source or Header  |  1998-04-23  |  21KB  |  933 lines
  1. /*
  2.     filetools.C (former paths.C) - part of LyX project
  3.     General path-mangling functions 
  4.     Copyright (C) 1996 Ivan Schreter
  5.     Parts Copyright (C) 1996 Dirk Niggemann
  6.         Parts Copyright (C) 1985, 1990, 1993 Free Software Foundation, Inc.
  7.     Parts Copyright (C) 1996 Asger Alstrup
  8.     
  9.     See also filetools.H.
  10.  
  11.     lyx-filetool.C : tools functions for file/path handling
  12.     this file is part of LyX, the High Level Word Processor
  13.     copyright (C) 1995-1996, Matthias Ettrich and the LyX Team
  14.  
  15. */
  16.  
  17. #include <config.h>
  18.  
  19. #include <stdlib.h>
  20. #include <ctype.h>
  21. #include <errno.h>        // I know it's OS/2 specific (SMiyata)
  22.  
  23. #ifdef __GNUG__
  24. #pragma implementation "filetools.h"
  25. #endif
  26.  
  27. #include "filetools.h"
  28. #include "lyx_gui_misc.h"
  29. #include "FileInfo.h"
  30. #include "path.h"
  31. #include "gettext.h"
  32.  
  33. // Which part of this is still necessary? (JMarc).
  34. #if HAVE_DIRENT_H
  35. # include <dirent.h>
  36. # define NAMLEN(dirent) strlen((dirent)->d_name)
  37. #else
  38. # define dirent direct
  39. # define NAMLEN(dirent) (dirent)->d_namlen
  40. # if HAVE_SYS_NDIR_H
  41. #  include <sys/ndir.h>
  42. # endif
  43. # if HAVE_SYS_DIR_H
  44. #  include <sys/dir.h>
  45. # endif
  46. # if HAVE_NDIR_H
  47. #  include <ndir.h>
  48. # endif
  49. #endif
  50.  
  51. //     $Id: filetools.C,v 1.1.1.1 1998/04/23 16:02:49 larsbj Exp $    
  52.  
  53. #if !defined(lint) && !defined(WITH_WARNINGS)
  54. static char vcid[] = "$Id: filetools.C,v 1.1.1.1 1998/04/23 16:02:49 larsbj Exp $";
  55. #endif /* lint */
  56.  
  57.  
  58. extern LString system_lyxdir;
  59. extern LString build_lyxdir;
  60. extern LString user_lyxdir;
  61. extern LString system_tempdir;
  62.  
  63.  
  64. bool IsLyXFilename(LString const & filename)
  65. {
  66.     return filename.contains(".lyx");
  67. }
  68.  
  69.  
  70. bool IsSGMLFilename(LString const & filename)
  71. {
  72.     return filename.contains(".sgml");
  73. }
  74.  
  75. // Substitutes spaces with underscores in filename (and path)
  76. LString SpaceLess(LString const & file)
  77. {
  78.     LString name = OnlyFilename(file);
  79.     LString path = OnlyPath(file);
  80.     // Substitute chars that LaTeX can't handle with safe ones
  81.     name.subst('~','-');
  82.     name.subst('$','S');
  83.     name.subst('%','_');
  84.  
  85.     LString temp = AddName(path, name);
  86.     // Replace spaces with underscores, also in directory
  87.     temp.subst(' ','_');
  88.  
  89.     return temp;
  90. }
  91.  
  92.  
  93. /// Returns an unique name to be used as a temporary file. 
  94. LString TmpFileName(LString const & dir, LString const & mask)
  95. {// With all these temporary variables, it should be safe enough :-) (JMarc)
  96.     LString tmpdir;    
  97.     if (dir.empty())
  98.         tmpdir = system_tempdir;
  99.     else
  100.         tmpdir = dir;
  101.     LString tmpfl = AddName(tmpdir, mask);
  102.  
  103.     // find a uniq postfix for the filename...
  104.     // using the pid, and...
  105.     tmpfl += int(getpid());
  106.     // a short string...
  107.     LString ret;
  108.     FileInfo fnfo;
  109.     for (int a='a'; a<= 'z'; a++)
  110.         for (int b='a'; b<= 'z'; b++)
  111.             for (int c='a'; c<= 'z'; c++) {
  112.                 // if this is not enough I have no idea what
  113.                 // to do.
  114.                 ret = tmpfl + char(a) + char(b) + char(c);
  115.                 // check if the file exist
  116.                 if (!fnfo.newFile(ret).exist())
  117.                     return ret;
  118.             }
  119.     lyxerr.print("Not able to find a uniq tmpfile name.");
  120.     return LString();
  121. }
  122.  
  123.  
  124. // Is a file readable ?
  125. bool IsFileReadable (LString const & path)
  126. {
  127.     FileInfo file(path);
  128.     if (file.isOK() && file.readable())
  129.         return true;
  130.     else
  131.         return false;
  132. }
  133.  
  134.  
  135. // Is a file read_only?
  136. // return 1 read-write
  137. //      0 read_only
  138. //     -1 error (doesn't exist, no access, anything else) 
  139. int IsFileWriteable (LString const & path)
  140. {
  141.     FilePtr fp(path, FilePtr::update);
  142.     if (!fp()) {
  143.         if ((errno == EACCES) || (errno == EROFS)) {
  144.             //fp = FilePtr(path, FilePtr::read);
  145.             fp.reopen(path, FilePtr::read);
  146.             if (fp()) {
  147.                 return 0;
  148.             }
  149.         }
  150.         return -1;
  151.     }
  152.     return 1;
  153. }
  154.  
  155.  
  156. //returns 1: dir writeable
  157. //      0: not writeable
  158. //     -1: error- couldn't find out
  159. int IsDirWriteable (LString const & path)
  160. {
  161.         LString tmpfl = TmpFileName(path);
  162.  
  163.     if (tmpfl.empty()) {
  164.         WriteFSAlert(_("LyX Internal Error!"), 
  165.                  _("Could not test if directory is writeable"));
  166.         return -1;
  167.     } else {
  168.     FilePtr fp(tmpfl, FilePtr::truncate);
  169.     if (!fp()) {
  170.         if (errno == EACCES) {
  171.             return 0;
  172.         } else { 
  173.                 WriteFSAlert(_("LyX Internal Error!"), 
  174.                      _("Cannot open directory test file"));
  175.             return -1;
  176.         }
  177.         }
  178.     }
  179.         if (remove (tmpfl.c_str())) {
  180.             WriteFSAlert(_("LyX Internal Error!"), 
  181.                     _("Created test file but cannot remove it?"));
  182.              return -1;
  183.     }
  184.     return 1;
  185. }
  186.  
  187.  
  188. // Uses a string of paths separated by ";"s to find a file to open.
  189. // Can't cope with pathnames with a ';' in them. Returns full path to file.
  190. // If path entry begins with $$LyX/, use system_lyxdir
  191. // If path entry begins with $$User/, use user_lyxdir
  192. // Example: "$$User/doc;$$LyX/doc"
  193. LString FileOpenSearch (LString const & path, LString const & name, 
  194.             LString const & ext)
  195. {
  196.     LString real_file, path_element;
  197.     LString tmppath = path;
  198.     bool notfound = true;
  199.  
  200.     tmppath.split(path_element, ';');
  201.     
  202.     while (notfound && !path_element.empty()) {
  203.  
  204.         if (!path_element.suffixIs('/'))
  205.             path_element+='/';
  206.         path_element.subst("$$LyX",system_lyxdir);
  207.         path_element.subst("$$User",user_lyxdir);
  208.         
  209.         real_file = FileSearch(path_element, name, ext);
  210.  
  211.         if (real_file.empty()) {
  212.           tmppath.split(path_element, ';');
  213.         } else {
  214.           notfound = false;
  215.         }
  216.     }
  217. #ifdef __EMX__
  218.     if (ext.empty() && notfound) {
  219.         real_file = FileOpenSearch(path, name, "exe");
  220.         if (notfound) real_file = FileOpenSearch(path, name, "cmd");
  221.     }
  222. #endif
  223.     return real_file;
  224. }
  225.  
  226.  
  227. // Returns the real name of file name in directory path, with optional
  228. // extension ext.  
  229. LString FileSearch(LString const & path, LString const & name, 
  230.            LString const & ext)
  231. {
  232.         LString fullname;
  233.     LString tmp;
  234.  
  235.     // if `name' is an absolute path, we ignore the setting of `path'
  236.     // Expand Environmentvariables in 'name'
  237.     LString tmpname = ReplaceEnvironmentPath(name);
  238.     fullname = MakeAbsPath(tmpname,path);
  239.  
  240.     // search first without extension, then with it.
  241.     if (IsFileReadable(fullname))
  242.         return fullname;
  243.     else if(ext.empty()) 
  244.         return LString();
  245.     else { // Is it not more reasonable to use ChangeExtension()? (SMiyata)
  246.         fullname += '.';
  247.         fullname += ext;
  248.         if (IsFileReadable(fullname))
  249.             return fullname;
  250.         else 
  251.             return LString();
  252.     }
  253. }
  254.  
  255.  
  256. // Search the file name.ext in the subdirectory dir of
  257. //   1) user_lyxdir
  258. //   2) build_lyxdir (if not empty)
  259. //   3) system_lyxdir
  260. LString LibFileSearch(LString const & dir, LString const & name, 
  261.               LString const & ext)
  262. {
  263.         LString fullname = FileSearch(AddPath(user_lyxdir,dir), name,
  264.                       ext); 
  265.     if (!fullname.empty())
  266.         return fullname;
  267.  
  268.     if (!build_lyxdir.empty()) 
  269.       fullname = FileSearch(AddPath(build_lyxdir,dir), 
  270.                 name, ext);
  271.     if (!fullname.empty())
  272.         return fullname;
  273.  
  274.     return FileSearch(AddPath(system_lyxdir,dir), name, ext);
  275. }
  276.  
  277.  
  278. static
  279. int DeleteAllFilesInDir (LString const & path)
  280. {
  281.     DIR * dir;
  282.     struct dirent *de;
  283.     dir = opendir(path.c_str());
  284.     if (!dir) {
  285.         WriteFSAlert (_("Error! Cannot open directory:"), path);
  286.         return -1;
  287.     }
  288.     while ((de = readdir(dir))) {
  289.         LString temp = de->d_name;
  290.         if (temp=="." || temp=="..") 
  291.             continue;
  292.         LString unlinkpath = AddName (path, temp);
  293.  
  294.         lyxerr.debug("Deleting file: " + unlinkpath);
  295.  
  296.          if (remove (unlinkpath.c_str()))
  297.             WriteFSAlert (_("Error! Could not remove file:"), 
  298.                       unlinkpath);
  299.         }
  300.     closedir (dir);
  301.     return 0;
  302. }
  303.  
  304.  
  305. static
  306. LString CreateTmpDir (LString const & tempdir, LString const & mask)
  307. {
  308.     LString tmpfl = TmpFileName(tempdir, mask);
  309.     
  310.     if ((tmpfl.empty()) || mkdir (tmpfl.c_str(), 0777)) {
  311.         WriteFSAlert(_("Error! Couldn't create temporary directory:"),
  312.                  tempdir);
  313.         return LString();
  314.     }
  315.     return MakeAbsPath(tmpfl);
  316. }
  317.  
  318.  
  319. static
  320. int DestroyTmpDir (LString const & tmpdir, bool Allfiles)
  321. {
  322.     if ((Allfiles) && (DeleteAllFilesInDir (tmpdir))) return -1;
  323.     if (rmdir(tmpdir.c_str())) { 
  324. #ifdef __EMX__
  325.         if (errno == EBUSY) {
  326.             chdir(user_lyxdir.c_str()); // They are in the same drive.
  327.             if (!rmdir(tmpdir.c_str())) return 0;
  328.         }
  329. #endif
  330.         WriteFSAlert(_("Error! Couldn't delete temporary directory:"), 
  331.                  tmpdir);
  332.         return -1;
  333.     }
  334.     return 0; 
  335. } 
  336.  
  337.  
  338. LString CreateBufferTmpDir (LString const & pathfor)
  339. {
  340.     return CreateTmpDir (pathfor, "lyx_bufrtmp");
  341. }
  342.  
  343.  
  344. int DestroyBufferTmpDir (LString const & tmpdir)
  345. {
  346.        return DestroyTmpDir (tmpdir, true);
  347. }
  348.  
  349.  
  350. LString CreateLyXTmpDir (LString const & deflt)
  351. {
  352.         LString t;
  353.         
  354.     if ((!deflt.empty()) && (deflt!="/tmp")) {
  355.         if (mkdir (deflt.c_str(), 0777)) {
  356. #ifdef __EMX__
  357.                         //PathPush(user_lyxdir);
  358.             Path p(user_lyxdir);
  359. #endif
  360.             t = CreateTmpDir (deflt.c_str(), "lyx_tmp");
  361. //#ifdef __EMX__
  362. //                        PathPop();
  363. //#endif
  364.                         return t;
  365.         } else
  366.                         return deflt;
  367.     } else {
  368. #ifdef __EMX__
  369.         //PathPush(user_lyxdir);
  370.         Path p(user_lyxdir);
  371. #endif
  372.         t = CreateTmpDir ("/tmp", "lyx_tmp");
  373. //#ifdef __EMX__
  374. //        PathPop();
  375. //#endif
  376.         return t;
  377.     }
  378. }
  379.  
  380.  
  381. int DestroyLyXTmpDir (LString const & tmpdir)
  382. {
  383.        return DestroyTmpDir (tmpdir, false); // Why false?
  384. }
  385.  
  386.  
  387. // Creates directory. Returns true if succesfull
  388. bool createDirectory(LString const & path, int permission)
  389. {
  390.     LString temp = path;
  391.     
  392.     // Cut off trailing /s
  393.     temp.strip('/');
  394.  
  395.     if (temp.empty()) {
  396.         WriteAlert(_("Internal error!"),
  397.                _("Call to createDirectory with invalid name"));
  398.         return false;
  399.     }
  400.  
  401.     if (mkdir(temp.c_str(), permission)) {
  402.         WriteFSAlert (_("Error! Couldn't create directory:"), temp);
  403.         return false;
  404.     }
  405.     return true;
  406. }
  407.  
  408.  
  409. // Should supposedly help with some automountd-stuff...
  410. // Fortunately no need to patch for OS/2 support
  411. LString safer_getcwd ()
  412. {
  413.     LString temp = getenv ("PWD");
  414.     if (temp.empty()) {
  415.         temp = getenv ("CWD");
  416.         if (temp.empty())
  417.             temp = GetCWD();
  418.     }
  419.     return temp;
  420. }
  421.  
  422.  
  423. // Returns current working directory
  424. LString GetCWD ()
  425. {
  426.       int n = 256;    // Assume path is less than 256 chars
  427.     char * err;
  428.       char * tbuf = new char [n];
  429.     LString result;
  430.       
  431.       // Safe. Hopefully all getcwds behave this way!
  432.       while (((err = getcwd (tbuf, n)) == NULL) && (errno == ERANGE)) {
  433.         // Buffer too small, double the buffersize and try again
  434.             delete[] tbuf;
  435.             n = 2*n;
  436.             tbuf = new char [n];
  437.       }
  438.  
  439.     if (err) result = tbuf;
  440.     delete[] tbuf;
  441.     return result;
  442. }
  443.  
  444.  
  445. // Strip filename from path name
  446. LString OnlyPath(LString const &Filename)
  447. {
  448.     // If empty filename, return empty
  449.     if (Filename.empty()) return Filename;
  450.  
  451.     // Find last / or start of filename
  452.     int j = Filename.length() - 1;
  453.     for (; j > 0 && Filename[j] != '/'; j--);
  454.  
  455.     if (Filename[j] != '/')
  456.         return "./";
  457.     else {
  458.         // Strip to pathname
  459.         LString temp = Filename;
  460.         return temp.substring(0, j);
  461.     }
  462. }
  463.  
  464.  
  465. // Convert relative path into absolute path based on a basepath.
  466. // If relpath is absolute, just use that.
  467. // If basepath is empty, use CWD as base.
  468. LString MakeAbsPath(LString const &RelPath, LString const &BasePath)
  469. {
  470.     // checks for already absolute path
  471.     if (AbsolutePath(RelPath))
  472. #ifdef __EMX__
  473.         if(RelPath[0]!='/')
  474. #endif
  475.         return RelPath;
  476.  
  477.     // Copies given paths
  478.     LString TempRel = RelPath;
  479.  
  480.     LString TempBase;
  481.  
  482.     if (!BasePath.empty()) {
  483. #ifndef __EMX__
  484.         TempBase = BasePath;
  485. #else
  486.         char* with_drive = new char[_MAX_PATH];
  487.         _abspath(with_drive, BasePath.c_str(), _MAX_PATH);
  488.         TempBase = with_drive;
  489.         delete[] with_drive;
  490. #endif
  491.     } else
  492.         TempBase = safer_getcwd();
  493. #ifdef __EMX__
  494.     if (AbsolutePath(TempRel))
  495.         return TempBase.substring(0,1) + TempRel;
  496. #endif
  497.  
  498.     // Handle /./ at the end of the path
  499.     while(TempBase.suffixIs("/./"))
  500.         TempBase.substring(0,TempBase.length()-3);
  501.  
  502.     // processes relative path
  503.     LString RTemp = TempRel;
  504.     LString Temp;
  505.  
  506.     while (!RTemp.empty()) {
  507.         // Split by next /
  508.         RTemp.split(Temp, '/');
  509.         
  510.         if (Temp==".") continue;
  511.         if (Temp=="..") {
  512.             // Remove one level of TempBase
  513.             int i = TempBase.length()-2;
  514. #ifndef __EMX__
  515.             if (i<0) i=0;
  516.             while (i>0 && TempBase[i] != '/') i--;
  517.             if (i>0)
  518. #else
  519.                 if (i<2) i=2;
  520.             while (i>2 && TempBase[i] != '/') i--;
  521.             if (i>2)
  522. #endif
  523.                 TempBase.substring(0, i);
  524.             else
  525.                 TempBase += '/';
  526.         } else {
  527.             // Add this piece to TempBase
  528.             if (!TempBase.suffixIs('/'))
  529.                 TempBase += '/';
  530.             TempBase += Temp;
  531.         }
  532.     }
  533.  
  534.     // returns absolute path
  535.     return TempBase;    
  536. }
  537.  
  538.  
  539. // Correctly append filename to the pathname.
  540. // If pathname is '.', then don't use pathname.
  541. // Chops any path of filename.
  542. LString AddName(LString const &Path, LString const &FileName)
  543. {
  544.     // Get basename
  545.     LString Basename = OnlyFilename(FileName);
  546.  
  547.     LString buf;
  548.  
  549.     if (Path != "." && Path != "./" && !Path.empty()) {
  550.         buf = Path;
  551.         if (!Path.suffixIs('/'))
  552.             buf += '/';
  553.     }
  554.  
  555.     return buf + Basename;
  556. }
  557.  
  558.  
  559. // Strips path from filename
  560. LString OnlyFilename(LString const &Filename)
  561. {
  562.     // If empty filename, return empty
  563.     if (Filename.empty()) return Filename;
  564.  
  565.     int j;
  566.     // Find last / or start of filename
  567.     for (j=Filename.length()-1; Filename[j] != '/' && j>0; j--);
  568.  
  569.     // Skip potential /
  570.     if (j!=0) j++;
  571.  
  572.     // Strip to basename
  573.     LString temp = Filename;
  574.     return temp.substring(j, temp.length()-1);
  575. }
  576.  
  577.  
  578. // Is a filename/path absolute?
  579. bool AbsolutePath(LString const &path)
  580. {
  581. #ifndef __EMX__
  582.     return (!path.empty() && path[0]=='/');
  583. #else
  584.     return (!path.empty() && (path[0]=='/' || (isalpha((unsigned char) path[0]) && path[1]==':')));
  585. #endif
  586. }
  587.  
  588.  
  589. // Create absolute path. If impossible, don't do anything
  590. // Supports ./ and ~/. Later we can add support for ~logname/. (Asger)
  591. LString ExpandPath(LString const &path)
  592. {
  593.     // checks for already absolute path
  594.     LString RTemp = ReplaceEnvironmentPath(path);
  595.     if (AbsolutePath(RTemp))
  596.         return RTemp;
  597.  
  598.     LString Temp;
  599.     LString copy(RTemp);
  600.  
  601.     // Split by next /
  602.     RTemp.split(Temp, '/');
  603.  
  604.     if (Temp==".") {
  605.         return GetCWD() + '/' + RTemp;
  606.     } else if (Temp=="~") {
  607.         return getEnvPath("HOME") + '/' + RTemp;
  608.     } else if (Temp=="..") {
  609.         return MakeAbsPath(copy);
  610.     } else
  611.         // Don't know how to handle this
  612.         return copy;
  613. }
  614.  
  615.  
  616. // Normalize a path
  617. // Constracts path/../path
  618. // Can't handle "../../" or "/../" (Asger)
  619. LString NormalizePath(LString const &path)
  620. {
  621.     LString TempBase;
  622.     LString RTemp;
  623.     LString Temp;
  624.  
  625.     if (AbsolutePath(path))
  626.         RTemp = path;
  627.     else
  628.         // Make implicit current directory explicit
  629.         RTemp = "./" +path;
  630.  
  631.     while (!RTemp.empty()) {
  632.         // Split by next /
  633.         RTemp.split(Temp, '/');
  634.         
  635.         if (Temp==".") {
  636.             TempBase = "./";
  637.         } else if (Temp=="..") {
  638.             // Remove one level of TempBase
  639.             int i = TempBase.length()-2;
  640.             while (i>0 && TempBase[i] != '/')
  641.                 i--;
  642.             if (i>=0 && TempBase[i] == '/')
  643.                 TempBase.substring(0, i);
  644.             else
  645.                 TempBase = "../";
  646.         } else {
  647.             TempBase += Temp + '/';
  648.         }
  649.     }
  650.  
  651.     // returns absolute path
  652.     return TempBase;    
  653. }
  654.  
  655.  
  656. //
  657. // Search ${...} as Variable-Name inside the string and replace it with
  658. // the denoted environmentvariable
  659. // Allow Variables according to 
  660. //  variable :=  '$' '{' [A-Za-z_]{[A-Za-z_0-9]*} '}'
  661. //
  662.  
  663. LString ReplaceEnvironmentPath(LString const &path)
  664. {
  665. // 
  666. // CompareChar: Environmentvariables starts with this character
  667. // PathChar:    Next path component start with this character
  668. // while CompareChar found do:
  669. //       Split String with PathChar
  670. //      Search Environmentvariable
  671. //     if found: Replace Strings
  672. //
  673.     const char CompareChar = '$';
  674.     const char FirstChar = '{'; 
  675.     const char EndChar = '}'; 
  676.     const char UnderscoreChar = '_'; 
  677.     LString EndString;
  678.     EndString += EndChar;
  679.     LString FirstString;
  680.     FirstString += FirstChar;
  681.     LString CompareString;
  682.     CompareString += CompareChar;
  683.     const LString RegExp("*}*"); // Exist EndChar inside a String?
  684.  
  685.     if (path.empty()) return path; // nothing to do.
  686.  
  687. // first: Search for a '$' - Sign.
  688.     LString copy(path);
  689.     LString result1(copy);    // for split-calls
  690.     LString result0 = copy.split(result1, CompareChar);
  691.     while (!result0.empty()) {
  692.         LString copy1(result0); // contains String after $
  693.         
  694.         // Check, if there is an EndChar inside original String.
  695.         
  696.         if (!copy1.regexMatch(RegExp)) {
  697.             // No EndChar inside. So we are finished
  698.             result1 += CompareString + result0;
  699.             result0 = LString();
  700.             continue;
  701.         }
  702.  
  703.         LString res1;
  704.         LString res0 = copy1.split(res1, EndChar);
  705.         // Now res1 holds the environmentvariable
  706.         // First, check, if Contents is ok.
  707.         if (res1.empty()) { // No environmentvariable. Continue Loop.
  708.             result1 += CompareString + FirstString;
  709.             result0  = res0;
  710.             continue;
  711.         }
  712.         // check contents of res1
  713.         const char *res1_contents = res1.c_str();
  714.         if (*res1_contents != FirstChar) {
  715.             // Again No Environmentvariable
  716.             result1 += CompareString;
  717.             result0  = res0;
  718.         }
  719.  
  720.         // Check for variable names
  721.         // Situation ${} is detected as "No Environmentvariable"
  722.         const char *cp1 = res1_contents+1;
  723.         bool result = isalpha((unsigned char) *cp1) || (*cp1 == UnderscoreChar);
  724.         ++cp1;
  725.         while (*cp1 && result) {
  726.             result = isalnum((unsigned char) *cp1) || 
  727.                 (*cp1 == UnderscoreChar); 
  728.             ++cp1;
  729.         }
  730.  
  731.         if (!result) {
  732.             // no correct variable name
  733.             result1 += CompareString + res1 + EndString;
  734.             result0  = res0.split(res1, CompareChar);
  735.             result1 += res1;
  736.             continue;
  737.         }
  738.             
  739.         char *env = getenv(res1_contents+1);
  740.         if (env) {
  741.             // Congratulations. Environmentvariable found
  742.             result1 += env;
  743.         } else {
  744.             result1 += CompareString + res1 + EndString;
  745.         }
  746.         // Next $-Sign?
  747.         result0  = res0.split(res1, CompareChar);
  748.         result1 += res1;
  749.     } 
  750.     return result1;
  751. }  // ReplaceEnvironmentPath
  752.  
  753.  
  754. // Make relative path out of two absolute paths
  755. LString MakeRelPath(LString const & abspath, LString const & basepath)
  756. // Makes relative path out of absolute path. If it is deeper than basepath,
  757. // it's easy. If basepath and abspath share something (they are all deeper
  758. // than some directory), it'll be rendered using ..'s. If they are completely
  759. // different, then the absolute path will be used as relative path.
  760. {
  761.     // This is a hack. It should probaly be done in another way. Lgb.
  762.     if (abspath.empty())
  763.         return "<unknown_path>";
  764.  
  765.     const int abslen = abspath.length();
  766.     const int baselen = basepath.length();
  767.     
  768.     // Find first different character
  769.     int i = 0;
  770.     while (i < abslen && i < baselen && abspath[i] == basepath[i]) ++i;
  771.  
  772.     // Go back to last /
  773.     if (i < abslen && i < baselen
  774.         || (i<abslen && abspath[i] != '/' && i==baselen)
  775.         || (i<baselen && basepath[i] != '/' && i==abslen))
  776.     {
  777.         if (i) --i;    // here was the last match
  778.         while (i && abspath[i] != '/') --i;
  779.     }
  780.  
  781.     if (i == 0) {
  782.         // actually no match - cannot make it relative
  783.         return abspath;
  784.     }
  785.  
  786.     // Count how many dirs there are in basepath above match
  787.     // and append as many '..''s into relpath
  788.     LString buf;
  789.     int j = i;
  790.     while (j < baselen) {
  791.         if (basepath[j] == '/') {
  792.             if (j+1 == baselen) break;
  793.             buf += "../";
  794.         }
  795.         ++j;
  796.     }
  797.  
  798.     // Append relative stuff from common directory to abspath
  799.     if (abspath[i] == '/') ++i;
  800.     for (; i<abslen; ++i)
  801.         buf += abspath[i];
  802.     // Remove trailing /
  803.     if (buf.suffixIs('/'))
  804.         buf.substring(0,buf.length()-2);
  805.     // Substitute empty with .
  806.     if (buf.empty())
  807.         buf = '.';
  808.     return buf;
  809. }
  810.  
  811.  
  812. // Append sub-directory(ies) to a path in an intelligent way
  813. LString AddPath(LString const & path, LString const & path2)
  814. {
  815.     LString buf;
  816.  
  817.     if (!path.empty() && path != "." && path != "./") {
  818.         buf = path;
  819.         if (!path.suffixIs('/'))
  820.             buf += '/';
  821.     }
  822.  
  823.     if (!path2.empty()){
  824.             int p2start = 0;
  825.         while (path2[p2start] == '/') p2start++;
  826.  
  827.         int p2end = path2.length()-1;
  828.         while (path2[p2end] == '/') p2end--;
  829.  
  830.         LString tmp = path2;
  831.         tmp.substring(p2start,p2end);
  832.         buf += tmp + '/';
  833.     }
  834.     return buf;
  835. }
  836.  
  837.  
  838. /* 
  839.  Change extension of oldname to extension.
  840.  Strips path off if no_path == true.
  841.  If no extension on oldname, just appends.
  842.  */
  843. LString ChangeExtension(LString const & oldname, LString const & extension, 
  844.             bool no_path) 
  845. { 
  846.     int n = oldname.length()-1;
  847.     int dot;
  848.  
  849.     // Make sure the extension includes the dot, if not empty
  850.     LString ext;
  851.     if (!extension.empty() && extension[0] != '.')
  852.         ext = "." + extension;
  853.     else
  854.         ext = extension;
  855.  
  856.     // Go back to the first dot not crossing any /
  857.     for (dot=n; dot>=0 && oldname[dot]!='.' && oldname[dot]!='/'; dot--);
  858.    
  859.     if (dot==-1 || oldname[dot]!='.')
  860.         // If no extension was found, we use the end of the string
  861.         dot = n;
  862.     else
  863.         // Remove the dot, because the new extension includes it
  864.         dot--;
  865.  
  866.     // "path" points to last / or 0 if path is wanted
  867.     int path = 0;
  868.     if (no_path) {
  869.         for (path=dot; path && oldname[path]!='/';path--);
  870.         if (oldname[path]=='/')
  871.             path++;
  872.     } else 
  873.         path = 0;
  874.  
  875.     LString result = oldname;
  876.     result.substring(path,dot);
  877.     if (!ext.empty())
  878.         result += ext;
  879.     return result;
  880. }
  881.  
  882.  
  883. // Creates a nice compact path for displaying
  884. LString MakeDisplayPath (LString const & path, int threshold)
  885. {
  886.     const int l1 = path.length();
  887.  
  888.     // First, we try a relative path compared to home
  889.     LString home = getEnvPath("HOME");
  890.     LString relhome = MakeRelPath(path, home);
  891.  
  892.     int l2 = relhome.length();
  893.  
  894.     LString prefix;
  895.  
  896.     // If we backup from home or don't have a relative path,
  897.     // this try is no good
  898.     if (relhome.prefixIs("../") || AbsolutePath(relhome)) {
  899.         // relative path was no good, just use the original path
  900.         relhome = path;
  901.         l2 = l1;
  902.     } else {
  903.         prefix = "~/";
  904.     }
  905.  
  906.     // Is the path too long?
  907.     if (l2 > threshold) {
  908.         // Yes, shortend it
  909.         prefix += ".../";
  910.         
  911.         LString temp;
  912.         
  913.         while (relhome.length()>threshold)
  914.             relhome.split(temp, '/');
  915.  
  916.         // Did we shortend everything away?
  917.         if (relhome.empty()) {
  918.             // Yes, filename in itself is too long.
  919.             // Pick the start and the end of the filename.
  920.             relhome = OnlyFilename(path);
  921.             LString head = relhome;
  922.             head.substring(0, threshold/2 - 3);
  923.  
  924.             LString tail = relhome;
  925.             l2 = tail.length();
  926.             tail.substring(l2 - threshold/2 -2, l2 - 1);
  927.  
  928.             relhome = head + "..." + tail;
  929.         }
  930.     }
  931.     return prefix + relhome;
  932. }
  933.