Return to string.c CVS log

Up to [Research Unix] / researchv8dc / cmd / qed

Annotation of researchv8dc/cmd/qed/string.c, revision 1.1

1.1     ! root        1: /*% cc -c -O %
        !             2:  */
        !             3: #include "vars.h"
        !             4: #define        strfree string[NSTRING].str
        !             5: char *strstart;
        !             6: 
        !             7: length(s)
        !             8:        register char *s;
        !             9: {
        !            10:        register char *t;
        !            11:        if((t=s)==0)
        !            12:                return(0);
        !            13:        do;while(*t++);
        !            14:        return(t-s-1);
        !            15: }
        !            16: startstring(){
        !            17:        strstart=strfree;
        !            18: }
        !            19: addstring(c){
        !            20:        if(strfree==strchars+NSTRCHARS)
        !            21:                strcompact();
        !            22:        *strfree++ = c;
        !            23: }
        !            24: dropstring(){
        !            25:        --strfree;
        !            26: }
        !            27: cpstr(a, b)
        !            28:        register char *a, *b;
        !            29: {
        !            30:        do;while (*b++ = *a++);
        !            31: }
        !            32: shiftstring(up){       /* A highly machine-dependent routine */
        !            33:        register struct string *sp;
        !            34:        for(sp=string; sp<=string+NSTRING; sp++)
        !            35:                if(up)
        !            36:                        sp->str += (int)strarea;
        !            37:                else
        !            38:                        sp->str -= (int)strarea;
        !            39: }
        !            40: clearstring(z){
        !            41:        string[z].len = 0;
        !            42:        string[z].str = nullstr;
        !            43: }
        !            44: copystring(s)
        !            45:        register char *s;
        !            46: {
        !            47:        while(*s)
        !            48:                addstring(*s++);
        !            49: }
        !            50: eqstr(a, b)
        !            51:        register char *a, *b;
        !            52: {
        !            53:        while(*a)
        !            54:                if(*a++ != *b++)
        !            55:                        return(FALSE);
        !            56:        return(*b=='\0');
        !            57: }
        !            58: /*
        !            59:  * dupstring duplicates a string.
        !            60:  * Because we may strcompact(), we do it first if necessary.
        !            61:  */
        !            62: dupstring(z)
        !            63: {
        !            64:        if(strfree+string[z].len > strchars+NSTRCHARS)
        !            65:                strcompact();   /* if insufficient, will get error when we copystring() */
        !            66:        copystring(string[z].str);
        !            67: }
        !            68: setstring(n){
        !            69:        addstring('\0');
        !            70:        if((string[n].len = length(strstart)) == 0)
        !            71:                string[n].str = nullstr;
        !            72:        else
        !            73:                string[n].str = strstart;
        !            74:        if(strfree >= strchars + NSTRCHARS)
        !            75:                strcompact();
        !            76: }
        !            77: strcompact(){
        !            78:        register struct string *cursor;
        !            79:        struct string *thisstr;
        !            80:        register char *s, *t;
        !            81:        lock++;
        !            82:        s=strchars;
        !            83:        for(;;){
        !            84:                t=strchars+NSTRCHARS;
        !            85:                for(cursor=string;cursor!=string+NSTRING;cursor++)
        !            86:                        if(s<=cursor->str && cursor->str<t){
        !            87:                                t = cursor->str;
        !            88:                                thisstr = cursor;
        !            89:                        }
        !            90:                if(t==strchars+NSTRCHARS)
        !            91:                        break;
        !            92:                thisstr->str=s;
        !            93:                do;while(*s++ = *t++);
        !            94:        }
        !            95:        t=strstart;
        !            96:        strstart=s;
        !            97:        while(t!=strfree)
        !            98:                *s++ = *t++;
        !            99:        strfree=s;
        !           100:        if(s==strchars+NSTRCHARS){
        !           101:                strfree=strstart;
        !           102:                error('Z');
        !           103:        }
        !           104:        unlock();
        !           105: }

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