Back to index

courier  0.68.2
buf.c
Go to the documentation of this file.
00001 #include "config.h"
00002 /*
00003 ** Copyright 1998 - 1999 Double Precision, Inc.  See COPYING for
00004 ** distribution information.
00005 */
00006 
00007 
00008 /*
00009 */
00010 #include      <string.h>
00011 #include      "buf.h"
00012 #include      "sqwebmail.h"
00013 
00014 void buf_append(struct buf *b, char c)
00015 {
00016        char cc[2];
00017 
00018        cc[0]=c;
00019        cc[1]=0;
00020        buf_cat(b, cc);
00021 }
00022 
00023 static int buf_allocbuf(struct buf *b, size_t n)
00024 {
00025        if (n > b->size)
00026        {
00027        size_t c=n+64;
00028        char   *p= b->ptr ? realloc(b->ptr, c):malloc(c);
00029 
00030               if (!p)
00031                      return 0;
00032 
00033               b->ptr=p;
00034               b->size=c;
00035        }
00036        return 1;
00037 }
00038 
00039 void   buf_cpy(struct buf *b, const char *c)
00040 {
00041        size_t l=strlen(c);
00042 
00043        if (!buf_allocbuf(b, l+1))
00044               return;
00045 
00046        strcpy(b->ptr, c);
00047        b->cnt=l;
00048 }
00049 
00050 void   buf_cpyn(struct buf *b, const char *c, size_t n)
00051 {
00052 size_t l;
00053 
00054        for (l=0; l<n; l++)
00055               if (c[l] == '\0')    break;
00056 
00057        if (!buf_allocbuf(b, l+1))
00058               return;
00059 
00060        memcpy(b->ptr, c, l);
00061        b->ptr[b->cnt=l]=0;
00062 }
00063 
00064 void   buf_cat(struct buf *b, const char *c)
00065 {
00066        size_t l=strlen(c);
00067 
00068        if (!buf_allocbuf(b, b->cnt+l+1))
00069               return;
00070 
00071        strcpy(b->ptr+b->cnt, c);
00072        b->cnt += l;
00073 }
00074 
00075 void   buf_catn(struct buf *b, const char *c, size_t n)
00076 {
00077 size_t l;
00078 
00079        for (l=0; l<n; l++)
00080               if (c[l] == '\0')    break;
00081 
00082        if (!buf_allocbuf(b, b->cnt+l+1))
00083               return;
00084 
00085        memcpy(b->ptr+b->cnt, c, l);
00086        b->ptr[b->cnt += l]=0;
00087 }
00088 
00089 void   buf_memcpy(struct buf *b, const char *c, size_t n)
00090 {
00091        if (!buf_allocbuf(b, n+1))
00092               return;
00093 
00094        memcpy(b->ptr, c, n);
00095        b->ptr[b->cnt=n]=0;
00096 }
00097 
00098 void   buf_memcat(struct buf *b, const char *c, size_t n)
00099 {
00100        if (!buf_allocbuf(b, b->cnt+n+1))
00101               return;
00102 
00103        memcpy(b->ptr+b->cnt, c, n);
00104        b->ptr[b->cnt += n]=0;
00105 }
00106 
00107 void   buf_trimleft(struct buf *b, size_t n)
00108 {
00109        if (n >= b->cnt)
00110               b->cnt=0;
00111        else
00112        {
00113        size_t i;
00114 
00115               for (b->cnt -= n, i=0; i<b->cnt; i++)
00116                      b->ptr[i]=b->ptr[i+n];
00117        }
00118        if (!buf_allocbuf(b, b->cnt+1))
00119               return;
00120 
00121        b->ptr[b->cnt]=0;
00122 }