//===--- iwyu_string_util.h - string utilities for include-what-you-use ---===//

//

// The LLVM Compiler Infrastructure

//

// This file is distributed under the University of Illinois Open Source

// License. See LICENSE.TXT for details.

//

//===----------------------------------------------------------------------===//

// String utilities for the IWYU checker.

//

#ifndef INCLUDE_WHAT_YOU_USE_IWYU_STRING_UTIL_H_

#define INCLUDE_WHAT_YOU_USE_IWYU_STRING_UTIL_H_

#include <cctype>

#include <ctime>

#include <string>

#include <utility>

#include <vector>

#include "iwyu_port.h"

#include "llvm/ADT/StringRef.h"

namespace include_what_you_use {

using llvm::StringRef;

using std::string;

using std::vector;

// Returns true if str starts with prefix.

inline bool StartsWith(StringRef str, StringRef prefix) {

return str.starts_with(prefix);

}

// Returns true if str ends with suffix.

inline bool EndsWith(StringRef str, StringRef suffix) {

return str.ends_with(suffix);

}

// If *str starts with prefix, removes the prefix and returns true.

inline bool StripLeft(string* str, StringRef prefix) {

if (StartsWith(*str, prefix)) {

*str = str->substr(prefix.size());

return true;

}

return false;

}

// If *str ends with suffix, removes the suffix and returns true.

inline bool StripRight(string* str, StringRef suffix) {

if (EndsWith(*str, suffix)) {

*str = str->substr(0, str->size() - suffix.size());

return true;

}

return false;

}

// Truncate str to width with ellipses to indicate truncation.

// Return str unchanged if it fits within width.

// Return empty string if width is too short to fit anything meaningful.

// Otherwise return str truncated to width chars.

inline string Ellipsize(StringRef str, size_t width) {

if (str.size() <= width)

return str.str();

// If we truncate strings too short, we'll end up with nonsense abbreviations

// like '...', 'T...' or 'Ty...' so make sure we have at least three chars

// from str and three chars for ellipsis.

if (width < 6)

return string();

return str.substr(0, width - 3).str() + "...";

}

// Finds the first occurrence of substr in *str and removes from *str

// everything before the occurrence and the occurrence itself. For

// example, string s = "What a hat!"; StripPast(&s, "hat"); will make s

// " a hat!".

inline bool StripPast(string* str, StringRef substr) {

const size_t pos = str->find(substr);

if (pos == string::npos)

return false;

*str = str->substr(pos + substr.size());

return true;

}

// Removes leading whitespace.

inline void StripWhiteSpaceLeft(string* str) {

for (string::size_type i = 0; i < str->size(); ++i) {

if (!isspace((*str)[i])) {

*str = str->substr(i);

return;

}

}

// Everything is whitespace. Return with an empty string.

str->clear();

}

// Removes trailing whitespace.

inline void StripWhiteSpaceRight(string* str) {

for (string::size_type end_of_string = str->size();

end_of_string > 0; --end_of_string) {

if (!isspace((*str)[end_of_string - 1])) {

*str = str->substr(0, end_of_string);

return;

}

}

// Everything is whitespace. Return with an empty string.

str->clear();

}

// Removes both leading and trailing whitespace.

inline void StripWhiteSpace(string* str) {

StripWhiteSpaceLeft(str);

StripWhiteSpaceRight(str);

}

// This is the same as split() in Python. If max_segs is 0, there's

// no limit on the number of the generated segments.

inline vector<string> Split(

string str, StringRef divider, size_t max_segs) {

CHECK_(!divider.empty());

vector<string> retval;

size_t pos;

// If max_segs is 0, the first part of the condition will always be true.

while (retval.size() + 1 != max_segs &&

(pos = str.find(divider)) != string::npos) {

retval.emplace_back(str.substr(0, pos));

str = str.substr(pos + divider.size());

}

retval.emplace_back(std::move(str));

return retval;

}

// Like Split, but using a divider of arbitrary whitespace.

// Whitespace at the beginning and end is ignored.

inline vector<string> SplitOnWhiteSpace(StringRef str, size_t max_segs) {

vector<string> retval;

size_t tokstart = string::npos;

for (size_t pos = 0; pos < str.size(); ++pos) {

if (isspace(str[pos])) {

if (tokstart != string::npos) {

retval.emplace_back(str.substr(tokstart, pos - tokstart).str());

if (retval.size() == max_segs) {

return retval;

}

tokstart = string::npos;

}

} else {

if (tokstart == string::npos) {

tokstart = pos;

}

}

}

if (tokstart != string::npos) {

retval.emplace_back(str.substr(tokstart).str());

}

return retval;

}

// Like SplitOnWhiteSpace, but double-quoted and bracketed strings are

// preserved. No error checking with respect to closing quotes is done.

inline vector<string> SplitOnWhiteSpacePreservingQuotes(StringRef str,

size_t max_segs) {

vector<string> retval;

size_t tokstart = string::npos;

char closing_quote = '\0';

for (size_t pos = 0; pos < str.size(); ++pos) {

if (isspace(str[pos])) {

if (tokstart != string::npos && closing_quote == '\0') {

retval.emplace_back(str.substr(tokstart, pos - tokstart).str());

if (retval.size() == max_segs) {

return retval;

}

tokstart = string::npos;

}

} else {

if (tokstart == string::npos) {

tokstart = pos;

if (str[pos] == '"') {

closing_quote = '"';

} else if (str[pos] == '<') {

closing_quote = '>';

} else {

closing_quote = '\0';

}

} else if (str[pos] == closing_quote) {

closing_quote = '\0';

}

}

}

if (tokstart != string::npos) {

retval.emplace_back(str.substr(tokstart).str());

}

return retval;

}

inline string FormatISO8601(time_t t) {

char buf[32];

strftime(buf, sizeof(buf), "%Y-%m-%dT%H:%M:%SZ", gmtime(&t));

return string(buf);

}

} // namespace include_what_you_use

#endif // INCLUDE_WHAT_YOU_USE_IWYU_STRING_UTIL_H_