base/files/file_path.cc - chromium/mini_chromium - Git at Google

 // Copyright 2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "base/files/file_path.h"

 #include <ctype.h>

 #include "base/logging.h"
 #include "base/stl_util.h"

 namespace base {

 #if defined(FILE_PATH_USES_WIN_SEPARATORS)
 const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("\\/");
 #else  // FILE_PATH_USES_WIN_SEPARATORS
 const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("/");
 #endif  // FILE_PATH_USES_WIN_SEPARATORS

 const FilePath::CharType FilePath::kCurrentDirectory[] = FILE_PATH_LITERAL(".");
 const FilePath::CharType FilePath::kParentDirectory[] = FILE_PATH_LITERAL("..");
 const FilePath::CharType FilePath::kExtensionSeparator = FILE_PATH_LITERAL('.');

 typedef FilePath::StringType StringType;

 namespace {

 const FilePath::CharType kStringTerminator = FILE_PATH_LITERAL('\0');

 // If this FilePath contains a drive letter specification, returns the
 // position of the last character of the drive letter specification,
 // otherwise returns npos.  This can only be true on Windows, when a pathname
 // begins with a letter followed by a colon.  On other platforms, this always
 // returns npos.
 StringType::size_type FindDriveLetter(const StringType& path) {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   // This is dependent on an ASCII-based character set, but that's a
   // reasonable assumption.  iswalpha can be too inclusive here.
   if (path.length() >= 2 && path[1] == L':' &&
       ((path[0] >= L'A' && path[0] <= L'Z') ||
        (path[0] >= L'a' && path[0] <= L'z'))) {
     return 1;
   }
 #endif  // FILE_PATH_USES_DRIVE_LETTERS
   return StringType::npos;
 }

 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
 bool EqualDriveLetterCaseInsensitive(const StringType& a,
                                      const StringType& b) {
   size_t a_letter_pos = FindDriveLetter(a);
   size_t b_letter_pos = FindDriveLetter(b);

   if (a_letter_pos == StringType::npos || b_letter_pos == StringType::npos)
     return a == b;

   if (::tolower(a[0]) != ::tolower(b[0]))
     return false;

   StringType a_rest(a.substr(a_letter_pos + 1));
   StringType b_rest(b.substr(b_letter_pos + 1));
   return a_rest == b_rest;
 }
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)

 bool IsPathAbsolute(const StringType& path) {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   StringType::size_type letter = FindDriveLetter(path);
   if (letter != StringType::npos) {
     // Look for a separator right after the drive specification.
     return path.length() > letter + 1 &&
         FilePath::IsSeparator(path[letter + 1]);
   }
   // Look for a pair of leading separators.
   return path.length() > 1 &&
       FilePath::IsSeparator(path[0]) && FilePath::IsSeparator(path[1]);
 #else  // FILE_PATH_USES_DRIVE_LETTERS
   // Look for a separator in the first position.
   return path.length() > 0 && FilePath::IsSeparator(path[0]);
 #endif  // FILE_PATH_USES_DRIVE_LETTERS
 }

 }  // namespace

 FilePath::FilePath() {
 }

 FilePath::FilePath(const FilePath& that) : path_(that.path_) {
 }

 FilePath::FilePath(const StringType& path) : path_(path) {
   StringType::size_type nul_pos = path_.find(kStringTerminator);
   if (nul_pos != StringType::npos)
     path_.erase(nul_pos, StringType::npos);
 }

 FilePath::~FilePath() {
 }

 FilePath& FilePath::operator=(const FilePath& that) {
   path_ = that.path_;
   return *this;
 }

 bool FilePath::operator==(const FilePath& that) const {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   return EqualDriveLetterCaseInsensitive(this->path_, that.path_);
 #else  // defined(FILE_PATH_USES_DRIVE_LETTERS)
   return path_ == that.path_;
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)
 }

 bool FilePath::operator!=(const FilePath& that) const {
 #if defined(FILE_PATH_USES_DRIVE_LETTERS)
   return !EqualDriveLetterCaseInsensitive(this->path_, that.path_);
 #else  // defined(FILE_PATH_USES_DRIVE_LETTERS)
   return path_ != that.path_;
 #endif  // defined(FILE_PATH_USES_DRIVE_LETTERS)
 }

 // static
 bool FilePath::IsSeparator(CharType character) {
   for (size_t i = 0; i < size(FilePath::kSeparators) - 1; ++i) {
     if (character == kSeparators[i]) {
       return true;
     }
   }

   return false;
 }

 // libgen's dirname and basename aren't guaranteed to be thread-safe and aren't
 // guaranteed to not modify their input strings, and in fact are implemented
 // differently in this regard on different platforms.  Don't use them, but
 // adhere to their behavior.
 FilePath FilePath::DirName() const {
   FilePath new_path(path_);
   new_path.StripTrailingSeparatorsInternal();

   // The drive letter, if any, always needs to remain in the output.  If there
   // is no drive letter, as will always be the case on platforms which do not
   // support drive letters, letter will be npos, or -1, so the comparisons and
   // resizes below using letter will still be valid.
   StringType::size_type letter = FindDriveLetter(new_path.path_);

   StringType::size_type last_separator =
       new_path.path_.find_last_of(kSeparators, StringType::npos,
                                   size(kSeparators) - 1);
   if (last_separator == StringType::npos) {
     // path_ is in the current directory.
     new_path.path_.resize(letter + 1);
   } else if (last_separator == letter + 1) {
     // path_ is in the root directory.
     new_path.path_.resize(letter + 2);
   } else if (last_separator == letter + 2 &&
              IsSeparator(new_path.path_[letter + 1])) {
     // path_ is in "//" (possibly with a drive letter); leave the double
     // separator intact indicating alternate root.
     new_path.path_.resize(letter + 3);
   } else if (last_separator != 0) {
     // path_ is somewhere else, trim the basename.
     new_path.path_.resize(last_separator);
   }

   new_path.StripTrailingSeparatorsInternal();
   if (!new_path.path_.length())
     new_path.path_ = kCurrentDirectory;

   return new_path;
 }

 FilePath FilePath::BaseName() const {
   FilePath new_path(path_);
   new_path.StripTrailingSeparatorsInternal();

   // The drive letter, if any, is always stripped.
   StringType::size_type letter = FindDriveLetter(new_path.path_);
   if (letter != StringType::npos) {
     new_path.path_.erase(0, letter + 1);
   }

   // Keep everything after the final separator, but if the pathname is only
   // one character and it's a separator, leave it alone.
   StringType::size_type last_separator =
       new_path.path_.find_last_of(kSeparators, StringType::npos,
                                   size(kSeparators) - 1);
   if (last_separator != StringType::npos &&
       last_separator < new_path.path_.length() - 1) {
     new_path.path_.erase(0, last_separator + 1);
   }

   return new_path;
 }

 StringType FilePath::FinalExtension() const {
   StringType base(BaseName().value());
   // Special case "." and ".."
   if (base == FilePath::kCurrentDirectory || base == FilePath::kParentDirectory)
     return StringType();
   const StringType::size_type dot = base.rfind(FilePath::kExtensionSeparator);
   if (dot == StringType::npos)
     return StringType();

   return base.substr(dot, StringType::npos);
 }

 FilePath FilePath::RemoveFinalExtension() const {
   StringType extension = FinalExtension();
   if (FinalExtension().empty())
     return *this;
   return FilePath(path_.substr(0, path_.size() - extension.size()));
 }

 FilePath FilePath::Append(const StringType& component) const {
   const StringType* appended = &component;
   StringType without_nuls;

   StringType::size_type nul_pos = component.find(kStringTerminator);
   if (nul_pos != StringType::npos) {
     without_nuls = component.substr(0, nul_pos);
     appended = &without_nuls;
   }

   DCHECK(!IsPathAbsolute(*appended));

   if (path_.compare(kCurrentDirectory) == 0) {
     // Append normally doesn't do any normalization, but as a special case,
     // when appending to kCurrentDirectory, just return a new path for the
     // component argument.  Appending component to kCurrentDirectory would
     // serve no purpose other than needlessly lengthening the path, and
     // it's likely in practice to wind up with FilePath objects containing
     // only kCurrentDirectory when calling DirName on a single relative path
     // component.
     return FilePath(*appended);
   }

   FilePath new_path(path_);
   new_path.StripTrailingSeparatorsInternal();

   // Don't append a separator if the path is empty (indicating the current
   // directory) or if the path component is empty (indicating nothing to
   // append).
   if (appended->length() > 0 && new_path.path_.length() > 0) {
     // Don't append a separator if the path still ends with a trailing
     // separator after stripping (indicating the root directory).
     if (!IsSeparator(new_path.path_[new_path.path_.length() - 1])) {
       // Don't append a separator if the path is just a drive letter.
       if (FindDriveLetter(new_path.path_) + 1 != new_path.path_.length()) {
         new_path.path_.append(1, kSeparators[0]);
       }
     }
   }

   new_path.path_.append(*appended);
   return new_path;
 }

 FilePath FilePath::Append(const FilePath& component) const {
   return Append(component.value());
 }

 bool FilePath::IsAbsolute() const {
   return IsPathAbsolute(path_);
 }

 void FilePath::StripTrailingSeparatorsInternal() {
   // If there is no drive letter, start will be 1, which will prevent stripping
   // the leading separator if there is only one separator.  If there is a drive
   // letter, start will be set appropriately to prevent stripping the first
   // separator following the drive letter, if a separator immediately follows
   // the drive letter.
   StringType::size_type start = FindDriveLetter(path_) + 2;

   StringType::size_type last_stripped = StringType::npos;
   for (StringType::size_type pos = path_.length();
        pos > start && IsSeparator(path_[pos - 1]);
        --pos) {
     // If the string only has two separators and they're at the beginning,
     // don't strip them, unless the string began with more than two separators.
     if (pos != start + 1 || last_stripped == start + 2 ||
         !IsSeparator(path_[start - 1])) {
       path_.resize(pos - 1);
       last_stripped = pos;
     }
   }
 }

 }  // namespace base

 void PrintTo(const base::FilePath& path, std::ostream* out) {
   *out << path.value().c_str();
 }
	// Copyright 2008 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "base/files/file_path.h"

	#include <ctype.h>

	#include "base/logging.h"
	#include "base/stl_util.h"

	namespace base {

	#if defined(FILE_PATH_USES_WIN_SEPARATORS)
	const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("\\/");
	#else // FILE_PATH_USES_WIN_SEPARATORS
	const FilePath::CharType FilePath::kSeparators[] = FILE_PATH_LITERAL("/");
	#endif // FILE_PATH_USES_WIN_SEPARATORS

	const FilePath::CharType FilePath::kCurrentDirectory[] = FILE_PATH_LITERAL(".");
	const FilePath::CharType FilePath::kParentDirectory[] = FILE_PATH_LITERAL("..");
	const FilePath::CharType FilePath::kExtensionSeparator = FILE_PATH_LITERAL('.');

	typedef FilePath::StringType StringType;

	namespace {

	const FilePath::CharType kStringTerminator = FILE_PATH_LITERAL('\0');

	// If this FilePath contains a drive letter specification, returns the
	// position of the last character of the drive letter specification,
	// otherwise returns npos. This can only be true on Windows, when a pathname
	// begins with a letter followed by a colon. On other platforms, this always
	// returns npos.
	StringType::size_type FindDriveLetter(const StringType& path) {
	#if defined(FILE_PATH_USES_DRIVE_LETTERS)
	// This is dependent on an ASCII-based character set, but that's a
	// reasonable assumption. iswalpha can be too inclusive here.
	if (path.length() >= 2 && path[1] == L':' &&
	((path[0] >= L'A' && path[0] <= L'Z') \|\|
	(path[0] >= L'a' && path[0] <= L'z'))) {
	return 1;
	}
	#endif // FILE_PATH_USES_DRIVE_LETTERS
	return StringType::npos;
	}

	#if defined(FILE_PATH_USES_DRIVE_LETTERS)
	bool EqualDriveLetterCaseInsensitive(const StringType& a,
	const StringType& b) {
	size_t a_letter_pos = FindDriveLetter(a);
	size_t b_letter_pos = FindDriveLetter(b);

	if (a_letter_pos == StringType::npos \|\| b_letter_pos == StringType::npos)
	return a == b;

	if (::tolower(a[0]) != ::tolower(b[0]))
	return false;

	StringType a_rest(a.substr(a_letter_pos + 1));
	StringType b_rest(b.substr(b_letter_pos + 1));
	return a_rest == b_rest;
	}
	#endif // defined(FILE_PATH_USES_DRIVE_LETTERS)

	bool IsPathAbsolute(const StringType& path) {
	#if defined(FILE_PATH_USES_DRIVE_LETTERS)
	StringType::size_type letter = FindDriveLetter(path);
	if (letter != StringType::npos) {
	// Look for a separator right after the drive specification.
	return path.length() > letter + 1 &&
	FilePath::IsSeparator(path[letter + 1]);
	}
	// Look for a pair of leading separators.
	return path.length() > 1 &&
	FilePath::IsSeparator(path[0]) && FilePath::IsSeparator(path[1]);
	#else // FILE_PATH_USES_DRIVE_LETTERS
	// Look for a separator in the first position.
	return path.length() > 0 && FilePath::IsSeparator(path[0]);
	#endif // FILE_PATH_USES_DRIVE_LETTERS
	}

	} // namespace

	FilePath::FilePath() {
	}

	FilePath::FilePath(const FilePath& that) : path_(that.path_) {
	}

	FilePath::FilePath(const StringType& path) : path_(path) {
	StringType::size_type nul_pos = path_.find(kStringTerminator);
	if (nul_pos != StringType::npos)
	path_.erase(nul_pos, StringType::npos);
	}

	FilePath::~FilePath() {
	}

	FilePath& FilePath::operator=(const FilePath& that) {
	path_ = that.path_;
	return *this;
	}

	bool FilePath::operator==(const FilePath& that) const {
	#if defined(FILE_PATH_USES_DRIVE_LETTERS)
	return EqualDriveLetterCaseInsensitive(this->path_, that.path_);
	#else // defined(FILE_PATH_USES_DRIVE_LETTERS)
	return path_ == that.path_;
	#endif // defined(FILE_PATH_USES_DRIVE_LETTERS)
	}

	bool FilePath::operator!=(const FilePath& that) const {
	#if defined(FILE_PATH_USES_DRIVE_LETTERS)
	return !EqualDriveLetterCaseInsensitive(this->path_, that.path_);
	#else // defined(FILE_PATH_USES_DRIVE_LETTERS)
	return path_ != that.path_;
	#endif // defined(FILE_PATH_USES_DRIVE_LETTERS)
	}

	// static
	bool FilePath::IsSeparator(CharType character) {
	for (size_t i = 0; i < size(FilePath::kSeparators) - 1; ++i) {
	if (character == kSeparators[i]) {
	return true;
	}
	}

	return false;
	}

	// libgen's dirname and basename aren't guaranteed to be thread-safe and aren't
	// guaranteed to not modify their input strings, and in fact are implemented
	// differently in this regard on different platforms. Don't use them, but
	// adhere to their behavior.
	FilePath FilePath::DirName() const {
	FilePath new_path(path_);
	new_path.StripTrailingSeparatorsInternal();

	// The drive letter, if any, always needs to remain in the output. If there
	// is no drive letter, as will always be the case on platforms which do not
	// support drive letters, letter will be npos, or -1, so the comparisons and
	// resizes below using letter will still be valid.
	StringType::size_type letter = FindDriveLetter(new_path.path_);

	StringType::size_type last_separator =
	new_path.path_.find_last_of(kSeparators, StringType::npos,
	size(kSeparators) - 1);
	if (last_separator == StringType::npos) {
	// path_ is in the current directory.
	new_path.path_.resize(letter + 1);
	} else if (last_separator == letter + 1) {
	// path_ is in the root directory.
	new_path.path_.resize(letter + 2);
	} else if (last_separator == letter + 2 &&
	IsSeparator(new_path.path_[letter + 1])) {
	// path_ is in "//" (possibly with a drive letter); leave the double
	// separator intact indicating alternate root.
	new_path.path_.resize(letter + 3);
	} else if (last_separator != 0) {
	// path_ is somewhere else, trim the basename.
	new_path.path_.resize(last_separator);
	}

	new_path.StripTrailingSeparatorsInternal();
	if (!new_path.path_.length())
	new_path.path_ = kCurrentDirectory;

	return new_path;
	}

	FilePath FilePath::BaseName() const {
	FilePath new_path(path_);
	new_path.StripTrailingSeparatorsInternal();

	// The drive letter, if any, is always stripped.
	StringType::size_type letter = FindDriveLetter(new_path.path_);
	if (letter != StringType::npos) {
	new_path.path_.erase(0, letter + 1);
	}

	// Keep everything after the final separator, but if the pathname is only
	// one character and it's a separator, leave it alone.
	StringType::size_type last_separator =
	new_path.path_.find_last_of(kSeparators, StringType::npos,
	size(kSeparators) - 1);
	if (last_separator != StringType::npos &&
	last_separator < new_path.path_.length() - 1) {
	new_path.path_.erase(0, last_separator + 1);
	}

	return new_path;
	}

	StringType FilePath::FinalExtension() const {
	StringType base(BaseName().value());
	// Special case "." and ".."
	if (base == FilePath::kCurrentDirectory \|\| base == FilePath::kParentDirectory)
	return StringType();
	const StringType::size_type dot = base.rfind(FilePath::kExtensionSeparator);
	if (dot == StringType::npos)
	return StringType();

	return base.substr(dot, StringType::npos);
	}

	FilePath FilePath::RemoveFinalExtension() const {
	StringType extension = FinalExtension();
	if (FinalExtension().empty())
	return *this;
	return FilePath(path_.substr(0, path_.size() - extension.size()));
	}

	FilePath FilePath::Append(const StringType& component) const {
	const StringType* appended = &component;
	StringType without_nuls;

	StringType::size_type nul_pos = component.find(kStringTerminator);
	if (nul_pos != StringType::npos) {
	without_nuls = component.substr(0, nul_pos);
	appended = &without_nuls;
	}

	DCHECK(!IsPathAbsolute(*appended));

	if (path_.compare(kCurrentDirectory) == 0) {
	// Append normally doesn't do any normalization, but as a special case,
	// when appending to kCurrentDirectory, just return a new path for the
	// component argument. Appending component to kCurrentDirectory would
	// serve no purpose other than needlessly lengthening the path, and
	// it's likely in practice to wind up with FilePath objects containing
	// only kCurrentDirectory when calling DirName on a single relative path
	// component.
	return FilePath(*appended);
	}

	FilePath new_path(path_);
	new_path.StripTrailingSeparatorsInternal();

	// Don't append a separator if the path is empty (indicating the current
	// directory) or if the path component is empty (indicating nothing to
	// append).
	if (appended->length() > 0 && new_path.path_.length() > 0) {
	// Don't append a separator if the path still ends with a trailing
	// separator after stripping (indicating the root directory).
	if (!IsSeparator(new_path.path_[new_path.path_.length() - 1])) {
	// Don't append a separator if the path is just a drive letter.
	if (FindDriveLetter(new_path.path_) + 1 != new_path.path_.length()) {
	new_path.path_.append(1, kSeparators[0]);
	}
	}
	}

	new_path.path_.append(*appended);
	return new_path;
	}

	FilePath FilePath::Append(const FilePath& component) const {
	return Append(component.value());
	}

	bool FilePath::IsAbsolute() const {
	return IsPathAbsolute(path_);
	}

	void FilePath::StripTrailingSeparatorsInternal() {
	// If there is no drive letter, start will be 1, which will prevent stripping
	// the leading separator if there is only one separator. If there is a drive
	// letter, start will be set appropriately to prevent stripping the first
	// separator following the drive letter, if a separator immediately follows
	// the drive letter.
	StringType::size_type start = FindDriveLetter(path_) + 2;

	StringType::size_type last_stripped = StringType::npos;
	for (StringType::size_type pos = path_.length();
	pos > start && IsSeparator(path_[pos - 1]);
	--pos) {
	// If the string only has two separators and they're at the beginning,
	// don't strip them, unless the string began with more than two separators.
	if (pos != start + 1 \|\| last_stripped == start + 2 \|\|
	!IsSeparator(path_[start - 1])) {
	path_.resize(pos - 1);
	last_stripped = pos;
	}
	}
	}

	} // namespace base

	void PrintTo(const base::FilePath& path, std::ostream* out) {
	*out << path.value().c_str();
	}