Return to string.c CVS log

Up to [Research Unix] / researchv10dc / 630 / src

Annotation of researchv10dc/630/src/string.c, revision 1.1

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

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