. /src /grammar /ci_string.cpp
98.44% Lines (63/64) 100.00% Functions (4/4)
[ ] prev/next file n p prev/next uncovered line
TLA Baseline Branch
Line Hits Code Line Hits Code
1   // 1   //
2   // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com) 2   // Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
3   // 3   //
4   // Distributed under the Boost Software License, Version 1.0. (See accompanying 4   // Distributed under the Boost Software License, Version 1.0. (See accompanying
5   // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) 5   // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
6   // 6   //
7   // Official repository: https://github.com/boostorg/url 7   // Official repository: https://github.com/boostorg/url
8   // 8   //
9   9  
10   10  
11   #include <boost/url/detail/config.hpp> 11   #include <boost/url/detail/config.hpp>
12   #include <boost/url/grammar/ci_string.hpp> 12   #include <boost/url/grammar/ci_string.hpp>
13   13  
  14 + // FNV-1a (in ci_digest below) relies on modular multiplication
  15 + // of unsigned values, which Clang's -fsanitize=integer flags as
  16 + // overflow. Suppress the check for that function only. GCC has
  17 + // no equivalent sanitizer (it does not flag unsigned overflow),
  18 + // so the annotation is Clang-only — applying it on GCC produces
  19 + // "attribute directive ignored" under -Werror=attributes.
  20 + #if defined(__clang__) && defined(__has_attribute)
  21 + # if __has_attribute(no_sanitize)
  22 + # define BOOST_URL_NO_SANITIZE_INT_OVERFLOW \
  23 + __attribute__((no_sanitize("unsigned-integer-overflow")))
  24 + # endif
  25 + #endif
  26 + #ifndef BOOST_URL_NO_SANITIZE_INT_OVERFLOW
  27 + # define BOOST_URL_NO_SANITIZE_INT_OVERFLOW
  28 + #endif
  29 +
14   namespace boost { 30   namespace boost {
15   namespace urls { 31   namespace urls {
16   namespace grammar { 32   namespace grammar {
17   33  
18   namespace detail { 34   namespace detail {
19   35  
20   //------------------------------------------------ 36   //------------------------------------------------
21   37  
22   // https://lemire.me/blog/2020/04/30/for-case-insensitive-string-comparisons-avoid-char-by-char-functions/ 38   // https://lemire.me/blog/2020/04/30/for-case-insensitive-string-comparisons-avoid-char-by-char-functions/
23   // https://github.com/lemire/Code-used-on-Daniel-Lemire-s-blog/blob/master/2020/04/30/tolower.cpp 39   // https://github.com/lemire/Code-used-on-Daniel-Lemire-s-blog/blob/master/2020/04/30/tolower.cpp
24   40  
25   bool 41   bool
HITCBC 26   8 ci_is_equal( 42   8 ci_is_equal(
27   core::string_view s0, 43   core::string_view s0,
28   core::string_view s1) noexcept 44   core::string_view s1) noexcept
29   { 45   {
HITCBC 30   8 auto n = s0.size(); 46   8 auto n = s0.size();
HITCBC 31   8 auto p1 = s0.data(); 47   8 auto p1 = s0.data();
HITCBC 32   8 auto p2 = s1.data(); 48   8 auto p2 = s1.data();
33   char a, b; 49   char a, b;
34   // fast loop 50   // fast loop
HITCBC 35 - 13 while(n--) 51 + 13 while(n != 0)
36   { 52   {
HITGNC   53 + 10 --n;
HITCBC 37   10 a = *p1++; 54   10 a = *p1++;
HITCBC 38   10 b = *p2++; 55   10 b = *p2++;
HITCBC 39   10 if(a != b) 56   10 if(a != b)
HITCBC 40   5 goto slow; 57   5 goto slow;
41   } 58   }
HITCBC 42   3 return true; 59   3 return true;
43 - do 60 + for(;;)
44   { 61   {
HITCBC 45   8 a = *p1++; 62   8 a = *p1++;
HITCBC 46   8 b = *p2++; 63   8 b = *p2++;
HITCBC 47   13 slow: 64   13 slow:
HITCBC 48   26 if( to_lower(a) != 65   26 if( to_lower(a) !=
HITCBC 49   13 to_lower(b)) 66   13 to_lower(b))
MISUBC 50   ✗ return false; 67   ✗ return false;
HITGNC   68 + 13 if(n == 0)
HITGNC   69 + 5 break;
HITGNC   70 + 8 --n;
51 - while(n--);  
ECB 52   13 } 71   }
HITCBC 53   5 return true; 72   5 return true;
54   } 73   }
55   74  
56   //------------------------------------------------ 75   //------------------------------------------------
57   76  
58   bool 77   bool
HITCBC 59   5 ci_is_less( 78   5 ci_is_less(
60   core::string_view s0, 79   core::string_view s0,
61   core::string_view s1) noexcept 80   core::string_view s1) noexcept
62   { 81   {
HITCBC 63   5 auto p1 = s0.data(); 82   5 auto p1 = s0.data();
HITCBC 64   5 auto p2 = s1.data(); 83   5 auto p2 = s1.data();
HITCBC 65   5 auto n = s0.size() < s1.size() 84   5 auto n = s0.size() < s1.size()
HITCBC 66   5 ? s0.size() : s1.size(); 85   5 ? s0.size() : s1.size();
HITCBC 67 - 18 while(n--) 86 + 18 while(n != 0)
68   { 87   {
HITGNC   88 + 15 --n;
HITCBC 69   15 auto c1 = to_lower(*p1++); 89   15 auto c1 = to_lower(*p1++);
HITCBC 70   15 auto c2 = to_lower(*p2++); 90   15 auto c2 = to_lower(*p2++);
HITCBC 71   15 if(c1 != c2) 91   15 if(c1 != c2)
HITCBC 72   2 return c1 < c2; 92   2 return c1 < c2;
73   } 93   }
HITCBC 74   3 return s0.size() < s1.size(); 94   3 return s0.size() < s1.size();
75   } 95   }
76   96  
77   } // detail 97   } // detail
78   98  
79   //------------------------------------------------ 99   //------------------------------------------------
80   100  
81   int 101   int
HITCBC 82   21 ci_compare( 102   21 ci_compare(
83   core::string_view s0, 103   core::string_view s0,
84   core::string_view s1) noexcept 104   core::string_view s1) noexcept
85   { 105   {
86   int bias; 106   int bias;
87   std::size_t n; 107   std::size_t n;
HITCBC 88   42 if( s0.size() < 108   42 if( s0.size() <
HITCBC 89   21 s1.size()) 109   21 s1.size())
90   { 110   {
HITCBC 91   2 bias = -1; 111   2 bias = -1;
HITCBC 92   2 n = s0.size(); 112   2 n = s0.size();
93   } 113   }
94   else 114   else
95   { 115   {
HITCBC 96   38 if( s0.size() > 116   38 if( s0.size() >
HITCBC 97   19 s1.size()) 117   19 s1.size())
HITCBC 98   2 bias = 1; 118   2 bias = 1;
99   else 119   else
HITCBC 100   17 bias = 0; 120   17 bias = 0;
HITCBC 101   19 n = s1.size(); 121   19 n = s1.size();
102   } 122   }
HITCBC 103   21 auto it0 = s0.data(); 123   21 auto it0 = s0.data();
HITCBC 104   21 auto it1 = s1.data(); 124   21 auto it1 = s1.data();
HITCBC 105 - 38 while(n--) 125 + 38 while(n != 0)
106   { 126   {
HITGNC   127 + 29 --n;
107   auto c0 = 128   auto c0 =
HITCBC 108   29 to_lower(*it0++); 129   29 to_lower(*it0++);
109   auto c1 = 130   auto c1 =
HITCBC 110   29 to_lower(*it1++); 131   29 to_lower(*it1++);
HITCBC 111   29 if(c0 == c1) 132   29 if(c0 == c1)
HITCBC 112   17 continue; 133   17 continue;
HITCBC 113   12 if(c0 < c1) 134   12 if(c0 < c1)
HITCBC 114   8 return -1; 135   8 return -1;
HITCBC 115   4 return 1; 136   4 return 1;
116   } 137   }
HITCBC 117   9 return bias; 138   9 return bias;
118   } 139   }
119   140  
120   //------------------------------------------------ 141   //------------------------------------------------
121   142  
  143 + BOOST_URL_NO_SANITIZE_INT_OVERFLOW
122   std::size_t 144   std::size_t
HITCBC 123   18 ci_digest( 145   18 ci_digest(
124   core::string_view s) noexcept 146   core::string_view s) noexcept
125   { 147   {
126   // Only 4 and 8 byte sizes are supported 148   // Only 4 and 8 byte sizes are supported
127   static_assert( 149   static_assert(
128   sizeof(std::size_t) == 4 || 150   sizeof(std::size_t) == 4 ||
129   sizeof(std::size_t) == 8, ""); 151   sizeof(std::size_t) == 8, "");
HITCBC 130   18 constexpr std::size_t prime = ( 152   18 constexpr std::size_t prime = (
131   sizeof(std::size_t) == 8) ? 153   sizeof(std::size_t) == 8) ?
132   0x100000001B3ULL : 154   0x100000001B3ULL :
133   0x01000193UL; 155   0x01000193UL;
HITCBC 134   18 constexpr std::size_t hash0 = ( 156   18 constexpr std::size_t hash0 = (
135   sizeof(std::size_t) == 8) ? 157   sizeof(std::size_t) == 8) ?
136   0xcbf29ce484222325ULL : 158   0xcbf29ce484222325ULL :
137   0x811C9DC5UL; 159   0x811C9DC5UL;
HITCBC 138   18 auto hash = hash0; 160   18 auto hash = hash0;
HITCBC 139   18 auto p = s.data(); 161   18 auto p = s.data();
HITCBC 140   18 auto n = s.size(); 162   18 auto n = s.size();
HITCBC 141 - 56 for(;n--;++p) 163 + 56 for(; n != 0; --n, ++p)
142   { 164   {
143   // VFALCO NOTE Consider using a lossy 165   // VFALCO NOTE Consider using a lossy
144   // to_lower which works 4 or 8 chars at a time. 166   // to_lower which works 4 or 8 chars at a time.
HITCBC 145   38 hash = (to_lower(*p) ^ hash) * prime; 167   38 hash = (to_lower(*p) ^ hash) * prime;
146   } 168   }
HITCBC 147   18 return hash; 169   18 return hash;
148   } 170   }
149   171  
150   } // grammar 172   } // grammar
151   } // urls 173   } // urls
152   } // boost 174   } // boost
153   175