]> git.lyx.org Git - lyx.git/blob - src/support/FileName.cpp
9820bdcabb546a762713f6ca6ba59c6228335385
[lyx.git] / src / support / FileName.cpp
1 /**
2  * \file FileName.cpp
3  * This file is part of LyX, the document processor.
4  * Licence details can be found in the file COPYING.
5  *
6  * \author Angus Leeming
7  *
8  * Full author contact details are available in file CREDITS.
9  */
10
11 #include <config.h>
12
13 #include "support/FileName.h"
14 #include "support/FileNameList.h"
15
16 #include "support/convert.h"
17 #include "support/debug.h"
18 #include "support/filetools.h"
19 #include "support/lassert.h"
20 #include "support/lstrings.h"
21 #include "support/qstring_helpers.h"
22 #include "support/os.h"
23 #include "support/Package.h"
24 #include "support/qstring_helpers.h"
25
26 #include <QDateTime>
27 #include <QDir>
28 #include <QFile>
29 #include <QFileInfo>
30 #include <QList>
31 #include <QTemporaryFile>
32 #include <QTime>
33
34 #include <boost/crc.hpp>
35 #include <boost/scoped_array.hpp>
36
37 #include <algorithm>
38 #include <iterator>
39 #include <fstream>
40 #include <iomanip>
41 #include <map>
42 #include <sstream>
43
44 #ifdef HAVE_SYS_TYPES_H
45 # include <sys/types.h>
46 #endif
47 #ifdef HAVE_SYS_STAT_H
48 # include <sys/stat.h>
49 #endif
50 #ifdef HAVE_UNISTD_H
51 # include <unistd.h>
52 #endif
53 #ifdef HAVE_DIRECT_H
54 # include <direct.h>
55 #endif
56 #ifdef _WIN32
57 # include <windows.h>
58 #endif
59
60 #include <cerrno>
61 #include <fcntl.h>
62
63 #if defined(HAVE_MKSTEMP) && ! defined(HAVE_DECL_MKSTEMP)
64 extern "C" int mkstemp(char *);
65 #endif
66
67 #if !defined(HAVE_MKSTEMP) && defined(HAVE_MKTEMP)
68 # ifdef HAVE_IO_H
69 #  include <io.h>
70 # endif
71 # ifdef HAVE_PROCESS_H
72 #  include <process.h>
73 # endif
74 #endif
75
76 // Three implementations of checksum(), depending on having mmap support or not.
77 #if defined(HAVE_MMAP) && defined(HAVE_MUNMAP)
78 #define SUM_WITH_MMAP
79 #include <sys/mman.h>
80 #endif // SUM_WITH_MMAP
81
82 using namespace std;
83
84 // OK, this is ugly, but it is the only workaround I found to compile
85 // with gcc (any version) on a system which uses a non-GNU toolchain.
86 // The problem is that gcc uses a weak symbol for a particular
87 // instantiation and that the system linker usually does not
88 // understand those weak symbols (seen on HP-UX, tru64, AIX and
89 // others). Thus we force an explicit instanciation of this particular
90 // template (JMarc)
91 template struct boost::detail::crc_table_t<32, 0x04C11DB7, true>;
92
93 namespace lyx {
94 namespace support {
95
96 /////////////////////////////////////////////////////////////////////
97 //
98 // FileName::Private
99 //
100 /////////////////////////////////////////////////////////////////////
101
102 struct FileName::Private
103 {
104         Private() {}
105
106         Private(string const & abs_filename) : fi(toqstr(abs_filename))
107         {
108                 name = abs_filename;
109                 fi.setCaching(fi.exists() ? true : false);
110         }
111         ///
112         inline void refresh() 
113         {
114 // There seems to be a bug in Qt >= 4.2.0, at least, that causes problems with
115 // QFileInfo::refresh() on *nix. So we recreate the object in that case.
116 // FIXME: When Trolltech fixes the bug, we will have to replace 0x999999 below
117 // with the actual working minimum version.
118 #if defined(_WIN32) || (QT_VERSION >= 0x999999)
119                 fi.refresh();
120 #else
121                 fi = QFileInfo(fi.absoluteFilePath());
122 #endif
123         }
124
125
126         static
127         bool isFilesystemEqual(QString const & lhs, QString const & rhs)
128         {
129                 return QString::compare(lhs, rhs, os::isFilesystemCaseSensitive() ?
130                         Qt::CaseSensitive : Qt::CaseInsensitive) == 0;
131         }
132
133         /// The absolute file name in UTF-8 encoding.
134         std::string name;
135         ///
136         QFileInfo fi;
137 };
138
139 /////////////////////////////////////////////////////////////////////
140 //
141 // FileName
142 //
143 /////////////////////////////////////////////////////////////////////
144
145
146 FileName::FileName() : d(new Private)
147 {
148 }
149
150
151 FileName::FileName(string const & abs_filename)
152         : d(abs_filename.empty() ? new Private : new Private(abs_filename))
153 {
154         //LYXERR(Debug::FILES, "FileName(" << abs_filename << ')');
155         LASSERT(empty() || isAbsolute(d->name), /**/);
156 }
157
158
159 FileName::~FileName()
160 {
161         delete d;
162 }
163
164
165 FileName::FileName(FileName const & rhs) : d(new Private)
166 {
167         d->name = rhs.d->name;
168         d->fi = rhs.d->fi;
169 }
170
171
172 FileName::FileName(FileName const & rhs, string const & suffix) : d(new Private)
173 {
174         set(rhs, suffix);
175 }
176
177
178 FileName & FileName::operator=(FileName const & rhs)
179 {
180         if (&rhs == this)
181                 return *this;
182         d->name = rhs.d->name;
183         d->fi = rhs.d->fi;
184         return *this;
185 }
186
187
188 bool FileName::empty() const
189 {
190         return d->name.empty();
191 }
192
193
194 bool FileName::isAbsolute(string const & name)
195 {
196         QFileInfo fi(toqstr(name));
197         return fi.isAbsolute();
198 }
199
200
201 string FileName::absFilename() const
202 {
203         return d->name;
204 }
205
206
207 string FileName::realPath() const
208 {
209         return os::real_path(toFilesystemEncoding());
210 }
211
212
213 void FileName::set(string const & name)
214 {
215         d->name = name;
216         d->fi.setFile(toqstr(name));
217         //LYXERR(Debug::FILES, "FileName::set(" << name << ')');
218         LASSERT(empty() || isAbsolute(d->name), /**/);
219 }
220
221
222 void FileName::set(FileName const & rhs, string const & suffix)
223 {
224         if (!rhs.d->fi.isDir())
225                 d->fi.setFile(rhs.d->fi.filePath() + toqstr(suffix));
226         else
227                 d->fi.setFile(QDir(rhs.d->fi.absoluteFilePath()), toqstr(suffix));
228         d->name = fromqstr(d->fi.absoluteFilePath());
229         //LYXERR(Debug::FILES, "FileName::set(" << d->name << ')');
230         LASSERT(empty() || isAbsolute(d->name), /**/);
231 }
232
233
234 void FileName::erase()
235 {
236         d->name.clear();
237         d->fi = QFileInfo();
238 }
239
240
241 bool FileName::copyTo(FileName const & name) const
242 {
243         LYXERR(Debug::FILES, "Copying " << name);
244         QFile::remove(name.d->fi.absoluteFilePath());
245         bool success = QFile::copy(d->fi.absoluteFilePath(), name.d->fi.absoluteFilePath());
246         if (!success)
247                 LYXERR0("FileName::copyTo(): Could not copy file "
248                         << *this << " to " << name);
249         return success;
250 }
251
252
253 bool FileName::renameTo(FileName const & name) const
254 {
255         bool success = QFile::rename(d->fi.absoluteFilePath(), name.d->fi.absoluteFilePath());
256         if (!success)
257                 LYXERR0("Could not rename file " << *this << " to " << name);
258         return success;
259 }
260
261
262 bool FileName::moveTo(FileName const & name) const
263 {
264         QFile::remove(name.d->fi.absoluteFilePath());
265
266         bool success = QFile::rename(d->fi.absoluteFilePath(),
267                 name.d->fi.absoluteFilePath());
268         if (!success)
269                 LYXERR0("Could not move file " << *this << " to " << name);
270         return success;
271 }
272
273
274 bool FileName::changePermission(unsigned long int mode) const
275 {
276 #if defined (HAVE_CHMOD) && defined (HAVE_MODE_T)
277         if (::chmod(toFilesystemEncoding().c_str(), mode_t(mode)) != 0) {
278                 LYXERR0("File " << *this << ": cannot change permission to "
279                         << mode << ".");
280                 return false;
281         }
282 #endif
283         return true;
284 }
285
286
287 string FileName::toFilesystemEncoding() const
288 {
289         // FIXME: This doesn't work on Windows for non ascii file names with Qt < 4.4.
290         // Provided that Windows package uses Qt4.4, this isn't a problem.
291         QByteArray const encoded = QFile::encodeName(d->fi.absoluteFilePath());
292         return string(encoded.begin(), encoded.end());
293 }
294
295
296 FileName FileName::fromFilesystemEncoding(string const & name)
297 {
298         QByteArray const encoded(name.c_str(), name.length());
299         return FileName(fromqstr(QFile::decodeName(encoded)));
300 }
301
302
303 bool FileName::exists() const
304 {
305         return !empty() && d->fi.exists();
306 }
307
308
309 bool FileName::isSymLink() const
310 {
311         return !empty() && d->fi.isSymLink();
312 }
313
314
315 bool FileName::isFileEmpty() const
316 {
317         LASSERT(!empty(), return true);
318         return d->fi.size() == 0;
319 }
320
321
322 bool FileName::isDirectory() const
323 {
324         return !empty() && d->fi.isDir();
325 }
326
327
328 bool FileName::isReadOnly() const
329 {
330         LASSERT(!empty(), return true);
331         return d->fi.isReadable() && !d->fi.isWritable();
332 }
333
334
335 bool FileName::isReadableDirectory() const
336 {
337         return isDirectory() && d->fi.isReadable();
338 }
339
340
341 string FileName::onlyFileName() const
342 {
343         return fromqstr(d->fi.fileName());
344 }
345
346
347 string FileName::onlyFileNameWithoutExt() const
348 {
349         return fromqstr(d->fi.completeBaseName());
350 }
351
352
353 string FileName::extension() const
354 {
355         return fromqstr(d->fi.suffix());
356 }
357
358
359 bool FileName::hasExtension(const string & ext)
360 {
361         return Private::isFilesystemEqual(d->fi.suffix(), toqstr(ext));
362 }
363
364
365 FileName FileName::onlyPath() const
366 {
367         FileName path;
368         if (empty())
369                 return path;
370         path.d->fi.setFile(d->fi.path());
371         path.d->name = fromqstr(path.d->fi.absoluteFilePath());
372         return path;
373 }
374
375
376 bool FileName::isReadableFile() const
377 {
378         return !empty() && d->fi.isFile() && d->fi.isReadable();
379 }
380
381
382 bool FileName::isWritable() const
383 {
384         return !empty() && d->fi.isWritable();
385 }
386
387
388 bool FileName::isDirWritable() const
389 {
390         LASSERT(isDirectory(), return false);
391         QFileInfo tmp(QDir(d->fi.absoluteFilePath()), "lyxwritetest");
392         QTemporaryFile qt_tmp(tmp.absoluteFilePath());
393         if (qt_tmp.open()) {
394                 LYXERR(Debug::FILES, "Directory " << *this << " is writable");
395                 return true;
396         }
397         LYXERR(Debug::FILES, "Directory " << *this << " is not writable");
398         return false;
399 }
400
401
402 FileNameList FileName::dirList(string const & ext) const
403 {
404         FileNameList dirlist;
405         if (!isDirectory()) {
406                 LYXERR0("Directory '" << *this << "' does not exist!");
407                 return dirlist;
408         }
409
410         QDir dir = d->fi.absoluteDir();
411
412         if (!ext.empty()) {
413                 QString filter;
414                 switch (ext[0]) {
415                 case '.': filter = "*" + toqstr(ext); break;
416                 case '*': filter = toqstr(ext); break;
417                 default: filter = "*." + toqstr(ext);
418                 }
419                 dir.setNameFilters(QStringList(filter));
420                 LYXERR(Debug::FILES, "filtering on extension "
421                         << fromqstr(filter) << " is requested.");
422         }
423
424         QFileInfoList list = dir.entryInfoList();
425         for (int i = 0; i != list.size(); ++i) {
426                 FileName fi(fromqstr(list.at(i).absoluteFilePath()));
427                 dirlist.push_back(fi);
428                 LYXERR(Debug::FILES, "found file " << fi);
429         }
430
431         return dirlist;
432 }
433
434
435 static string createTempFile(QString const & mask)
436 {
437         QTemporaryFile qt_tmp(mask);
438         if (qt_tmp.open()) {
439                 string const temp_file = fromqstr(qt_tmp.fileName());
440                 LYXERR(Debug::FILES, "Temporary file `" << temp_file << "' created.");
441                 return temp_file;
442         }
443         LYXERR(Debug::FILES, "Unable to create temporary file with following template: "
444                 << qt_tmp.fileTemplate());
445         return string();
446 }
447
448
449 FileName FileName::tempName(FileName const & temp_dir, string const & mask)
450 {
451         QFileInfo tmp_fi(QDir(temp_dir.d->fi.absoluteFilePath()), toqstr(mask));
452         LYXERR(Debug::FILES, "Temporary file in " << tmp_fi.absoluteFilePath());
453         return FileName(createTempFile(tmp_fi.absoluteFilePath()));
454 }
455
456
457 FileName FileName::tempName(string const & mask)
458 {
459         return tempName(package().temp_dir(), mask);
460 }
461
462
463 FileName FileName::getcwd()
464 {
465         // return makeAbsPath("."); would create an infinite loop
466         QFileInfo fi(".");
467         return FileName(fromqstr(fi.absoluteFilePath()));
468 }
469
470
471 FileName FileName::tempPath()
472 {
473         return FileName(os::internal_path(fromqstr(QDir::tempPath())));
474 }
475
476
477 time_t FileName::lastModified() const
478 {
479         // QFileInfo caches information about the file. So, in case this file has
480         // been touched between the object creation and now, we refresh the file
481         // information.
482         d->refresh();
483         return d->fi.lastModified().toTime_t();
484 }
485
486
487 bool FileName::chdir() const
488 {
489         return QDir::setCurrent(d->fi.absoluteFilePath());
490 }
491
492
493 unsigned long FileName::checksum() const
494 {
495         unsigned long result = 0;
496
497         if (!exists()) {
498                 //LYXERR0("File \"" << absFilename() << "\" does not exist!");
499                 return result;
500         }
501         // a directory may be passed here so we need to test it. (bug 3622)
502         if (isDirectory()) {
503                 LYXERR0('"' << absFilename() << "\" is a directory!");
504                 return result;
505         }
506
507         // This is used in the debug output at the end of the method.
508         static QTime t;
509         if (lyxerr.debugging(Debug::FILES))
510                 t.restart();
511
512 #if QT_VERSION >= 0x999999
513         // First version of checksum uses Qt4.4 mmap support.
514         // FIXME: This code is not ready with Qt4.4.2,
515         // see http://bugzilla.lyx.org/show_bug.cgi?id=5293
516         // FIXME: should we check if the MapExtension extension is supported?
517         // see QAbstractFileEngine::supportsExtension() and 
518         // QAbstractFileEngine::MapExtension)
519         QFile qf(fi.filePath());
520         if (!qf.open(QIODevice::ReadOnly))
521                 return result;
522         qint64 size = fi.size();
523         uchar * ubeg = qf.map(0, size);
524         uchar * uend = ubeg + size;
525         boost::crc_32_type ucrc;
526         ucrc.process_block(ubeg, uend);
527         qf.unmap(ubeg);
528         qf.close();
529         result = ucrc.checksum();
530
531 #else // QT_VERSION
532
533         string const encoded = toFilesystemEncoding();
534         char const * file = encoded.c_str();
535
536  #ifdef SUM_WITH_MMAP
537         //LYXERR(Debug::FILES, "using mmap (lightning fast)");
538
539         int fd = open(file, O_RDONLY);
540         if (!fd)
541                 return result;
542
543         struct stat info;
544         fstat(fd, &info);
545
546         void * mm = mmap(0, info.st_size, PROT_READ,
547                          MAP_PRIVATE, fd, 0);
548         // Some platforms have the wrong type for MAP_FAILED (compaq cxx).
549         if (mm == reinterpret_cast<void*>(MAP_FAILED)) {
550                 close(fd);
551                 return result;
552         }
553
554         char * beg = static_cast<char*>(mm);
555         char * end = beg + info.st_size;
556
557         boost::crc_32_type crc;
558         crc.process_block(beg, end);
559         result = crc.checksum();
560
561         munmap(mm, info.st_size);
562         close(fd);
563
564  #else // no SUM_WITH_MMAP
565
566         //LYXERR(Debug::FILES, "lyx::sum() using istreambuf_iterator (fast)");
567         ifstream ifs(file, ios_base::in | ios_base::binary);
568         if (!ifs)
569                 return result;
570
571         istreambuf_iterator<char> beg(ifs);
572         istreambuf_iterator<char> end;
573         boost::crc_32_type crc;
574         crc = for_each(beg, end, crc);
575         result = crc.checksum();
576
577  #endif // SUM_WITH_MMAP
578 #endif // QT_VERSION
579
580         LYXERR(Debug::FILES, "Checksumming \"" << absFilename() << "\" "
581                 << result << " lasted " << t.elapsed() << " ms.");
582         return result;
583 }
584
585
586 bool FileName::removeFile() const
587 {
588         bool const success = QFile::remove(d->fi.absoluteFilePath());
589         d->refresh();
590         if (!success && exists())
591                 LYXERR0("Could not delete file " << *this);
592         return success;
593 }
594
595
596 static bool rmdir(QFileInfo const & fi)
597 {
598         QDir dir(fi.absoluteFilePath());
599         QFileInfoList list = dir.entryInfoList();
600         bool success = true;
601         for (int i = 0; i != list.size(); ++i) {
602                 if (list.at(i).fileName() == ".")
603                         continue;
604                 if (list.at(i).fileName() == "..")
605                         continue;
606                 bool removed;
607                 if (list.at(i).isDir()) {
608                         LYXERR(Debug::FILES, "Removing dir " 
609                                 << fromqstr(list.at(i).absoluteFilePath()));
610                         removed = rmdir(list.at(i));
611                 }
612                 else {
613                         LYXERR(Debug::FILES, "Removing file " 
614                                 << fromqstr(list.at(i).absoluteFilePath()));
615                         removed = dir.remove(list.at(i).fileName());
616                 }
617                 if (!removed) {
618                         success = false;
619                         LYXERR0("Could not delete "
620                                 << fromqstr(list.at(i).absoluteFilePath()));
621                 }
622         } 
623         QDir parent = fi.absolutePath();
624         success &= parent.rmdir(fi.fileName());
625         return success;
626 }
627
628
629 bool FileName::destroyDirectory() const
630 {
631         bool const success = rmdir(d->fi);
632         if (!success)
633                 LYXERR0("Could not delete " << *this);
634
635         return success;
636 }
637
638
639 // Only used in non Win32 platforms
640 static int mymkdir(char const * pathname, unsigned long int mode)
641 {
642         // FIXME: why don't we have mode_t in lyx::mkdir prototype ??
643 #if HAVE_MKDIR
644 # if MKDIR_TAKES_ONE_ARG
645         // MinGW32
646         return ::mkdir(pathname);
647         // FIXME: "Permissions of created directories are ignored on this system."
648 # else
649         // POSIX
650         return ::mkdir(pathname, mode_t(mode));
651 # endif
652 #elif defined(_WIN32)
653         // plain Windows 32
654         return CreateDirectory(pathname, 0) != 0 ? 0 : -1;
655         // FIXME: "Permissions of created directories are ignored on this system."
656 #elif HAVE__MKDIR
657         return ::_mkdir(pathname);
658         // FIXME: "Permissions of created directories are ignored on this system."
659 #else
660 #   error "Don't know how to create a directory on this system."
661 #endif
662
663 }
664
665
666 bool FileName::createDirectory(int permission) const
667 {
668         LASSERT(!empty(), return false);
669 #ifdef Q_OS_WIN32
670         // FIXME: "Permissions of created directories are ignored on this system."
671         return createPath();
672 #else
673         return mymkdir(toFilesystemEncoding().c_str(), permission) == 0;
674 #endif
675 }
676
677
678 bool FileName::createPath() const
679 {
680         LASSERT(!empty(), return false);
681         LYXERR(Debug::FILES, "creating path '" << *this << "'.");
682         if (isDirectory())
683                 return false;
684
685         QDir dir;
686         bool success = dir.mkpath(d->fi.absoluteFilePath());
687         if (!success)
688                 LYXERR0("Cannot create path '" << *this << "'!");
689         return success;
690 }
691
692
693 docstring const FileName::absoluteFilePath() const
694 {
695         return qstring_to_ucs4(d->fi.absoluteFilePath());
696 }
697
698
699 docstring FileName::displayName(int threshold) const
700 {
701         return makeDisplayPath(absFilename(), threshold);
702 }
703
704
705 docstring FileName::fileContents(string const & encoding) const
706 {
707         if (!isReadableFile()) {
708                 LYXERR0("File '" << *this << "' is not redable!");
709                 return docstring();
710         }
711
712         QFile file(d->fi.absoluteFilePath());
713         if (!file.open(QIODevice::ReadOnly)) {
714                 LYXERR0("File '" << *this
715                         << "' could not be opened in read only mode!");
716                 return docstring();
717         }
718         QByteArray contents = file.readAll();
719         file.close();
720
721         if (contents.isEmpty()) {
722                 LYXERR(Debug::FILES, "File '" << *this
723                         << "' is either empty or some error happened while reading it.");
724                 return docstring();
725         }
726
727         QString s;
728         if (encoding.empty() || encoding == "UTF-8")
729                 s = QString::fromUtf8(contents.data());
730         else if (encoding == "ascii")
731                 s = QString::fromAscii(contents.data());
732         else if (encoding == "local8bit")
733                 s = QString::fromLocal8Bit(contents.data());
734         else if (encoding == "latin1")
735                 s = QString::fromLatin1(contents.data());
736
737         return qstring_to_ucs4(s);
738 }
739
740
741 void FileName::changeExtension(string const & extension)
742 {
743         // FIXME: use Qt native methods...
744         string const oldname = absFilename();
745         string::size_type const last_slash = oldname.rfind('/');
746         string::size_type last_dot = oldname.rfind('.');
747         if (last_dot < last_slash && last_slash != string::npos)
748                 last_dot = string::npos;
749
750         string ext;
751         // Make sure the extension starts with a dot
752         if (!extension.empty() && extension[0] != '.')
753                 ext= '.' + extension;
754         else
755                 ext = extension;
756
757         set(oldname.substr(0, last_dot) + ext);
758 }
759
760
761 string FileName::guessFormatFromContents() const
762 {
763         // the different filetypes and what they contain in one of the first lines
764         // (dots are any characters).           (Herbert 20020131)
765         // AGR  Grace...
766         // BMP  BM...
767         // EPS  %!PS-Adobe-3.0 EPSF...
768         // FIG  #FIG...
769         // FITS ...BITPIX...
770         // GIF  GIF...
771         // JPG  JFIF
772         // PDF  %PDF-...
773         // PNG  .PNG...
774         // PBM  P1... or P4     (B/W)
775         // PGM  P2... or P5     (Grayscale)
776         // PPM  P3... or P6     (color)
777         // PS   %!PS-Adobe-2.0 or 1.0,  no "EPSF"!
778         // SGI  \001\332...     (decimal 474)
779         // TGIF %TGIF...
780         // TIFF II... or MM...
781         // XBM  ..._bits[]...
782         // XPM  /* XPM */    sometimes missing (f.ex. tgif-export)
783         //      ...static char *...
784         // XWD  \000\000\000\151        (0x00006900) decimal 105
785         //
786         // GZIP \037\213        http://www.ietf.org/rfc/rfc1952.txt
787         // ZIP  PK...                   http://www.halyava.ru/document/ind_arch.htm
788         // Z    \037\235                UNIX compress
789
790         // paranoia check
791         if (empty() || !isReadableFile())
792                 return string();
793
794         ifstream ifs(toFilesystemEncoding().c_str());
795         if (!ifs)
796                 // Couldn't open file...
797                 return string();
798
799         // gnuzip
800         static string const gzipStamp = "\037\213";
801
802         // PKZIP
803         static string const zipStamp = "PK";
804
805         // compress
806         static string const compressStamp = "\037\235";
807
808         // Maximum strings to read
809         int const max_count = 50;
810         int count = 0;
811
812         string str;
813         string format;
814         bool firstLine = true;
815         while ((count++ < max_count) && format.empty()) {
816                 if (ifs.eof()) {
817                         LYXERR(Debug::GRAPHICS, "filetools(getFormatFromContents)\n"
818                                 << "\tFile type not recognised before EOF!");
819                         break;
820                 }
821
822                 getline(ifs, str);
823                 string const stamp = str.substr(0, 2);
824                 if (firstLine && str.size() >= 2) {
825                         // at first we check for a zipped file, because this
826                         // information is saved in the first bytes of the file!
827                         // also some graphic formats which save the information
828                         // in the first line, too.
829                         if (prefixIs(str, gzipStamp)) {
830                                 format =  "gzip";
831
832                         } else if (stamp == zipStamp) {
833                                 format =  "zip";
834
835                         } else if (stamp == compressStamp) {
836                                 format =  "compress";
837
838                         // the graphics part
839                         } else if (stamp == "BM") {
840                                 format =  "bmp";
841
842                         } else if (stamp == "\001\332") {
843                                 format =  "sgi";
844
845                         // PBM family
846                         // Don't need to use str.at(0), str.at(1) because
847                         // we already know that str.size() >= 2
848                         } else if (str[0] == 'P') {
849                                 switch (str[1]) {
850                                 case '1':
851                                 case '4':
852                                         format =  "pbm";
853                                     break;
854                                 case '2':
855                                 case '5':
856                                         format =  "pgm";
857                                     break;
858                                 case '3':
859                                 case '6':
860                                         format =  "ppm";
861                                 }
862                                 break;
863
864                         } else if ((stamp == "II") || (stamp == "MM")) {
865                                 format =  "tiff";
866
867                         } else if (prefixIs(str,"%TGIF")) {
868                                 format =  "tgif";
869
870                         } else if (prefixIs(str,"#FIG")) {
871                                 format =  "fig";
872
873                         } else if (prefixIs(str,"GIF")) {
874                                 format =  "gif";
875
876                         } else if (str.size() > 3) {
877                                 int const c = ((str[0] << 24) & (str[1] << 16) &
878                                                (str[2] << 8)  & str[3]);
879                                 if (c == 105) {
880                                         format =  "xwd";
881                                 }
882                         }
883
884                         firstLine = false;
885                 }
886
887                 if (!format.empty())
888                     break;
889                 else if (contains(str,"EPSF"))
890                         // dummy, if we have wrong file description like
891                         // %!PS-Adobe-2.0EPSF"
892                         format = "eps";
893
894                 else if (contains(str, "Grace"))
895                         format = "agr";
896
897                 else if (contains(str, "JFIF"))
898                         format = "jpg";
899
900                 else if (contains(str, "%PDF"))
901                         format = "pdf";
902
903                 else if (contains(str, "PNG"))
904                         format = "png";
905
906                 else if (contains(str, "%!PS-Adobe")) {
907                         // eps or ps
908                         ifs >> str;
909                         if (contains(str,"EPSF"))
910                                 format = "eps";
911                         else
912                             format = "ps";
913                 }
914
915                 else if (contains(str, "_bits[]"))
916                         format = "xbm";
917
918                 else if (contains(str, "XPM") || contains(str, "static char *"))
919                         format = "xpm";
920
921                 else if (contains(str, "BITPIX"))
922                         format = "fits";
923         }
924
925         // Dia knows also compressed form
926         if ((format == "gzip") && (!compare_ascii_no_case(extension(), "dia")))
927                 format="dia";
928
929         if (!format.empty()) {
930                 LYXERR(Debug::GRAPHICS, "Recognised Fileformat: " << format);
931                 return format;
932         }
933
934         LYXERR(Debug::GRAPHICS, "filetools(getFormatFromContents)\n"
935                 << "\tCouldn't find a known format!");
936         return string();
937 }
938
939
940 bool FileName::isZippedFile() const
941 {
942         string const type = guessFormatFromContents();
943         return contains("gzip zip compress", type) && !type.empty();
944 }
945
946
947 docstring const FileName::relPath(string const & path) const
948 {
949         // FIXME UNICODE
950         return makeRelPath(absoluteFilePath(), from_utf8(path));
951 }
952
953
954 // Note: According to Qt, QFileInfo::operator== is undefined when
955 // both files do not exist (Qt4.5 gives true for all non-existent
956 // files, while Qt4.4 compares the filenames).
957 // see:
958 // http://www.qtsoftware.com/developer/task-tracker/
959 //   index_html?id=248471&method=entry.
960 bool equivalent(FileName const & l, FileName const & r)
961 {
962         // FIXME: In future use Qt.
963         // Qt 4.4: We need to solve this warning from Qt documentation:
964         // * Long and short file names that refer to the same file on Windows are
965         //   treated as if they referred to different files.
966         // This is supposed to be fixed for Qt5.
967         FileName const lhs(os::internal_path(l.absFilename()));
968         FileName const rhs(os::internal_path(r.absFilename()));
969
970         if (lhs.empty())
971                 // QFileInfo::operator==() returns false if the two QFileInfo are empty.
972                 return rhs.empty();
973
974         if (rhs.empty())
975                 // Avoid unnecessary checks below.
976                 return false;
977
978         lhs.d->refresh();
979         rhs.d->refresh();
980
981         if (!lhs.d->fi.isSymLink() && !rhs.d->fi.isSymLink()) {
982                 // Qt already checks if the filesystem is case sensitive or not.
983                 // see note above why the extra check with fileName is needed.
984                 return lhs.d->fi == rhs.d->fi
985                         && lhs.d->fi.fileName() == rhs.d->fi.fileName();
986         }
987
988         // FIXME: When/if QFileInfo support symlink comparison, remove this code.
989         QFileInfo fi1(lhs.d->fi);
990         if (fi1.isSymLink())
991                 fi1 = QFileInfo(fi1.symLinkTarget());
992         QFileInfo fi2(rhs.d->fi);
993         if (fi2.isSymLink())
994                 fi2 = QFileInfo(fi2.symLinkTarget());
995         // see note above why the extra check with fileName is needed.
996         return fi1 == fi2 && fi1.fileName() == fi2.fileName();
997 }
998
999
1000 bool operator==(FileName const & lhs, FileName const & rhs)
1001 {
1002         return lhs.absFilename() == rhs.absFilename();
1003 }
1004
1005
1006 bool operator!=(FileName const & lhs, FileName const & rhs)
1007 {
1008         return !(operator==(lhs, rhs));
1009 }
1010
1011
1012 bool operator<(FileName const & lhs, FileName const & rhs)
1013 {
1014         return lhs.absFilename() < rhs.absFilename();
1015 }
1016
1017
1018 bool operator>(FileName const & lhs, FileName const & rhs)
1019 {
1020         return lhs.absFilename() > rhs.absFilename();
1021 }
1022
1023
1024 ostream & operator<<(ostream & os, FileName const & filename)
1025 {
1026         return os << filename.absFilename();
1027 }
1028
1029
1030 /////////////////////////////////////////////////////////////////////
1031 //
1032 // DocFileName
1033 //
1034 /////////////////////////////////////////////////////////////////////
1035
1036
1037 DocFileName::DocFileName()
1038         : save_abs_path_(true)
1039 {}
1040
1041
1042 DocFileName::DocFileName(string const & abs_filename, bool save_abs)
1043         : FileName(abs_filename), save_abs_path_(save_abs), zipped_valid_(false)
1044 {}
1045
1046
1047 DocFileName::DocFileName(FileName const & abs_filename, bool save_abs)
1048         : FileName(abs_filename), save_abs_path_(save_abs), zipped_valid_(false)
1049 {}
1050
1051
1052 void DocFileName::set(string const & name, string const & buffer_path)
1053 {
1054         save_abs_path_ = isAbsolute(name);
1055         if (save_abs_path_)
1056                 FileName::set(name);
1057         else
1058                 FileName::set(makeAbsPath(name, buffer_path).absFilename());
1059         zipped_valid_ = false;
1060 }
1061
1062
1063 void DocFileName::erase()
1064 {
1065         FileName::erase();
1066         zipped_valid_ = false;
1067 }
1068
1069
1070 string DocFileName::relFilename(string const & path) const
1071 {
1072         // FIXME UNICODE
1073         return to_utf8(relPath(path));
1074 }
1075
1076
1077 string DocFileName::outputFilename(string const & path) const
1078 {
1079         return save_abs_path_ ? absFilename() : relFilename(path);
1080 }
1081
1082
1083 string DocFileName::mangledFilename(string const & dir) const
1084 {
1085         // We need to make sure that every DocFileName instance for a given
1086         // filename returns the same mangled name.
1087         typedef map<string, string> MangledMap;
1088         static MangledMap mangledNames;
1089         MangledMap::const_iterator const it = mangledNames.find(absFilename());
1090         if (it != mangledNames.end())
1091                 return (*it).second;
1092
1093         string const name = absFilename();
1094         // Now the real work
1095         string mname = os::internal_path(name);
1096         // Remove the extension.
1097         mname = support::changeExtension(name, string());
1098         // The mangled name must be a valid LaTeX name.
1099         // The list of characters to keep is probably over-restrictive,
1100         // but it is not really a problem.
1101         // Apart from non-ASCII characters, at least the following characters
1102         // are forbidden: '/', '.', ' ', and ':'.
1103         // On windows it is not possible to create files with '<', '>' or '?'
1104         // in the name.
1105         static string const keep = "abcdefghijklmnopqrstuvwxyz"
1106                                    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1107                                    "+,-0123456789;=";
1108         string::size_type pos = 0;
1109         while ((pos = mname.find_first_not_of(keep, pos)) != string::npos)
1110                 mname[pos++] = '_';
1111         // Add the extension back on
1112         mname = support::changeExtension(mname, getExtension(name));
1113
1114         // Prepend a counter to the filename. This is necessary to make
1115         // the mangled name unique.
1116         static int counter = 0;
1117         ostringstream s;
1118         s << counter++ << mname;
1119         mname = s.str();
1120
1121         // MiKTeX's YAP (version 2.4.1803) crashes if the file name
1122         // is longer than about 160 characters. MiKTeX's pdflatex
1123         // is even pickier. A maximum length of 100 has been proven to work.
1124         // If dir.size() > max length, all bets are off for YAP. We truncate
1125         // the filename nevertheless, keeping a minimum of 10 chars.
1126
1127         string::size_type max_length = max(100 - ((int)dir.size() + 1), 10);
1128
1129         // If the mangled file name is too long, hack it to fit.
1130         // We know we're guaranteed to have a unique file name because
1131         // of the counter.
1132         if (mname.size() > max_length) {
1133                 int const half = (int(max_length) / 2) - 2;
1134                 if (half > 0) {
1135                         mname = mname.substr(0, half) + "___" +
1136                                 mname.substr(mname.size() - half);
1137                 }
1138         }
1139
1140         mangledNames[absFilename()] = mname;
1141         return mname;
1142 }
1143
1144
1145 bool DocFileName::isZipped() const
1146 {
1147         if (!zipped_valid_) {
1148                 zipped_ = isZippedFile();
1149                 zipped_valid_ = true;
1150         }
1151         return zipped_;
1152 }
1153
1154
1155 string DocFileName::unzippedFilename() const
1156 {
1157         return unzippedFileName(absFilename());
1158 }
1159
1160
1161 bool operator==(DocFileName const & lhs, DocFileName const & rhs)
1162 {
1163         return static_cast<FileName const &>(lhs)
1164                 == static_cast<FileName const &>(rhs)
1165                 && lhs.saveAbsPath() == rhs.saveAbsPath();
1166 }
1167
1168
1169 bool operator!=(DocFileName const & lhs, DocFileName const & rhs)
1170 {
1171         return !(lhs == rhs);
1172 }
1173
1174 } // namespace support
1175 } // namespace lyx