Back to index

glibc  2.9
Functions
argz-replace.c File Reference
#include <stdlib.h>
#include <string.h>
#include <argz.h>

Go to the source code of this file.

Functions

static void str_append (char **to, size_t *to_len, const char *buf, const size_t buf_len)
error_t __argz_replace (char **argz, size_t *argz_len, const char *str, const char *with, unsigned *replace_count)

Function Documentation

error_t __argz_replace ( char **  argz,
size_t argz_len,
const char *  str,
const char *  with,
unsigned *  replace_count 
)

Definition at line 51 of file argz-replace.c.

{
  error_t err = 0;

  if (str && *str)
    {
      char *arg = 0;
      char *src = *argz;
      size_t src_len = *argz_len;
      char *dst = 0;
      size_t dst_len = 0;
      int delayed_copy = 1; /* True while we've avoided copying anything.  */
      size_t str_len = strlen (str), with_len = strlen (with);

      while (!err && (arg = argz_next (src, src_len, arg)))
       {
         char *match = strstr (arg, str);
         if (match)
           {
             char *from = match + str_len;
             size_t to_len = match - arg;
             char *to = __strndup (arg, to_len);

             while (to && from)
              {
                str_append (&to, &to_len, with, with_len);
                if (to)
                  {
                    match = strstr (from, str);
                    if (match)
                     {
                       str_append (&to, &to_len, from, match - from);
                       from = match + str_len;
                     }
                    else
                     {
                       str_append (&to, &to_len, from, strlen (from));
                       from = 0;
                     }
                  }
              }

             if (to)
              {
                if (delayed_copy)
                  /* We avoided copying SRC to DST until we found a match;
                       now that we've done so, copy everything from the start
                       of SRC.  */
                  {
                    if (arg > src)
                     err = __argz_append (&dst, &dst_len, src, (arg - src));
                    delayed_copy = 0;
                  }
                if (! err)
                  err = __argz_add (&dst, &dst_len, to);
                free (to);
              }
             else
              err = ENOMEM;

             if (replace_count)
              (*replace_count)++;
           }
         else if (! delayed_copy)
           err = __argz_add (&dst, &dst_len, arg);
       }

      if (! err)
       {
         if (! delayed_copy)
           /* We never found any instances of str.  */
           {
             free (src);
             *argz = dst;
             *argz_len = dst_len;
           }
       }
      else if (dst_len > 0)
       free (dst);
    }

  return err;
}

Here is the call graph for this function:

static void str_append ( char **  to,
size_t to_len,
const char *  buf,
const size_t  buf_len 
) [static]

Definition at line 29 of file argz-replace.c.

{
  size_t new_len = *to_len + buf_len;
  char *new_to = realloc (*to, new_len + 1);

  if (new_to)
    {
      *((char *) __mempcpy (new_to + *to_len, buf, buf_len)) = '\0';
      *to = new_to;
      *to_len = new_len;
    }
  else
    {
      free (*to);
      *to = 0;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function: