Return to string.c CVS log

Up to [CSRG BSD Unix] / 3BSD / cmd / pi

Annotation of 3BSD/cmd/pi/string.c, revision 1.1

1.1     ! root        1: /* Copyright (c) 1979 Regents of the University of California */
        !             2: #
        !             3: /*
        !             4:  * pi - Pascal interpreter code translator
        !             5:  *
        !             6:  * Charles Haley, Bill Joy UCB
        !             7:  * Version 1.2 November 1978
        !             8:  *
        !             9:  * pxp - Pascal execution profiler
        !            10:  *
        !            11:  * Bill Joy UCB
        !            12:  * Version 1.2 November 1978
        !            13:  */
        !            14: 
        !            15: #include "whoami"
        !            16: #include "0.h"
        !            17: #ifndef PI01
        !            18: #ifndef PXP
        !            19: #include "send.h"
        !            20: #endif
        !            21: #endif
        !            22: 
        !            23: /*
        !            24:  * STRING SPACE DECLARATIONS
        !            25:  *
        !            26:  * Strng is the base of the current
        !            27:  * string space and strngp the
        !            28:  * base of the free area therein.
        !            29:  * Strp is the array of descriptors.
        !            30:  */
        !            31: #ifndef PI0
        !            32: STATIC char strings[STRINC];
        !            33: STATIC char *strng = strings;
        !            34: STATIC char *strngp = strings;
        !            35: #else
        !            36: char   *strng, *strngp;
        !            37: #endif
        !            38: #ifndef PI01
        !            39: #ifndef PXP
        !            40: STATIC char *strp[20];
        !            41: STATIC char **stract strp;
        !            42: int    strmax;
        !            43: #endif
        !            44: #endif
        !            45: 
        !            46: #ifndef PI01
        !            47: #ifndef PXP
        !            48: #ifndef PI0
        !            49: initstring()
        !            50: #else
        !            51: initstring(strings)
        !            52:        char *strings;
        !            53: #endif
        !            54: {
        !            55: 
        !            56:        *stract++ = strings;
        !            57: #ifdef PI0
        !            58:        strng = strngp = strings;
        !            59: #endif
        !            60:        strmax = STRINC * 2;
        !            61: }
        !            62: #endif
        !            63: #endif
        !            64: 
        !            65: /*
        !            66:  * Copy a string into the string area.
        !            67:  */
        !            68: char *
        !            69: savestr(cp)
        !            70:        register char *cp;
        !            71: {
        !            72:        register int i;
        !            73: 
        !            74:        i = strlen(cp) + 1;
        !            75:        if (strngp + i >= strng + STRINC) {
        !            76:                strngp = malloc(STRINC);
        !            77:                if (strngp == -1) {
        !            78:                        yerror("Ran out of memory (string)");
        !            79:                        pexit(DIED);
        !            80:                }
        !            81: #ifndef PI01
        !            82: #ifndef PXP
        !            83:                *stract++ = strngp;
        !            84:                strmax =+ STRINC;
        !            85: #endif
        !            86: #endif
        !            87:                strng = strngp;
        !            88:        }
        !            89:        strcpy(strngp, cp);
        !            90:        cp = strngp;
        !            91:        strngp = cp + i;
        !            92: #ifdef PI0
        !            93:        send(RSTRING, cp);
        !            94: #endif
        !            95:        return (cp);
        !            96: }
        !            97: 
        !            98: #ifndef PI1
        !            99: #ifndef PXP
        !           100: esavestr(cp)
        !           101:        char *cp;
        !           102: {
        !           103: 
        !           104: #ifdef PI0
        !           105:        send(REVENIT);
        !           106: #endif
        !           107:        strngp = ( (char *) ( ( (int) (strngp + 1) ) &~ 1 ) );
        !           108:        return (savestr(cp));
        !           109: }
        !           110: #endif
        !           111: #endif
        !           112: 
        !           113: #ifndef PI01
        !           114: #ifndef PXP
        !           115: soffset(cp)
        !           116:        register char *cp;
        !           117: {
        !           118:        register char **sp;
        !           119:        register int i;
        !           120: 
        !           121:        if (cp == NIL || cp == OCT || cp == HEX)
        !           122:                return (-cp);
        !           123:        for (i = STRINC, sp = strp; sp < stract; sp++) {
        !           124:                if (cp >= *sp && cp < (*sp + STRINC))
        !           125:                        return (i + (cp - *sp));
        !           126:                i =+ STRINC;
        !           127:        }
        !           128:        i = nlfund(cp);
        !           129:        if (i != 0)
        !           130:                return (i);
        !           131:        panic("soffset");
        !           132: }
        !           133: #ifdef PI1
        !           134: sreloc(i)
        !           135:        register int i;
        !           136: {
        !           137: 
        !           138:        if (i == 0 || i == -OCT || i == -HEX)
        !           139:                return (-i);
        !           140:        if (i < STRINC) {
        !           141:                if (i >= INL)
        !           142:                        panic("sreloc INL");
        !           143:                i = nl[i].symbol;
        !           144:                if (i == 0)
        !           145:                        panic("sreloc nl[i]");
        !           146:                return (i);
        !           147:        }
        !           148:        if (i > strmax || i < 0)
        !           149:                panic("sreloc");
        !           150:        return (strp[(i / STRINC) - 1] + (i % STRINC));
        !           151: }
        !           152: 
        !           153: evenit()
        !           154: {
        !           155: 
        !           156:        strngp = (strngp + 1) &~ 1;
        !           157: }
        !           158: #endif
        !           159: #endif
        !           160: #endif

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