Return to string.c CVS log

Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / src

Annotation of 43BSD/ucb/pascal/src/string.c, revision 1.1

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

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