src/support/filetools.h

   1 // -*- C++-*-
   2 /* lyx-filetool.h : tools functions for file/path handling
   3    this file is part of LyX, the High Level Word Processor
   4    Copyright 1995-1999, Matthias Ettrich and the LyX Team
   5 */
   6
   7 #ifndef LYX_FILETOOL_H
   8 #define LYX_FILETOOL_H
   9
  10 #ifdef __GNUG__
  11 #pragma interface
  12 #endif
  13
  14 #include <cstdio>
  15 #include <cstdlib>
  16 #include <fcntl.h>
  17 #include <cerrno>
  18 #include "debug.h"
  19 #include "LString.h"
  20 #include "support/lstrings.h"
  21
  22 /** A file class.
  23   Use this instead of FILE *, it gives a much better structure.
  24   It should prehaps do a bit more error checking than it does now.
  25   Currently it is a verbatim copy from p309 of Bjarne Stroupstrups
  26   The C++ Programming Language. + some additions.
  27  */
  28 class FilePtr {
  29 public:
  30         ///
  31         enum file_mode {
  32                 read,
  33                 write,
  34                 update,
  35                 truncate
  36         };
  37         ///
  38         FilePtr(string const & name, file_mode mode) {
  39                 init();
  40                 do_open(name, mode);
  41         }
  42         ///
  43         FilePtr(FILE * pp) { init(); p = pp; }
  44         ///
  45         ~FilePtr() { close(); }
  46
  47         /** Use this if you want to rebind the FilePtr to another file.
  48          */
  49         FilePtr & reopen(string const & name, file_mode mode) {
  50                 // close the file it it is already open
  51                 close();
  52                 // Now open the file.
  53                 do_open(name, mode);
  54
  55                 return *this;
  56         }
  57         /** Close the file.
  58             Use this with some carefullness. After it has been used
  59             the FilePtr is unusable. Only use it if it is important
  60             that the file is closed before the FilePtr goes out
  61             of scope. */
  62         int close() {
  63                 if (p) {
  64                         int result = fclose(p);
  65                         p = 0;
  66                         return result;
  67                 } else
  68                         return 0;
  69         }
  70         /// automatic converson to FILE* if that is needed.
  71         operator FILE*() { return p; }
  72         ///
  73         FilePtr & operator=(FILE * f) { p= f; return *this;}
  74         ///
  75         FILE * operator()() { return p; }
  76 private:
  77         ///
  78         void do_open(string const & name, file_mode mode) {
  79                 string modestr;
  80
  81                 switch(mode) {
  82                         // do appropiate #ifdef here so support EMX
  83 #ifndef __EMX__
  84                 case read: modestr = "r"; break;
  85                 case write: modestr = "w"; break;
  86 #else
  87                 case read: modestr = "rt"; break; // Can read both DOS & UNIX text files.
  88                 case write: modestr = "w"; break; // Write UNIX text files.
  89 #endif
  90
  91                 case update: modestr = "r+"; break;
  92                 case truncate: modestr = "w+"; break;
  93                 }
  94                 // Should probably be rewritten to use open(2)
  95                 if((p = fopen(name.c_str(), modestr.c_str()))) {
  96                         // file succesfully opened.
  97                         if (fcntl(fileno(p), F_SETFD, FD_CLOEXEC) == -1) {
  98                                 p = 0;
  99                         }
 100                 } else {
 101                         // we have an error let's check what it is.
 102                         switch(errno) {
 103                         case EINVAL:
 104                                 // Internal LyX error.
 105                                 lyxerr << "FilePtr: Wrong parameter given to fopen." << endl;
 106                                 break;
 107                         default:
 108                                 // unknown error
 109                                 break;
 110                         }
 111                 }
 112         }
 113         ///
 114         void init() { p = 0; }
 115         ///
 116         FILE * p;
 117 };
 118
 119
 120 ///
 121 string CreateBufferTmpDir (string const & pathfor = string());
 122
 123 /// Creates directory. Returns true on succes.
 124 bool createDirectory(string const & name, int permissions);
 125
 126 ///
 127 string CreateLyXTmpDir (string const & deflt);
 128
 129 ///
 130 int DestroyBufferTmpDir (string const & tmpdir);
 131
 132 ///
 133 int DestroyLyXTmpDir (string const & tmpdir);
 134
 135 /** Find file by searching several directories.
 136   Uses a string of paths separated by ";"s to find a file to open.
 137     Can't cope with pathnames with a ';' in them. Returns full path to file.
 138     If path entry begins with $$LyX/, use system_lyxdir.
 139     If path entry begins with $$User/, use user_lyxdir.
 140     Example: "$$User/doc;$$LyX/doc".
 141 */
 142 string FileOpenSearch (string const & path, string const & name,
 143                        string const & ext = string());
 144
 145 /** Returns the real name of file name in directory path, with optional
 146   extension ext.
 147   The file is searched in the given path (unless it is an absolute
 148   file name), first directly, and then with extension .ext (if given).
 149   */
 150 string FileSearch(string const & path, string const & name,
 151                   string const & ext = string());
 152
 153 /** Is directory read only?
 154   returns
 155     1: dir writeable
 156     0: not writeable
 157    -1: error- couldn't find out, or unsure
 158   */
 159 int IsDirWriteable (string const & path);
 160
 161 /** Is a file readable ?
 162   Returns true if the file `path' is readable.
 163  */
 164 bool IsFileReadable (string const & path);
 165
 166 /** Is file read only?
 167   returns
 168     1: read-write
 169     0: read_only
 170    -1: error (doesn't exist, no access, anything else)
 171   */
 172 int IsFileWriteable (string const & path);
 173
 174 ///
 175 bool IsLyXFilename(string const & filename);
 176
 177 ///
 178 bool IsSGMLFilename(string const & filename);
 179
 180 /** Returns the path of a library data file.
 181   Search the file name.ext in the subdirectory dir of
 182   \begin{enumerate}
 183     \item user_lyxdir
 184     \item build_lyxdir (if not empty)
 185     \item system_lyxdir
 186   \end{enumerate}
 187     The third parameter `ext' is optional.
 188 */
 189 string LibFileSearch(string const & dir, string const & name,
 190                      string const & ext = string());
 191
 192 /** Same as LibFileSearch(), but tries first to find an
 193   internationalized version of the file by prepending $LANG_ to the
 194   name
 195   */
 196 string i18nLibFileSearch(string const & dir, string const & name,
 197                          string const & ext = string());
 198
 199 ///
 200 string GetEnv(string const & envname);
 201
 202 /// A helper function.
 203 string GetEnvPath(string const & name);
 204
 205 ///
 206 bool PutEnv(string const & envstr);
 207
 208 ///
 209 bool PutEnvPath(string const & envstr);
 210
 211 /// Substitutes spaces with underscores in filename (and path)
 212 string SpaceLess(string const & file);
 213
 214 /** Returns an unique name to be used as a temporary file. If given,
 215   'mask' should the prefix to the temporary file, the rest of the
 216   temporary filename will be made from the pid and three letters.
 217   */
 218 string TmpFileName(string const & dir = string(),
 219                    string const & mask = "lyx_tmp");
 220
 221 /// Is a filename/path absolute?
 222 bool AbsolutePath(string const & path);
 223
 224 /// Add a filename to a path. Any path from filename is stripped first.
 225 string AddName(string const & path, string const & fname);
 226
 227 /// Append sub-directory(ies) to path in an intelligent way
 228 string AddPath(string const & path, string const & path2);
 229
 230 /** Change extension of oldname to extension.
 231  If no_path is true, the path is stripped from the filename.
 232  If oldname does not have an extension, it is appended.
 233  If the extension is empty, any extension is removed from the name.
 234  */
 235 string ChangeExtension(string const & oldname, string const & extension,
 236                        bool no_path);
 237
 238 /// Create absolute path. If impossible, don't do anything
 239 string ExpandPath(string const & path);
 240
 241 /// gets current working directory
 242 string GetCWD();
 243
 244
 245 /** Convert relative path into absolute path based on a basepath.
 246   If relpath is absolute, just use that.
 247   If basepath doesn't exist use CWD.
 248   */
 249 string MakeAbsPath(string const & RelPath = string(),
 250                    string const & BasePath = string());
 251
 252 /** Creates a nice compact path for displaying. The parameter
 253   threshold, if given, specifies the maximal length of the path.
 254   */
 255 string MakeDisplayPath(string const & path, unsigned int threshold= 1000);
 256
 257 /** Makes relative path out of absolute path.
 258   If it is deeper than basepath,
 259   it's easy. If basepath and abspath share something (they are all deeper
 260   than some directory), it'll be rendered using ..'s. If they are completely
 261   different, then the absolute path will be used as relative path
 262   WARNING: the absolute path and base path must really be absolute paths!!!
 263   */
 264 string MakeRelPath(string const & abspath, string const & basepath);
 265
 266 /// Strip filename from path name
 267 string OnlyPath(string const & fname);
 268
 269 /// Normalize a path. Constracts path/../path
 270 string NormalizePath(string const & path);
 271
 272 /// Strips path from filename
 273 string OnlyFilename(string const & fname);
 274
 275 /// Cleanup a path if necessary. Currently only useful with OS/2
 276 string CleanupPath(string const & path) ;
 277
 278 /** Check and Replace Environmentvariables ${NAME} in Path.
 279     Replaces all occurences of these, if they are found in the
 280     environment.
 281     Variables are defined by Var := '${' [a-zA-Z_][a-zA-Z_0-9]* '}'
 282 */
 283 string ReplaceEnvironmentPath(string const & path);
 284
 285 /* Set Link to the path File Points to as a symbolic link.
 286    Return True if succesfull, False other wise */
 287 bool LyXReadLink(string const & file, string & Link);
 288
 289 /* Uses kpsewhich to find tex files */
 290 string findtexfile(string const & fil, string const & format);
 291
 292 #endif