Return to HTChunk.html CVS log

Up to [Public] / libwww / Library / src

Annotation of libwww/Library/src/HTChunk.html, revision 2.1

2.1     ! timbl       1: <PRE>
        !             2: /*             Chunk handling: Flexible arrays
        !             3: **             ===============================
        !             4: **
        !             5: ** This module implements a flexible array. It is a general utility module.
        !             6: ** A chunk is a structure which may be extended.  These routines create
        !             7: ** and append data to chnuks, automatically reallocating them as necessary.
        !             8: **
        !             9: */
        !            10: 
        !            11: 
        !            12: typedef struct {
        !            13:        int     size;           /* In bytes                     */
        !            14:        int     growby;         /* Allocation unit in bytes     */
        !            15:        int     allocated;      /* Current size of *data        */
        !            16:        char *  data;           /* Pointer to malloced area or 0 */
        !            17: } HTChunk;
        !            18: 
        !            19: 
        !            20: #ifdef SHORT_NAMES
        !            21: #define HTChunkClear           HTChClea
        !            22: #define HTChunkPutc            HTChPutc
        !            23: #define HTChunkPuts            HTChPuts
        !            24: #define HTChunkCreate          HTChCrea
        !            25: #define HTChunkTerminate       HTChTerm
        !            26: #define HTChunkEnsure          HtChEnsu
        !            27: #endif
        !            28: 
        !            29: 
        !            30: /*     Create new chunk
        !            31: **
        !            32: ** On entry,
        !            33: **
        !            34: **     growby          The number of bytes to allocate at a time
        !            35: **                     when the chunk is later extended. Arbitrary but
        !            36: **                     normally a trade-off time vs. memory
        !            37: **
        !            38: ** On exit,
        !            39: **     returns         A chunk pointer to the new chunk,
        !            40: */
        !            41: extern HTChunk * HTChunkCreate PARAMS((int growby));
        !            42: 
        !            43: 
        !            44: /*     Free a chunk
        !            45: **
        !            46: ** On entry,
        !            47: **     ch      A valid chunk pointer made by HTChunkCreate()
        !            48: **
        !            49: ** On exit,
        !            50: **     ch      is invalid and may not be used.
        !            51: */
        !            52: extern void HTChunkFree PARAMS((HTChunk * ch));
        !            53: 
        !            54: 
        !            55: /*     Clear a chunk
        !            56: **
        !            57: ** On entry,
        !            58: **     ch      A valid chunk pointer made by HTChunkCreate()
        !            59: **
        !            60: ** On exit,
        !            61: **     *ch     The size of the chunk is zero.
        !            62: */
        !            63: extern void HTChunkClear PARAMS((HTChunk * ch));
        !            64: 
        !            65: 
        !            66: /*     Ensure a chunk has a certain space in
        !            67: **
        !            68: ** On entry,
        !            69: **     ch      A valid chunk pointer made by HTChunkCreate()
        !            70: **     s       The size required
        !            71: **
        !            72: ** On exit,
        !            73: **     *ch     Has size at least s
        !            74: */
        !            75: extern void HTChunkEnsure PARAMS((HTChunk * ch, int s));
        !            76: 
        !            77: 
        !            78: /*     Append a character to a  chunk
        !            79: **
        !            80: ** On entry,
        !            81: **     ch      A valid chunk pointer made by HTChunkCreate()
        !            82: **     c       The character to be appended
        !            83: ** On exit,
        !            84: **     *ch     Is one character bigger
        !            85: */
        !            86: 
        !            87: extern void HTChunkPutc PARAMS((HTChunk * ch, char c));
        !            88: 
        !            89: /*     Append a string to a  chunk
        !            90: **
        !            91: ** On entry,
        !            92: **     ch      A valid chunk pointer made by HTChunkCreate()
        !            93: **     s       Tpoints to a zero-terminated string to be appended
        !            94: ** On exit,
        !            95: **     *ch     Is bigger by strlen(s)
        !            96: */
        !            97: 
        !            98: extern void HTChunkPuts PARAMS((HTChunk * ch, const char *s));
        !            99: 
        !           100: 
        !           101: /*     Append a zero character to a  chunk
        !           102: **
        !           103: ** On entry,
        !           104: **     ch      A valid chunk pointer made by HTChunkCreate()
        !           105: ** On exit,
        !           106: **     *ch     Is one character bigger
        !           107: */
        !           108: 
        !           109: extern void HTChunkTerminate PARAMS((HTChunk * ch));
        !           110: </PRE>