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

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.