Return to ec.h CVS log

Up to [local] / OpenXM / src / kan96xx / gc-4.14 / cord

Annotation of OpenXM/src/kan96xx/gc-4.14/cord/ec.h, Revision 1.1

1.1     ! maekawa     1: # ifndef EC_H
        !             2: # define EC_H
        !             3:
        !             4: # ifndef CORD_H
        !             5: #  include "cord.h"
        !             6: # endif
        !             7:
        !             8: /* Extensible cords are strings that may be destructively appended to. */
        !             9: /* They allow fast construction of cords from characters that are      */
        !            10: /* being read from a stream.                                           */
        !            11: /*
        !            12:  * A client might look like:
        !            13:  *
        !            14:  *     {
        !            15:  *         CORD_ec x;
        !            16:  *         CORD result;
        !            17:  *         char c;
        !            18:  *         FILE *f;
        !            19:  *
        !            20:  *         ...
        !            21:  *         CORD_ec_init(x);
        !            22:  *         while(...) {
        !            23:  *             c = getc(f);
        !            24:  *             ...
        !            25:  *             CORD_ec_append(x, c);
        !            26:  *         }
        !            27:  *         result = CORD_balance(CORD_ec_to_cord(x));
        !            28:  *
        !            29:  * If a C string is desired as the final result, the call to CORD_balance
        !            30:  * may be replaced by a call to CORD_to_char_star.
        !            31:  */
        !            32:
        !            33: # ifndef CORD_BUFSZ
        !            34: #   define CORD_BUFSZ 128
        !            35: # endif
        !            36:
        !            37: typedef struct CORD_ec_struct {
        !            38:     CORD ec_cord;
        !            39:     char * ec_bufptr;
        !            40:     char ec_buf[CORD_BUFSZ+1];
        !            41: } CORD_ec[1];
        !            42:
        !            43: /* This structure represents the concatenation of ec_cord with         */
        !            44: /* ec_buf[0 ... (ec_bufptr-ec_buf-1)]                                  */
        !            45:
        !            46: /* Flush the buffer part of the extended chord into ec_cord.   */
        !            47: /* Note that this is almost the only real function, and it is  */
        !            48: /* implemented in 6 lines in cordxtra.c                                */
        !            49: void CORD_ec_flush_buf(CORD_ec x);
        !            50:
        !            51: /* Convert an extensible cord to a cord. */
        !            52: # define CORD_ec_to_cord(x) (CORD_ec_flush_buf(x), (x)[0].ec_cord)
        !            53:
        !            54: /* Initialize an extensible cord. */
        !            55: # define CORD_ec_init(x) ((x)[0].ec_cord = 0, (x)[0].ec_bufptr = (x)[0].ec_buf)
        !            56:
        !            57: /* Append a character to an extensible cord.   */
        !            58: # define CORD_ec_append(x, c) \
        !            59:     {  \
        !            60:        if ((x)[0].ec_bufptr == (x)[0].ec_buf + CORD_BUFSZ) { \
        !            61:                CORD_ec_flush_buf(x); \
        !            62:        } \
        !            63:        *((x)[0].ec_bufptr)++ = (c); \
        !            64:     }
        !            65:
        !            66: /* Append a cord to an extensible cord.  Structure remains shared with         */
        !            67: /* original.                                                           */
        !            68: void CORD_ec_append_cord(CORD_ec x, CORD s);
        !            69:
        !            70: # endif /* EC_H */