Return to string.c CVS log

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

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

1.1     ! root        1: #include "sam.h"
        !             2: 
        !             3: #define        MINSIZE 16              /* minimum number of chars allocated */
        !             4: #define        MAXSIZE BLOCKSIZE       /* maximum number of chars for an empty string */
        !             5: 
        !             6: strinit(p)
        !             7:        String *p;
        !             8: {
        !             9:        gcnew(p->s, MINSIZE);
        !            10:        p->n=0;
        !            11:        p->size=MINSIZE;
        !            12: }
        !            13: strclose(p)
        !            14:        String *p;
        !            15: {
        !            16:        gcfree(p->s);
        !            17: }
        !            18: strzero(p)
        !            19:        register String *p;
        !            20: {
        !            21:        if(p->size>MAXSIZE){
        !            22:                (void)gcrealloc(p->s, (ulong)MAXSIZE);  /* throw away the garbage */
        !            23:                p->size=MAXSIZE;
        !            24:        }
        !            25:        p->n=0;
        !            26: }
        !            27: strdup(p, s)   /* copies the null */
        !            28:        register String *p;
        !            29:        register uchar *s;
        !            30: {
        !            31:        strinsure(p, (ulong)(p->n=strlen(s)+1));
        !            32:        bcopy((uchar *)s, s+p->n, p->s, 1);
        !            33: }
        !            34: strdupstr(p, q)        /* will copy the null if there's one there */
        !            35:        register String *p, *q;
        !            36: {
        !            37:        strinsure(p, (ulong)q->n);
        !            38:        p->n=q->n;
        !            39:        bcopy(q->s, q->s+q->n, p->s, 1);
        !            40: }
        !            41: straddc(p, c)
        !            42:        register String *p;
        !            43:        register c;
        !            44: {
        !            45:        strinsure(p, (ulong)p->n+1);
        !            46:        p->s[p->n++]=c;
        !            47: }
        !            48: strinsure(p, n)
        !            49:        register String *p;
        !            50:        register ulong n;
        !            51: {
        !            52:        register i;
        !            53:        if(n>=32767)
        !            54:                error(Etoolong);
        !            55:        if(p->size<n){  /* p needs to grow */
        !            56:                for(i=1; i<n; i<<=1)
        !            57:                        ;
        !            58:                gcrenew(p->s, i);
        !            59:                p->size=i;
        !            60:        }
        !            61: }
        !            62: strinsert(p, q, p0)
        !            63:        register String *p, *q;
        !            64:        register Posn p0;
        !            65: {
        !            66: if(p0>p->n) panic("strinsert");
        !            67:        strinsure(p, (ulong)(p->n+q->n));
        !            68:        bcopy(p->s+p0, p->s+p->n, p->s+p0+q->n, -1);
        !            69:        bcopy(q->s, q->s+q->n, p->s+p0, 1);
        !            70:        p->n+=q->n;
        !            71: }
        !            72: strdelete(p, p1, p2)
        !            73:        register String *p;
        !            74:        register Posn p1, p2;
        !            75: {
        !            76: if(p1>p->n || p2>p->n || p1>p2) panic("strdelete");
        !            77:        bcopy(p->s+p2, p->s+p->n, p->s+p1, 1);
        !            78:        p->n-=(p2-p1);
        !            79: }
        !            80: strncmp(s1, s2, n)
        !            81:        register uchar *s1, *s2;
        !            82:        register n;
        !            83: {
        !            84:        while (--n >= 0 && *s1 == *s2++)
        !            85:                if (*s1++ == '\0')
        !            86:                        return(0);
        !            87:        return(n<0 ? 0 : *s1 - *--s2);
        !            88: }
        !            89: strcmp(s1, s2)
        !            90:        register uchar *s1, *s2;
        !            91: {
        !            92:        while (*s1 == *s2++)
        !            93:                if (*s1++=='\0')
        !            94:                        return(0);
        !            95:        return(*s1 - *--s2);
        !            96: }
        !            97: strcpy(s1, s2)
        !            98:        register uchar *s1, *s2;
        !            99: {
        !           100:        while (*s1++ = *s2++)
        !           101:                ;
        !           102: }
        !           103: strlen(s)
        !           104:        register uchar *s;
        !           105: {
        !           106:        register n=0;
        !           107:        while(*s++)
        !           108:                n++;
        !           109:        return n;
        !           110: }
        !           111: String *
        !           112: tempstr(s, n)
        !           113:        uchar *s;
        !           114: {
        !           115:        static String p;
        !           116:        p.s=s;
        !           117:        p.n=n;
        !           118:        p.size=n;
        !           119:        return &p;
        !           120: }

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