LCOV - code coverage report
Current view: top level - lib/Support - StringExtras.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 37 37 100.0 %
Date: 2018-06-17 00:07:59 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        3727 : StringRef::size_type llvm::StrInStrNoCase(StringRef s1, StringRef s2) {
      23             :   size_t N = s2.size(), M = s1.size();
      24        3727 :   if (N > M)
      25             :     return StringRef::npos;
      26       34537 :   for (size_t i = 0, e = M - N + 1; i != e; ++i)
      27       62619 :     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      755709 : std::pair<StringRef, StringRef> llvm::getToken(StringRef Source,
      39             :                                                StringRef Delimiters) {
      40             :   // Figure out where the token starts.
      41      755709 :   StringRef::size_type Start = Source.find_first_not_of(Delimiters);
      42             : 
      43             :   // Find the next occurrence of the delimiter.
      44      755709 :   StringRef::size_type End = Source.find_first_of(Delimiters, Start);
      45             : 
      46      755709 :   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       33485 : void llvm::SplitString(StringRef Source,
      52             :                        SmallVectorImpl<StringRef> &OutFragments,
      53             :                        StringRef Delimiters) {
      54       33485 :   std::pair<StringRef, StringRef> S = getToken(Source, Delimiters);
      55      373291 :   while (!S.first.empty()) {
      56      169903 :     OutFragments.push_back(S.first);
      57      339806 :     S = getToken(S.second, Delimiters);
      58             :   }
      59       33485 : }
      60             : 
      61      423999 : void llvm::printEscapedString(StringRef Name, raw_ostream &Out) {
      62     7431134 :   for (unsigned i = 0, e = Name.size(); i != e; ++i) {
      63    14014270 :     unsigned char C = Name[i];
      64     7007135 :     if (isprint(C) && C != '\\' && C != '"')
      65             :       Out << C;
      66             :     else
      67       74858 :       Out << '\\' << hexdigit(C >> 4) << hexdigit(C & 0x0F);
      68             :   }
      69      423999 : }
      70             : 
      71        2819 : void llvm::printHTMLEscaped(StringRef String, raw_ostream &Out) {
      72      111577 :   for (char C : String) {
      73       54379 :     if (C == '&')
      74          39 :       Out << "&amp;";
      75       54340 :     else if (C == '<')
      76         459 :       Out << "&lt;";
      77       53881 :     else if (C == '>')
      78         485 :       Out << "&gt;";
      79       53396 :     else if (C == '\"')
      80         101 :       Out << "&quot;";
      81       53295 :     else if (C == '\'')
      82         311 :       Out << "&apos;";
      83             :     else
      84             :       Out << C;
      85             :   }
      86        2819 : }
      87             : 
      88      404159 : void llvm::printLowerCase(StringRef String, raw_ostream &Out) {
      89     2658889 :   for (const char C : String)
      90             :     Out << toLower(C);
      91      404159 : }

Generated by: LCOV version 1.13