tor-browser

string_utils.cpp (9200B)

---

//
// Copyright 2015 The ANGLE Project Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
//
// string_utils:
//   String helper functions.
//

#include "common/string_utils.h"

#include <stdlib.h>
#include <string.h>
#include <algorithm>
#include <cctype>
#include <fstream>
#include <sstream>

#include "common/platform.h"
#include "common/system_utils.h"

namespace
{

bool EndsWithSuffix(const char *str,
                   const size_t strLen,
                   const char *suffix,
                   const size_t suffixLen)
{
   return suffixLen <= strLen && strncmp(str + strLen - suffixLen, suffix, suffixLen) == 0;
}

}  // anonymous namespace

namespace angle
{

const char kWhitespaceASCII[] = " \f\n\r\t\v";

std::vector<std::string> SplitString(const std::string &input,
                                    const std::string &delimiters,
                                    WhitespaceHandling whitespace,
                                    SplitResult resultType)
{
   std::vector<std::string> result;
   if (input.empty())
   {
       return result;
   }

   std::string::size_type start = 0;
   while (start != std::string::npos)
   {
       auto end = input.find_first_of(delimiters, start);

       std::string piece;
       if (end == std::string::npos)
       {
           piece = input.substr(start);
           start = std::string::npos;
       }
       else
       {
           piece = input.substr(start, end - start);
           start = end + 1;
       }

       if (whitespace == TRIM_WHITESPACE)
       {
           piece = TrimString(piece, kWhitespaceASCII);
       }

       if (resultType == SPLIT_WANT_ALL || !piece.empty())
       {
           result.push_back(std::move(piece));
       }
   }

   return result;
}

void SplitStringAlongWhitespace(const std::string &input, std::vector<std::string> *tokensOut)
{

   std::istringstream stream(input);
   std::string line;

   while (std::getline(stream, line))
   {
       size_t prev = 0, pos;
       while ((pos = line.find_first_of(kWhitespaceASCII, prev)) != std::string::npos)
       {
           if (pos > prev)
               tokensOut->push_back(line.substr(prev, pos - prev));
           prev = pos + 1;
       }
       if (prev < line.length())
           tokensOut->push_back(line.substr(prev, std::string::npos));
   }
}

std::string TrimString(const std::string &input, const std::string &trimChars)
{
   auto begin = input.find_first_not_of(trimChars);
   if (begin == std::string::npos)
   {
       return "";
   }

   std::string::size_type end = input.find_last_not_of(trimChars);
   if (end == std::string::npos)
   {
       return input.substr(begin);
   }

   return input.substr(begin, end - begin + 1);
}

std::string GetPrefix(const std::string &input, size_t offset, const char *delimiter)
{
   size_t match = input.find(delimiter, offset);
   if (match == std::string::npos)
   {
       return input.substr(offset);
   }
   return input.substr(offset, match - offset);
}

std::string GetPrefix(const std::string &input, size_t offset, char delimiter)
{
   size_t match = input.find(delimiter, offset);
   if (match == std::string::npos)
   {
       return input.substr(offset);
   }
   return input.substr(offset, match - offset);
}

bool HexStringToUInt(const std::string &input, unsigned int *uintOut)
{
   unsigned int offset = 0;

   if (input.size() >= 2 && input[0] == '0' && input[1] == 'x')
   {
       offset = 2u;
   }

   // Simple validity check
   if (input.find_first_not_of("0123456789ABCDEFabcdef", offset) != std::string::npos)
   {
       return false;
   }

   std::stringstream inStream(input);
   inStream >> std::hex >> *uintOut;
   return !inStream.fail();
}

bool ReadFileToString(const std::string &path, std::string *stringOut)
{
   std::ifstream inFile(path.c_str());
   if (inFile.fail())
   {
       return false;
   }

   inFile.seekg(0, std::ios::end);
   stringOut->reserve(static_cast<std::string::size_type>(inFile.tellg()));
   inFile.seekg(0, std::ios::beg);

   stringOut->assign(std::istreambuf_iterator<char>(inFile), std::istreambuf_iterator<char>());
   return !inFile.fail();
}

bool BeginsWith(const std::string &str, const std::string &prefix)
{
   return strncmp(str.c_str(), prefix.c_str(), prefix.length()) == 0;
}

bool BeginsWith(const std::string &str, const char *prefix)
{
   return strncmp(str.c_str(), prefix, strlen(prefix)) == 0;
}

bool BeginsWith(const char *str, const char *prefix)
{
   return strncmp(str, prefix, strlen(prefix)) == 0;
}

bool BeginsWith(const std::string &str, const std::string &prefix, const size_t prefixLength)
{
   return strncmp(str.c_str(), prefix.c_str(), prefixLength) == 0;
}

bool EndsWith(const std::string &str, const std::string &suffix)
{
   return EndsWithSuffix(str.c_str(), str.length(), suffix.c_str(), suffix.length());
}

bool EndsWith(const std::string &str, const char *suffix)
{
   return EndsWithSuffix(str.c_str(), str.length(), suffix, strlen(suffix));
}

bool EndsWith(const char *str, const char *suffix)
{
   return EndsWithSuffix(str, strlen(str), suffix, strlen(suffix));
}

bool ContainsToken(const std::string &tokenStr, char delimiter, const std::string &token)
{
   if (token.empty())
   {
       return false;
   }
   // Compare token with all sub-strings terminated by delimiter or end of string
   std::string::size_type start = 0u;
   do
   {
       std::string::size_type end = tokenStr.find(delimiter, start);
       if (end == std::string::npos)
       {
           end = tokenStr.length();
       }
       const std::string::size_type length = end - start;
       if (length == token.length() && tokenStr.compare(start, length, token) == 0)
       {
           return true;
       }
       start = end + 1u;
   } while (start < tokenStr.size());
   return false;
}

void ToLower(std::string *str)
{
   for (char &ch : *str)
   {
       ch = static_cast<char>(::tolower(ch));
   }
}

void ToUpper(std::string *str)
{
   for (char &ch : *str)
   {
       ch = static_cast<char>(::toupper(ch));
   }
}

bool ReplaceSubstring(std::string *str,
                     const std::string &substring,
                     const std::string &replacement)
{
   size_t replacePos = str->find(substring);
   if (replacePos == std::string::npos)
   {
       return false;
   }
   str->replace(replacePos, substring.size(), replacement);
   return true;
}

int ReplaceAllSubstrings(std::string *str,
                        const std::string &substring,
                        const std::string &replacement)
{
   int count = 0;
   while (ReplaceSubstring(str, substring, replacement))
   {
       count++;
   }
   return count;
}

std::string ToCamelCase(const std::string &str)
{
   std::string result;

   bool lastWasUnderscore = false;
   for (char c : str)
   {
       if (c == '_')
       {
           lastWasUnderscore = true;
           continue;
       }

       if (lastWasUnderscore)
       {
           c                 = static_cast<char>(std::toupper(c));
           lastWasUnderscore = false;
       }
       result += c;
   }

   return result;
}

std::vector<std::string> GetStringsFromEnvironmentVarOrAndroidProperty(const char *varName,
                                                                      const char *propertyName,
                                                                      const char *separator)
{
   std::string environment = GetEnvironmentVarOrAndroidProperty(varName, propertyName);
   return SplitString(environment, separator, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
}

std::vector<std::string> GetCachedStringsFromEnvironmentVarOrAndroidProperty(
   const char *varName,
   const char *propertyName,
   const char *separator)
{
   std::string environment = GetEnvironmentVarOrAndroidProperty(varName, propertyName);
   return SplitString(environment, separator, TRIM_WHITESPACE, SPLIT_WANT_NONEMPTY);
}

// glob can have * as wildcard
bool NamesMatchWithWildcard(const char *glob, const char *name)
{
   // Find the first * in glob.
   const char *firstWildcard = strchr(glob, '*');

   // If there are no wildcards, match the strings precisely.
   if (firstWildcard == nullptr)
   {
       return strcmp(glob, name) == 0;
   }

   // Otherwise, match up to the wildcard first.
   size_t preWildcardLen = firstWildcard - glob;
   if (strncmp(glob, name, preWildcardLen) != 0)
   {
       return false;
   }

   const char *postWildcardRef = glob + preWildcardLen + 1;

   // As a small optimization, if the wildcard is the last character in glob, accept the match
   // already.
   if (postWildcardRef[0] == '\0')
   {
       return true;
   }

   // Try to match the wildcard with a number of characters.
   for (size_t matchSize = 0; name[matchSize] != '\0'; ++matchSize)
   {
       if (NamesMatchWithWildcard(postWildcardRef, name + matchSize))
       {
           return true;
       }
   }

   return false;
}

}  // namespace angle