Return to string.c CVS log

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

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

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