LTP GCOV extension - code coverage report
Current view: directory - include - vstr-inline.h
Test: Vstr coverage
Date: 2005-01-10 Instrumented lines: 528
Code covered: 100.0 % Executed lines: 528

       1                 : #ifndef VSTR__HEADER_H
       2                 : # error " You must _just_ #include <vstr.h>"
       3                 : #endif
       4                 : /*
       5                 :  *  Copyright (C) 2002, 2003, 2004  James Antill
       6                 :  *
       7                 :  *  This library is free software; you can redistribute it and/or
       8                 :  *  modify it under the terms of the GNU Lesser General Public
       9                 :  *  License as published by the Free Software Foundation; either
      10                 :  *  version 2 of the License, or (at your option) any later version.
      11                 :  *
      12                 :  *  This library is distributed in the hope that it will be useful,
      13                 :  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
      14                 :  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15                 :  *  Lesser General Public License for more details.
      16                 :  *
      17                 :  *  You should have received a copy of the GNU Lesser General Public
      18                 :  *  License along with this library; if not, write to the Free Software
      19                 :  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
      20                 :  *
      21                 :  *  email: james@and.org
      22                 :  */
      23                 : /* exported functions which are inlined */
      24                 : /* NOTE: this implementation can change when the ABI changes ... DO NOT use
      25                 :  * undocumented knowledge from here */
      26                 : 
      27                 : #ifndef VSTR__ASSERT
      28                 : #  define VSTR__ASSERT(x) /* do nothing */
      29                 : #endif
      30                 : 
      31                 : #ifndef VSTR__ASSERT_RET
      32                 : #  define VSTR__ASSERT_RET(x, y)   do { if (x) {} else return (y); } while (0)
      33                 : #endif
      34                 : 
      35                 : #ifndef VSTR__ASSERT_RET_VOID
      36                 : #  define VSTR__ASSERT_RET_VOID(x) do { if (x) {} else return;     } while (0)
      37                 : #endif
      38                 : 
      39                 : #ifndef VSTR__ASSERT_NO_SWITCH_DEF
      40                 : #  define VSTR__ASSERT_NO_SWITCH_DEF() break; default: break
      41                 : #endif
      42                 : 
      43                 : /* cast so it warns for ptrs */
      44                 : #undef  VSTR__TRUE
      45                 : #define VSTR__TRUE  ((int)1)
      46                 : #undef  VSTR__FALSE
      47                 : #define VSTR__FALSE ((int)0)
      48                 : 
      49                 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMCPY
      50                 : extern inline void *vstr_wrap_memcpy(void *passed_s1, const void *passed_s2,
      51                 :                                      size_t n)
      52         2704329 : {
      53         2704329 :   unsigned char *s1 = passed_s1;
      54         2704329 :   const unsigned char *s2 = passed_s2;
      55                 : 
      56         2704329 :   if ((n > 7) || VSTR__AT_COMPILE_CONST_P(n))
      57          381497 :     memcpy(passed_s1, passed_s2, n);
      58         2322832 :   else switch (n)
      59                 :   {
      60           85280 :     case 7:  s1[6] = s2[6];
      61          228377 :     case 6:  s1[5] = s2[5];
      62          379719 :     case 5:  s1[4] = s2[4];
      63          518067 :     case 4:  s1[3] = s2[3];
      64          683013 :     case 3:  s1[2] = s2[2];
      65         1166798 :     case 2:  s1[1] = s2[1];
      66         2321428 :     case 1:  s1[0] = s2[0];
      67                 :     case 0:
      68                 :       break;
      69                 :   }
      70                 : 
      71         2704329 :   return (passed_s1);
      72                 : }
      73                 : #else
      74                 : # define vstr_wrap_memcpy(x, y, z)  memcpy(x, y, z)
      75                 : #endif
      76                 : 
      77                 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMCMP
      78                 : extern inline int vstr_wrap_memcmp(const void *passed_s1,
      79                 :                                    const void *passed_s2, size_t n)
      80       239870478 : {
      81       239870478 :   const unsigned char *s1 = passed_s1;
      82       239870478 :   const unsigned char *s2 = passed_s2;
      83       239870478 :   int ret = 0;
      84       239870478 :   int tmp = 0;
      85                 : 
      86       239870478 :   if ((n > 7) || VSTR__AT_COMPILE_CONST_P(n))
      87       150366297 :     ret = memcmp(passed_s1, passed_s2, n);
      88        89504181 :   else switch (n)
      89                 :   {
      90        34180288 :     case 7:  tmp = s1[6] - s2[6]; if (tmp) ret = tmp;
      91        59398824 :     case 6:  tmp = s1[5] - s2[5]; if (tmp) ret = tmp;
      92        66495875 :     case 5:  tmp = s1[4] - s2[4]; if (tmp) ret = tmp;
      93        75179887 :     case 4:  tmp = s1[3] - s2[3]; if (tmp) ret = tmp;
      94        81019943 :     case 3:  tmp = s1[2] - s2[2]; if (tmp) ret = tmp;
      95        87426540 :     case 2:  tmp = s1[1] - s2[1]; if (tmp) ret = tmp;
      96        89504181 :     case 1:  tmp = s1[0] - s2[0]; if (tmp) ret = tmp;
      97                 :     case 0:
      98                 :       break;
      99                 :   }
     100                 : 
     101       239870478 :   return (ret);
     102                 : }
     103                 : #else
     104                 : # define vstr_wrap_memcmp(x, y, z)  memcmp(x, y, z)
     105                 : #endif
     106                 : 
     107                 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMCHR
     108                 : extern inline void *vstr_wrap_memchr(const void *passed_s1, int c, size_t n)
     109         8268273 : {
     110         8268273 :   const unsigned char *s1 = passed_s1;
     111         8268273 :   const void *ret = 0;
     112         8268273 :   int tmp = 0;
     113                 : 
     114         8268273 :   switch (n)
     115                 :   {
     116           41597 :     case 7:  tmp = s1[6] == c; if (tmp) ret = s1 + 6;
     117           60603 :     case 6:  tmp = s1[5] == c; if (tmp) ret = s1 + 5;
     118           65086 :     case 5:  tmp = s1[4] == c; if (tmp) ret = s1 + 4;
     119           79122 :     case 4:  tmp = s1[3] == c; if (tmp) ret = s1 + 3;
     120          452003 :     case 3:  tmp = s1[2] == c; if (tmp) ret = s1 + 2;
     121         1306533 :     case 2:  tmp = s1[1] == c; if (tmp) ret = s1 + 1;
     122         1375050 :     case 1:  tmp = s1[0] == c; if (tmp) ret = s1 + 0;
     123          160657 :       break;
     124         6893223 :     default: ret = memchr(s1, c, n);
     125         8268273 :       break;
     126                 :   }
     127                 : 
     128         8268273 :   return ((void *)ret);
     129                 : }
     130                 : #else
     131                 : # define vstr_wrap_memchr(x, y, z)  memchr(x, y, z)
     132                 : #endif
     133                 : 
     134                 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMSET
     135                 : extern inline void *vstr_wrap_memset(void *passed_s1, int c, size_t n)
     136          528176 : {
     137          528176 :   unsigned char *s1 = passed_s1;
     138                 : 
     139          528176 :   if ((n > 7) || VSTR__AT_COMPILE_CONST_P(n))
     140           54014 :     memset(passed_s1, c, n);
     141          528176 :   switch (n)
     142                 :   {
     143            3390 :     case 7:  s1[6] = c;
     144           12192 :     case 6:  s1[5] = c;
     145           16228 :     case 5:  s1[4] = c;
     146          267033 :     case 4:  s1[3] = c;
     147          292146 :     case 3:  s1[2] = c;
     148          328868 :     case 2:  s1[1] = c;
     149          474142 :     case 1:  s1[0] = c;
     150                 :     case 0:
     151                 :       break;
     152                 :   }
     153                 : 
     154          528176 :   return (passed_s1);
     155                 : }
     156                 : #else
     157                 : # define vstr_wrap_memset(x, y, z)  memset(x, y, z)
     158                 : #endif
     159                 : 
     160                 : #ifdef VSTR_AUTOCONF_USE_WRAP_MEMMOVE
     161                 : extern inline void *vstr_wrap_memmove(void *s1, const void *s2, size_t n)
     162           14728 : {
     163           14728 :   if (n < 8)
     164                 :   {
     165            8087 :     unsigned char tmp[8];
     166            8087 :     vstr_wrap_memcpy(tmp,  s2, n);
     167            8087 :     vstr_wrap_memcpy(s1, tmp, n);
     168            8087 :     return (s1);
     169                 :   }
     170                 : 
     171            6641 :   return memmove(s1, s2, n);
     172                 : }
     173                 : #else
     174                 : # define vstr_wrap_memmove(x, y, z) memmove(x, y, z)
     175                 : #endif
     176                 : 
     177                 : /* needed at the top so vstr_del() etc. can use it */
     178                 : extern inline void vstr_ref_del(struct Vstr_ref *tmp)
     179          237718 : {
     180          237718 :   if (!tmp)
     181           12693 :     return; /* std. free semantics */
     182                 : 
     183          225025 :   if (!--tmp->ref)
     184           50757 :     (*tmp->func)(tmp);
     185                 : }
     186                 : 
     187                 : extern inline struct Vstr_ref *vstr_ref_add(struct Vstr_ref *tmp)
     188          176372 : {
     189          176372 :   ++tmp->ref;
     190                 : 
     191          176372 :   return (tmp);
     192                 : }
     193                 : 
     194                 : extern inline void *vstr_cache_get(const struct Vstr_base *base,
     195                 :                                    unsigned int pos)
     196        19275068 : {
     197        19275068 :   if (!pos)
     198               5 :     return (NULL);
     199                 : 
     200        19275063 :   if (!base->cache_available)
     201           55697 :     return (NULL);
     202                 : 
     203         8848077 :   VSTR__ASSERT(VSTR__CACHE(base));
     204                 :   
     205        19219366 :   --pos;
     206                 : 
     207        19219366 :   if (pos >= VSTR__CACHE(base)->sz)
     208         5105584 :     return (NULL);
     209                 : 
     210        14113782 :   return (VSTR__CACHE(base)->data[pos]);
     211                 : }
     212                 : 
     213                 : extern inline void *vstr_data_get(struct Vstr_conf *conf,
     214                 :                                   unsigned int pos)
     215             263 : {
     216             263 :   struct Vstr_ref *data = NULL;
     217                 :   
     218             263 :   if (!conf)
     219              64 :     return (vstr_extern_inline_data_get(pos));
     220                 :   
     221             199 :   VSTR__ASSERT_RET(pos && (pos <= conf->data_usr_len), NULL);
     222                 : 
     223             195 :   if (!(data = conf->data_usr_ents[pos - 1].data))
     224              70 :     return (NULL);
     225                 :   
     226             125 :   return (data->ptr);
     227                 : }
     228                 : 
     229                 : extern inline void vstr_data_set(struct Vstr_conf *conf,
     230                 :                                  unsigned int pos,  struct Vstr_ref *ref)
     231              65 : {
     232              65 :   if (!conf)
     233                 :   {
     234              20 :     vstr_extern_inline_data_set(pos, ref);
     235              20 :     return;
     236                 :   }
     237                 :   
     238              45 :   VSTR__ASSERT_RET_VOID(pos && (pos <= conf->data_usr_len));
     239                 : 
     240              45 :   vstr_ref_del(conf->data_usr_ents[pos - 1].data);
     241              45 :   conf->data_usr_ents[pos - 1].data = ref ? vstr_ref_add(ref) : NULL;
     242                 : }
     243                 : 
     244                 : extern inline
     245                 : int vstr_cache__pos(const struct Vstr_base *base,
     246                 :                     struct Vstr_node *node, size_t pos, unsigned int num)
     247         1125337 : {
     248         1125337 :   struct Vstr__cache_data_pos *data = NULL;
     249                 : 
     250         1125337 :   if (!base->cache_available)
     251            4145 :     return (VSTR__FALSE);
     252                 : 
     253         1121192 :   data = vstr_cache_get(base, 1);
     254          233371 :   VSTR__ASSERT(data);
     255                 : 
     256         1121192 :   data->node = node;
     257         1121192 :   data->pos = pos;
     258         1121192 :   data->num = num;
     259                 : 
     260         1121192 :   return (VSTR__TRUE);
     261                 : }
     262                 : 
     263                 : extern inline size_t vstr_sc_posdiff(size_t beg_pos, size_t end_pos)
     264          219686 : {
     265          219686 :   return ((end_pos - beg_pos) + 1);
     266                 : }
     267                 : 
     268                 : extern inline size_t vstr_sc_poslast(size_t beg_pos, size_t diff_pos)
     269       238335235 : {
     270       238335235 :   return (beg_pos + (diff_pos - 1));
     271                 : }
     272                 : 
     273                 : extern inline
     274                 : struct Vstr_node *vstr_base__pos(const struct Vstr_base *base,
     275                 :                                  size_t *pos, unsigned int *num, int cache)
     276       240572606 : {
     277       240572606 :   size_t orig_pos = *pos;
     278       240572606 :   struct Vstr_node *scan = base->beg;
     279       240572606 :   struct Vstr__cache_data_pos *data = NULL;
     280       240572606 :   unsigned int dummy_num = 0;
     281                 : 
     282       240572606 :   if (!num) num = &dummy_num;
     283                 : 
     284       240572606 :   *pos += base->used;
     285       240572606 :   *num = 1;
     286                 : 
     287       240572606 :   if (*pos <= base->beg->len)
     288       237042897 :     return (base->beg);
     289                 : 
     290                 :   /* must be more than one node */
     291                 : 
     292         3529709 :   if (orig_pos > (base->len - base->end->len))
     293                 :   {
     294         2375586 :     *pos = orig_pos - (base->len - base->end->len);
     295         2375586 :     *num = base->num;
     296         2375586 :     return (base->end);
     297                 :   }
     298                 : 
     299         1154123 :   if ((data = vstr_cache_get(base, 1)) && data->node && (data->pos <= orig_pos))
     300                 :   {
     301         1014651 :     scan = data->node;
     302         1014651 :     *num = data->num;
     303         1014651 :     *pos = (orig_pos - data->pos) + 1;
     304                 :   }
     305                 : 
     306         3340351 :   while (*pos > scan->len)
     307                 :   {
     308         2186228 :     *pos -= scan->len;
     309                 : 
     310          616895 :     VSTR__ASSERT(scan->next);
     311         2186228 :     scan = scan->next;
     312         2186228 :     ++*num;
     313                 :   }
     314                 : 
     315         1154123 :   if (cache)
     316         1125337 :     vstr_cache__pos(base, scan, (orig_pos - *pos) + 1, *num);
     317                 : 
     318         1154123 :   return (scan);
     319                 : }
     320                 : 
     321                 : extern inline char *vstr_export__node_ptr(const struct Vstr_node *node)
     322       580558605 : {
     323       580558605 :   switch (node->type)
     324                 :   {
     325                 :     case VSTR_TYPE_NODE_BUF:
     326        92147402 :       return (((struct Vstr_node_buf *)node)->buf);
     327                 :     case VSTR_TYPE_NODE_PTR:
     328       155718834 :       return (((const struct Vstr_node_ptr *)node)->ptr);
     329                 :     case VSTR_TYPE_NODE_REF:
     330       332690835 :       return (((char *)((const struct Vstr_node_ref *)node)->ref->ptr) +
     331                 :               ((const struct Vstr_node_ref *)node)->off);
     332                 :     case VSTR_TYPE_NODE_NON:
     333             244 :       VSTR__ASSERT_NO_SWITCH_DEF();
     334                 :   }
     335                 : 
     336            1534 :   return (NULL);
     337                 : }
     338                 : 
     339                 : extern inline char vstr_export_chr(const struct Vstr_base *base, size_t pos)
     340          861836 : {
     341          861836 :   struct Vstr_node *node = NULL;
     342          861836 :   const char *tmp = NULL;
     343                 :   
     344          861836 :   node = vstr_base__pos(base, &pos, NULL, VSTR__TRUE);
     345          209923 :   VSTR__ASSERT(pos);
     346                 :   
     347                 :   /* errors, requests for data from NON nodes and real data are all == 0 */
     348          861836 :   if (!node) return (0);
     349                 : 
     350          861836 :   if (!(tmp = vstr_export__node_ptr(node)))
     351              80 :     return (0);
     352                 :   
     353          861756 :   return (*(tmp + --pos));
     354                 : }
     355                 : 
     356                 : extern inline size_t vstr_iter_len(struct Vstr_iter *iter)
     357        11409517 : {
     358        11409517 :   return (iter->len + iter->remaining);
     359                 : }
     360                 : extern inline size_t vstr_iter_pos(struct Vstr_iter *iter,
     361                 :                                    size_t pos, size_t len)
     362          357787 : {
     363          357787 :   VSTR__ASSERT_RET((len >= (iter->len + iter->remaining)), 0);
     364                 :     
     365          357787 :   return (pos + (len - vstr_iter_len(iter)));
     366                 : }
     367                 : 
     368                 : extern inline int vstr_iter_fwd_beg(const struct Vstr_base *base,
     369                 :                                     size_t pos, size_t len,
     370                 :                                     struct Vstr_iter *iter)
     371       237299329 : {
     372       237299329 :   VSTR__ASSERT_RET(base && iter, 0);
     373                 : 
     374       237299325 :   iter->node = NULL;
     375                 : 
     376       237299325 :   VSTR__ASSERT_RET(pos && (((pos <= base->len) &&
     377                 :                             (vstr_sc_poslast(pos, len) <= base->len)) || !len),
     378                 :                    VSTR__FALSE);
     379                 : 
     380       237299205 :   if (!len)
     381           20304 :     return (VSTR__FALSE);
     382                 :   
     383       237278901 :   iter->node = vstr_base__pos(base, &pos, &iter->num, VSTR__TRUE);
     384       237278901 :   --pos;
     385                 : 
     386       237278901 :   iter->len = iter->node->len - pos;
     387       237278901 :   if (iter->len > len)
     388       219183462 :     iter->len = len;
     389       237278901 :   len -= iter->len;
     390                 : 
     391       237278901 :   iter->remaining = len;
     392                 : 
     393       237278901 :   iter->ptr = NULL;
     394       237278901 :   if (iter->node->type != VSTR_TYPE_NODE_NON)
     395       237263614 :     iter->ptr = vstr_export__node_ptr(iter->node) + pos;
     396                 : 
     397       237278901 :   return (VSTR__TRUE);
     398                 : }
     399                 : 
     400                 : extern inline int vstr_iter_fwd_nxt(struct Vstr_iter *iter)
     401         7131730 : {
     402         7131730 :   if (!iter->remaining)
     403                 :   {
     404          274489 :     iter->len  = 0;
     405          274489 :     iter->node = NULL;
     406          274489 :     return (VSTR__FALSE);
     407                 :   }
     408                 : 
     409         6857241 :   iter->node = iter->node->next;
     410         6857241 :   ++iter->num;
     411                 : 
     412         6857241 :   iter->len = iter->node->len;
     413                 : 
     414         2431339 :   VSTR__ASSERT(iter->len);
     415                 : 
     416         6857241 :   if (iter->len > iter->remaining)
     417          668692 :     iter->len = iter->remaining;
     418         6857241 :   iter->remaining -= iter->len;
     419                 : 
     420         6857241 :   iter->ptr = NULL;
     421         6857241 :   if (iter->node->type != VSTR_TYPE_NODE_NON)
     422         6689988 :     iter->ptr = vstr_export__node_ptr(iter->node);
     423                 : 
     424         6857241 :   return (VSTR__TRUE);
     425                 : }
     426                 : 
     427                 : extern inline char vstr_iter_fwd_chr(struct Vstr_iter *iter, unsigned int *ern)
     428          587284 : {
     429          587284 :   unsigned int dummy_ern;
     430                 :   
     431          587284 :   if (!ern)
     432          404404 :     ern = &dummy_ern;
     433                 : 
     434          587284 :   if (!iter->len && !vstr_iter_fwd_nxt(iter))
     435                 :   {
     436            5325 :     *ern = VSTR_TYPE_ITER_END;
     437            5325 :     return (0);
     438                 :   }
     439                 :   
     440          118282 :   VSTR__ASSERT(iter->len);
     441          581959 :   --iter->len;
     442                 :   
     443          118282 :   VSTR__ASSERT(iter->node);
     444          581959 :   if (iter->node->type == VSTR_TYPE_NODE_NON)
     445                 :   {
     446            6435 :     *ern = VSTR_TYPE_ITER_NON;
     447            6435 :     return (0);
     448                 :   }
     449                 :   
     450          575524 :   *ern = VSTR_TYPE_ITER_DEF;
     451          575524 :   return (*iter->ptr++);
     452                 : }
     453                 : 
     454                 : extern inline size_t vstr_iter_fwd_buf(struct Vstr_iter *iter, size_t len,
     455                 :                                        void *passed_buf, size_t buf_len,
     456                 :                                        unsigned int *ern)
     457              35 : {
     458              35 :   size_t orig_len = len;
     459              35 :   char *buf = passed_buf;
     460              35 :   unsigned int dummy_ern;
     461                 :   
     462               7 :   VSTR__ASSERT(buf || !buf_len);
     463                 : 
     464              35 :   if (!ern)
     465              15 :     ern = &dummy_ern;
     466                 : 
     467              35 :   if (!iter->len && !vstr_iter_fwd_nxt(iter))
     468                 :   {
     469               5 :     *ern = VSTR_TYPE_ITER_END;
     470               5 :     return (0);
     471                 :   }
     472                 : 
     473              30 :   *ern = VSTR_TYPE_ITER_DEF;
     474             130 :   while ((iter->len || vstr_iter_fwd_nxt(iter)) && len)
     475                 :   {
     476             100 :     size_t tmp = len;
     477             100 :     size_t tmp_buf_len = 0;
     478                 :     
     479              20 :     VSTR__ASSERT(iter->len);
     480              20 :     VSTR__ASSERT(iter->node);
     481                 : 
     482             100 :     if (tmp > iter->len)
     483              85 :       tmp = iter->len;
     484                 :     
     485             100 :     tmp_buf_len = tmp;
     486             100 :     if (tmp_buf_len > buf_len)
     487              50 :       tmp_buf_len = buf_len;
     488                 :     
     489             100 :     len       -= tmp;
     490             100 :     iter->len -= tmp;
     491                 :     
     492             100 :     if (tmp_buf_len && (iter->node->type != VSTR_TYPE_NODE_NON))
     493              50 :       vstr_wrap_memcpy(buf, iter->ptr, tmp_buf_len);
     494             100 :     if (tmp_buf_len)
     495                 :     {
     496              55 :       buf       += tmp_buf_len;
     497              55 :       buf_len   -= tmp_buf_len;
     498                 :     }
     499             100 :     if (iter->node->type != VSTR_TYPE_NODE_NON)
     500              85 :       iter->ptr += tmp;
     501                 :   }
     502                 : 
     503              30 :   return (orig_len - len);
     504                 : }
     505                 : 
     506                 : extern inline size_t vstr_iter_fwd_cstr(struct Vstr_iter *iter, size_t len,
     507                 :                                         char *buf, size_t buf_len,
     508                 :                                         unsigned int *ern)
     509              14 : {
     510              14 :   size_t ret = 0;
     511                 :   
     512               2 :   VSTR__ASSERT(buf);
     513                 : 
     514              14 :   if (!buf_len)
     515               4 :     return (0);
     516                 :   
     517              10 :   --buf_len;
     518              10 :   buf[buf_len] = 0;
     519              10 :   ret = vstr_iter_fwd_buf(iter, len, buf, buf_len, ern);
     520              10 :   if (ret < buf_len)
     521               5 :     buf[ret] = 0;
     522                 :   
     523              10 :   return (ret);
     524                 : }
     525                 : 
     526                 : extern inline unsigned int vstr_num(const struct Vstr_base *base,
     527                 :                                     size_t pos, size_t len)
     528             313 : {
     529             313 :   struct Vstr_iter dummy_iter;
     530             313 :   struct Vstr_iter *iter = &dummy_iter;
     531             313 :   unsigned int beg_num = 0;
     532                 : 
     533             313 :   VSTR__ASSERT_RET(base, VSTR__FALSE);
     534                 :   
     535             313 :   if (pos == 1 && len == base->len)
     536             288 :     return (base->num);
     537                 : 
     538              25 :   if (!vstr_iter_fwd_beg(base, pos, len, iter))
     539              10 :     return (0);
     540                 : 
     541              15 :   beg_num = iter->num;
     542              20 :   while (vstr_iter_fwd_nxt(iter))
     543                 :   { /* do nothing */; }
     544                 : 
     545              15 :   return ((iter->num - beg_num) + 1);
     546                 : }
     547                 : 
     548                 : extern inline int vstr_add_buf(struct Vstr_base *base, size_t pos,
     549                 :                                const void *buffer, size_t len)
     550         2383693 : {
     551         2383693 :   VSTR__ASSERT_RET(!(!base || !buffer || (pos > base->len)), VSTR__FALSE);
     552                 : 
     553         2383685 :   if (!len) return (VSTR__TRUE);
     554                 : 
     555         2349826 :   if (base->len && (pos == base->len) &&
     556                 :       (base->end->type == VSTR_TYPE_NODE_BUF) &&
     557                 :       (len <= (base->conf->buf_sz - base->end->len)) &&
     558                 :       (!base->cache_available || base->cache_internal))
     559                 :   {
     560         2040123 :     struct Vstr_node *scan = base->end;
     561                 : 
     562          524832 :     VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
     563          524832 :     VSTR__ASSERT(vstr__check_real_nodes(base));
     564                 : 
     565         2040123 :     vstr_wrap_memcpy(((struct Vstr_node_buf *)scan)->buf + scan->len,
     566                 :                      buffer, len);
     567         2040123 :     scan->len += len;
     568         2040123 :     base->len += len;
     569                 : 
     570         2040123 :     if (base->iovec_upto_date)
     571                 :     {
     572          869382 :       unsigned int num = base->num + VSTR__CACHE(base)->vec->off - 1;
     573          869382 :       VSTR__CACHE(base)->vec->v[num].iov_len += len;
     574                 :     }
     575                 : 
     576          524832 :     VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
     577          524832 :     VSTR__ASSERT(vstr__check_real_nodes(base));
     578                 : 
     579         2040123 :     return (VSTR__TRUE);
     580                 :   }
     581                 : 
     582          309703 :   return (vstr_extern_inline_add_buf(base, pos, buffer, len));
     583                 : }
     584                 : 
     585                 : extern inline int vstr_add_rep_chr(struct Vstr_base *base, size_t pos,
     586                 :                                    char chr, size_t len)
     587          263383 : { /* almost embarassingly similar to add_buf */
     588          263383 :   VSTR__ASSERT_RET(!(!base || (pos > base->len)), VSTR__FALSE);
     589                 : 
     590          263379 :   if (!len) return (VSTR__TRUE);
     591                 : 
     592          261803 :   if (base->len && (pos == base->len) &&
     593                 :       (base->end->type == VSTR_TYPE_NODE_BUF) &&
     594                 :       (len <= (base->conf->buf_sz - base->end->len)) &&
     595                 :       (!base->cache_available || base->cache_internal))
     596                 :   {
     597          159433 :     struct Vstr_node *scan = base->end;
     598                 : 
     599           43206 :     VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
     600           43206 :     VSTR__ASSERT(vstr__check_real_nodes(base));
     601                 : 
     602          159433 :     vstr_wrap_memset(((struct Vstr_node_buf *)scan)->buf + scan->len, chr, len);
     603          159433 :     scan->len += len;
     604          159433 :     base->len += len;
     605                 : 
     606          159433 :     if (base->iovec_upto_date)
     607                 :     {
     608           32682 :       unsigned int num = base->num + VSTR__CACHE(base)->vec->off - 1;
     609           32682 :       VSTR__CACHE(base)->vec->v[num].iov_len += len;
     610                 :     }
     611                 : 
     612           43206 :     VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
     613           43206 :     VSTR__ASSERT(vstr__check_real_nodes(base));
     614                 : 
     615          159433 :     return (VSTR__TRUE);
     616                 :   }
     617                 : 
     618          102370 :   return (vstr_extern_inline_add_rep_chr(base, pos, chr, len));
     619                 : }
     620                 : 
     621                 : extern inline int vstr_del(struct Vstr_base *base, size_t pos, size_t len)
     622         5923189 : {
     623         5923189 :   VSTR__ASSERT_RET(!(!base || ((pos > base->len) && len)), VSTR__FALSE);
     624                 : 
     625         5923181 :   if (!len) return (VSTR__TRUE);
     626                 : 
     627         5409977 :   if (!base->cache_available || base->cache_internal)
     628                 :   {
     629         5408487 :     size_t end_len = 0;
     630                 : 
     631         5408487 :     if ((pos == 1) && ((len + base->used) < base->beg->len))
     632                 :     { /* delete from beginning, in one node */
     633         5064055 :       struct Vstr_node *scan = base->beg;
     634         5064055 :       struct Vstr__cache_data_cstr *cdata = NULL;
     635         5064055 :       struct Vstr__cache_data_pos  *pdata = NULL;
     636                 : 
     637         1147304 :       VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
     638         1147304 :       VSTR__ASSERT(vstr__check_real_nodes(base));
     639                 : 
     640         5064055 :       base->len -= len;
     641                 : 
     642         5064055 :       switch (scan->type)
     643                 :       {
     644                 :         case VSTR_TYPE_NODE_BUF:
     645         4258754 :           base->used += len;
     646         4258754 :           break;
     647                 :         case VSTR_TYPE_NODE_NON:
     648              35 :           scan->len -= len;
     649              35 :           break;
     650                 :         case VSTR_TYPE_NODE_PTR:
     651                 :         {
     652            3519 :           char *tmp = ((struct Vstr_node_ptr *)scan)->ptr;
     653            3519 :           ((struct Vstr_node_ptr *)scan)->ptr = tmp + len;
     654            3519 :           scan->len -= len;
     655                 :         }
     656            3519 :         break;
     657                 :         case VSTR_TYPE_NODE_REF:
     658          801747 :           ((struct Vstr_node_ref *)scan)->off += len;
     659          801747 :           scan->len -= len;
     660                 :           break;
     661                 :       }
     662                 : 
     663         5064055 :       if ((cdata = vstr_cache_get(base, 3)) && cdata->ref && cdata->len)
     664                 :       {
     665            3279 :         size_t data_end_pos = vstr_sc_poslast(cdata->pos, cdata->len);
     666            3279 :         size_t end_pos = vstr_sc_poslast(1, len);
     667                 : 
     668            3279 :         if (cdata->pos > end_pos)
     669              55 :           cdata->pos -= len;
     670            3224 :         else if (data_end_pos <= end_pos)
     671             134 :           cdata->len = 0;
     672                 :         else
     673                 :         {
     674            3090 :           cdata->len -= vstr_sc_posdiff(cdata->pos, end_pos);
     675            3090 :           cdata->off += vstr_sc_posdiff(cdata->pos, end_pos);
     676                 :           
     677            3090 :           cdata->pos = pos;
     678                 :         }
     679                 :       }
     680         5064055 :       if (base->iovec_upto_date)
     681                 :       {
     682         5057637 :         unsigned int num = VSTR__CACHE(base)->vec->off;
     683                 : 
     684         5057637 :         if (scan->type != VSTR_TYPE_NODE_NON)
     685                 :         {
     686         5057637 :           char *tmp = VSTR__CACHE(base)->vec->v[num].iov_base;
     687         5057637 :           VSTR__CACHE(base)->vec->v[num].iov_base = tmp + len;
     688                 :         }
     689         5057637 :         VSTR__CACHE(base)->vec->v[num].iov_len -= len;
     690                 :       }
     691         5064055 :       if ((pdata = vstr_cache_get(base, 1)))
     692         5062730 :         pdata->node = NULL;
     693                 : 
     694         1147304 :       VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
     695         1147304 :       VSTR__ASSERT(vstr__check_real_nodes(base));
     696                 : 
     697         5064055 :       return (VSTR__TRUE);
     698                 :     }
     699                 : 
     700          344432 :     end_len = base->end->len;
     701          344432 :     if (base->beg == base->end)
     702                 :     {
     703           14274 :       VSTR__ASSERT(base->num == 1);
     704           48523 :       end_len += base->used;
     705                 :     }
     706                 : 
     707          344432 :     if ((pos > (base->len - (end_len - 1))) &&
     708                 :         (len == vstr_sc_posdiff(pos, base->len)))
     709                 :     { /* delete from end, in one node */
     710           19560 :       struct Vstr_node *scan = base->end;
     711           19560 :       struct Vstr__cache_data_cstr *cdata = NULL;
     712           19560 :       struct Vstr__cache_data_pos  *pdata = NULL;
     713                 :       
     714            6675 :       VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
     715            6675 :       VSTR__ASSERT(vstr__check_real_nodes(base));
     716                 : 
     717           19560 :       base->len -= len;
     718           19560 :       scan->len -= len;
     719                 : 
     720           19560 :       if ((cdata = vstr_cache_get(base, 3)) && cdata->ref && cdata->len)
     721                 :       {
     722              20 :         size_t data_end_pos = vstr_sc_poslast(cdata->pos, cdata->len);
     723                 : 
     724              20 :         if (data_end_pos >= pos)
     725              20 :           cdata->len = 0;
     726                 :       }
     727           19560 :       if (base->iovec_upto_date)
     728                 :       {
     729            2760 :         unsigned int num = base->num + VSTR__CACHE(base)->vec->off - 1;
     730                 : 
     731            2760 :         VSTR__CACHE(base)->vec->v[num].iov_len -= len;
     732                 :       }
     733           19560 :       if ((pdata = vstr_cache_get(base, 1)))
     734           17302 :         pdata->node = NULL;
     735                 : 
     736            6675 :       VSTR__ASSERT(vstr__check_spare_nodes(base->conf));
     737            6675 :       VSTR__ASSERT(vstr__check_real_nodes(base));
     738                 : 
     739           19560 :       return (VSTR__TRUE);
     740                 :     }
     741                 :   }
     742                 : 
     743          326362 :   return (vstr_extern_inline_del(base, pos, len));
     744                 : }
     745                 : 
     746                 : extern inline int vstr_sc_reduce(struct Vstr_base *base,
     747                 :                                  size_t pos, size_t len, size_t reduce)
     748           19899 : {
     749           19899 :   VSTR__ASSERT_RET(len >= reduce, 0);
     750                 : 
     751           19899 :   if (!len) return (VSTR__TRUE);
     752                 : 
     753           19854 :   return (vstr_del(base, pos + (len - reduce), reduce));
     754                 : }
     755                 : 
     756                 : extern inline int vstr_sects_add(struct Vstr_sects *sects,
     757                 :                                  size_t pos, size_t len)
     758          101195 : {
     759          101195 :   if (!sects->sz || (sects->num >= sects->sz))
     760                 :   {
     761             633 :     if (!sects->can_add_sz)
     762             180 :       return (VSTR__FALSE);
     763                 : 
     764             453 :     if (!vstr_extern_inline_sects_add(sects, pos, len))
     765              24 :       return (VSTR__FALSE);
     766                 :   }
     767                 : 
     768          100991 :   sects->ptr[sects->num].pos = pos;
     769          100991 :   sects->ptr[sects->num].len = len;
     770          100991 :   ++sects->num;
     771                 : 
     772          100991 :   return (VSTR__TRUE);
     773                 : }
     774                 : 
     775                 : /* do inline versions of macro functions */
     776                 : /* cmp */
     777                 : extern inline int vstr_cmp_eq(const struct Vstr_base *s1, size_t p1, size_t l1,
     778                 :                               const struct Vstr_base *s2, size_t p2, size_t l2)
     779             424 : { return ((l1 == l2) && !vstr_cmp(s1, p1, l1, s2, p2, l1)); }
     780                 : extern inline int vstr_cmp_buf_eq(const struct Vstr_base *s1,
     781                 :                                   size_t p1, size_t l1,
     782                 :                                   const void *buf, size_t buf_len)
     783       229483198 : { return ((l1 == buf_len) && !vstr_cmp_buf(s1, p1, l1, buf, buf_len)); }
     784                 : extern inline int vstr_cmp_cstr(const struct Vstr_base *s1,
     785                 :                                 size_t p1, size_t l1,
     786                 :                                 const char *buf)
     787             385 : { return (vstr_cmp_buf(s1, p1, l1, buf, strlen(buf))); }
     788                 : extern inline int vstr_cmp_cstr_eq(const struct Vstr_base *s1,
     789                 :                                    size_t p1, size_t l1,
     790                 :                                    const char *buf)
     791           47123 : { return (vstr_cmp_buf_eq(s1, p1, l1, buf, strlen(buf))); }
     792                 : 
     793                 : /* cmp case */
     794                 : extern inline int vstr_cmp_case_eq(const struct Vstr_base *s1,
     795                 :                                    size_t p1, size_t l1,
     796                 :                                    const struct Vstr_base *s2,
     797                 :                                    size_t p2, size_t l2)
     798              10 : { return ((l1 == l2) && !vstr_cmp_case(s1, p1, l1, s2, p2, l1)); }
     799                 : extern inline int vstr_cmp_case_buf_eq(const struct Vstr_base *s1,
     800                 :                                        size_t p1, size_t l1,
     801                 :                                        const char *buf, size_t buf_len)
     802          120190 : { return ((l1 == buf_len) && !vstr_cmp_case_buf(s1, p1, l1, buf, buf_len)); }
     803                 : extern inline int vstr_cmp_case_cstr(const struct Vstr_base *s1,
     804                 :                                      size_t p1, size_t l1,
     805                 :                                      const char *buf)
     806             385 : { return (vstr_cmp_case_buf(s1, p1, l1, buf, strlen(buf))); }
     807                 : extern inline int vstr_cmp_case_cstr_eq(const struct Vstr_base *s1,
     808                 :                                         size_t p1, size_t l1, const char *buf)
     809            5858 : { return (vstr_cmp_case_buf_eq(s1, p1, l1, buf, strlen(buf))); }
     810                 : 
     811                 : /* cmp vers */
     812                 : extern inline int vstr_cmp_vers_eq(const struct Vstr_base *s1,
     813                 :                                    size_t p1, size_t l1,
     814                 :                                    const struct Vstr_base *s2,
     815                 :                                    size_t p2, size_t l2)
     816              20 : { return ((l1 == l2) && !vstr_cmp_vers(s1, p1, l1, s2, p2, l1)); }
     817                 : extern inline int vstr_cmp_vers_buf_eq(const struct Vstr_base *s1,
     818                 :                                        size_t p1, size_t l1,
     819                 :                                        const char *buf, size_t buf_len)
     820              30 : { return ((l1 == buf_len) && !vstr_cmp_vers_buf(s1, p1, l1, buf, buf_len)); }
     821                 : extern inline int vstr_cmp_vers_cstr(const struct Vstr_base *s1,
     822                 :                                      size_t p1, size_t l1, const char *buf)
     823             595 : { return (vstr_cmp_vers_buf(s1, p1, l1, buf, strlen(buf))); }
     824                 : extern inline int vstr_cmp_vers_cstr_eq(const struct Vstr_base *s1,
     825                 :                                         size_t p1, size_t l1, const char *buf)
     826              10 : { return (vstr_cmp_vers_buf_eq(s1, p1, l1, buf, strlen(buf))); }
     827                 : 
     828                 : /* add */
     829                 : extern inline int vstr_add_cstr_buf(struct Vstr_base *s1, size_t pa1,
     830                 :                                     const char *buf)
     831          425441 : { return (vstr_add_buf(s1, pa1, buf, strlen(buf))); }
     832                 : extern inline int vstr_add_cstr_ptr(struct Vstr_base *s1, size_t pa1,
     833                 :                                     const char *ptr)
     834          362718 : { return (vstr_add_ptr(s1, pa1, ptr, strlen(ptr))); }
     835                 : extern inline int vstr_add_cstr_ref(struct Vstr_base *s1, size_t pa1,
     836                 :                                     struct Vstr_ref *ref, size_t off)
     837              45 : { return (vstr_add_ref(s1, pa1, ref, off,
     838                 :                        strlen(((const char *)ref->ptr) + off))); }
     839                 : 
     840                 : /* dup */
     841                 : extern inline struct Vstr_base *vstr_dup_cstr_buf(struct Vstr_conf *conf,
     842                 :                                                   const char *buf)
     843              42 : { return (vstr_dup_buf(conf, buf, strlen(buf))); }
     844                 : extern inline struct Vstr_base *vstr_dup_cstr_ptr(struct Vstr_conf *conf,
     845                 :                                                   const char *ptr)
     846              42 : { return (vstr_dup_ptr(conf, ptr, strlen(ptr))); }
     847                 : extern inline struct Vstr_base *vstr_dup_cstr_ref(struct Vstr_conf *conf,
     848                 :                                                   struct Vstr_ref *ref,
     849                 :                                                   size_t off)
     850              15 : { return (vstr_dup_ref(conf, ref, off,
     851                 :                        strlen(((const char *)ref->ptr) + off))); }
     852                 : 
     853                 : /* sub */
     854                 : extern inline int vstr_sub_cstr_buf(struct Vstr_base *s1, size_t p1, size_t l1,
     855                 :                                     const char *buf)
     856             150 : { return (vstr_sub_buf(s1, p1, l1, buf, strlen(buf))); }
     857                 : extern inline int vstr_sub_cstr_ptr(struct Vstr_base *s1, size_t p1, size_t l1,
     858                 :                                     const char *ptr)
     859              21 : { return (vstr_sub_ptr(s1, p1, l1, ptr, strlen(ptr))); }
     860                 : extern inline int vstr_sub_cstr_ref(struct Vstr_base *s1, size_t p1, size_t l1,
     861                 :                                     struct Vstr_ref *ref, size_t off)
     862              10 : { return (vstr_sub_ref(s1, p1, l1, ref, off,
     863                 :                        strlen(((const char *)ref->ptr) + off))); }
     864                 : 
     865                 : /* srch */
     866                 : extern inline size_t vstr_srch_cstr_buf_fwd(const struct Vstr_base *s1,
     867                 :                                             size_t p1, size_t l1,
     868                 :                                             const char *buf)
     869          249998 : { return (vstr_srch_buf_fwd(s1, p1, l1, buf, strlen(buf))); }
     870                 : extern inline size_t vstr_srch_cstr_buf_rev(const struct Vstr_base *s1,
     871                 :                                             size_t p1, size_t l1,
     872                 :                                             const char *buf)
     873              84 : { return (vstr_srch_buf_rev(s1, p1, l1, buf, strlen(buf))); }
     874                 : 
     875                 : extern inline size_t vstr_srch_cstr_chrs_fwd(const struct Vstr_base *s1,
     876                 :                                              size_t p1, size_t l1,
     877                 :                                              const char *chrs)
     878           34853 : { return (vstr_srch_chrs_fwd(s1, p1, l1, chrs, strlen(chrs))); }
     879                 : extern inline size_t vstr_srch_cstr_chrs_rev(const struct Vstr_base *s1,
     880                 :                                              size_t p1, size_t l1,
     881                 :                                              const char *chrs)
     882              15 : { return (vstr_srch_chrs_rev(s1, p1, l1, chrs, strlen(chrs))); }
     883                 : 
     884                 : extern inline size_t vstr_csrch_cstr_chrs_fwd(const struct Vstr_base *s1,
     885                 :                                               size_t p1, size_t l1,
     886                 :                                               const char *chrs)
     887              15 : { return (vstr_csrch_chrs_fwd(s1, p1, l1, chrs, strlen(chrs))); }
     888                 : extern inline size_t vstr_csrch_cstr_chrs_rev(const struct Vstr_base *s1,
     889                 :                                               size_t p1, size_t l1,
     890                 :                                               const char *chrs)
     891              15 : { return (vstr_csrch_chrs_rev(s1, p1, l1, chrs, strlen(chrs))); }
     892                 : 
     893                 : extern inline size_t vstr_srch_case_cstr_buf_fwd(const struct Vstr_base *s1,
     894                 :                                                  size_t p1, size_t l1,
     895                 :                                                  const char *buf)
     896           13374 : { return (vstr_srch_case_buf_fwd(s1, p1, l1, buf, strlen(buf))); }
     897                 : extern inline size_t vstr_srch_case_cstr_buf_rev(const struct Vstr_base *s1,
     898                 :                                                  size_t p1, size_t l1,
     899                 :                                                  const char *buf)
     900              24 : { return (vstr_srch_case_buf_rev(s1, p1, l1, buf, strlen(buf))); }
     901                 : 
     902                 : /* spn */
     903                 : extern inline size_t vstr_spn_cstr_chrs_fwd(const struct Vstr_base *s1,
     904                 :                                             size_t p1, size_t l1,
     905                 :                                             const char *chrs)
     906          170765 : { return (vstr_spn_chrs_fwd(s1, p1, l1, chrs, strlen(chrs))); }
     907                 : extern inline size_t vstr_spn_cstr_chrs_rev(const struct Vstr_base *s1,
     908                 :                                             size_t p1, size_t l1,
     909                 :                                             const char *chrs)
     910           28314 : { return (vstr_spn_chrs_rev(s1, p1, l1, chrs, strlen(chrs))); }
     911                 : 
     912                 : extern inline size_t vstr_cspn_cstr_chrs_fwd(const struct Vstr_base *s1,
     913                 :                                              size_t p1, size_t l1,
     914                 :                                              const char *chrs)
     915          609525 : { return (vstr_cspn_chrs_fwd(s1, p1, l1, chrs, strlen(chrs))); }
     916                 : extern inline size_t vstr_cspn_cstr_chrs_rev(const struct Vstr_base *s1,
     917                 :                                              size_t p1, size_t l1,
     918                 :                                              const char *chrs)
     919              36 : { return (vstr_cspn_chrs_rev(s1, p1, l1, chrs, strlen(chrs))); }
     920                 : 
     921                 : /* split */
     922                 : extern inline size_t vstr_split_cstr_buf(const struct Vstr_base *s1,
     923                 :                                          size_t p1, size_t l1,
     924                 :                                          const char *buf,
     925                 :                                          struct Vstr_sects *sect,
     926                 :                                          unsigned int lim, unsigned int flags)
     927             115 : {  return (vstr_split_buf(s1, p1, l1, buf, strlen(buf), sect, lim, flags)); }
     928                 : extern inline size_t vstr_split_cstr_chrs(const struct Vstr_base *s1,
     929                 :                                           size_t p1, size_t l1,
     930                 :                                           const char *chrs,
     931                 :                                           struct Vstr_sects *sect,
     932                 :                                           unsigned int lim, unsigned int flags)
     933            9259 : {  return (vstr_split_chrs(s1, p1, l1, chrs, strlen(chrs), sect, lim, flags)); }
     934                 : 
     935                 : 
     936                 : /* simple inlines that can't easily be macros... */
     937                 : /* cmp */
     938                 : extern inline int vstr_cmp_bod(const struct Vstr_base *s1, size_t p1, size_t l1,
     939                 :                                const struct Vstr_base *s2, size_t p2, size_t l2)
     940                 : {
     941              20 :   size_t tmp = l1; if (tmp > l2) tmp = l2;
     942              20 :   return (vstr_cmp(s1, p1, tmp, s2, p2, tmp));
     943                 : }
     944                 : extern inline int vstr_cmp_eod(const struct Vstr_base *s1, size_t p1, size_t l1,
     945                 :                                const struct Vstr_base *s2, size_t p2, size_t l2)
     946          835866 : {
     947          835866 :   size_t tmp = l1; if (tmp > l2) tmp = l2;
     948          835866 :   p1 += (l1 - tmp);
     949          835866 :   p2 += (l2 - tmp);
     950          835866 :   return (vstr_cmp(s1, p1, tmp, s2, p2, tmp));
     951                 : }
     952                 : extern inline int vstr_cmp_bod_eq(const struct Vstr_base *s1,
     953                 :                                   size_t p1, size_t l1,
     954                 :                                   const struct Vstr_base *s2,
     955                 :                                   size_t p2, size_t l2)
     956              30 : { return (!vstr_cmp_bod(s1, p1, l1, s2, p2, l2)); }
     957                 : extern inline int vstr_cmp_eod_eq(const struct Vstr_base *s1,
     958                 :                                   size_t p1, size_t l1,
     959                 :                                   const struct Vstr_base *s2,
     960                 :                                   size_t p2, size_t l2)
     961          835861 : { return (!vstr_cmp_eod(s1, p1, l1, s2, p2, l2)); }
     962                 : 
     963                 : /* cmp buf */
     964                 : extern inline int vstr_cmp_bod_buf(const struct Vstr_base *s1,
     965                 :                                    size_t p1, size_t l1,
     966                 :                                    const void *buf, size_t buf_len)
     967                 : {
     968         4560756 :   size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
     969         4560756 :   return (vstr_cmp_buf(s1, p1, tmp, buf, tmp));
     970                 : }
     971                 : extern inline int vstr_cmp_eod_buf(const struct Vstr_base *s1,
     972                 :                                    size_t p1, size_t l1,
     973                 :                                    const void *pbuf, size_t buf_len)
     974           22018 : {
     975           22018 :   const char *buf = (const char *)pbuf;
     976           22018 :   size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
     977           22018 :   p1  += (l1 - tmp);
     978           22018 :   buf += (buf_len - tmp);
     979           22018 :   return (vstr_cmp_buf(s1, p1, tmp, buf, tmp));
     980                 : }
     981                 : extern inline int vstr_cmp_bod_buf_eq(const struct Vstr_base *s1,
     982                 :                                       size_t p1, size_t l1,
     983                 :                                       const void *pbuf, size_t buf_len)
     984         9121492 : { return (!vstr_cmp_bod_buf(s1, p1, l1, pbuf, buf_len)); }
     985                 : extern inline int vstr_cmp_eod_buf_eq(const struct Vstr_base *s1,
     986                 :                                       size_t p1, size_t l1,
     987                 :                                       const void *pbuf, size_t buf_len)
     988           22008 : { return (!vstr_cmp_eod_buf(s1, p1, l1, pbuf, buf_len)); }
     989                 : 
     990                 : /* cmp cstr */
     991                 : extern inline int vstr_cmp_bod_cstr(const struct Vstr_base *s1,
     992                 :                                     size_t p1, size_t l1,
     993                 :                                     const char *buf)
     994               5 : { return (vstr_cmp_bod_buf(s1, p1, l1, buf, strlen(buf))); }
     995                 : extern inline int vstr_cmp_eod_cstr(const struct Vstr_base *s1,
     996                 :                                     size_t p1, size_t l1,
     997                 :                                     const char *buf)
     998               5 : { return (vstr_cmp_eod_buf(s1, p1, l1, buf, strlen(buf))); }
     999                 : extern inline int vstr_cmp_bod_cstr_eq(const struct Vstr_base *s1,
    1000                 :                                        size_t p1, size_t l1,
    1001                 :                                        const char *buf)
    1002         4560245 : { return (vstr_cmp_bod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
    1003                 : extern inline int vstr_cmp_eod_cstr_eq(const struct Vstr_base *s1,
    1004                 :                                        size_t p1, size_t l1,
    1005                 :                                        const char *buf)
    1006           21087 : { return (vstr_cmp_eod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
    1007                 : 
    1008                 : /* cmp case */
    1009                 : extern inline int vstr_cmp_case_bod(const struct Vstr_base *s1,
    1010                 :                                     size_t p1, size_t l1,
    1011                 :                                     const struct Vstr_base *s2,
    1012                 :                                     size_t p2, size_t l2)
    1013                 : {
    1014              20 :   size_t tmp = l1; if (tmp > l2) tmp = l2;
    1015              20 :   return (vstr_cmp_case(s1, p1, tmp, s2, p2, tmp));
    1016                 : }
    1017                 : extern inline int vstr_cmp_case_eod(const struct Vstr_base *s1,
    1018                 :                                     size_t p1, size_t l1,
    1019                 :                                     const struct Vstr_base *s2,
    1020                 :                                     size_t p2, size_t l2)
    1021              20 : {
    1022              20 :   size_t tmp = l1; if (tmp > l2) tmp = l2;
    1023              20 :   p1 += (l1 - tmp);
    1024              20 :   p2 += (l2 - tmp);
    1025              20 :   return (vstr_cmp_case(s1, p1, tmp, s2, p2, tmp));
    1026                 : }
    1027                 : extern inline int vstr_cmp_case_bod_eq(const struct Vstr_base *s1,
    1028                 :                                   size_t p1, size_t l1,
    1029                 :                                   const struct Vstr_base *s2,
    1030                 :                                   size_t p2, size_t l2)
    1031              30 : { return (!vstr_cmp_case_bod(s1, p1, l1, s2, p2, l2)); }
    1032                 : extern inline int vstr_cmp_case_eod_eq(const struct Vstr_base *s1,
    1033                 :                                   size_t p1, size_t l1,
    1034                 :                                   const struct Vstr_base *s2,
    1035                 :                                   size_t p2, size_t l2)
    1036              15 : { return (!vstr_cmp_case_eod(s1, p1, l1, s2, p2, l2)); }
    1037                 : 
    1038                 : /* cmp case buf */
    1039                 : extern inline int vstr_cmp_case_bod_buf(const struct Vstr_base *s1,
    1040                 :                                         size_t p1, size_t l1,
    1041                 :                                         const char *buf, size_t buf_len)
    1042                 : {
    1043           20033 :   size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
    1044           20033 :   return (vstr_cmp_case_buf(s1, p1, tmp, buf, tmp));
    1045                 : }
    1046                 : extern inline int vstr_cmp_case_eod_buf(const struct Vstr_base *s1,
    1047                 :                                         size_t p1, size_t l1,
    1048                 :                                         const char *buf, size_t buf_len)
    1049              25 : {
    1050              25 :   size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
    1051              25 :   p1  += (l1 - tmp);
    1052              25 :   buf += (buf_len - tmp);
    1053              25 :   return (vstr_cmp_case_buf(s1, p1, tmp, buf, tmp));
    1054                 : }
    1055                 : extern inline int vstr_cmp_case_bod_buf_eq(const struct Vstr_base *s1,
    1056                 :                                            size_t p1, size_t l1,
    1057                 :                                            const char *buf, size_t buf_len)
    1058           40046 : { return (!vstr_cmp_case_bod_buf(s1, p1, l1, buf, buf_len)); }
    1059                 : extern inline int vstr_cmp_case_eod_buf_eq(const struct Vstr_base *s1,
    1060                 :                                            size_t p1, size_t l1,
    1061                 :                                            const char *buf, size_t buf_len)
    1062              15 : { return (!vstr_cmp_case_eod_buf(s1, p1, l1, buf, buf_len)); }
    1063                 : 
    1064                 : /* cmp case cstr */
    1065                 : extern inline int vstr_cmp_case_bod_cstr(const struct Vstr_base *s1,
    1066                 :                                          size_t p1, size_t l1,
    1067                 :                                          const char *buf)
    1068               5 : { return (vstr_cmp_case_bod_buf(s1, p1, l1, buf, strlen(buf))); }
    1069                 : extern inline int vstr_cmp_case_eod_cstr(const struct Vstr_base *s1,
    1070                 :                                          size_t p1, size_t l1,
    1071                 :                                          const char *buf)
    1072               5 : { return (vstr_cmp_case_eod_buf(s1, p1, l1, buf, strlen(buf))); }
    1073                 : extern inline int vstr_cmp_case_bod_cstr_eq(const struct Vstr_base *s1,
    1074                 :                                             size_t p1, size_t l1,
    1075                 :                                             const char *buf)
    1076           20018 : { return (vstr_cmp_case_bod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
    1077                 : extern inline int vstr_cmp_case_eod_cstr_eq(const struct Vstr_base *s1,
    1078                 :                                             size_t p1, size_t l1,
    1079                 :                                             const char *buf)
    1080              10 : { return (vstr_cmp_case_eod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
    1081                 : 
    1082                 : /* cmp vers */
    1083                 : extern inline int vstr_cmp_vers_bod(const struct Vstr_base *s1,
    1084                 :                                     size_t p1, size_t l1,
    1085                 :                                     const struct Vstr_base *s2,
    1086                 :                                     size_t p2, size_t l2)
    1087                 : {
    1088              20 :   size_t tmp = l1; if (tmp > l2) tmp = l2;
    1089              20 :   return (vstr_cmp_vers(s1, p1, tmp, s2, p2, tmp));
    1090                 : }
    1091                 : extern inline int vstr_cmp_vers_eod(const struct Vstr_base *s1,
    1092                 :                                     size_t p1, size_t l1,
    1093                 :                                     const struct Vstr_base *s2,
    1094                 :                                     size_t p2, size_t l2)
    1095              20 : {
    1096              20 :   size_t tmp = l1; if (tmp > l2) tmp = l2;
    1097              20 :   p1 += (l1 - tmp);
    1098              20 :   p2 += (l2 - tmp);
    1099              20 :   return (vstr_cmp_vers(s1, p1, tmp, s2, p2, tmp));
    1100                 : }
    1101                 : extern inline int vstr_cmp_vers_bod_eq(const struct Vstr_base *s1,
    1102                 :                                   size_t p1, size_t l1,
    1103                 :                                   const struct Vstr_base *s2,
    1104                 :                                   size_t p2, size_t l2)
    1105              30 : { return (!vstr_cmp_vers_bod(s1, p1, l1, s2, p2, l2)); }
    1106                 : extern inline int vstr_cmp_vers_eod_eq(const struct Vstr_base *s1,
    1107                 :                                   size_t p1, size_t l1,
    1108                 :                                   const struct Vstr_base *s2,
    1109                 :                                   size_t p2, size_t l2)
    1110              15 : { return (!vstr_cmp_vers_eod(s1, p1, l1, s2, p2, l2)); }
    1111                 : 
    1112                 : /* cmp vers buf */
    1113                 : extern inline int vstr_cmp_vers_bod_buf(const struct Vstr_base *s1,
    1114                 :                                         size_t p1, size_t l1,
    1115                 :                                         const char *buf, size_t buf_len)
    1116                 : {
    1117              25 :   size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
    1118              25 :   return (vstr_cmp_vers_buf(s1, p1, tmp, buf, tmp));
    1119                 : }
    1120                 : extern inline int vstr_cmp_vers_eod_buf(const struct Vstr_base *s1,
    1121                 :                                         size_t p1, size_t l1,
    1122                 :                                         const char *buf, size_t buf_len)
    1123              25 : {
    1124              25 :   size_t tmp = l1; if (tmp > buf_len) tmp = buf_len;
    1125              25 :   p1  += (l1 - tmp);
    1126              25 :   buf += (buf_len - tmp);
    1127              25 :   return (vstr_cmp_vers_buf(s1, p1, tmp, buf, tmp));
    1128                 : }
    1129                 : extern inline int vstr_cmp_vers_bod_buf_eq(const struct Vstr_base *s1,
    1130                 :                                            size_t p1, size_t l1,
    1131                 :                                            const char *buf, size_t buf_len)
    1132              30 : { return (!vstr_cmp_vers_bod_buf(s1, p1, l1, buf, buf_len)); }
    1133                 : extern inline int vstr_cmp_vers_eod_buf_eq(const struct Vstr_base *s1,
    1134                 :                                            size_t p1, size_t l1,
    1135                 :                                            const char *buf, size_t buf_len)
    1136              15 : { return (!vstr_cmp_vers_eod_buf(s1, p1, l1, buf, buf_len)); }
    1137                 : 
    1138                 : /* cmp vers cstr */
    1139                 : extern inline int vstr_cmp_vers_bod_cstr(const struct Vstr_base *s1,
    1140                 :                                          size_t p1, size_t l1,
    1141                 :                                          const char *buf)
    1142               5 : { return (vstr_cmp_vers_bod_buf(s1, p1, l1, buf, strlen(buf))); }
    1143                 : extern inline int vstr_cmp_vers_eod_cstr(const struct Vstr_base *s1,
    1144                 :                                          size_t p1, size_t l1,
    1145                 :                                          const char *buf)
    1146               5 : { return (vstr_cmp_vers_eod_buf(s1, p1, l1, buf, strlen(buf))); }
    1147                 : extern inline int vstr_cmp_vers_bod_cstr_eq(const struct Vstr_base *s1,
    1148                 :                                             size_t p1, size_t l1,
    1149                 :                                             const char *buf)
    1150              10 : { return (vstr_cmp_vers_bod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
    1151                 : extern inline int vstr_cmp_vers_eod_cstr_eq(const struct Vstr_base *s1,
    1152                 :                                             size_t p1, size_t l1,
    1153                 :                                             const char *buf)
    1154              10 : { return (vstr_cmp_vers_eod_buf_eq(s1, p1, l1, buf, strlen(buf))); }
    1155                 : 
    1156                 : /* ref */
    1157                 : extern inline struct Vstr_ref *vstr_ref_make_strdup(const char *val)
    1158           28100 : { return (vstr_ref_make_memdup(val, strlen(val) + 1)); }
    1159                 : 
    1160                 : /* sc */
    1161                 : extern inline int vstr_sc_add_cstr_grpbasenum_buf(struct Vstr_base *s1,
    1162                 :                                                   size_t p1, unsigned int nb,
    1163                 :                                                   const char *val)
    1164              15 : { return (vstr_sc_add_grpbasenum_buf(s1, p1, nb, val, strlen(val))); }
    1165                 : extern inline int vstr_sc_add_cstr_grpbasenum_ptr(struct Vstr_base *s1,
    1166                 :                                                   size_t p1, unsigned int nb,
    1167                 :                                                   const char *val)
    1168              12 : { return (vstr_sc_add_grpbasenum_ptr(s1, p1, nb, val, strlen(val))); }
    1169                 : extern inline int vstr_sc_add_cstr_grpbasenum_ref(struct Vstr_base *s1,
    1170                 :                                                   size_t p1, unsigned int nb,
    1171                 :                                                   struct Vstr_ref *ref,
    1172                 :                                                   size_t off)
    1173              12 : { return (vstr_sc_add_grpbasenum_ref(s1, p1, nb, ref, off,
    1174                 :                                      strlen(((const char *)ref->ptr) + off))); }
    1175                 : extern inline int vstr_sc_add_grpnum_buf(struct Vstr_base *s1, size_t p1,
    1176                 :                                          const void *val, size_t len)
    1177            1646 : { return (vstr_sc_add_grpbasenum_buf(s1, p1, 0, val, len)); }
    1178                 : extern inline int vstr_sc_add_cstr_grpnum_buf(struct Vstr_base *s1, size_t p1,
    1179                 :                                               const char *val)
    1180               6 : { return (vstr_sc_add_grpnum_buf(s1, p1, val, strlen(val))); }
    1181                 : 
    1182                 : /* binary */
    1183                 : extern inline int vstr_sc_add_b_uint16(struct Vstr_base *s1, size_t p1,
    1184                 :                                        VSTR_AUTOCONF_uint_least16_t data)
    1185                 : {
    1186              20 :   unsigned char buf[2];
    1187                 : 
    1188              20 :   buf[1] = data & 0xFF; data >>= 8;
    1189              20 :   buf[0] = data & 0xFF;
    1190                 : 
    1191              20 :   return (vstr_add_buf(s1, p1, buf, sizeof(buf)));
    1192                 : }
    1193                 : extern inline int vstr_sc_add_b_uint32(struct Vstr_base *s1, size_t p1,
    1194                 :                                        VSTR_AUTOCONF_uint_least32_t data)
    1195              50 : {
    1196              50 :   unsigned char buf[4];
    1197                 : 
    1198              50 :   buf[3] = data & 0xFF; data >>= 8;
    1199              50 :   buf[2] = data & 0xFF; data >>= 8;
    1200              50 :   buf[1] = data & 0xFF; data >>= 8;
    1201              50 :   buf[0] = data & 0xFF;
    1202                 : 
    1203              50 :   return (vstr_add_buf(s1, p1, buf, sizeof(buf)));
    1204                 : }
    1205                 : 
    1206                 : extern inline int vstr_sc_sub_b_uint16(struct Vstr_base *s1,
    1207                 :                                        size_t p1, size_t l1,
    1208                 :                                        VSTR_AUTOCONF_uint_least16_t data)
    1209               5 : {
    1210               5 :   unsigned char buf[2];
    1211                 : 
    1212               5 :   buf[1] = data & 0xFF; data >>= 8;
    1213               5 :   buf[0] = data & 0xFF;
    1214                 : 
    1215               5 :   return (vstr_sub_buf(s1, p1, l1, buf, sizeof(buf)));
    1216                 : }
    1217                 : extern inline int vstr_sc_sub_b_uint32(struct Vstr_base *s1,
    1218                 :                                        size_t p1, size_t l1,
    1219                 :                                        VSTR_AUTOCONF_uint_least32_t data)
    1220               5 : {
    1221               5 :   unsigned char buf[4];
    1222                 : 
    1223               5 :   buf[3] = data & 0xFF; data >>= 8;
    1224               5 :   buf[2] = data & 0xFF; data >>= 8;
    1225               5 :   buf[1] = data & 0xFF; data >>= 8;
    1226               5 :   buf[0] = data & 0xFF;
    1227                 : 
    1228               5 :   return (vstr_sub_buf(s1, p1, l1, buf, sizeof(buf)));
    1229                 : }
    1230                 : 
    1231                 : extern inline VSTR_AUTOCONF_uint_least16_t
    1232                 : vstr_sc_parse_b_uint16(struct Vstr_base *s1, size_t p1)
    1233              54 : {
    1234              54 :   unsigned char buf[2];
    1235              54 :   VSTR_AUTOCONF_uint_least16_t num = 0;
    1236                 :   
    1237              54 :   if (!vstr_export_buf(s1, p1, sizeof(buf), buf, sizeof(buf)))
    1238               4 :     return (0);
    1239                 : 
    1240              50 :   num += buf[0]; num <<= 8;
    1241              50 :   num += buf[1];
    1242                 :   
    1243              50 :   return (num);
    1244                 : }
    1245                 : extern inline VSTR_AUTOCONF_uint_least32_t
    1246                 : vstr_sc_parse_b_uint32(struct Vstr_base *s1, size_t p1)
    1247              64 : {
    1248              64 :   unsigned char buf[4];
    1249              64 :   VSTR_AUTOCONF_uint_least32_t num = 0;
    1250                 : 
    1251              64 :   if (!vstr_export_buf(s1, p1, sizeof(buf), buf, sizeof(buf)))
    1252               4 :     return (0);
    1253                 : 
    1254              60 :   num += buf[0]; num <<= 8;
    1255              60 :   num += buf[1]; num <<= 8;
    1256              60 :   num += buf[2]; num <<= 8;
    1257              60 :   num += buf[3];
    1258                 :   
    1259              60 :   return (num);
    1260                 : }
    1261                 : 
    1262                 : #undef VSTR__ASSERT
    1263                 : #undef VSTR__ASSERT_RET
    1264                 : #undef VSTR__ASSERT_NO_SWITCH_DEF
    1265                 : #undef VSTR__TRUE
    1266                 : #undef VSTR__FALSE

Generated by: LTP GCOV extension version 1.1