Filewatcher File Search File Search
Catalog
Content Search
» » » » » libqdbm-dev_1.8.74-1.1_i386.deb » Content »
pkg://libqdbm-dev_1.8.74-1.1_i386.deb:221800/usr/share/man/man3/  info  control  downloads

libqdbm-dev - QDBM Database Libraries [development]…  more info»

cabin.3.gz

CABIN(3)               Quick Database Manager               CABIN(3)



NAME
       Cabin - the utility API of QDBM


SYNOPSIS
       #include <cabin.h>
       #include <stdlib.h>

       extern void (*cbfatalfunc)(const char *message);

       void *cbmalloc(size_t size);

       void *cbrealloc(void *ptr, size_t size);

       char *cbmemdup(const char *ptr, int size);

       void cbfree(void *ptr);

       void cbglobalgc(void *ptr, void (*func)(void *));

       void cbggcsweep(void);

       int cbvmemavail(size_t size);

       void  cbisort(void  *base,  int  nmemb,  int  size, int(*com‐
       par)(const void *, const void *));

       void cbssort(void  *base,  int  nmemb,  int  size,  int(*com‐
       par)(const void *, const void *));

       void  cbhsort(void  *base,  int  nmemb,  int  size, int(*com‐
       par)(const void *, const void *));

       void cbqsort(void  *base,  int  nmemb,  int  size,  int(*com‐
       par)(const void *, const void *));

       int cbstricmp(const char *astr, const char *bstr);

       int cbstrfwmatch(const char *str, const char *key);

       int cbstrfwimatch(const char *str, const char *key);

       int cbstrbwmatch(const char *str, const char *key);

       int cbstrbwimatch(const char *str, const char *key);

       char *cbstrstrkmp(const char *haystack, const char *needle);

       char *cbstrstrbm(const char *haystack, const char *needle);

       char *cbstrtoupper(char *str);

       char *cbstrtolower(char *str);

       char *cbstrtrim(char *str);

       char *cbstrsqzspc(char *str);

       int cbstrcountutf(const char *str);

       char *cbstrcututf(char *str, int num);

       CBDATUM *cbdatumopen(const char *ptr, int size);

       CBDATUM *cbdatumdup(const CBDATUM *datum);

       void cbdatumclose(CBDATUM *datum);

       void cbdatumcat(CBDATUM *datum, const char *ptr, int size);

       const char *cbdatumptr(const CBDATUM *datum);

       int cbdatumsize(const CBDATUM *datum);

       void cbdatumsetsize(CBDATUM *datum, int size);

       char *cbdatumtomalloc(CBDATUM *datum, int *sp);

       CBLIST *cblistopen(void);

       CBLIST *cblistdup(const CBLIST *list);

       void cblistclose(CBLIST *list);

       int cblistnum(const CBLIST *list);

       const  char  *cblistval(const  CBLIST  *list,  int index, int
       *sp);

       void cblistpush(CBLIST *list, const char *ptr, int size);

       char *cblistpop(CBLIST *list, int *sp);

       void cblistunshift(CBLIST *list, const char *ptr, int size);

       char *cblistshift(CBLIST *list, int *sp);

       void cblistinsert(CBLIST *list, int index, const  char  *ptr,
       int size);

       char *cblistremove(CBLIST *list, int index, int *sp);

       void cblistover(CBLIST *list, int index, const char *ptr, int
       size);

       void cblistsort(CBLIST *list);

       int cblistlsearch(const CBLIST *list, const  char  *ptr,  int
       size);

       int  cblistbsearch(const  CBLIST  *list, const char *ptr, int
       size);

       char *cblistdump(const CBLIST *list, int *sp);

       CBLIST *cblistload(const char *ptr, int size);

       CBMAP *cbmapopen(void);

       CBMAP *cbmapdup(CBMAP *map);

       void cbmapclose(CBMAP *map);

       int cbmapput(CBMAP *map, const char *kbuf,  int  ksiz,  const
       char *vbuf, int vsiz, int over);

       void  cbmapputcat(CBMAP  *map,  const  char  *kbuf, int ksiz,
       const char *vbuf, int vsiz);

       int cbmapout(CBMAP *map, const char *kbuf, int ksiz);

       const char *cbmapget(const CBMAP *map, const char *kbuf,  int
       ksiz, int *sp);

       int  cbmapmove(CBMAP  *map,  const  char *kbuf, int ksiz, int
       head);

       void cbmapiterinit(CBMAP *map);

       const char *cbmapiternext(CBMAP *map, int *sp);

       const char *cbmapiterval(const char *kbuf, int *sp);

       int cbmaprnum(const CBMAP *map);

       CBLIST *cbmapkeys(CBMAP *map);

       CBLIST *cbmapvals(CBMAP *map);

       char *cbmapdump(const CBMAP *map, int *sp);

       CBMAP *cbmapload(const char *ptr, int size);

       char *cbmaploadone(const char  *ptr,  int  size,  const  char
       *kbuf, int ksiz, int *sp);

       CBHEAP *cbheapopen(int size, int max, int(*compar)(const void
       *, const void *));

       CBHEAP *cbheapdup(CBHEAP *heap);

       void cbheapclose(CBHEAP *heap);

       int cbheapnum(CBHEAP *heap);

       int cbheapinsert(CBHEAP *heap, const void *ptr);

       void *cbheapval(CBHEAP *heap, int index);

       void *cbheaptomalloc(CBHEAP *heap, int *np);

       char *cbsprintf(const char *format, ...);

       char *cbreplace(const char *str, CBMAP *pairs);

       CBLIST  *cbsplit(const  char  *ptr,  int  size,  const   char
       *delim);

       char *cbreadfile(const char *name, int *sp);

       int cbwritefile(const char *name, const char *ptr, int size);

       CBLIST *cbreadlines(const char *name);

       CBLIST *cbdirlist(const char *name);

       int  cbfilestat(const  char  *name,  int *isdirp, int *sizep,
       time_t *mtimep);

       int cbremove(const char *name);

       CBMAP *cburlbreak(const char *str);

       char *cburlresolve(const char *base, const char *target);

       char *cburlencode(const char *ptr, int size);

       char *cburldecode(const char *str, int *sp);

       char *cbbaseencode(const char *ptr, int size);

       char *cbbasedecode(const char *str, int *sp);

       char *cbquoteencode(const char *ptr, int size);

       char *cbquotedecode(const char *str, int *sp);

       char *cbmimebreak(const char *ptr, int  size,  CBMAP  *attrs,
       int *sp);

       CBLIST  *cbmimeparts(const  char  *ptr,  int size, const char
       *boundary);

       char *cbmimeencode(const char *str, const char *encname,  int
       base);

       char *cbmimedecode(const char *str, char *enp);

       CBLIST *cbcsvrows(const char *str);

       CBLIST *cbcsvcells(const char *str);

       char *cbcsvescape(const char *str);

       char *cbcsvunescape(const char *str);

       CBLIST *cbxmlbreak(const char *str, int cr);

       CBMAP *cbxmlattrs(const char *str);

       char *cbxmlescape(const char *str);

       char *cbxmlunescape(const char *str);

       char *cbdeflate(const char *ptr, int size, int *sp);

       char *cbinflate(const char *ptr, int size, int *sp);

       char *cbgzencode(const char *ptr, int size, int *sp);

       char *cbgzdecode(const char *ptr, int size, int *sp);

       unsigned int cbgetcrc(const char *ptr, int size);

       char *cblzoencode(const char *ptr, int size, int *sp);

       char *cblzodecode(const char *ptr, int size, int *sp);

       char *cbbzencode(const char *ptr, int size, int *sp);

       char *cbbzdecode(const char *ptr, int size, int *sp);

       char  *cbiconv(const  char *ptr, int size, const char *icode,
       const char *ocode, int *sp, int *mp);

       const char *cbencname(const char *ptr, int size);

       int cbjetlag(void);

       void cbcalendar(time_t t, int jl, int *yearp, int *monp,  int
       *dayp, int *hourp, int *minp, int *secp);

       int cbdayofweek(int year, int mon, int day);

       char *cbdatestrwww(time_t t, int jl);

       char *cbdatestrhttp(time_t t, int jl);

       time_t cbstrmktime(const char *str);

       void cbproctime(double *usrp, double *sysp);

       void cbstdiobin(void);


DESCRIPTION
       Cabin  is  the  utility  API which provides memory allocating
       functions, sorting functions, extensible datum,  array  list,
       hash  map,  heap array, and so on for handling records easily
       on memory.  This API features also  parsing  MIME,  CSV,  and
       XML, and features various types of encoding and decoding.

       In  order  to  use  Cabin,  you  should include `cabin.h' and
       `stdlib.h' in  the  source  files.   Usually,  the  following
       description will be near the beginning of a source file.

              #include <cabin.h>
              #include <stdlib.h>

       A  pointer  to `CBDATUM' is used as a handle of an extensible
       datum.  A datum handle is opened with the  function  `cbdatu‐
       mopen' and closed with `cbdatumclose'.  A pointer to `CBLIST'
       is used as a handle of an  array  list.   A  list  handle  is
       opened   with  the  function  `cblistopen'  and  closed  with
       `cblistclose'.  A pointer to `CBMAP' is used as a handle of a
       hash   map.   A  map  handle  is  opened  with  the  function
       `cbmapopen' and  closed  with  `cbmapclose'.   A  pointer  to
       `CBHEAP'  is used as a handle of a heap array.  A heap handle
       is opened with the  function  `cbheapopen'  and  closed  with
       `cbheapclose'.   You  should not refer directly to any member
       of each handles.

       The external variable `cbfatalfunc' is the  pointer  to  call
       back function for handling a fatal error.

       extern void (*cbfatalfunc)(const char *message);
              The argument specifies the error message.  The initial
              value of this variable is `NULL'.   If  the  value  is
              `NULL',  the  default  function is called when a fatal
              error occurs.  A fatal error occurs when memory  allo‐
              cation is failed.

       The function `cbmalloc' is used in order to allocate a region
       on memory.

       void *cbmalloc(size_t size);
              `size' specifies the size of the region.   The  return
              value is the pointer to the allocated region.  Because
              the region of the return value is allocated  with  the
              `malloc'  call,  it should be released with the `free'
              call if it is no longer in use.

       The function `cbrealloc' is used in order  to  re-allocate  a
       region on memory.

       void *cbrealloc(void *ptr, size_t size);
              `ptr' specifies the pointer to a region.  `size' spec‐
              ifies the size of the region.  The return value is the
              pointer  to  the  re-allocated  region.   Because  the
              region of the return value is allocated with the `mal‐
              loc'  call, it should be released with the `free' call
              if it is no longer in use.

       The function `cbmemdup' is  used  in  order  to  duplicate  a
       region on memory.

       char *cbmemdup(const char *ptr, int size);
              `ptr' specifies the pointer to a region.  `size' spec‐
              ifies the size of the region.  If it is negative,  the
              size is assigned with `strlen(ptr)'.  The return value
              is the pointer to the allocated region of  the  dupli‐
              cate.   Because an additional zero code is appended at
              the end of the region of the return value, the  return
              value  can  be treated as a character string.  Because
              the region of the return value is allocated  with  the
              `malloc'  call,  it should be released with the `free'
              call if it is no longer in use.

       The function `cbfree' is used in order to free  a  region  on
       memory.

       void cbfree(void *ptr);
              `ptr'  specifies  the  pointer  to a region.  If it is
              `NULL', this function has no  effect.   Although  this
              function  is  just  a  wrapper of `free' call, this is
              useful in applications using another  package  of  the
              `malloc' series.

       The  function  `cbglobalgc'  is used in order to register the
       pointer or handle of an object to the global garbage  collec‐
       tor.

       void cbglobalgc(void *ptr, void (*func)(void *));
              `ptr'  specifies  the  pointer or handle of an object.
              `func' specifies the pointer to a function to  release
              resources  of the object.  Its argument is the pointer
              or handle of the object  to  release.   This  function
              assures  that resources of an object are released when
              the process  exits  normally  by  returning  from  the
              `main' function or calling the `exit' function.

       The  function  `cbggcsweep'  is used in order to exercise the
       global garbage collector explicitly.

       void cbggcsweep(void);
              Note that you should not use objects registered to the
              global garbage collector any longer after calling this
              function.  Because the  global  garbage  collector  is
              initialized and you can register new objects into it.

       The  function  `cbvmemavail' is used in order to check avail‐
       ability of allocation of the virtual memory.

       int cbvmemavail(size_t size);
              `size' specifies the size of region  to  be  allocated
              newly.   The return value is true if allocation should
              be success, or false if not.

       The function `cbisort' is used in  order  to  sort  an  array
       using insert sort.

       void  cbisort(void  *base,  int  nmemb,  int  size, int(*com‐
       par)(const void *, const void *));
              `base' specifies the pointer  to  an  array.   `nmemb'
              specifies the number of elements of the array.  `size'
              specifies the size of each element.   `compar'  speci‐
              fies the pointer to comparing function.  The two argu‐
              ments specify the pointers of elements.  The comparing
              function should returns positive if the former is big,
              negative if the latter is big, 0 if  both  are  equal.
              Insert  sort is useful only if most elements have been
              sorted already.

       The function `cbssort' is used in  order  to  sort  an  array
       using shell sort.

       void  cbssort(void  *base,  int  nmemb,  int  size, int(*com‐
       par)(const void *, const void *));
              `base' specifies the pointer  to  an  array.   `nmemb'
              specifies the number of elements of the array.  `size'
              specifies the size of each element.   `compar'  speci‐
              fies the pointer to comparing function.  The two argu‐
              ments specify the pointers of elements.  The comparing
              function should returns positive if the former is big,
              negative if the latter is big, 0 if  both  are  equal.
              If  most  elements have been sorted, shell sort may be
              faster than heap sort or quick sort.

       The function `cbhsort' is used in  order  to  sort  an  array
       using heap sort.

       void  cbhsort(void  *base,  int  nmemb,  int  size, int(*com‐
       par)(const void *, const void *));
              `base' specifies the pointer  to  an  array.   `nmemb'
              specifies the number of elements of the array.  `size'
              specifies the size of each element. `compar' specifies
              the  pointer to comparing function.  The two arguments
              specify the pointers of elements.  The comparing func‐
              tion  should  returns  positive  if the former is big,
              negative if the latter is big, 0 if  both  are  equal.
              Although  heap  sort  is robust against bias of input,
              quick sort is faster in most cases.

       The function `cbqsort' is used in  order  to  sort  an  array
       using quick sort.

       void  cbqsort(void  *base,  int  nmemb,  int  size, int(*com‐
       par)(const void *, const void *));
              `base' specifies the pointer  to  an  array.   `nmemb'
              specifies the number of elements of the array.  `size'
              specifies the size of each element. `compar' specifies
              the  pointer to comparing function.  The two arguments
              specify the pointers of elements.  The comparing func‐
              tion  should  returns  positive  if the former is big,
              negative if the latter is big, 0 if  both  are  equal.
              Being  sensitive  to  bias of input, quick sort is the
              fastest sorting algorithm.

       The function `cbstricmp' is used  in  order  to  compare  two
       strings with case insensitive evaluation.

       int cbstricmp(const char *astr, const char *bstr);
              `astr'  specifies  the  pointer of one string.  `astr'
              specifies the pointer of the other string.  The return
              value  is  positive  if the former is big, negative if
              the latter is big, 0 if both  are  equivalent.   Upper
              cases  and  lower cases of alphabets in ASCII code are
              not distinguished.

       The function `cbstrfwmatch' is used in order to check whether
       a string begins with a key.

       int cbstrfwmatch(const char *str, const char *key);
              `str' specifies the pointer of a target string.  `key'
              specifies  the  pointer  of  a  forward  matching  key
              string.  The return value is true if the target string
              begins with the key, else, it is false.

       The function  `cbstrfwimatch'  is  used  in  order  to  check
       whether  a  string  begins  with a key, with case insensitive
       evaluation.

       int cbstrfwimatch(const char *str, const char *key);
              `str' specifies the pointer of a target string.  `key'
              specifies  the  pointer  of  a  forward  matching  key
              string.  The return value is true if the target string
              begins  with  the key, else, it is false.  Upper cases
              and lower cases of alphabets in  ASCII  code  are  not
              distinguished.

       The function `cbstrbwmatch' is used in order to check whether
       a string ends with a key.

       int cbstrbwmatch(const char *str, const char *key);
              `str' specifies the pointer of a target string.  `key'
              specifies  the  pointer  of  a  backward  matching key
              string.  The return value is true if the target string
              ends with the key, else, it is false.

       The  function  `cbstrbwimatch'  is  used  in  order  to check
       whether a string ends with a key, with case insensitive eval‐
       uation.

       int cbstrbwimatch(const char *str, const char *key);
              `str' specifies the pointer of a target string.  `key'
              specifies the  pointer  of  a  backward  matching  key
              string.  The return value is true if the target string
              ends with the key, else, it is false.  Upper cases and
              lower cases of alphabets in ASCII code are not distin‐
              guished.

       The function `cbstrstrkmp' is used in order to locate a  sub‐
       string in a string using KMP method.

       char *cbstrstrkmp(const char *haystack, const char *needle);
              `haystack'  specifies  the pointer of a target string.
              `needle' specifies the pointer of a  substring  to  be
              found.   The return value is the pointer to the begin‐
              ning of the substring or `NULL' if  the  substring  is
              not  found.   In  most  cases,  `strstr' as a built-in
              function of the compiler is faster than this function.

       The function `cbstrstrkmp' is used in order to locate a  sub‐
       string in a string using BM method.

       char *cbstrstrbm(const char *haystack, const char *needle);
              `haystack'  specifies  the pointer of a target string.
              `needle' specifies the pointer of a  substring  to  be
              found.   The return value is the pointer to the begin‐
              ning of the substring or `NULL' if  the  substring  is
              not  found.   In  most  cases,  `strstr' as a built-in
              function of the compiler is faster than this function.

       The function `cbstrtoupper' is used in order to  convert  the
       letters of a string to upper case.

       char *cbstrtoupper(char *str);
              `str'  specifies  the  pointer of a string to convert.
              The return value is the pointer to the string.

       The function `cbstrtolower' is used in order to  convert  the
       letters of a string to lower case.

       char *cbstrtolower(char *str);
              `str'  specifies  the  pointer of a string to convert.
              The return value is the pointer to the string.

       The function `cbstrtrim' is used in order to cut space  char‐
       acters at head or tail of a string.

       char *cbstrtrim(char *str);
              `str'  specifies  the  pointer of a string to convert.
              The return value is the pointer to the string.

       The function `cbstrsqzspc' is used in order to squeeze  space
       characters in a string and trim it.

       char *cbstrsqzspc(char *str);
              `str'  specifies  the  pointer of a string to convert.
              The return value is the pointer to the string.

       The function `cbstrcountutf' is used in order  to  count  the
       number of characters in a string of UTF-8.

       int cbstrcountutf(const char *str);
              `str' specifies the pointer of a string of UTF-8.  The
              return value  is  the  number  of  characters  in  the
              string.

       The  function  `cbstrcututf' is used in order to cut a string
       of UTF-8 at the specified number of characters.

       char *cbstrcututf(char *str, int num);
              `str' specifies the pointer  of  a  string  of  UTF-8.
              `num'  specifies  the number of characters to be kept.
              The return value is the pointer to the string.

       The function `cbdatumopen' is used in order to  get  a  datum
       handle.

       CBDATUM *cbdatumopen(const char *ptr, int size);
              `ptr'  specifies the pointer to the region of the ini‐
              tial content.  If it is `NULL', an empty datum is cre‐
              ated.  `size' specifies the size of the region.  If it
              is negative, the size is assigned with  `strlen(ptr)'.
              The return value is a datum handle.

       The function `cbdatumdup' is used in order to copy a datum.

       CBDATUM *cbdatumdup(const CBDATUM *datum);
              `datum' specifies a datum handle.  The return value is
              a new datum handle.

       The function `cbdatumclose' is used in order to free a  datum
       handle.

       void cbdatumclose(CBDATUM *datum);
              `datum'  specifies a datum handle.  Because the region
              of a closed handle is released, it becomes  impossible
              to use the handle.

       The  function  `cbdatumcat' is used in order to concatenate a
       datum and a region.

       void cbdatumcat(CBDATUM *datum, const char *ptr, int size);
              `datum' specifies a datum handle.  `ptr' specifies the
              pointer  to  the region to be appended.  `size' speci‐
              fies the size of the region.  If it is  negative,  the
              size is assigned with `strlen(ptr)'.

       The function `cbdatumptr' is used in order to get the pointer
       of the region of a datum.

       const char *cbdatumptr(const CBDATUM *datum);
              `datum' specifies a datum handle.  The return value is
              the  pointer  of  the  region  of a datum.  Because an
              additional zero code is appended at  the  end  of  the
              region  of  the  return value, the return value can be
              treated as a character string.

       The function `cbdatumsize' is used in order to get  the  size
       of the region of a datum.

       int cbdatumsize(const CBDATUM *datum);
              `datum' specifies a datum handle.  The return value is
              the size of the region of a datum.

       The function `cbdatumsetsize' is used in order to change  the
       size of the region of a datum.

       void cbdatumsetsize(CBDATUM *datum, int size);
              `datum'  specifies  a  datum handle.  `size' specifies
              the new size of the region.  If the new size is bigger
              than the one of old, the surplus region is filled with
              zero codes.

       The function `cbdatumtomalloc' is used in order to convert  a
       datum to an allocated region.

       char *cbdatumtomalloc(CBDATUM *datum, int *sp);
              `datum'  specifies a datum handle.  `sp' specifies the
              pointer to a variable to which the size of the  region
              of  the return value is assigned.  If it is `NULL', it
              is not used.  The return value is the pointer  to  the
              region  of the datum.  Because an additional zero code
              is appended at the end of the  region  of  the  return
              value,  the return value can be treated as a character
              string.  Because the region of  the  return  value  is
              allocated   with  the  `malloc'  call,  it  should  be
              released with the `free' call if it is  no  longer  in
              use.   Because  the  region  of  the original datum is
              released, it should not be released again.

       The function `cblistopen' is used in order to get a list han‐
       dle.

       CBLIST *cblistopen(void);
              The return value is a list handle.

       The function `cblistdup' is used in order to copy a list.

       CBLIST *cblistdup(const CBLIST *list);
              `list' specifies a list handle.  The return value is a
              new list handle.

       The function `cblistclose' is used in order to close  a  list
       handle.

       void cblistclose(CBLIST *list);
              `list' specifies a list handle.  Because the region of
              a closed handle is released, it becomes impossible  to
              use the handle.

       The  function  `cblistnum' is used in order to get the number
       of elements of a list.

       int cblistnum(const CBLIST *list);
              `list' specifies a list handle.  The return  value  is
              the number of elements of the list.

       The  function `cblistval' is used in order to get the pointer
       to the region of an element of a list.

       const char *cblistval(const  CBLIST  *list,  int  index,  int
       *sp);
              `list' specifies a list handle.  `index' specifies the
              index of an element.  `sp' specifies the pointer to  a
              variable to which the size of the region of the return
              value is assigned.  If it is `NULL', it is  not  used.
              The  return  value is the pointer to the region of the
              element.  Because an additional zero code is  appended
              at  the  end  of  the  region of the return value, the
              return value can be treated as a character string.  If
              `index'  is  equal  to or more than the number of ele‐
              ments, the return value is `NULL'.

       The function `cblistpush' is used in order to add an  element
       at the end of a list.

       void cblistpush(CBLIST *list, const char *ptr, int size);
              `list'  specifies  a list handle.  `ptr' specifies the
              pointer to the region of an element.  `size' specifies
              the  size  of the region.  If it is negative, the size
              is assigned with `strlen(ptr)'.

       The function `cblistpop' is used in order to remove  an  ele‐
       ment of the end of a list.

       char *cblistpop(CBLIST *list, int *sp);
              `list'  specifies  a  list handle.  `sp' specifies the
              pointer to a variable to which the size of the  region
              of  the return value is assigned.  If it is `NULL', it
              is not used.  The return value is the pointer  to  the
              region  of the value.  Because an additional zero code
              is appended at the end of the  region  of  the  return
              value,  the return value can be treated as a character
              string.  Because the region of  the  return  value  is
              allocated   with  the  `malloc'  call,  it  should  be
              released with the `free' call if it is  no  longer  in
              use.   If  the  list  is  empty,  the  return value is
              `NULL'.

       The function `cblistunshift' is used in order to add an  ele‐
       ment at the top of a list.

       void cblistunshift(CBLIST *list, const char *ptr, int size);
              `list'  specifies  a list handle.  `ptr' specifies the
              pointer to the region of an element.  `size' specifies
              the  size  of the region.  If it is negative, the size
              is assigned with `strlen(ptr)'.

       The function `cblistshift' is used in order to remove an ele‐
       ment of the top of a list.

       char *cblistshift(CBLIST *list, int *sp);
              `list'  specifies  a  list handle.  `sp' specifies the
              pointer to a variable to which the size of the  region
              of  the return value is assigned.  If it is `NULL', it
              is not used.  The return value is the pointer  to  the
              region  of the value.  Because an additional zero code
              is appended at the end of the  region  of  the  return
              value,  the return value can be treated as a character
              string.  Because the region of  the  return  value  is
              allocated   with  the  `malloc'  call,  it  should  be
              released with the `free' call if it is  no  longer  in
              use.   If  the  list  is  empty,  the  return value is
              `NULL'.

       The function `cblistinsert' is used in order to add  an  ele‐
       ment at the specified location of a list.

       void  cblistinsert(CBLIST  *list, int index, const char *ptr,
       int size);
              `list' specifies a list handle.  `index' specifies the
              index  of  an element.  `ptr' specifies the pointer to
              the region of the element.  `size' specifies the  size
              of  the  region.   If  it  is  negative,  the  size is
              assigned with `strlen(ptr)'.

       The function `cblistremove' is used in  order  to  remove  an
       element at the specified location of a list.

       char *cblistremove(CBLIST *list, int index, int *sp);
              `list' specifies a list handle.  `index' specifies the
              index of an element.  `sp' specifies the pointer to  a
              variable to which the size of the region of the return
              value is assigned.  If it is `NULL', it is  not  used.
              The  return  value is the pointer to the region of the
              value.  Because an additional zero code is appended at
              the  end of the region of the return value, the return
              value can be treated as a character  string.   Because
              the  region  of the return value is allocated with the
              `malloc' call, it should be released with  the  `free'
              call  if  it is no longer in use.  If `index' is equal
              to or more than the number of elements, no element  is
              removed and the return value is `NULL'.

       The  function  `cblistover'  is used in order to overwrite an
       element at the specified location of a list.

       void cblistover(CBLIST *list, int index, const char *ptr, int
       size);
              `list' specifies a list handle.  `index' specifies the
              index of an element.  `ptr' specifies the  pointer  to
              the  region  of the new content.  `size' specifies the
              size of the new content.  If it is negative, the  size
              is  assigned  with `strlen(ptr)'.  If `index' is equal
              to or more than the number of elements, this  function
              has no effect.

       The  function  `cblistsort' is used in order to sort elements
       of a list in lexical order.

       void cblistsort(CBLIST *list);
              `list' specifies a list handle.  Quick  sort  is  used
              for sorting.

       The  function  `cblistlsearch'  is  used in order to search a
       list for an element using liner search.

       int cblistlsearch(const CBLIST *list, const  char  *ptr,  int
       size);
              `list'  specifies  a list handle.  `ptr' specifies the
              pointer to the region of a key.  `size' specifies  the
              size  of  the  region.  If it is negative, the size is
              assigned with `strlen(ptr)'.  The return value is  the
              index  of a corresponding element or -1 if there is no
              corresponding element.  If two or more elements corre‐
              sponds, the former returns.

       The  function  `cblistbsearch'  is  used in order to search a
       list for an element using binary search.

       int cblistbsearch(const CBLIST *list, const  char  *ptr,  int
       size);
              `list'  specifies  a list handle.  It should be sorted
              in lexical order.  `ptr' specifies the pointer to  the
              region  of  a  key.   `size' specifies the size of the
              region.  If it is negative, the size is assigned  with
              `strlen(ptr)'.   The  return  value  is the index of a
              corresponding element or -1 if there is no correspond‐
              ing  element.   If  two  or more elements corresponds,
              which returns is not defined.

       The function `cblistdump' is used in  order  to  serialize  a
       list into a byte array.

       char *cblistdump(const CBLIST *list, int *sp);
              `list'  specifies  a  list handle.  `sp' specifies the
              pointer to a variable to which the size of the  region
              of  the return value is assigned.  The return value is
              the pointer to the region of the result serial region.
              Because  the  region  of the return value is allocated
              with the `malloc' call, it should be released with the
              `free' call if it is no longer in use.

       The  function `cblistload' is used in order to redintegrate a
       serialized list.

       CBLIST *cblistload(const char *ptr, int size);
              `ptr' specifies the pointer to a byte  array.   `size'
              specifies the size of the region.  The return value is
              a new list handle.

       The function `cbmapopen' is used in order to get a  map  han‐
       dle.

       CBMAP *cbmapopen(void);
              The return value is a map handle.

       The function `cbmapdup' is used in order to copy a map.

       CBMAP *cbmapdup(CBMAP *map);
              `map'  specifies  a map handle.  The return value is a
              new map handle.  The iterator of  the  source  map  is
              initialized.

       The  function  `cbmapclose'  is  used in order to close a map
       handle.

       void cbmapclose(CBMAP *map);
              `map' specifies a map handle.  Because the region of a
              closed  handle  is  released, it becomes impossible to
              use the handle.

       The function `cbmapput' is used in order to  store  a  record
       into a map.

       int  cbmapput(CBMAP  *map,  const char *kbuf, int ksiz, const
       char *vbuf, int vsiz, int over);
              `map' specifies a map handle.   `kbuf'  specifies  the
              pointer  to the region of a key.  `ksiz' specifies the
              size of the region of the key.  If it is negative, the
              size  is  assigned with `strlen(kbuf)'.  `vbuf' speci‐
              fies the pointer to the region  of  a  value.   `vsiz'
              specifies  the size of the region of the value.  If it
              is negative, the size is assigned with `strlen(vbuf)'.
              `over'  specifies  whether the value of the duplicated
              record is overwritten or not.  If `over' is false  and
              the  key  is  duplicated,  the  return value is false,
              else, it is true.

       The function `cbmapputcat' is used in order to concatenate  a
       value at the end of the value of the existing record.

       void  cbmapputcat(CBMAP  *map,  const  char  *kbuf, int ksiz,
       const char *vbuf, int vsiz);
              `map' specifies a map handle.   `kbuf'  specifies  the
              pointer  to the region of a key.  `ksiz' specifies the
              size of the region of the key.  If it is negative, the
              size  is  assigned with `strlen(kbuf)'.  `vbuf' speci‐
              fies the pointer to the region  of  a  value.   `vsiz'
              specifies  the size of the region of the value.  If it
              is negative, the size is assigned with `strlen(vbuf)'.
              If  there  is no corresponding record, a new record is
              created.

       The function `cbmapout' is used in order to delete  a  record
       in a map.

       int cbmapout(CBMAP *map, const char *kbuf, int ksiz);
              `map'  specifies  a  map handle.  `kbuf' specifies the
              pointer to the region of a key.  `ksiz' specifies  the
              size of the region of the key.  If it is negative, the
              size is assigned with `strlen(kbuf)'.  If  successful,
              the  return  value is true.  False is returned when no
              record corresponds to the specified key.

       The function `cbmapget' is used in order to retrieve a record
       in a map.

       const  char *cbmapget(const CBMAP *map, const char *kbuf, int
       ksiz, int *sp);
              `map' specifies a map handle.   `kbuf'  specifies  the
              pointer  to the region of a key.  `ksiz' specifies the
              size of the region of the key.  If it is negative, the
              size  is assigned with `strlen(kbuf)'.  `sp' specifies
              the pointer to a variable to which  the  size  of  the
              region  of  the  return  value  is assigned.  If it is
              `NULL', it is not used.   If  successful,  the  return
              value is the pointer to the region of the value of the
              corresponding record.   `NULL'  is  returned  when  no
              record  corresponds.   Because an additional zero code
              is appended at the end of the  region  of  the  return
              value,  the return value can be treated as a character
              string.

       The function `cbmapmove' is used in order to move a record to
       the edge of a map.

       int  cbmapmove(CBMAP  *map,  const  char *kbuf, int ksiz, int
       head);
              `map' specifies a map handle.   `kbuf'  specifies  the
              pointer  to the region of a key.  `ksiz' specifies the
              size of the region of the key.  If it is negative, the
              size  is  assigned with `strlen(kbuf)'.  `head' speci‐
              fies the destination which is head if it  is  true  or
              tail  if  else.   If  successful,  the return value is
              true.  False is returned when no record corresponds to
              the specified key.

       The  function  `cbmapiterinit' is used in order to initialize
       the iterator of a map.

       void cbmapiterinit(CBMAP *map);
              `map' specifies a map handle.  The iterator is used in
              order  to  access  the key of every record stored in a
              map.

       The function `cbmapiternext' is used in order to get the next
       key of the iterator of a map.

       const char *cbmapiternext(CBMAP *map, int *sp);
              `map'  specifies  a  map  handle.   `sp' specifies the
              pointer to a variable to which the size of the  region
              of  the return value is assigned.  If it is `NULL', it
              is not used.  If successful, the return value  is  the
              pointer  to  the  region  of the next key, else, it is
              `NULL'.  `NULL' is returned when no record  is  to  be
              get  out  of the iterator.  Because an additional zero
              code is appended at the  end  of  the  region  of  the
              return  value,  the  return  value can be treated as a
              character string.  The order of iteration  is  assured
              to be the same of the one of storing.

       The function `cbmapiterval' is used in order to get the value
       binded to the key fetched from the iterator of a map.

       const char *cbmapiterval(const char *kbuf, int *sp);
              `kbuf' specifies the pointer to the region of a itera‐
              tion key.  `sp' specifies the pointer to a variable to
              which the size of the region of the  return  value  is
              assigned.   If  it  is  `NULL',  it  is not used.  The
              return value is the pointer to the region of the value
              of  the  corresponding  record.  Because an additional
              zero code is appended at the end of the region of  the
              return  value,  the  return  value can be treated as a
              character string.

       The function `cbmaprnum' is used in order to get  the  number
       of the records stored in a map.

       int cbmaprnum(const CBMAP *map);
              `map' specifies a map handle.  The return value is the
              number of the records stored in the map.

       The function `cbmapkeys' is used in order  to  get  the  list
       handle contains all keys in a map.

       CBLIST *cbmapkeys(CBMAP *map);
              `map' specifies a map handle.  The return value is the
              list handle contains all keys in the map.  Because the
              handle of the return value is opened with the function
              `cblistopen', it should be closed  with  the  function
              `cblistclose' if it is no longer in use.

       The  function  `cbmapvals'  is  used in order to get the list
       handle contains all values in a map.

       CBLIST *cbmapvals(CBMAP *map);
              `map' specifies a map handle.  The return value is the
              list  handle  contains all values in the map.  Because
              the handle of the return  value  is  opened  with  the
              function  `cblistopen',  it  should be closed with the
              function `cblistclose' if it is no longer in use.

       The function `cbmapdump' is used in order to serialize a  map
       into a byte array.

       char *cbmapdump(const CBMAP *map, int *sp);
              `map'  specifies  a  map  handle.   `sp' specifies the
              pointer to a variable to which the size of the  region
              of  the return value is assigned.  The return value is
              the pointer to the region of the result serial region.
              Because  the  region  of the return value is allocated
              with the `malloc' call, it should be released with the
              `free' call if it is no longer in use.

       The  function  `cbmapload' is used in order to redintegrate a
       serialized map.

       CBMAP *cbmapload(const char *ptr, int size);
              `ptr' specifies the pointer to a byte  array.   `size'
              specifies the size of the region.  The return value is
              a new map handle.

       The function `cbmaploadone' is used in  order  to  extract  a
       record from a serialized map.

       char  *cbmaploadone(const  char  *ptr,  int  size, const char
       *kbuf, int ksiz, int *sp);
              `ptr' specifies the pointer to a byte  array.   `size'
              specifies  the  size  of the region.  `kbuf' specifies
              the pointer to the region of a key.  `ksiz'  specifies
              the size of the region of the key.  If it is negative,
              the size is assigned with `strlen(kbuf)'.  `sp' speci‐
              fies  the  pointer  to a variable to which the size of
              the region of the return value is assigned.  If it  is
              `NULL',  it  is  not  used.  If successful, the return
              value is the pointer to the region of the value of the
              corresponding  record.   `NULL'  is  returned  when no
              record corresponds.  Because an additional  zero  code
              is  appended  at  the  end of the region of the return
              value, the return value can be treated as a  character
              string.

       The function `cbheapopen' is used in order to get a heap han‐
       dle.

       CBHEAP *cbheapopen(int size, int max, int(*compar)(const void
       *, const void *));
              `size' specifies the size of each record.  `max' spec‐
              ifies the maximum  number  of  records  in  the  heap.
              `compar'  specifies the pointer to comparing function.
              The two arguments specify  the  pointers  of  records.
              The  comparing function should returns positive if the
              former is big, negative if the latter  is  big,  0  if
              both are equal.  The return value is a heap handle.

       The function `cbheapdup' is used in order to copy a heap.

       CBHEAP *cbheapdup(CBHEAP *heap);
              `heap' specifies a heap handle.  The return value is a
              new heap handle.

       The function `cbheapclose' is used in order to close  a  heap
       handle.

       void cbheapclose(CBHEAP *heap);
              `heap' specifies a heap handle.  Because the region of
              a closed handle is released, it becomes impossible  to
              use the handle.

       The  function  `cbheapnum' is used in order to get the number
       of the records stored in a heap.

       int cbheapnum(CBHEAP *heap);
              `heap' specifies a heap handle.  The return  value  is
              the number of the records stored in the heap.

       The  function  `cbheapinsert'  is  used  in order to insert a
       record into a heap.

       int cbheapinsert(CBHEAP *heap, const void *ptr);
              `heap' specifies a heap handle.  `ptr'  specifies  the
              pointer  to  the region of a record.  The return value
              is true if the record is added, else  false.   If  the
              new record is bigger than the biggest existing regord,
              the new record is not added.  If  the  new  record  is
              added  and  the  number of records exceeds the maximum
              number, the biggest existing record is removed.

       The function `cbheapval' is used in order to get the  pointer
       to the region of a record in a heap.

       void *cbheapval(CBHEAP *heap, int index);
              `heap' specifies a heap handle.  `index' specifies the
              index of a record.  The return value is the pointer to
              the  region  of the record.  If `index' is equal to or
              more than the number of records, the return  value  is
              `NULL'.   Note that records are organized by the naga‐
              tive order the comparing function.

       The function `cbheaptomalloc' is used in order to  convert  a
       heap to an allocated region.

       void *cbheaptomalloc(CBHEAP *heap, int *np);
              `heap'  specifies  a  heap handle.  `np' specifies the
              pointer to a variable to which the number  of  records
              of  the return value is assigned.  If it is `NULL', it
              is not used.  The return value is the pointer  to  the
              region  of the heap.  Records are sorted.  Because the
              region of the return value is allocated with the `mal‐
              loc'  call, it should be released with the `free' call
              if it is no longer in use.  Because the region of  the
              original  heap  is released, it should not be released
              again.

       The function `cbsprintf' is used in order to allocate a  for‐
       matted string on memory.

       char *cbsprintf(const char *format, ...);
              `format'  specifies  a printf-like format string.  The
              conversion character `%' can be used  with  such  flag
              characters  as `d', `o', `u', `x', `X', `e', `E', `f',
              `g', `G', `c', `s', and `%'.  Specifiers of the  field
              length  and  the precision can be put between the con‐
              version characters and the flag characters.  The spec‐
              ifiers  consist  of decimal characters, `.', `+', `-',
              and the space character.  The other arguments are used
              according  to  the format string.  The return value is
              the pointer to the  allocated  region  of  the  result
              string.   Because  the  region  of the return value is
              allocated  with  the  `malloc'  call,  it  should   be
              released  with  the  `free' call if it is no longer in
              use.

       The function `cbreplace' is used in  order  to  replace  some
       patterns in a string.

       char *cbreplace(const char *str, CBMAP *pairs);
              `str'  specifies  the  pointer  to  a  source  string.
              `pairs' specifies the handle  of  a  map  composed  of
              pairs  of replacement.  The key of each pair specifies
              a pattern before replacement and its  value  specifies
              the  pattern  after  replacement.  The return value is
              the pointer to the  allocated  region  of  the  result
              string.   Because  the  region  of the return value is
              allocated  with  the  `malloc'  call,  it  should   be
              released  with  the  `free' call if it is no longer in
              use.

       The function `cbsplit' is used in order to  make  a  list  by
       splitting a serial datum.

       CBLIST   *cbsplit(const  char  *ptr,  int  size,  const  char
       *delim);
              `ptr' specifies the  pointer  to  the  region  of  the
              source  content.   `size'  specifies  the  size of the
              region.  If it is negative, the size is assigned  with
              `strlen(ptr)'.   `delim' specifies a string containing
              delimiting characters.  If it is `NULL', zero code  is
              used  as a delimiter.  The return value is a list han‐
              dle.  If two delimiters are successive, it is  assumed
              that an empty element is between the two.  Because the
              handle of the return value is opened with the function
              `cblistopen',  it  should  be closed with the function
              `cblistclose'.

       The function `cbreadfile' is used in order to read whole data
       of a file.

       char *cbreadfile(const char *name, int *sp);
              `name' specifies the name of a file.  If it is `NULL',
              the standard input is specified.  `sp'  specifies  the
              pointer  to a variable to which the size of the region
              of the return value is assigned.  If it is `NULL',  it
              is  not  used.  The return value is the pointer to the
              allocated region of the read data.  Because  an  addi‐
              tional  zero code is appended at the end of the region
              of the return value, the return value can  be  treated
              as  a  character  string.   Because  the region of the
              return value is allocated with the `malloc'  call,  it
              should  be  released  with the `free' call if it is no
              longer in use.

       The function `cbwritefile' is used in order to write a serial
       datum into a file.

       int cbwritefile(const char *name, const char *ptr, int size);
              `name  specifies the name of a file.  If it is `NULL',
              the standard output is specified.  `ptr' specifies the
              pointer  to  the region of the source content.  `size'
              specifies the size of the region.  If it is  negative,
              the  size is assigned with `strlen(ptr)'.  If success‐
              ful, the return value is true, else, it is false.   If
              the  file exists, it is overwritten.  Else, a new file
              is created.

       The function `cbreadlines' is used in  order  to  read  every
       line of a file.

       CBLIST *cbreadlines(const char *name);
              `name' specifies the name of a file.  If it is `NULL',
              the standard input is specified.  The return value  is
              a  list  handle of the lines if successful, else it is
              NULL.  Line separators are cut out.  Because the  han‐
              dle  of  the  return value is opened with the function
              `cblistopen', it should be closed  with  the  function
              `cblistclose' if it is no longer in use.

       The  function  `cbdirlist'  is used in order to read names of
       files in a directory.

       CBLIST *cbdirlist(const char *name);
              `name' specifies the name of a directory.  The  return
              value is a list handle of names if successful, else it
              is NULL.  Because the handle of the  return  value  is
              opened  with  the  function `cblistopen', it should be
              closed with the function `cblistclose'  if  it  is  no
              longer in use.

       The  function `cbfilestat' is used in order to get the status
       of a file or a directory.

       int cbfilestat(const char *name,  int  *isdirp,  int  *sizep,
       time_t *mtimep);
              `name'  specifies  the  name of a file or a directory.
              `dirp' specifies the pointer to a  variable  to  which
              whether the file is a directory is assigned.  If it is
              `NULL', it is not used.  `sizep' specifies the pointer
              to  a  variable  to  which  the  size  of  the file is
              assigned.  If it is `NULL', it is not used.   `mtimep'
              specifies  the pointer to a variable to which the last
              modified time of the  file  is  assigned.   If  it  is
              `NULL',  it  is  not  used.  If successful, the return
              value is true, else, false.  False  is  returned  when
              the file does not exist or the permission is denied.

       The  function `cbremove' is used in order to remove a file or
       a directory and its sub ones recursively.

       int cbremove(const char *name);
              `name' specifies the name of a file  or  a  directory.
              If  successful, the return value is true, else, false.
              False is returned when the file does not exist or  the
              permission is denied.

       The  function `cburlbreak' is used in order to break up a URL
       into elements.

       CBMAP *cburlbreak(const char *str);
              `str' specifies the pointer to a string of  URL.   The
              return  value is a map handle.  Each key of the map is
              the name of an element.  The key "self" specifies  the
              URL  itself.   The  key "scheme" specifies the scheme.
              The key "host" specifies the host of the server.   The
              key  "port"  specifies  the port number of the server.
              The key "authority" specifies the  authority  informa‐
              tion.   The  key  "path"  specifies  the  path  of the
              resource.  The key  "file"  specifies  the  file  name
              without the directory section.  The key "query" speci‐
              fies the query string.  The key  "fragment"  specifies
              the  fragment  string.   Supported  schema  are  HTTP,
              HTTPS, FTP, and FILE.  Absolute URL and  relative  URL
              are supported.  Because the handle of the return value
              is opened with the function `cbmapopen', it should  be
              closed  with  the  function  `cbmapclose'  if it is no
              longer in use.

       The runction `cburlresolve' is used in  order  to  resolve  a
       relative URL with another absolute URL.

       char *cburlresolve(const char *base, const char *target);
              `base'  specifies  an absolute URL of a base location.
              `target' specifies a URL to be resolved.   The  return
              value  is  a resolved URL.  If the target URL is rela‐
              tive, a new URL of relative  location  from  the  base
              location  is returned.  Else, a copy of the target URL
              is returned.  Because the region of the  return  value
              is  allocated  with  the  `malloc'  call, it should be
              released with the `free' call if it is  no  longer  in
              use.

       The  function  `cburlencode'  is  used  in  order to encode a
       serial object with URL encoding.

       char *cburlencode(const char *ptr, int size);
              `ptr' specifies the pointer to a region.  `size' spec‐
              ifies  the size of the region.  If it is negative, the
              size is assigned with `strlen(ptr)'.  The return value
              is  the  pointer  to  the  result string.  Because the
              region of the return value is allocated with the `mal‐
              loc'  call, it should be released with the `free' call
              if it is no longer in use.

       The function `cburldecode' is  used  in  order  to  decode  a
       string encoded with URL encoding.

       char *cburldecode(const char *str, int *sp);
              `str'  specifies the pointer to a source string.  `sp'
              specifies the pointer to a variable to which the  size
              of  the region of the return value is assigned.  If it
              is `NULL', it is not used.  The return  value  is  the
              pointer to the region of the result.  Because an addi‐
              tional zero code is appended at the end of the  region
              of  the  return value, the return value can be treated
              as a character string.   Because  the  region  of  the
              return  value  is allocated with the `malloc' call, it
              should be released with the `free' call if  it  is  no
              longer in use.

       The  function  `cbbaseencode'  is  used  in order to encode a
       serial object with Base64 encoding.

       char *cbbaseencode(const char *ptr, int size);
              `ptr' specifies the pointer to a region.  `size' spec‐
              ifies  the size of the region.  If it is negative, the
              size is assigned with `strlen(ptr)'.  The return value
              is  the  pointer  to  the  result string.  Because the
              region of the return value is allocated with the `mal‐
              loc'  call, it should be released with the `free' call
              if it is no longer in use.

       The function `cbbasedecode' is used  in  order  to  decode  a
       string encoded with Base64 encoding.

       char *cbbasedecode(const char *str, int *sp);
              `str'  specifies the pointer to a source string.  `sp'
              specifies the pointer to a variable to which the  size
              of  the region of the return value is assigned.  If it
              is `NULL', it is not used.  The return  value  is  the
              pointer to the region of the result.  Because an addi‐
              tional zero code is appended at the end of the  region
              of  the  return value, the return value can be treated
              as a character string.   Because  the  region  of  the
              return  value  is allocated with the `malloc' call, it
              should be released with the `free' call if  it  is  no
              longer in use.

       The  function  `cbquoteencode'  is  used in order to encode a
       serial object with quoted-printable encoding.

       char *cbquoteencode(const char *ptr, int size);
              `ptr' specifies the pointer to a region.  `size' spec‐
              ifies  the size of the region.  If it is negative, the
              size is assigned with `strlen(ptr)'.  The return value
              is  the  pointer  to  the  result string.  Because the
              region of the return value is allocated with the `mal‐
              loc'  call, it should be released with the `free' call
              if it is no longer in use.

       The function `cbquotedecode' is used in  order  to  decode  a
       string encoded with quoted-printable encoding.

       char *cbquotedecode(const char *str, int *sp);
              `str'  specifies the pointer to a source string.  `sp'
              specifies the pointer to a variable to which the  size
              of  the region of the return value is assigned.  If it
              is `NULL', it is not used.  The return  value  is  the
              pointer to the region of the result.  Because an addi‐
              tional zero code is appended at the end of the  region
              of  the  return value, the return value can be treated
              as a character string.   Because  the  region  of  the
              return  value  is allocated with the `malloc' call, it
              should be released with the `free' call if  it  is  no
              longer in use.

       The function `cbmimebreak' is used in order to split a string
       of MIME into headers and the body.

       char *cbmimebreak(const char *ptr, int  size,  CBMAP  *attrs,
       int *sp);
              `ptr'  specifies  the  pointer  to  the region of MIME
              data.  `size' specifies the size of the region.  If it
              is  negative, the size is assigned with `strlen(ptr)'.
              `attrs' specifies a map handle  to  store  attributes.
              If  it is `NULL', it is not used.  Each key of the map
              is an attribute name  uncapitalized.   `sp'  specifies
              the  pointer  to  a  variable to which the size of the
              region of the return value  is  assigned.   If  it  is
              `NULL',  it  is  not  used.   The  return value is the
              pointer of the body data.   If  the  content  type  is
              defined, the attribute map has the key "TYPE" specify‐
              ing the type.  If the character encoding  is  defined,
              the key "CHARSET" specifies the encoding name.  If the
              boundary string  of  multipart  is  defined,  the  key
              "BOUNDARY"  specifies the string.  If the content dis‐
              position is defined, the key  "DISPOSITION"  specifies
              the  direction.   If the file name is defined, the key
              "FILENAME" specifies the name.  If the attribute  name
              is   defined,  the  key  "NAME"  specifies  the  name.
              Because the region of the return  value  is  allocated
              with the `malloc' call, it should be released with the
              `free' call if it is no longer in use.

       The function `cbmimeparts' is used in order to  split  multi‐
       part data of MIME into its parts.

       CBLIST  *cbmimeparts(const  char  *ptr,  int size, const char
       *boundary);
              `ptr' specifies the pointer to the region of multipart
              data  of  MIME.   `size'  specifies  the  size  of the
              region.  If it is negative, the size is assigned  with
              `strlen(ptr)'.   `boundary'  specifies  the pointer to
              the region of the boundary string.  The  return  value
              is  a  list  handle.   Each element of the list is the
              string of a part.  Because the handle  of  the  return
              value  is  opened  with  the function `cblistopen', it
              should be closed with the function `cblistclose' if it
              is no longer in use.

       The  function  `cbmimeencode'  is  used  in order to encode a
       string with MIME encoding.

       char *cbmimeencode(const char *str, const char *encname,  int
       base);
              `str'  specifies  the  pointer to a string.  `encname'
              specifies a string of the name of the character encod‐
              ing.   The  return  value is the pointer to the result
              string.  `base' specifies whether to use Base64 encod‐
              ing.   If  it  is  false,  quoted-printable  is  used.
              Because the region of the return  value  is  allocated
              with the `malloc' call, it should be released with the
              `free' call if it is no longer in use.

       The function `cbmimedecode' is used  in  order  to  decode  a
       string encoded with MIME encoding.

       char *cbmimedecode(const char *str, char *enp);
              `str'  specifies  the  pointer  to  an encoded string.
              `enp' specifies the pointer to a region into which the
              name  of  encoding is written.  If it is `NULL', it is
              not used.  The size of the buffer should be  equal  to
              or  more  than  32  bytes.   The  return  value is the
              pointer to the result string.  Because the  region  of
              the  return value is allocated with the `malloc' call,
              it should be releas
Results 1 - 1 of 1
Help - FTP Sites List - Software Dir.
Search over 15 billion files
© 1997-2017 FileWatcher.com