Annotation of libwww/Library/src/HTChunk.c, revision 2.19

2.10      frystyk     1: /*                                                                   HTChunk.c
                      2: **     CHUNK HANDLING: FLEXIBLE ARRAYS
                      3: **
2.13      frystyk     4: **     (c) COPYRIGHT MIT 1995.
2.10      frystyk     5: **     Please first read the full copyright statement in the file COPYRIGH.
1.1       timbl       6: **
2.6       frystyk     7: ** history:    AL, HF  28 Apr 94, Now chunk->data is filled by '\0' so
                      8: **                     that the string is terminated at any time. That makes
2.15      frystyk     9: **                     HTChunk_terminate not needed any more, but never mind.
2.6       frystyk    10: **
1.1       timbl      11: */
                     12: 
2.12      frystyk    13: /* Library include files */
2.19    ! frystyk    14: #include "sysdep.h"
1.1       timbl      15: #include "HTUtils.h"
2.12      frystyk    16: #include "HTChunk.h"                                    /* Implemented here */
1.1       timbl      17: 
                     18: /*     Create a chunk with a certain allocation unit
                     19: **     --------------
                     20: */
2.15      frystyk    21: PUBLIC HTChunk * HTChunk_new (int grow)
1.1       timbl      22: {
2.18      frystyk    23:     HTChunk * ch;
                     24:     if ((ch = (HTChunk  *) HT_CALLOC(1, sizeof(HTChunk))) == NULL)
                     25:         HT_OUTOFMEM("HTChunk_new");
1.1       timbl      26:     ch->growby = grow;
                     27:     return ch;
                     28: }
                     29: 
                     30: 
                     31: /*     Clear a chunk of all data
                     32: **     --------------------------
2.19    ! frystyk    33: **     Zero the space but do NOT HT_FREE it. We zero because we promise to have
2.17      frystyk    34: **     a NUL terminated string at all times.
1.1       timbl      35: */
2.15      frystyk    36: PUBLIC void HTChunk_clear (HTChunk * ch)
1.1       timbl      37: {
2.16      frystyk    38:     if (ch) {
                     39:        ch->size = 0;
                     40:        memset((void *) ch->data, '\0', ch->allocated);
1.1       timbl      41:     }
                     42: }
                     43: 
                     44: 
                     45: /*     Free a chunk
                     46: **     ------------
                     47: */
2.15      frystyk    48: PUBLIC void HTChunk_delete (HTChunk * ch)
1.1       timbl      49: {
2.16      frystyk    50:     if (ch) {
2.18      frystyk    51:        HT_FREE(ch->data);
                     52:        HT_FREE(ch);
2.16      frystyk    53:     }
1.1       timbl      54: }
                     55: 
                     56: 
                     57: /*     Append a character
                     58: **     ------------------
                     59: */
2.15      frystyk    60: PUBLIC void HTChunk_putc (HTChunk * ch, char c)
1.1       timbl      61: {
2.17      frystyk    62:     if (ch) {
                     63:        if (ch->size >= ch->allocated-1) {
                     64:            if (ch->data) {
2.18      frystyk    65:                if ((ch->data = (char  *) HT_REALLOC(ch->data,ch->allocated+ch->growby)) == NULL)
                     66:                    HT_OUTOFMEM("HTChunk_putc");
2.17      frystyk    67:                memset((void *) (ch->data + ch->allocated), '\0', ch->growby);
                     68:            } else {
2.18      frystyk    69:                if ((ch->data = (char  *) HT_CALLOC(1, ch->allocated+ch->growby)) == NULL)
                     70:                    HT_OUTOFMEM("HTChunk_putc");
2.17      frystyk    71:            }
                     72:            ch->allocated += ch->growby;
2.6       frystyk    73:        }
2.17      frystyk    74:        *(ch->data+ch->size++) = c;
1.1       timbl      75:     }
2.16      frystyk    76: }
                     77: 
                     78: /*     Append a string
                     79: **     ---------------
                     80: */
2.19    ! frystyk    81: PUBLIC void HTChunk_puts (HTChunk * ch, const char * s)
2.16      frystyk    82: {
                     83:     HTChunk_putb(ch, s, (int) strlen(s));
                     84: }
                     85: 
                     86: /*     Append a block
                     87: **     ---------------
                     88: **     The string is always zero terminated
                     89: */
2.19    ! frystyk    90: PUBLIC void HTChunk_putb (HTChunk * ch, const char * block, int len)
2.16      frystyk    91: {
                     92:     if (ch && block && len) {
                     93:        int needed = ch->size+len;
                     94:        if (needed >= ch->allocated) {
                     95:            ch->allocated = needed - needed%ch->growby + ch->growby;
                     96:            if (ch->data) {
2.18      frystyk    97:                if ((ch->data = (char *) HT_REALLOC(ch->data, ch->allocated)) == NULL)
                     98:                    HT_OUTOFMEM("HTChunk_putb");
2.16      frystyk    99:                memset((void *) (ch->data + needed), '\0', ch->allocated-needed);
                    100:            } else {
2.18      frystyk   101:                if ((ch->data = (char *) HT_CALLOC(1, ch->allocated)) == NULL)
                    102:                    HT_OUTOFMEM("HTChunk_putb");
2.16      frystyk   103:            }
                    104:        }
                    105:        memcpy((void *) (ch->data+ch->size), block, len);
                    106:        ch->size = needed;
                    107:     }
1.1       timbl     108: }
                    109: 
                    110: 
                    111: /*     Ensure a certain size
                    112: **     ---------------------
                    113: */
2.16      frystyk   114: PUBLIC void HTChunk_ensure (HTChunk * ch, int len)
1.1       timbl     115: {
2.16      frystyk   116:     if (ch && len) {
                    117:        int needed = ch->size+len;
                    118:        if (needed >= ch->allocated) {
                    119:            ch->allocated = needed - needed%ch->growby + ch->growby;
                    120:            if (ch->data) {
2.18      frystyk   121:                if ((ch->data = (char  *) HT_REALLOC(ch->data, ch->allocated)) == NULL)
                    122:                    HT_OUTOFMEM("HTChunk_putb");
2.16      frystyk   123:                memset((void *) (ch->data + ch->size), '\0', ch->allocated-ch->size);
                    124:            } else {
2.18      frystyk   125:                if ((ch->data = (char  *) HT_CALLOC(1, ch->allocated)) == NULL)
                    126:                    HT_OUTOFMEM("ch->data ");
2.16      frystyk   127:            }
                    128:        }
                    129:     }
                    130: #if 0
1.1       timbl     131:     if (needed <= ch->allocated) return;
                    132:     ch->allocated = needed-1 - ((needed-1) % ch->growby)
                    133:                             + ch->growby; /* Round up */
                    134:     ch->data = ch->data ? (char *)realloc(ch->data, ch->allocated)
2.19    ! frystyk   135:                        : (char *)HT_MALLOC(ch->allocated);
        !           136:     if (ch->data == NULL) HT_OUTOFMEM(__FILE__, "HTChunk_ensure");
2.16      frystyk   137: #endif
1.1       timbl     138: }

Webmaster