#include "common/path.h"

#include "common/hash-str.h"

#include "common/list.h"

#include "common/punycode.h"

namespace Common {

#ifndef RELEASE_BUILD

bool Path::_shownSeparatorCollisionWarning = false;

#endif

inline void Path::escape(String &dst, char srcSeparator, const char *begin, const char *end) {

}

inline String Path::unescape(char dstSeparator, const char *begin, const char *end) {

}

bool Path::canUnescape(bool willBeAtBegin, bool wasAtBegin,

}

String Path::encode(const char *str, char separator) {

}

Path Path::extract(const char *begin, const char *end) const {

}

String Path::toString(char separator) const {

}

size_t Path::findLastSeparator(size_t last) const {

}

Path Path::getParent() const {

}

Path Path::getLastComponent() const {

}

String Path::baseName() const {

}

int Path::numComponents() const {

}

Path &Path::appendInPlace(const Path &x) {

if (x._str.empty()) {

return *this;

}

if (_str.empty()) {

_str = x._str;

return *this;

}

// From here both paths have data

if (isEscaped() == x.isEscaped()) {

if (isEscaped()) {

// Both are escaped: no chance we could unescape

// Append the other without its escape mark

_str.append(x._str.begin() + 1, x._str.end());

} else {

// No escape: append as we will don't need to escape

_str += x._str;

}

return *this;

}

// If we are here, one of us is escaped and the other one is not

if (isEscaped()) {

// This one is escaped not the other one

// There is no chance we could unescape this one

escape(_str, SEPARATOR, x._str.c_str(), x._str.c_str() + x._str.size());

return *this;

}

// This one is not escaped the other one is

// There is a small chance the other one is escaped because it started with ESCAPED

// In this case (and only this one) we could unescape

const char *other = x._str.c_str() + 1; // Remove leading ESCAPE

if (canUnescape(false, true, other)) {

// This one stays unescaped and the other one becomes unescaped

_str += unescape(SEPARATOR, other, x._str.c_str() + x._str.size());

} else {

// This one gets escaped and the other one stays escaped

String str(ESCAPE);

escape(str, SEPARATOR, _str.c_str(), _str.c_str() + _str.size());

str.append(other, x._str.c_str() + x._str.size());

// Replace ourselves

_str = str;

}

return *this;

}

Path &Path::appendInPlace(const char *str, char separator) {

if (!*str) {

return *this;

}

if (_str.empty()) {

set(str, separator);

return *this;

}

// From here both paths have data

if (isEscaped()) {

// This one is escaped

// There is no chance we could unescape it

escape(_str, separator, str);

return *this;

}

// We are not escaped, let's hope str won't need escaping

if (!needsEncoding(str, separator)) {

// No need to encode means it's perfect

_str += str;

return *this;

}

if (!strchr(str, SEPARATOR)) {

// No SEPARATOR, no clash

// Even if str starts with ESCAPE, no need to escape as we append

Common::String tmp(str);

if (separator) {

// If separator is 0 there is only one path component

tmp.replace(separator, SEPARATOR);

}

_str += tmp;

return *this;

}

// Too bad, we need to escape

String tmp(ESCAPE);

escape(tmp, SEPARATOR, _str.c_str(), _str.c_str() + _str.size());

escape(tmp, separator, str);

// Replace ourselves

_str = tmp;

return *this;

}

Path Path::appendComponent(const char *str) const {

}

Path &Path::joinInPlace(const Path &x) {

if (x.empty()) {

return *this;

}

if (_str.empty()) {

_str = x._str;

return *this;

}

const char *str = x._str.c_str();

// Append SEPARATOR if:

// - we don't finish with SEPARATOR already

// - other Path is escaped and doesn't begin by SEPARATOR

// - or other Path isn't escaped and doesn't begin by SEPARATOR

if (*(_str.end() - 1) != SEPARATOR &&

((x.isEscaped() && str[1] != SEPARATOR) ||

*str != SEPARATOR)) {

_str += SEPARATOR;

}

return appendInPlace(x);

}

Path &Path::joinInPlace(const char *str, char separator) {

if (*str == '\0') {

return *this;

}

if (_str.empty()) {

set(str, separator);

return *this;

}

if (*(_str.end() - 1) != SEPARATOR && *str != separator) {

_str += SEPARATOR;

}

return appendInPlace(str, separator);

}

Path &Path::removeTrailingSeparators() {

while (_str.size() > 1 && _str.lastChar() == SEPARATOR) {

_str.deleteLastChar();

}

return *this;

}

Path &Path::removeExtension(const char *ext) {

if (_str.empty()) {

return *this;

}

// Find the last separator

size_t last = _str.size() - 1;

if (isSeparatorTerminated()) {

last--;

}

size_t sepPos = findLastSeparator(last);

const char *begin;

if (sepPos == String::npos) {

// No separator found, we are a single component

begin = _str.c_str();

} else {

// We have a separator, so we can find the last component

begin = _str.c_str() + sepPos + 1;

}

const char *end = _str.c_str() + _str.size();

String component(begin, end);

// If the last component is shorter than the extension,

// or it is punycode encoded, we do not change the path

if ((ext && component.size() < strlen(ext)) || punycode_hasprefix(component))

return *this;

if (!ext) {

// Remove the last extension, if any

size_t dotPos = component.findLastOf('.');

if (dotPos == String::npos) {

return *this; // No change

}

_str.chop(end - begin - dotPos);

return *this;

} else if (component.hasSuffix(ext)) {

// Remove the given extension, if it matches

_str.chop(strlen(ext));

}

return *this;

}

const char *Path::getSuffix(const Common::Path &other) const {

if (other.empty()) {

// Other is empty, return full string

const char *suffix = _str.c_str();

if (isEscaped()) {

suffix++;

}

return suffix;

}

if (isEscaped() == other.isEscaped()) {

// Easy one both have same escapism

if (_str.hasPrefix(other._str)) {

const char *suffix = _str.c_str() + other._str.size();

if (!other.isSeparatorTerminated()) {

if (*suffix == SEPARATOR) {

// Skip the separator

return suffix + 1;

} else if (*suffix == '\x00') {

// Both paths are equal: return end of string

return suffix;

} else {

// We are in the middle of some path component: this is not relative

return nullptr;

}

} else {

// Other already had a separator: this is relative and starts with next component

return suffix;

}

} else {

return nullptr;

}

}

// One is escaped and not the other

if (other.isEscaped()) {

// If the other is escaped it can't be a substring of this one

// as it must contain something which needed escape and we obviously didn't need it

return nullptr;

}

// We may be escaped because something needs escape after the end of the prefix

// We need to iterate over both paths and checking escape in ours

const char *str = _str.c_str() + 1;

const char *strOther = other._str.c_str();

while (*strOther) {

char c = *str;

if (c == ESCAPE) {

str++;

switch (*str) {

case ESCAPED_ESCAPE:

c = ESCAPE;

break;

case ESCAPED_SEPARATOR:

/* We are not supposed to have an escaped separator as

c = SEPARATOR;

break;

default:

error("Invalid escape character '%c' in path \"%s\"", *str, _str.c_str());

}

}

if (*strOther != c) {

break;

}

++strOther;

++str;

}

// It's a prefix, if and only if all letters in other are 'used up' before

// we end.

if (*strOther != '\0') {

return nullptr;

}

if (!other.isSeparatorTerminated()) {

// Make sure we didn't end up in the middle of some path component

if (*str != SEPARATOR) {

return nullptr;

}

str++;

}

return str;

}

Path Path::relativeTo(const Common::Path &other) const {

}

Path Path::normalize() const {

}

StringArray Path::splitComponents() const {

}

Path Path::joinComponents(StringArray::const_iterator begin, StringArray::const_iterator end) {

}

template<typename T>

T Path::reduceComponents(T(*reducer)(T value, const String &element, bool last), T value) const {

}

bool Path::compareComponents(bool (*comparator)(const String &x, const String &y),