Return to string.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / sux

Annotation of researchv9/jtools/src/sux/string.c, revision 1.1

1.1     ! root        1: #include <jerq.h>
        !             2: #include "frame.h"
        !             3: 
        !             4: #define        MAXROOM 1024    /* maximum extra number of chars after insure() */
        !             5: 
        !             6: char *
        !             7: GCalloc(n, p)
        !             8:        int n;
        !             9:        char **p;
        !            10: {
        !            11:        gcalloc((unsigned long)n, p);
        !            12: }
        !            13: 
        !            14: insure(p, n)
        !            15:        register String *p;
        !            16:        register short n;
        !            17: {
        !            18:        register i;
        !            19:        char *old;
        !            20:        if (p->size < n) {      /* p needs to grow */
        !            21:                for (i = 1; i < n; i <<= 1)
        !            22:                        ;
        !            23:                if(i > n+MAXROOM)
        !            24:                        i = n+MAXROOM;
        !            25:                if(p->s==0)
        !            26:                        old=0;
        !            27:                else{
        !            28:                        GCalloc(p->n, &old);
        !            29:                        movstring(p->n, p->s, old);
        !            30:                        gcfree(p->s);
        !            31:                }
        !            32:                GCalloc(i, &p->s);
        !            33:                if(old){
        !            34:                        movstring(p->n, old, p->s);
        !            35:                        gcfree(old);
        !            36:                }
        !            37:                p->size = i;
        !            38:        }
        !            39: }
        !            40: #define        MINCHARS 64     /* for efficiency; min size of a string we'll alloc */
        !            41: strzero(p)
        !            42:        String *p;
        !            43: {
        !            44:        if(p->s && p->size>MINCHARS){
        !            45:                p->n=0;
        !            46:                p->size=0;      /* forces strinsure to free the old stuff */
        !            47:        }
        !            48:        insure(p, MINCHARS);
        !            49:        p->n = 0;
        !            50: }
        !            51: insstring(p, i, q)
        !            52:        register String *p, *q;
        !            53:        register short i;
        !            54: {
        !            55:        insure(p, p->n+q->n);
        !            56:        movstring(i-p->n, p->s+p->n, p->s+p->n+q->n);
        !            57:        movstring(q->n, q->s, p->s+i);
        !            58:        p->n += q->n;
        !            59: }
        !            60: delstring(p, i, j)
        !            61:        register String *p;
        !            62:        register short i, j;
        !            63: {
        !            64:        register n = j-i;
        !            65:        movstring(p->n-j, p->s+j, p->s+i);
        !            66:        p->n -= n;
        !            67: }
        !            68: movstring(i, s, d)
        !            69:        register short i;
        !            70:        register char *s, *d;
        !            71: {
        !            72:        if (i > 0)
        !            73:                do
        !            74:                        *d++ = *s++;
        !            75:                while (--i > 0);
        !            76:        else {
        !            77:                if (i++ < 0)            /* transfer -i chars in loop */
        !            78:                        do
        !            79:                                *--d = *--s;
        !            80:                        while (i++ < 0);
        !            81:        }
        !            82: }

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