NOMBRE

       argz_add, argz_add_sep, argz_append, argz_count, argz_create, argz_create_sep, argz_delete, argz_extract,
       argz_insert, argz_next, argz_replace, argz_stringify - funciones para manejar una lista argz

SINOPSIS

       #include <argz.h>

       error_t
       argz_add(char **argz, size_t *argz_len, const char *str);

       error_t
       argz_add_sep(char **argz, size_t *argz_len,
                    const char *str, int delim);

       error_t
       argz_append(char **argz, size_t *argz_len,
                    const char *buf, size_t buf_len);

       size_t
       argz_count(const char *argz, size_t argz_len);

       error_t
       argz_create(char * const argv[], char **argz,
                    size_t *argz_len);

       error_t
       argz_create_sep(const char *str, int sep, char **argz,
                    size_t *argz_len);

       error_t
       argz_delete(char **argz, size_t *argz_len, char *entry);

       void
       argz_extract(char *argz, size_t argz_len, char  **argv);

       error_t
       argz_insert (char **argz, size_t *argz_len, char *before,
                    const char *entry);

       char *
       argz_next(char *argz, size_t argz_len, const char *entry);

       error_t
       argz_replace(char **argz, size_t *argz_len, const char *str,
                    const char *with, unsigned int *replace_count);

       void
       argz_stringify(char *argz, size_t len, int sep);

DESCRIPCIÓN

       Estas funciones son específicas de glibc.

       Un vector argz es un puntero a un buffer de caracteres junto con una longitud.  Se pretende que el buffer
       de caracteres sea interpretado como un array de cadenas, donde las cadenas están separadas por bytes NUL.
       Si la longitud es distinta de cero, el último byte del buffer debe ser NUL.

       Estas  funciones  se  ofrecen  para  manejar  vectores  argz.   El  par (NULL,0) es un vector argz, y, al
       contrario, los vectores argz de longitud 0 deben tener un puntero NULL.  La reserva  de  memoria  de  los
       vectores  argz  no  vacíos  se  realiza  mediante  malloc(3), así free(3) puede utilizarse para liberarla
       después.

       argz_add() añade la cadena str al final del array *argz, y actualiza *argz y *argz_len.

       argz_add_sep() es similar, pero separa la cadena str en  dos  subcadenas  separadas  por  el  delimitador
       delim.  Por ejemplo, se puede utilizar está función en una ruta de búsqueda Unix con el delimitador ':'.

       argz_append()  añade  el  vector  argz  (buf,buf_len)  después  de  (*argz,*argz_len) y actualiza *argz y
       *argz_len.  (Así, *argz_len se incrementará en buf_len.)

       argz_count() cuenta el número de cadenas, esto es, el número de bytes NUL, en (argz,argz_len).

       argz_create() convierte un vector de argumentos al estilo Unix argv, terminado  en  (char  *)  0,  en  un
       vector argz (*argz,*argz_len).

       argz_create_sep()  convierte  la  cadena  terminada  en  NUL  str  en  un  vector  argz (*argz,*argz_len)
       partiéndola en cada ocurrencia del separador sep.

       argz_delete() elimina la subcadena apuntada por entry del vector argz (*argz,*argz_len) y actualiza *argz
       y *argz_len.

       argz_extract() es la contraria de argz_create().  Toma un vector argz (argz,argz_len) y rellena el  array
       que  comienza  en argv con punteros a las subcadenas, añadiendo un NULL al final, formando un vector argv
       al estilo Unix.  El array argv debe tener suficiente espacio para argz_count(argz,argz_len) + 1 punteros.

       argz_insert() es la opuesta de argz_delete().  Inserta el argumento entry en la  posición  before  en  el
       vector  argz (*argz,*argz_len) y actualiza *argz y *argz_len.  Si before es NULL, entry será insertada al
       final.

       argz_next() es una función para recorrer el vector argz.  Si  entry  es  NULL,  se  devuelve  la  primera
       entrada. En otro caso, se devuelve la siguiente entrada. Devuelve NULL si no quedan más entradas.

       argz_replace()  reemplaza  cada  ocurrencia  de  str  con  with,  reasignando  argz  si  es necesario. Si
       replace_count es distinto de NULL, *replace_count se incrementará con el número de reemplazos.

       argz_stringify() es la opuesta de argz_create_sep().  Transforma el vector  argz  en  una  cadena  normal
       reemplazando todos los NULs excepto el último por sep.

VALOR DEVUELTO

       Todas las funciones argz que realizan reserva de memoria devuelven un tipo error_t, devolviendo 0 en caso
       de éxito, y ENOMEM si ocurre un error de asignación de memoria.

FALLOS

       Los vectores argz sin un NUL final pueden provocar Violaciones de Segmento.

OBSERVACIONES

       Estas funciones son extensiones de GNU. Manejar con cuidado.

VÉASE TAMBIÉN

       envz(3)

                                                                                                     ARGZ_ADD(3)