LTP GCOV extension - code coverage report
Current view: directory - work/ustr - ustr-spn-code.h
Test: Ustr coverage
Date: 2008-02-26 Instrumented lines: 197
Code covered: 100.0 % Executed lines: 197

       1                 : /* Copyright (c) 2007 James Antill -- See LICENSE file for terms. */
       2                 : 
       3                 : #ifndef USTR_SPN_H
       4                 : #error " You should have already included ustr-spn.h, or just include ustr.h."
       5                 : #endif
       6                 : 
       7                 : #ifndef USTR_SRCH_H
       8                 : #error " You should have already included ustr-srch.h, or just include ustr.h."
       9                 : #endif
      10                 : 
      11                 : USTR_CONF_I_PROTO
      12                 : size_t ustr_spn_chr_fwd(const struct Ustr *s1, size_t off, char chr)
      13              52 : {
      14              52 :   const char *ptr = 0;
      15              52 :   size_t len = 0;
      16              52 :   size_t clen = 0;
      17                 : 
      18              29 :   USTR_ASSERT(ustr_assert_valid(s1));
      19                 : 
      20              39 :   ptr = ustr_cstr(s1);
      21              39 :   len = ustr_len(s1);
      22                 : 
      23              52 :   USTR_ASSERT_RET(off <= len, 0);
      24              52 :   ptr += off;
      25              52 :   len -= off;
      26                 : 
      27              52 :   clen = len;
      28          320158 :   while (len)
      29                 :   {
      30          320092 :     if (*ptr != chr)
      31              38 :       break;
      32                 : 
      33          320054 :     ++ptr;
      34          320054 :     --len;
      35                 :   }
      36                 : 
      37              52 :   return (clen - len);
      38                 : }
      39                 : 
      40                 : USTR_CONF_I_PROTO
      41                 : size_t ustr_spn_chr_rev(const struct Ustr *s1, size_t off, char chr)
      42              52 : {
      43              52 :   const char *ptr = 0;
      44              52 :   size_t len = 0;
      45              52 :   size_t clen = 0;
      46                 : 
      47              26 :   USTR_ASSERT(ustr_assert_valid(s1));
      48                 : 
      49              41 :   ptr = ustr_cstr(s1);
      50              41 :   len = ustr_len(s1);
      51                 : 
      52              52 :   USTR_ASSERT_RET(off <= len, 0);
      53              52 :   len -= off;
      54                 : 
      55              52 :   clen = len;
      56              52 :   ptr += len;
      57             378 :   while (len)
      58                 :   {
      59             326 :     --ptr;
      60                 :     
      61             326 :     if (*ptr != chr)
      62              52 :       break;
      63                 : 
      64             274 :     --len;
      65                 :   }
      66                 : 
      67              52 :   return (clen - len);
      68                 : }
      69                 : 
      70                 : USTR_CONF_I_PROTO size_t ustr_spn_chrs_fwd(const struct Ustr *s1, size_t off,
      71                 :                                            const char *chrs, size_t slen)
      72             516 : {
      73             516 :   const char *ptr = 0;
      74             516 :   size_t len = 0;
      75             516 :   size_t clen = 0;
      76                 :   
      77             345 :   USTR_ASSERT(chrs);
      78                 : 
      79             516 :   if (slen == 1)
      80              40 :     return (ustr_spn_chr_fwd(s1, off, *chrs));
      81                 : 
      82             322 :   USTR_ASSERT(ustr_assert_valid(s1));
      83                 : 
      84             319 :   ptr = ustr_cstr(s1);
      85             319 :   len = ustr_len(s1);
      86                 : 
      87             476 :   USTR_ASSERT_RET(off <= len, 0);
      88             476 :   ptr += off;
      89             476 :   len -= off;
      90                 : 
      91             476 :   clen = len;
      92            2778 :   while (len)
      93                 :   {
      94            2198 :     if (!memchr(chrs, *ptr, slen))
      95             372 :       break;
      96                 : 
      97            1826 :     ++ptr;
      98            1826 :     --len;
      99                 :   }
     100                 : 
     101             476 :   return (clen - len);
     102                 : }
     103                 : 
     104                 : USTR_CONF_I_PROTO size_t ustr_spn_chrs_rev(const struct Ustr *s1, size_t off,
     105                 :                                            const char *chrs, size_t slen)
     106             216 : {
     107             216 :   const char *ptr = 0;
     108             216 :   size_t len = 0;
     109             216 :   size_t clen = 0;
     110                 :   
     111             108 :   USTR_ASSERT(chrs);
     112                 : 
     113             216 :   if (slen == 1)
     114              40 :     return (ustr_spn_chr_rev(s1, off, *chrs));
     115                 : 
     116              88 :   USTR_ASSERT(ustr_assert_valid(s1));
     117                 : 
     118             136 :   ptr = ustr_cstr(s1);
     119             176 :   len = clen = ustr_len(s1);
     120                 : 
     121             176 :   USTR_ASSERT_RET(off <= len, 0);
     122             176 :   len -= off;
     123                 : 
     124             176 :   clen = len;
     125             176 :   ptr += len;
     126            1664 :   while (len)
     127                 :   {
     128            1472 :     --ptr;
     129                 :     
     130            1472 :     if (!memchr(chrs, *ptr, slen))
     131             160 :       break;
     132                 : 
     133            1312 :     --len;
     134                 :   }
     135                 : 
     136             176 :   return (clen - len);
     137                 : }
     138                 : 
     139                 : USTR_CONF_I_PROTO
     140                 : size_t ustr_cspn_chr_fwd(const struct Ustr *s1, size_t off, char chr)
     141             132 : {
     142             132 :   size_t f_pos = ustr_srch_chr_fwd(s1, off, chr);
     143                 : 
     144             132 :   if (!f_pos)
     145              58 :     return (ustr_len(s1) - off);
     146                 :     
     147              74 :   return (f_pos - off - 1);
     148                 : }
     149                 : 
     150                 : USTR_CONF_I_PROTO
     151                 : size_t ustr_cspn_chr_rev(const struct Ustr *s1, size_t off, char chr)
     152              96 : {
     153              96 :   size_t f_pos = ustr_srch_chr_rev(s1, off, chr);
     154                 : 
     155              96 :   if (!f_pos)
     156              62 :     return (ustr_len(s1) - off);
     157                 :     
     158              34 :   return ((ustr_len(s1) - f_pos) - off);
     159                 : }
     160                 : 
     161                 : USTR_CONF_I_PROTO size_t ustr_cspn_chrs_fwd(const struct Ustr *s1, size_t off,
     162                 :                                             const char *chrs, size_t slen)
     163             584 : {
     164             584 :   const char *ptr = 0;
     165             584 :   size_t len = 0;
     166             584 :   size_t clen = 0;
     167                 :   
     168             292 :   USTR_ASSERT(chrs);
     169                 : 
     170             584 :   if (slen == 1)
     171             108 :     return (ustr_cspn_chr_fwd(s1, off, *chrs));
     172                 : 
     173             238 :   USTR_ASSERT(ustr_assert_valid(s1));
     174                 : 
     175             364 :   ptr = ustr_cstr(s1);
     176             364 :   len = ustr_len(s1);
     177                 : 
     178             476 :   USTR_ASSERT_RET(off <= len, 0);
     179             476 :   ptr += off;
     180             476 :   len -= off;
     181                 : 
     182             476 :   clen = len;
     183            2632 :   while (len)
     184                 :   {
     185            2064 :     if (memchr(chrs, *ptr, slen))
     186             384 :       break;
     187                 : 
     188            1680 :     ++ptr;
     189            1680 :     --len;
     190                 :   }
     191                 : 
     192             476 :   return (clen - len);
     193                 : }
     194                 : 
     195                 : USTR_CONF_I_PROTO size_t ustr_cspn_chrs_rev(const struct Ustr *s1, size_t off,
     196                 :                                             const char *chrs, size_t slen)
     197             188 : {
     198             188 :   const char *ptr = 0;
     199             188 :   size_t len = 0;
     200             188 :   size_t clen = 0;
     201                 :   
     202              94 :   USTR_ASSERT(chrs);
     203                 : 
     204             188 :   if (slen == 1)
     205              84 :     return (ustr_cspn_chr_rev(s1, off, *chrs));
     206                 : 
     207              52 :   USTR_ASSERT(ustr_assert_valid(s1));
     208                 : 
     209              82 :   ptr = ustr_cstr(s1);
     210              82 :   len = ustr_len(s1);
     211                 : 
     212             104 :   USTR_ASSERT_RET(off <= len, 0);
     213             104 :   len -= off;
     214                 : 
     215             104 :   clen = len;
     216             104 :   ptr += len;
     217            1416 :   while (len)
     218                 :   {
     219            1260 :     --ptr;
     220                 :     
     221            1260 :     if (memchr(chrs, *ptr, slen))
     222              52 :       break;
     223                 : 
     224            1208 :     --len;
     225                 :   }
     226                 : 
     227             104 :   return (clen - len);
     228                 : }
     229                 : 
     230                 : #ifdef USTR_UTF8_H
     231                 : USTR_CONF_I_PROTO size_t ustr_utf8_spn_chrs_fwd(const struct Ustr*s1,size_t off,
     232                 :                                                 const char *pchrs, size_t slen)
     233              24 : {
     234              24 :   const unsigned char *chrs = (const unsigned char *)pchrs;
     235              24 :   const unsigned char *ptr = 0;
     236              24 :   size_t ret = 0;
     237                 :   
     238              12 :   USTR_ASSERT(chrs);
     239              12 :   USTR_ASSERT(ustr_assert_valid(s1));
     240                 : 
     241              24 :   ptr = (const unsigned char *)ustr_cstr(s1);
     242                 : 
     243              24 :   if (off)
     244              12 :     off = ustr_utf8_chars2bytes(s1, 1, off, 0);
     245              24 :   ptr += off;
     246                 : 
     247              96 :   while (*ptr)
     248                 :   {
     249              72 :     const unsigned char *bptr = ptr;
     250                 : 
     251              72 :     ptr = ustr__utf8_next(ptr);
     252              72 :     if (!ptr || !USTR__SYS_MEMMEM(chrs, slen, bptr, ptr - bptr))
     253                 :       break;
     254                 :     
     255              48 :     ++ret;
     256                 :   }
     257                 : 
     258              24 :   return (ret);
     259                 : }
     260                 : 
     261                 : USTR_CONF_I_PROTO size_t ustr_utf8_spn_chrs_rev(const struct Ustr*s1,size_t off,
     262                 :                                                 const char *pchrs, size_t slen)
     263              36 : {
     264              36 :   const unsigned char *chrs = (const unsigned char *)pchrs;
     265              36 :   const unsigned char *ptr = 0;
     266              36 :   size_t len = 0;
     267              36 :   size_t ret = 0;
     268                 :   
     269              18 :   USTR_ASSERT(chrs);
     270              18 :   USTR_ASSERT(ustr_assert_valid(s1));
     271                 : 
     272              36 :   ptr = (const unsigned char *)ustr_cstr(s1);
     273              27 :   len = ustr_len(s1);
     274                 : 
     275              36 :   if (off)
     276                 :   {
     277              12 :     size_t ulen = ustr_utf8_len(s1);
     278                 :     size_t dummy;
     279              12 :     off = ustr_utf8_chars2bytes(s1, ulen - off, off, &dummy);
     280                 :   }
     281              36 :   len -= off;
     282                 :   
     283             120 :   while (len)
     284                 :   {
     285              84 :     const unsigned char *eptr = ptr + len;
     286              84 :     const unsigned char *bptr = ustr__utf8_prev(eptr, len);
     287                 : 
     288              84 :     if (!bptr || !USTR__SYS_MEMMEM(chrs, slen, bptr, eptr - bptr))
     289                 :       break;
     290                 :     
     291              48 :     ++ret;
     292              48 :     len -= (eptr - bptr);
     293                 :   }
     294                 : 
     295              36 :   return (ret);
     296                 : }
     297                 : 
     298                 : USTR_CONF_I_PROTO
     299                 : size_t ustr_utf8_cspn_chrs_fwd(const struct Ustr *s1, size_t off,
     300                 :                                const char *pchrs, size_t slen)
     301              68 : {
     302              68 :   const unsigned char *chrs = (const unsigned char *)pchrs;
     303              68 :   const unsigned char *ptr = 0;
     304              68 :   size_t ret = 0;
     305                 :   
     306              34 :   USTR_ASSERT(chrs);
     307              34 :   USTR_ASSERT(ustr_assert_valid(s1));
     308                 : 
     309              68 :   ptr = (const unsigned char *)ustr_cstr(s1);
     310                 : 
     311              68 :   if (off)
     312              36 :     off = ustr_utf8_chars2bytes(s1, 1, off, 0);
     313              68 :   ptr += off;
     314                 : 
     315             656 :   while (*ptr)
     316                 :   {
     317             536 :     const unsigned char *bptr = ptr;
     318                 : 
     319             536 :     ptr = ustr__utf8_next(ptr);
     320             536 :     if (USTR__SYS_MEMMEM(chrs, slen, bptr, ptr - bptr))
     321              16 :       break;
     322                 :     
     323             520 :     ++ret;
     324                 :   }
     325                 : 
     326              68 :   return (ret);
     327                 : }
     328                 : 
     329                 : USTR_CONF_I_PROTO
     330                 : size_t ustr_utf8_cspn_chrs_rev(const struct Ustr *s1, size_t off,
     331                 :                                const char *pchrs, size_t slen)
     332              68 : {
     333              68 :   const unsigned char *chrs = (const unsigned char *)pchrs;
     334              68 :   const unsigned char *ptr = 0;
     335              68 :   size_t len = 0;
     336              68 :   size_t ret = 0;
     337                 :   
     338              34 :   USTR_ASSERT(chrs);
     339              34 :   USTR_ASSERT(ustr_assert_valid(s1));
     340                 : 
     341              68 :   ptr = (const unsigned char *)ustr_cstr(s1);
     342              51 :   len = ustr_len(s1);
     343                 : 
     344              68 :   if (off)
     345                 :   {
     346              36 :     size_t ulen = ustr_utf8_len(s1);
     347                 :     size_t dummy;
     348              36 :     off = ustr_utf8_chars2bytes(s1, ulen - off, off, &dummy);
     349                 :   }
     350              68 :   len -= off;
     351                 :     
     352             660 :   while (len)
     353                 :   {
     354             544 :     const unsigned char *eptr = ptr + len;
     355             544 :     const unsigned char *bptr = ustr__utf8_prev(eptr, len);
     356                 : 
     357             544 :     if (!bptr || USTR__SYS_MEMMEM(chrs, slen, bptr, eptr - bptr))
     358                 :       break;
     359                 :     
     360             524 :     ++ret;
     361             524 :     len -= (eptr - bptr);
     362                 :   }
     363                 : 
     364              68 :   return (ret);
     365                 : }
     366                 : #endif

Generated by: LTP GCOV extension version 1.4