LCOV - code coverage report
Current view: top level - lib/Support - StringExtras.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 38 38 100.0 %
Date: 2018-09-23 13:06:45 Functions: 6 6 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : //===-- StringExtras.cpp - Implement the StringExtras header --------------===//
       2             : //
       3             : //                     The LLVM Compiler Infrastructure
       4             : //
       5             : // This file is distributed under the University of Illinois Open Source
       6             : // License. See LICENSE.TXT for details.
       7             : //
       8             : //===----------------------------------------------------------------------===//
       9             : //
      10             : // This file implements the StringExtras.h header
      11             : //
      12             : //===----------------------------------------------------------------------===//
      13             : 
      14             : #include "llvm/ADT/StringExtras.h"
      15             : #include "llvm/ADT/SmallVector.h"
      16             : #include "llvm/Support/raw_ostream.h"
      17             : using namespace llvm;
      18             : 
      19             : /// StrInStrNoCase - Portable version of strcasestr.  Locates the first
      20             : /// occurrence of string 's1' in string 's2', ignoring case.  Returns
      21             : /// the offset of s2 in s1 or npos if s2 cannot be found.
      22        3255 : StringRef::size_type llvm::StrInStrNoCase(StringRef s1, StringRef s2) {
      23             :   size_t N = s2.size(), M = s1.size();
      24        3255 :   if (N > M)
      25             :     return StringRef::npos;
      26       29663 :   for (size_t i = 0, e = M - N + 1; i != e; ++i)
      27       53769 :     if (s1.substr(i, N).equals_lower(s2))
      28          23 :       return i;
      29             :   return StringRef::npos;
      30             : }
      31             : 
      32             : /// getToken - This function extracts one token from source, ignoring any
      33             : /// leading characters that appear in the Delimiters string, and ending the
      34             : /// token at any of the characters that appear in the Delimiters string.  If
      35             : /// there are no tokens in the source string, an empty string is returned.
      36             : /// The function returns a pair containing the extracted token and the
      37             : /// remaining tail string.
      38      876521 : std::pair<StringRef, StringRef> llvm::getToken(StringRef Source,
      39             :                                                StringRef Delimiters) {
      40             :   // Figure out where the token starts.
      41      876521 :   StringRef::size_type Start = Source.find_first_not_of(Delimiters);
      42             : 
      43             :   // Find the next occurrence of the delimiter.
      44      876521 :   StringRef::size_type End = Source.find_first_of(Delimiters, Start);
      45             : 
      46      876521 :   return std::make_pair(Source.slice(Start, End), Source.substr(End));
      47             : }
      48             : 
      49             : /// SplitString - Split up the specified string according to the specified
      50             : /// delimiters, appending the result fragments to the output list.
      51       54848 : void llvm::SplitString(StringRef Source,
      52             :                        SmallVectorImpl<StringRef> &OutFragments,
      53             :                        StringRef Delimiters) {
      54       54848 :   std::pair<StringRef, StringRef> S = getToken(Source, Delimiters);
      55      330993 :   while (!S.first.empty()) {
      56      276145 :     OutFragments.push_back(S.first);
      57      276145 :     S = getToken(S.second, Delimiters);
      58             :   }
      59       54848 : }
      60             : 
      61      456504 : void llvm::printEscapedString(StringRef Name, raw_ostream &Out) {
      62     8633777 :   for (unsigned i = 0, e = Name.size(); i != e; ++i) {
      63    16354546 :     unsigned char C = Name[i];
      64     8177273 :     if (isPrint(C) && C != '\\' && C != '"')
      65     8139023 :       Out << C;
      66             :     else
      67       38250 :       Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
      68             :   }
      69      456504 : }
      70             : 
      71        2809 : void llvm::printHTMLEscaped(StringRef String, raw_ostream &Out) {
      72       56598 :   for (char C : String) {
      73       53790 :     if (C == '&')
      74          37 :       Out << "&amp;";
      75       53753 :     else if (C == '<')
      76         459 :       Out << "&lt;";
      77       53294 :     else if (C == '>')
      78         481 :       Out << "&gt;";
      79       52813 :     else if (C == '\"')
      80          97 :       Out << "&quot;";
      81       52716 :     else if (C == '\'')
      82         311 :       Out << "&apos;";
      83             :     else
      84             :       Out << C;
      85             :   }
      86        2808 : }
      87             : 
      88      421930 : void llvm::printLowerCase(StringRef String, raw_ostream &Out) {
      89     1621809 :   for (const char C : String)
      90             :     Out << toLower(C);
      91      421930 : }

Generated by: LCOV version 1.13