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

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.