1//===-- Path.cpp - Implement OS Path Concept ------------------------------===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10//  This file implements the operating system Path API.
11//
12//===----------------------------------------------------------------------===//
13
14#include "llvm/Support/COFF.h"
15#include "llvm/Support/MachO.h"
16#include "llvm/Support/Endian.h"
17#include "llvm/Support/Errc.h"
18#include "llvm/Support/ErrorHandling.h"
19#include "llvm/Support/FileSystem.h"
20#include "llvm/Support/Path.h"
21#include "llvm/Support/Process.h"
22#include <cctype>
23#include <cstring>
24
25#if !defined(_MSC_VER) && !defined(__MINGW32__)
26#include <unistd.h>
27#else
28#include <io.h>
29#endif
30
31using namespace llvm;
32using namespace llvm::support::endian;
33
34namespace {
35  using llvm::StringRef;
36  using llvm::sys::path::is_separator;
37
38#ifdef LLVM_ON_WIN32
39  const char *separators = "\\/";
40  const char preferred_separator = '\\';
41#else
42  const char  separators = '/';
43  const char preferred_separator = '/';
44#endif
45
46  StringRef find_first_component(StringRef path) {
47    // Look for this first component in the following order.
48    // * empty (in this case we return an empty string)
49    // * either C: or {//,\\}net.
50    // * {/,\}
51    // * {file,directory}name
52
53    if (path.empty())
54      return path;
55
56#ifdef LLVM_ON_WIN32
57    // C:
58    if (path.size() >= 2 && std::isalpha(static_cast<unsigned char>(path[0])) &&
59        path[1] == ':')
60      return path.substr(0, 2);
61#endif
62
63    // //net
64    if ((path.size() > 2) &&
65        is_separator(path[0]) &&
66        path[0] == path[1] &&
67        !is_separator(path[2])) {
68      // Find the next directory separator.
69      size_t end = path.find_first_of(separators, 2);
70      return path.substr(0, end);
71    }
72
73    // {/,\}
74    if (is_separator(path[0]))
75      return path.substr(0, 1);
76
77    // * {file,directory}name
78    size_t end = path.find_first_of(separators);
79    return path.substr(0, end);
80  }
81
82  size_t filename_pos(StringRef str) {
83    if (str.size() == 2 &&
84        is_separator(str[0]) &&
85        str[0] == str[1])
86      return 0;
87
88    if (str.size() > 0 && is_separator(str[str.size() - 1]))
89      return str.size() - 1;
90
91    size_t pos = str.find_last_of(separators, str.size() - 1);
92
93#ifdef LLVM_ON_WIN32
94    if (pos == StringRef::npos)
95      pos = str.find_last_of(':', str.size() - 2);
96#endif
97
98    if (pos == StringRef::npos ||
99        (pos == 1 && is_separator(str[0])))
100      return 0;
101
102    return pos + 1;
103  }
104
105  size_t root_dir_start(StringRef str) {
106    // case "c:/"
107#ifdef LLVM_ON_WIN32
108    if (str.size() > 2 &&
109        str[1] == ':' &&
110        is_separator(str[2]))
111      return 2;
112#endif
113
114    // case "//"
115    if (str.size() == 2 &&
116        is_separator(str[0]) &&
117        str[0] == str[1])
118      return StringRef::npos;
119
120    // case "//net"
121    if (str.size() > 3 &&
122        is_separator(str[0]) &&
123        str[0] == str[1] &&
124        !is_separator(str[2])) {
125      return str.find_first_of(separators, 2);
126    }
127
128    // case "/"
129    if (str.size() > 0 && is_separator(str[0]))
130      return 0;
131
132    return StringRef::npos;
133  }
134
135  size_t parent_path_end(StringRef path) {
136    size_t end_pos = filename_pos(path);
137
138    bool filename_was_sep = path.size() > 0 && is_separator(path[end_pos]);
139
140    // Skip separators except for root dir.
141    size_t root_dir_pos = root_dir_start(path.substr(0, end_pos));
142
143    while(end_pos > 0 &&
144          (end_pos - 1) != root_dir_pos &&
145          is_separator(path[end_pos - 1]))
146      --end_pos;
147
148    if (end_pos == 1 && root_dir_pos == 0 && filename_was_sep)
149      return StringRef::npos;
150
151    return end_pos;
152  }
153} // end unnamed namespace
154
155enum FSEntity {
156  FS_Dir,
157  FS_File,
158  FS_Name
159};
160
161static std::error_code createUniqueEntity(const Twine &Model, int &ResultFD,
162                                          SmallVectorImpl<char> &ResultPath,
163                                          bool MakeAbsolute, unsigned Mode,
164                                          FSEntity Type) {
165  SmallString<128> ModelStorage;
166  Model.toVector(ModelStorage);
167
168  if (MakeAbsolute) {
169    // Make model absolute by prepending a temp directory if it's not already.
170    if (!sys::path::is_absolute(Twine(ModelStorage))) {
171      SmallString<128> TDir;
172      sys::path::system_temp_directory(true, TDir);
173      sys::path::append(TDir, Twine(ModelStorage));
174      ModelStorage.swap(TDir);
175    }
176  }
177
178  // From here on, DO NOT modify model. It may be needed if the randomly chosen
179  // path already exists.
180  ResultPath = ModelStorage;
181  // Null terminate.
182  ResultPath.push_back(0);
183  ResultPath.pop_back();
184
185retry_random_path:
186  // Replace '%' with random chars.
187  for (unsigned i = 0, e = ModelStorage.size(); i != e; ++i) {
188    if (ModelStorage[i] == '%')
189      ResultPath[i] = "0123456789abcdef"[sys::Process::GetRandomNumber() & 15];
190  }
191
192  // Try to open + create the file.
193  switch (Type) {
194  case FS_File: {
195    if (std::error_code EC =
196            sys::fs::openFileForWrite(Twine(ResultPath.begin()), ResultFD,
197                                      sys::fs::F_RW | sys::fs::F_Excl, Mode)) {
198      if (EC == errc::file_exists)
199        goto retry_random_path;
200      return EC;
201    }
202
203    return std::error_code();
204  }
205
206  case FS_Name: {
207    std::error_code EC =
208        sys::fs::access(ResultPath.begin(), sys::fs::AccessMode::Exist);
209    if (EC == errc::no_such_file_or_directory)
210      return std::error_code();
211    if (EC)
212      return EC;
213    goto retry_random_path;
214  }
215
216  case FS_Dir: {
217    if (std::error_code EC =
218            sys::fs::create_directory(ResultPath.begin(), false)) {
219      if (EC == errc::file_exists)
220        goto retry_random_path;
221      return EC;
222    }
223    return std::error_code();
224  }
225  }
226  llvm_unreachable("Invalid Type");
227}
228
229namespace llvm {
230namespace sys  {
231namespace path {
232
233const_iterator begin(StringRef path) {
234  const_iterator i;
235  i.Path      = path;
236  i.Component = find_first_component(path);
237  i.Position  = 0;
238  return i;
239}
240
241const_iterator end(StringRef path) {
242  const_iterator i;
243  i.Path      = path;
244  i.Position  = path.size();
245  return i;
246}
247
248const_iterator &const_iterator::operator++() {
249  assert(Position < Path.size() && "Tried to increment past end!");
250
251  // Increment Position to past the current component
252  Position += Component.size();
253
254  // Check for end.
255  if (Position == Path.size()) {
256    Component = StringRef();
257    return *this;
258  }
259
260  // Both POSIX and Windows treat paths that begin with exactly two separators
261  // specially.
262  bool was_net = Component.size() > 2 &&
263    is_separator(Component[0]) &&
264    Component[1] == Component[0] &&
265    !is_separator(Component[2]);
266
267  // Handle separators.
268  if (is_separator(Path[Position])) {
269    // Root dir.
270    if (was_net
271#ifdef LLVM_ON_WIN32
272        // c:/
273        || Component.endswith(":")
274#endif
275        ) {
276      Component = Path.substr(Position, 1);
277      return *this;
278    }
279
280    // Skip extra separators.
281    while (Position != Path.size() &&
282           is_separator(Path[Position])) {
283      ++Position;
284    }
285
286    // Treat trailing '/' as a '.'.
287    if (Position == Path.size()) {
288      --Position;
289      Component = ".";
290      return *this;
291    }
292  }
293
294  // Find next component.
295  size_t end_pos = Path.find_first_of(separators, Position);
296  Component = Path.slice(Position, end_pos);
297
298  return *this;
299}
300
301bool const_iterator::operator==(const const_iterator &RHS) const {
302  return Path.begin() == RHS.Path.begin() && Position == RHS.Position;
303}
304
305ptrdiff_t const_iterator::operator-(const const_iterator &RHS) const {
306  return Position - RHS.Position;
307}
308
309reverse_iterator rbegin(StringRef Path) {
310  reverse_iterator I;
311  I.Path = Path;
312  I.Position = Path.size();
313  return ++I;
314}
315
316reverse_iterator rend(StringRef Path) {
317  reverse_iterator I;
318  I.Path = Path;
319  I.Component = Path.substr(0, 0);
320  I.Position = 0;
321  return I;
322}
323
324reverse_iterator &reverse_iterator::operator++() {
325  // If we're at the end and the previous char was a '/', return '.' unless
326  // we are the root path.
327  size_t root_dir_pos = root_dir_start(Path);
328  if (Position == Path.size() &&
329      Path.size() > root_dir_pos + 1 &&
330      is_separator(Path[Position - 1])) {
331    --Position;
332    Component = ".";
333    return *this;
334  }
335
336  // Skip separators unless it's the root directory.
337  size_t end_pos = Position;
338
339  while(end_pos > 0 &&
340        (end_pos - 1) != root_dir_pos &&
341        is_separator(Path[end_pos - 1]))
342    --end_pos;
343
344  // Find next separator.
345  size_t start_pos = filename_pos(Path.substr(0, end_pos));
346  Component = Path.slice(start_pos, end_pos);
347  Position = start_pos;
348  return *this;
349}
350
351bool reverse_iterator::operator==(const reverse_iterator &RHS) const {
352  return Path.begin() == RHS.Path.begin() && Component == RHS.Component &&
353         Position == RHS.Position;
354}
355
356ptrdiff_t reverse_iterator::operator-(const reverse_iterator &RHS) const {
357  return Position - RHS.Position;
358}
359
360StringRef root_path(StringRef path) {
361  const_iterator b = begin(path),
362                 pos = b,
363                 e = end(path);
364  if (b != e) {
365    bool has_net = b->size() > 2 && is_separator((*b)[0]) && (*b)[1] == (*b)[0];
366    bool has_drive =
367#ifdef LLVM_ON_WIN32
368      b->endswith(":");
369#else
370      false;
371#endif
372
373    if (has_net || has_drive) {
374      if ((++pos != e) && is_separator((*pos)[0])) {
375        // {C:/,//net/}, so get the first two components.
376        return path.substr(0, b->size() + pos->size());
377      } else {
378        // just {C:,//net}, return the first component.
379        return *b;
380      }
381    }
382
383    // POSIX style root directory.
384    if (is_separator((*b)[0])) {
385      return *b;
386    }
387  }
388
389  return StringRef();
390}
391
392StringRef root_name(StringRef path) {
393  const_iterator b = begin(path),
394                 e = end(path);
395  if (b != e) {
396    bool has_net = b->size() > 2 && is_separator((*b)[0]) && (*b)[1] == (*b)[0];
397    bool has_drive =
398#ifdef LLVM_ON_WIN32
399      b->endswith(":");
400#else
401      false;
402#endif
403
404    if (has_net || has_drive) {
405      // just {C:,//net}, return the first component.
406      return *b;
407    }
408  }
409
410  // No path or no name.
411  return StringRef();
412}
413
414StringRef root_directory(StringRef path) {
415  const_iterator b = begin(path),
416                 pos = b,
417                 e = end(path);
418  if (b != e) {
419    bool has_net = b->size() > 2 && is_separator((*b)[0]) && (*b)[1] == (*b)[0];
420    bool has_drive =
421#ifdef LLVM_ON_WIN32
422      b->endswith(":");
423#else
424      false;
425#endif
426
427    if ((has_net || has_drive) &&
428        // {C:,//net}, skip to the next component.
429        (++pos != e) && is_separator((*pos)[0])) {
430      return *pos;
431    }
432
433    // POSIX style root directory.
434    if (!has_net && is_separator((*b)[0])) {
435      return *b;
436    }
437  }
438
439  // No path or no root.
440  return StringRef();
441}
442
443StringRef relative_path(StringRef path) {
444  StringRef root = root_path(path);
445  return path.substr(root.size());
446}
447
448void append(SmallVectorImpl<char> &path, const Twine &a,
449                                         const Twine &b,
450                                         const Twine &c,
451                                         const Twine &d) {
452  SmallString<32> a_storage;
453  SmallString<32> b_storage;
454  SmallString<32> c_storage;
455  SmallString<32> d_storage;
456
457  SmallVector<StringRef, 4> components;
458  if (!a.isTriviallyEmpty()) components.push_back(a.toStringRef(a_storage));
459  if (!b.isTriviallyEmpty()) components.push_back(b.toStringRef(b_storage));
460  if (!c.isTriviallyEmpty()) components.push_back(c.toStringRef(c_storage));
461  if (!d.isTriviallyEmpty()) components.push_back(d.toStringRef(d_storage));
462
463  for (auto &component : components) {
464    bool path_has_sep = !path.empty() && is_separator(path[path.size() - 1]);
465    bool component_has_sep = !component.empty() && is_separator(component[0]);
466    bool is_root_name = has_root_name(component);
467
468    if (path_has_sep) {
469      // Strip separators from beginning of component.
470      size_t loc = component.find_first_not_of(separators);
471      StringRef c = component.substr(loc);
472
473      // Append it.
474      path.append(c.begin(), c.end());
475      continue;
476    }
477
478    if (!component_has_sep && !(path.empty() || is_root_name)) {
479      // Add a separator.
480      path.push_back(preferred_separator);
481    }
482
483    path.append(component.begin(), component.end());
484  }
485}
486
487void append(SmallVectorImpl<char> &path,
488            const_iterator begin, const_iterator end) {
489  for (; begin != end; ++begin)
490    path::append(path, *begin);
491}
492
493StringRef parent_path(StringRef path) {
494  size_t end_pos = parent_path_end(path);
495  if (end_pos == StringRef::npos)
496    return StringRef();
497  else
498    return path.substr(0, end_pos);
499}
500
501void remove_filename(SmallVectorImpl<char> &path) {
502  size_t end_pos = parent_path_end(StringRef(path.begin(), path.size()));
503  if (end_pos != StringRef::npos)
504    path.set_size(end_pos);
505}
506
507void replace_extension(SmallVectorImpl<char> &path, const Twine &extension) {
508  StringRef p(path.begin(), path.size());
509  SmallString<32> ext_storage;
510  StringRef ext = extension.toStringRef(ext_storage);
511
512  // Erase existing extension.
513  size_t pos = p.find_last_of('.');
514  if (pos != StringRef::npos && pos >= filename_pos(p))
515    path.set_size(pos);
516
517  // Append '.' if needed.
518  if (ext.size() > 0 && ext[0] != '.')
519    path.push_back('.');
520
521  // Append extension.
522  path.append(ext.begin(), ext.end());
523}
524
525void replace_path_prefix(SmallVectorImpl<char> &Path,
526                         const StringRef &OldPrefix,
527                         const StringRef &NewPrefix) {
528  if (OldPrefix.empty() && NewPrefix.empty())
529    return;
530
531  StringRef OrigPath(Path.begin(), Path.size());
532  if (!OrigPath.startswith(OldPrefix))
533    return;
534
535  // If prefixes have the same size we can simply copy the new one over.
536  if (OldPrefix.size() == NewPrefix.size()) {
537    std::copy(NewPrefix.begin(), NewPrefix.end(), Path.begin());
538    return;
539  }
540
541  StringRef RelPath = OrigPath.substr(OldPrefix.size());
542  SmallString<256> NewPath;
543  path::append(NewPath, NewPrefix);
544  path::append(NewPath, RelPath);
545  Path.swap(NewPath);
546}
547
548void native(const Twine &path, SmallVectorImpl<char> &result) {
549  assert((!path.isSingleStringRef() ||
550          path.getSingleStringRef().data() != result.data()) &&
551         "path and result are not allowed to overlap!");
552  // Clear result.
553  result.clear();
554  path.toVector(result);
555  native(result);
556}
557
558void native(SmallVectorImpl<char> &Path) {
559#ifdef LLVM_ON_WIN32
560  std::replace(Path.begin(), Path.end(), '/', '\\');
561#else
562  for (auto PI = Path.begin(), PE = Path.end(); PI < PE; ++PI) {
563    if (*PI == '\\') {
564      auto PN = PI + 1;
565      if (PN < PE && *PN == '\\')
566        ++PI; // increment once, the for loop will move over the escaped slash
567      else
568        *PI = '/';
569    }
570  }
571#endif
572}
573
574StringRef filename(StringRef path) {
575  return *rbegin(path);
576}
577
578StringRef stem(StringRef path) {
579  StringRef fname = filename(path);
580  size_t pos = fname.find_last_of('.');
581  if (pos == StringRef::npos)
582    return fname;
583  else
584    if ((fname.size() == 1 && fname == ".") ||
585        (fname.size() == 2 && fname == ".."))
586      return fname;
587    else
588      return fname.substr(0, pos);
589}
590
591StringRef extension(StringRef path) {
592  StringRef fname = filename(path);
593  size_t pos = fname.find_last_of('.');
594  if (pos == StringRef::npos)
595    return StringRef();
596  else
597    if ((fname.size() == 1 && fname == ".") ||
598        (fname.size() == 2 && fname == ".."))
599      return StringRef();
600    else
601      return fname.substr(pos);
602}
603
604bool is_separator(char value) {
605  switch(value) {
606#ifdef LLVM_ON_WIN32
607    case '\\': // fall through
608#endif
609    case '/': return true;
610    default: return false;
611  }
612}
613
614static const char preferred_separator_string[] = { preferred_separator, '\0' };
615
616StringRef get_separator() {
617  return preferred_separator_string;
618}
619
620bool has_root_name(const Twine &path) {
621  SmallString<128> path_storage;
622  StringRef p = path.toStringRef(path_storage);
623
624  return !root_name(p).empty();
625}
626
627bool has_root_directory(const Twine &path) {
628  SmallString<128> path_storage;
629  StringRef p = path.toStringRef(path_storage);
630
631  return !root_directory(p).empty();
632}
633
634bool has_root_path(const Twine &path) {
635  SmallString<128> path_storage;
636  StringRef p = path.toStringRef(path_storage);
637
638  return !root_path(p).empty();
639}
640
641bool has_relative_path(const Twine &path) {
642  SmallString<128> path_storage;
643  StringRef p = path.toStringRef(path_storage);
644
645  return !relative_path(p).empty();
646}
647
648bool has_filename(const Twine &path) {
649  SmallString<128> path_storage;
650  StringRef p = path.toStringRef(path_storage);
651
652  return !filename(p).empty();
653}
654
655bool has_parent_path(const Twine &path) {
656  SmallString<128> path_storage;
657  StringRef p = path.toStringRef(path_storage);
658
659  return !parent_path(p).empty();
660}
661
662bool has_stem(const Twine &path) {
663  SmallString<128> path_storage;
664  StringRef p = path.toStringRef(path_storage);
665
666  return !stem(p).empty();
667}
668
669bool has_extension(const Twine &path) {
670  SmallString<128> path_storage;
671  StringRef p = path.toStringRef(path_storage);
672
673  return !extension(p).empty();
674}
675
676bool is_absolute(const Twine &path) {
677  SmallString<128> path_storage;
678  StringRef p = path.toStringRef(path_storage);
679
680  bool rootDir = has_root_directory(p),
681#ifdef LLVM_ON_WIN32
682       rootName = has_root_name(p);
683#else
684       rootName = true;
685#endif
686
687  return rootDir && rootName;
688}
689
690bool is_relative(const Twine &path) { return !is_absolute(path); }
691
692StringRef remove_leading_dotslash(StringRef Path) {
693  // Remove leading "./" (or ".//" or "././" etc.)
694  while (Path.size() > 2 && Path[0] == '.' && is_separator(Path[1])) {
695    Path = Path.substr(2);
696    while (Path.size() > 0 && is_separator(Path[0]))
697      Path = Path.substr(1);
698  }
699  return Path;
700}
701
702static SmallString<256> remove_dots(StringRef path, bool remove_dot_dot) {
703  SmallVector<StringRef, 16> components;
704
705  // Skip the root path, then look for traversal in the components.
706  StringRef rel = path::relative_path(path);
707  for (StringRef C : llvm::make_range(path::begin(rel), path::end(rel))) {
708    if (C == ".")
709      continue;
710    if (remove_dot_dot) {
711      if (C == "..") {
712        if (!components.empty())
713          components.pop_back();
714        continue;
715      }
716    }
717    components.push_back(C);
718  }
719
720  SmallString<256> buffer = path::root_path(path);
721  for (StringRef C : components)
722    path::append(buffer, C);
723  return buffer;
724}
725
726bool remove_dots(SmallVectorImpl<char> &path, bool remove_dot_dot) {
727  StringRef p(path.data(), path.size());
728
729  SmallString<256> result = remove_dots(p, remove_dot_dot);
730  if (result == path)
731    return false;
732
733  path.swap(result);
734  return true;
735}
736
737} // end namespace path
738
739namespace fs {
740
741std::error_code getUniqueID(const Twine Path, UniqueID &Result) {
742  file_status Status;
743  std::error_code EC = status(Path, Status);
744  if (EC)
745    return EC;
746  Result = Status.getUniqueID();
747  return std::error_code();
748}
749
750std::error_code createUniqueFile(const Twine &Model, int &ResultFd,
751                                 SmallVectorImpl<char> &ResultPath,
752                                 unsigned Mode) {
753  return createUniqueEntity(Model, ResultFd, ResultPath, false, Mode, FS_File);
754}
755
756std::error_code createUniqueFile(const Twine &Model,
757                                 SmallVectorImpl<char> &ResultPath) {
758  int Dummy;
759  return createUniqueEntity(Model, Dummy, ResultPath, false, 0, FS_Name);
760}
761
762static std::error_code
763createTemporaryFile(const Twine &Model, int &ResultFD,
764                    llvm::SmallVectorImpl<char> &ResultPath, FSEntity Type) {
765  SmallString<128> Storage;
766  StringRef P = Model.toNullTerminatedStringRef(Storage);
767  assert(P.find_first_of(separators) == StringRef::npos &&
768         "Model must be a simple filename.");
769  // Use P.begin() so that createUniqueEntity doesn't need to recreate Storage.
770  return createUniqueEntity(P.begin(), ResultFD, ResultPath,
771                            true, owner_read | owner_write, Type);
772}
773
774static std::error_code
775createTemporaryFile(const Twine &Prefix, StringRef Suffix, int &ResultFD,
776                    llvm::SmallVectorImpl<char> &ResultPath, FSEntity Type) {
777  const char *Middle = Suffix.empty() ? "-%%%%%%" : "-%%%%%%.";
778  return createTemporaryFile(Prefix + Middle + Suffix, ResultFD, ResultPath,
779                             Type);
780}
781
782std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
783                                    int &ResultFD,
784                                    SmallVectorImpl<char> &ResultPath) {
785  return createTemporaryFile(Prefix, Suffix, ResultFD, ResultPath, FS_File);
786}
787
788std::error_code createTemporaryFile(const Twine &Prefix, StringRef Suffix,
789                                    SmallVectorImpl<char> &ResultPath) {
790  int Dummy;
791  return createTemporaryFile(Prefix, Suffix, Dummy, ResultPath, FS_Name);
792}
793
794
795// This is a mkdtemp with a different pattern. We use createUniqueEntity mostly
796// for consistency. We should try using mkdtemp.
797std::error_code createUniqueDirectory(const Twine &Prefix,
798                                      SmallVectorImpl<char> &ResultPath) {
799  int Dummy;
800  return createUniqueEntity(Prefix + "-%%%%%%", Dummy, ResultPath,
801                            true, 0, FS_Dir);
802}
803
804static std::error_code make_absolute(const Twine &current_directory,
805                                     SmallVectorImpl<char> &path,
806                                     bool use_current_directory) {
807  StringRef p(path.data(), path.size());
808
809  bool rootDirectory = path::has_root_directory(p),
810#ifdef LLVM_ON_WIN32
811       rootName = path::has_root_name(p);
812#else
813       rootName = true;
814#endif
815
816  // Already absolute.
817  if (rootName && rootDirectory)
818    return std::error_code();
819
820  // All of the following conditions will need the current directory.
821  SmallString<128> current_dir;
822  if (use_current_directory)
823    current_directory.toVector(current_dir);
824  else if (std::error_code ec = current_path(current_dir))
825    return ec;
826
827  // Relative path. Prepend the current directory.
828  if (!rootName && !rootDirectory) {
829    // Append path to the current directory.
830    path::append(current_dir, p);
831    // Set path to the result.
832    path.swap(current_dir);
833    return std::error_code();
834  }
835
836  if (!rootName && rootDirectory) {
837    StringRef cdrn = path::root_name(current_dir);
838    SmallString<128> curDirRootName(cdrn.begin(), cdrn.end());
839    path::append(curDirRootName, p);
840    // Set path to the result.
841    path.swap(curDirRootName);
842    return std::error_code();
843  }
844
845  if (rootName && !rootDirectory) {
846    StringRef pRootName      = path::root_name(p);
847    StringRef bRootDirectory = path::root_directory(current_dir);
848    StringRef bRelativePath  = path::relative_path(current_dir);
849    StringRef pRelativePath  = path::relative_path(p);
850
851    SmallString<128> res;
852    path::append(res, pRootName, bRootDirectory, bRelativePath, pRelativePath);
853    path.swap(res);
854    return std::error_code();
855  }
856
857  llvm_unreachable("All rootName and rootDirectory combinations should have "
858                   "occurred above!");
859}
860
861std::error_code make_absolute(const Twine &current_directory,
862                              SmallVectorImpl<char> &path) {
863  return make_absolute(current_directory, path, true);
864}
865
866std::error_code make_absolute(SmallVectorImpl<char> &path) {
867  return make_absolute(Twine(), path, false);
868}
869
870std::error_code create_directories(const Twine &Path, bool IgnoreExisting,
871                                   perms Perms) {
872  SmallString<128> PathStorage;
873  StringRef P = Path.toStringRef(PathStorage);
874
875  // Be optimistic and try to create the directory
876  std::error_code EC = create_directory(P, IgnoreExisting, Perms);
877  // If we succeeded, or had any error other than the parent not existing, just
878  // return it.
879  if (EC != errc::no_such_file_or_directory)
880    return EC;
881
882  // We failed because of a no_such_file_or_directory, try to create the
883  // parent.
884  StringRef Parent = path::parent_path(P);
885  if (Parent.empty())
886    return EC;
887
888  if ((EC = create_directories(Parent, IgnoreExisting, Perms)))
889      return EC;
890
891  return create_directory(P, IgnoreExisting, Perms);
892}
893
894std::error_code copy_file(const Twine &From, const Twine &To) {
895  int ReadFD, WriteFD;
896  if (std::error_code EC = openFileForRead(From, ReadFD))
897    return EC;
898  if (std::error_code EC = openFileForWrite(To, WriteFD, F_None)) {
899    close(ReadFD);
900    return EC;
901  }
902
903  const size_t BufSize = 4096;
904  char *Buf = new char[BufSize];
905  int BytesRead = 0, BytesWritten = 0;
906  for (;;) {
907    BytesRead = read(ReadFD, Buf, BufSize);
908    if (BytesRead <= 0)
909      break;
910    while (BytesRead) {
911      BytesWritten = write(WriteFD, Buf, BytesRead);
912      if (BytesWritten < 0)
913        break;
914      BytesRead -= BytesWritten;
915    }
916    if (BytesWritten < 0)
917      break;
918  }
919  close(ReadFD);
920  close(WriteFD);
921  delete[] Buf;
922
923  if (BytesRead < 0 || BytesWritten < 0)
924    return std::error_code(errno, std::generic_category());
925  return std::error_code();
926}
927
928bool exists(file_status status) {
929  return status_known(status) && status.type() != file_type::file_not_found;
930}
931
932bool status_known(file_status s) {
933  return s.type() != file_type::status_error;
934}
935
936bool is_directory(file_status status) {
937  return status.type() == file_type::directory_file;
938}
939
940std::error_code is_directory(const Twine &path, bool &result) {
941  file_status st;
942  if (std::error_code ec = status(path, st))
943    return ec;
944  result = is_directory(st);
945  return std::error_code();
946}
947
948bool is_regular_file(file_status status) {
949  return status.type() == file_type::regular_file;
950}
951
952std::error_code is_regular_file(const Twine &path, bool &result) {
953  file_status st;
954  if (std::error_code ec = status(path, st))
955    return ec;
956  result = is_regular_file(st);
957  return std::error_code();
958}
959
960bool is_other(file_status status) {
961  return exists(status) &&
962         !is_regular_file(status) &&
963         !is_directory(status);
964}
965
966std::error_code is_other(const Twine &Path, bool &Result) {
967  file_status FileStatus;
968  if (std::error_code EC = status(Path, FileStatus))
969    return EC;
970  Result = is_other(FileStatus);
971  return std::error_code();
972}
973
974void directory_entry::replace_filename(const Twine &filename, file_status st) {
975  SmallString<128> path = path::parent_path(Path);
976  path::append(path, filename);
977  Path = path.str();
978  Status = st;
979}
980
981/// @brief Identify the magic in magic.
982file_magic identify_magic(StringRef Magic) {
983  if (Magic.size() < 4)
984    return file_magic::unknown;
985  switch ((unsigned char)Magic[0]) {
986    case 0x00: {
987      // COFF bigobj or short import library file
988      if (Magic[1] == (char)0x00 && Magic[2] == (char)0xff &&
989          Magic[3] == (char)0xff) {
990        size_t MinSize = offsetof(COFF::BigObjHeader, UUID) + sizeof(COFF::BigObjMagic);
991        if (Magic.size() < MinSize)
992          return file_magic::coff_import_library;
993
994        int BigObjVersion = read16le(
995            Magic.data() + offsetof(COFF::BigObjHeader, Version));
996        if (BigObjVersion < COFF::BigObjHeader::MinBigObjectVersion)
997          return file_magic::coff_import_library;
998
999        const char *Start = Magic.data() + offsetof(COFF::BigObjHeader, UUID);
1000        if (memcmp(Start, COFF::BigObjMagic, sizeof(COFF::BigObjMagic)) != 0)
1001          return file_magic::coff_import_library;
1002        return file_magic::coff_object;
1003      }
1004      // Windows resource file
1005      const char Expected[] = { 0, 0, 0, 0, '\x20', 0, 0, 0, '\xff' };
1006      if (Magic.size() >= sizeof(Expected) &&
1007          memcmp(Magic.data(), Expected, sizeof(Expected)) == 0)
1008        return file_magic::windows_resource;
1009      // 0x0000 = COFF unknown machine type
1010      if (Magic[1] == 0)
1011        return file_magic::coff_object;
1012      break;
1013    }
1014    case 0xDE:  // 0x0B17C0DE = BC wraper
1015      if (Magic[1] == (char)0xC0 && Magic[2] == (char)0x17 &&
1016          Magic[3] == (char)0x0B)
1017        return file_magic::bitcode;
1018      break;
1019    case 'B':
1020      if (Magic[1] == 'C' && Magic[2] == (char)0xC0 && Magic[3] == (char)0xDE)
1021        return file_magic::bitcode;
1022      break;
1023    case '!':
1024      if (Magic.size() >= 8)
1025        if (memcmp(Magic.data(), "!<arch>\n", 8) == 0 ||
1026            memcmp(Magic.data(), "!<thin>\n", 8) == 0)
1027          return file_magic::archive;
1028      break;
1029
1030    case '\177':
1031      if (Magic.size() >= 18 && Magic[1] == 'E' && Magic[2] == 'L' &&
1032          Magic[3] == 'F') {
1033        bool Data2MSB = Magic[5] == 2;
1034        unsigned high = Data2MSB ? 16 : 17;
1035        unsigned low  = Data2MSB ? 17 : 16;
1036        if (Magic[high] == 0)
1037          switch (Magic[low]) {
1038            default: return file_magic::elf;
1039            case 1: return file_magic::elf_relocatable;
1040            case 2: return file_magic::elf_executable;
1041            case 3: return file_magic::elf_shared_object;
1042            case 4: return file_magic::elf_core;
1043          }
1044        else
1045          // It's still some type of ELF file.
1046          return file_magic::elf;
1047      }
1048      break;
1049
1050    case 0xCA:
1051      if (Magic[1] == char(0xFE) && Magic[2] == char(0xBA) &&
1052          (Magic[3] == char(0xBE) || Magic[3] == char(0xBF))) {
1053        // This is complicated by an overlap with Java class files.
1054        // See the Mach-O section in /usr/share/file/magic for details.
1055        if (Magic.size() >= 8 && Magic[7] < 43)
1056          return file_magic::macho_universal_binary;
1057      }
1058      break;
1059
1060      // The two magic numbers for mach-o are:
1061      // 0xfeedface - 32-bit mach-o
1062      // 0xfeedfacf - 64-bit mach-o
1063    case 0xFE:
1064    case 0xCE:
1065    case 0xCF: {
1066      uint16_t type = 0;
1067      if (Magic[0] == char(0xFE) && Magic[1] == char(0xED) &&
1068          Magic[2] == char(0xFA) &&
1069          (Magic[3] == char(0xCE) || Magic[3] == char(0xCF))) {
1070        /* Native endian */
1071        size_t MinSize;
1072        if (Magic[3] == char(0xCE))
1073          MinSize = sizeof(MachO::mach_header);
1074        else
1075          MinSize = sizeof(MachO::mach_header_64);
1076        if (Magic.size() >= MinSize)
1077          type = Magic[12] << 24 | Magic[13] << 12 | Magic[14] << 8 | Magic[15];
1078      } else if ((Magic[0] == char(0xCE) || Magic[0] == char(0xCF)) &&
1079                 Magic[1] == char(0xFA) && Magic[2] == char(0xED) &&
1080                 Magic[3] == char(0xFE)) {
1081        /* Reverse endian */
1082        size_t MinSize;
1083        if (Magic[0] == char(0xCE))
1084          MinSize = sizeof(MachO::mach_header);
1085        else
1086          MinSize = sizeof(MachO::mach_header_64);
1087        if (Magic.size() >= MinSize)
1088          type = Magic[15] << 24 | Magic[14] << 12 |Magic[13] << 8 | Magic[12];
1089      }
1090      switch (type) {
1091        default: break;
1092        case 1: return file_magic::macho_object;
1093        case 2: return file_magic::macho_executable;
1094        case 3: return file_magic::macho_fixed_virtual_memory_shared_lib;
1095        case 4: return file_magic::macho_core;
1096        case 5: return file_magic::macho_preload_executable;
1097        case 6: return file_magic::macho_dynamically_linked_shared_lib;
1098        case 7: return file_magic::macho_dynamic_linker;
1099        case 8: return file_magic::macho_bundle;
1100        case 9: return file_magic::macho_dynamically_linked_shared_lib_stub;
1101        case 10: return file_magic::macho_dsym_companion;
1102        case 11: return file_magic::macho_kext_bundle;
1103      }
1104      break;
1105    }
1106    case 0xF0: // PowerPC Windows
1107    case 0x83: // Alpha 32-bit
1108    case 0x84: // Alpha 64-bit
1109    case 0x66: // MPS R4000 Windows
1110    case 0x50: // mc68K
1111    case 0x4c: // 80386 Windows
1112    case 0xc4: // ARMNT Windows
1113      if (Magic[1] == 0x01)
1114        return file_magic::coff_object;
1115
1116    case 0x90: // PA-RISC Windows
1117    case 0x68: // mc68K Windows
1118      if (Magic[1] == 0x02)
1119        return file_magic::coff_object;
1120      break;
1121
1122    case 'M': // Possible MS-DOS stub on Windows PE file
1123      if (Magic[1] == 'Z') {
1124        uint32_t off = read32le(Magic.data() + 0x3c);
1125        // PE/COFF file, either EXE or DLL.
1126        if (off < Magic.size() &&
1127            memcmp(Magic.data()+off, COFF::PEMagic, sizeof(COFF::PEMagic)) == 0)
1128          return file_magic::pecoff_executable;
1129      }
1130      break;
1131
1132    case 0x64: // x86-64 Windows.
1133      if (Magic[1] == char(0x86))
1134        return file_magic::coff_object;
1135      break;
1136
1137    default:
1138      break;
1139  }
1140  return file_magic::unknown;
1141}
1142
1143std::error_code identify_magic(const Twine &Path, file_magic &Result) {
1144  int FD;
1145  if (std::error_code EC = openFileForRead(Path, FD))
1146    return EC;
1147
1148  char Buffer[32];
1149  int Length = read(FD, Buffer, sizeof(Buffer));
1150  if (close(FD) != 0 || Length < 0)
1151    return std::error_code(errno, std::generic_category());
1152
1153  Result = identify_magic(StringRef(Buffer, Length));
1154  return std::error_code();
1155}
1156
1157std::error_code directory_entry::status(file_status &result) const {
1158  return fs::status(Path, result);
1159}
1160
1161} // end namespace fs
1162} // end namespace sys
1163} // end namespace llvm
1164
1165// Include the truly platform-specific parts.
1166#if defined(LLVM_ON_UNIX)
1167#include "Unix/Path.inc"
1168#endif
1169#if defined(LLVM_ON_WIN32)
1170#include "Windows/Path.inc"
1171#endif
1172
1173namespace llvm {
1174namespace sys {
1175namespace path {
1176
1177bool user_cache_directory(SmallVectorImpl<char> &Result, const Twine &Path1,
1178                          const Twine &Path2, const Twine &Path3) {
1179  if (getUserCacheDir(Result)) {
1180    append(Result, Path1, Path2, Path3);
1181    return true;
1182  }
1183  return false;
1184}
1185
1186} // end namespace path
1187} // end namsspace sys
1188} // end namespace llvm
1189