| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "partition_alloc/partition_alloc_base/files/file_path.h" |
| |
| #include <string.h> |
| #include <algorithm> |
| |
| #include "partition_alloc/partition_alloc_base/check.h" |
| |
| #if BUILDFLAG(IS_WIN) |
| #include <windows.h> |
| #elif BUILDFLAG(IS_APPLE) |
| #include <CoreFoundation/CoreFoundation.h> |
| #endif |
| |
| namespace partition_alloc::internal::base { |
| |
| using StringType = FilePath::StringType; |
| const FilePath::CharType kStringTerminator = PA_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(PA_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 // PA_FILE_PATH_USES_DRIVE_LETTERS |
| return StringType::npos; |
| } |
| |
| bool IsPathAbsolute(const StringType& path) { |
| #if defined(PA_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 // PA_FILE_PATH_USES_DRIVE_LETTERS |
| // Look for a separator in the first position. |
| return path.length() > 0 && FilePath::IsSeparator(path[0]); |
| #endif // PA_FILE_PATH_USES_DRIVE_LETTERS |
| } |
| |
| FilePath::FilePath() = default; |
| |
| FilePath::FilePath(const FilePath& that) = default; |
| FilePath::FilePath(FilePath&& that) noexcept = default; |
| |
| 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() = default; |
| |
| FilePath& FilePath::operator=(const FilePath& that) = default; |
| |
| FilePath& FilePath::operator=(FilePath&& that) noexcept = default; |
| |
| // static |
| bool FilePath::IsSeparator(CharType character) { |
| for (size_t i = 0; i < kSeparatorsLength - 1; ++i) { |
| if (character == kSeparators[i]) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| FilePath FilePath::Append(const StringType& component) 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; |
| } |
| |
| PA_BASE_DCHECK(!IsPathAbsolute(appended)); |
| |
| if (path_.compare(kCurrentDirectory) == 0 && !appended.empty()) { |
| // 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.empty() && !new_path.path_.empty()) { |
| // 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_.back())) { |
| // 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()); |
| } |
| |
| 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 partition_alloc::internal::base |