Return to expand.h CVS log

Up to [MW Coherent from dump] / coherent / a / usr / bob / korn

Annotation of coherent/a/usr/bob/korn/expand.h, revision 1.1

1.1     ! root        1: /*
        !             2:  * Expandable strings
        !             3:  *
        !             4:  * Usage
        !             5:  *     XString xs;
        !             6:  *     char *xp;
        !             7:  *
        !             8:  *     Xinit(xs, xp, 128);
        !             9:  *     while ((c = generate()) {
        !            10:  *             Xcheck(xs, xp);
        !            11:  *             Xput(xs, xp, c);
        !            12:  *     }
        !            13:  *     return Xclose(xs, xp);
        !            14:  */
        !            15: 
        !            16: typedef struct XString {
        !            17:        char   *end, *beg;      /* end, begin of string */
        !            18: #if 1
        !            19:        char   *oth, *old;      /* togo, adjust */
        !            20: #endif
        !            21:        size_t  len;            /* length */
        !            22: } XString;
        !            23: 
        !            24: typedef char * XStringP;
        !            25: 
        !            26: /* initialize expandable string */
        !            27: #define        Xinit(xs, xp, length) { \
        !            28:                        (xs).len = length; \
        !            29:                        (xs).beg = alloc((xs).len + 4, ATEMP); \
        !            30:                        (xs).end = (xs).beg + (xs).len; \
        !            31:                        xp = (xs).beg; \
        !            32:                }
        !            33: 
        !            34: /* stuff char into string */
        !            35: #define        Xput(xs, xp, c) *xp++ = (c)
        !            36: 
        !            37: /* check for overflow, expand string */
        !            38: #define        Xcheck(xs, xp) if (xp >= (xs).end) { \
        !            39:                        char *old_beg = (xs).beg; \
        !            40:                        (xs).len += (xs).len; \
        !            41:                        (xs).beg = alloc((xs).len + 4, ATEMP); \
        !            42:                        (xs).end = (xs).beg + (xs).len; \
        !            43:                        memcpy((xs).beg, old_beg, (size_t)(xp - old_beg)); \
        !            44:                        afree((Void*) old_beg, ATEMP); \
        !            45:                        xp = (xs).beg + (xp - old_beg); \
        !            46:                }
        !            47: 
        !            48: /* free string */
        !            49: #define        Xfree(xs, xp)   afree((Void*) (xs).beg, ATEMP)
        !            50: 
        !            51: /* close, return string */
        !            52: #define        Xclose(xs, xp)  (char*) aresize((Void*)(xs).beg, \
        !            53:                                        (size_t)(xp - (xs).beg), ATEMP)
        !            54: /* begin of string */
        !            55: #define        Xstring(xs, xp) ((xs).beg)
        !            56: 
        !            57: #define        Xsavepos(xs, xp) (xp - (xs).beg)
        !            58: #define        Xrestpos(xs, xp, n) ((xs).beg + (n))
        !            59: 
        !            60: /*
        !            61:  * expandable vector of generic pointers
        !            62:  */
        !            63: 
        !            64: typedef struct XPtrV {
        !            65:        Void  **cur;            /* next avail ptr */
        !            66:        Void  **beg, **end;     /* begin, end of vector */
        !            67: } XPtrV;
        !            68: 
        !            69: #define        XPinit(x, n) { \
        !            70:                        register Void **vp; \
        !            71:                        vp = (Void**) alloc(sizeofN(Void*, n), ATEMP); \
        !            72:                        (x).cur = (x).beg = vp; \
        !            73:                        (x).end = vp + n; \
        !            74:                        }
        !            75: 
        !            76: #define        XPput(x, p) { \
        !            77:                        if ((x).cur >= (x).end) \
        !            78:                                xpexpand(&(x)); \
        !            79:                        *(x).cur++ = (p); \
        !            80:                        }
        !            81: 
        !            82: #define        XPptrv(x)       ((x).beg)
        !            83: #define        XPsize(x)       ((x).cur - (x).beg)
        !            84: 
        !            85: #define        XPclose(x)      (Void**) aresize((Void*)(x).beg, \
        !            86:                                         sizeofN(Void*, XPsize(x)), ATEMP)
        !            87: 
        !            88: #define        XPfree(x)       afree((Void*) (x).beg, ATEMP)
        !            89: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.