Return to subr.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / pgrm / pascal / src

Annotation of 43BSDReno/pgrm/pascal/src/subr.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[] = "@(#)subr.c     5.2 (Berkeley) 5/28/90";
        !             9: #endif not lint
        !            10: 
        !            11: #include "whoami.h"
        !            12: #include "0.h"
        !            13: 
        !            14: #ifndef PI1
        !            15: /*
        !            16:  * Does the string fp end in '.' and the character c ?
        !            17:  */
        !            18: dotted(fp, c)
        !            19:        register char *fp;
        !            20:        char c;
        !            21: {
        !            22:        register int i;
        !            23: 
        !            24:        i = strlen(fp);
        !            25:        return (i > 1 && fp[i - 2] == '.' && fp[i - 1] == c);
        !            26: }
        !            27: 
        !            28: /*
        !            29:  * Toggle the option c.
        !            30:  */
        !            31: togopt(c)
        !            32:        char c;
        !            33: {
        !            34:        register char *tp;
        !            35: 
        !            36:        tp = &opt( c );
        !            37:        *tp = 1 - *tp;
        !            38: }
        !            39: 
        !            40: /*
        !            41:  * Set the time vector "tvec" to the
        !            42:  * modification time stamp of a file.
        !            43:  */
        !            44: gettime( filename )
        !            45:     char *filename;
        !            46: {
        !            47: #include <sys/stat.h>
        !            48:        struct stat stb;
        !            49: 
        !            50:        stat(filename, &stb);
        !            51:        tvec = stb.st_mtime;
        !            52: }
        !            53: 
        !            54: /*
        !            55:  * Convert a "ctime" into a Pascal styple time line
        !            56:  */
        !            57: char *
        !            58: myctime(tv)
        !            59:        int *tv;
        !            60: {
        !            61:        register char *cp, *dp;
        !            62:        extern char *ctime();
        !            63:        char *cpp;
        !            64:        static char mycbuf[26];
        !            65: 
        !            66:        cpp = ctime(tv);
        !            67:        dp = mycbuf;
        !            68:        cp = cpp;
        !            69:        cpp[16] = 0;
        !            70:        while (*dp++ = *cp++);
        !            71:        dp--;
        !            72:        cp = cpp+19;
        !            73:        cpp[24] = 0;
        !            74:        while (*dp++ = *cp++);
        !            75:        return (mycbuf);
        !            76: }
        !            77: 
        !            78: /*
        !            79:  * Is "fp" in the command line list of names ?
        !            80:  */
        !            81: inpflist(fp)
        !            82:        char *fp;
        !            83: {
        !            84:        register i;
        !            85:        register char **pfp;
        !            86: 
        !            87:        pfp = pflist;
        !            88:        for (i = pflstc; i > 0; i--)
        !            89:                if (pstrcmp(fp, *pfp++) == 0)
        !            90:                        return (1);
        !            91:        return (0);
        !            92: }
        !            93: #endif
        !            94: 
        !            95: /*
        !            96:  * Boom!
        !            97:  */
        !            98: Perror(file, error)
        !            99:        char *file, *error;
        !           100: {
        !           101: 
        !           102:        fprintf( stderr , "%s: %s\n" , file , error );
        !           103: }
        !           104: 
        !           105: int *
        !           106: pcalloc(num, size)
        !           107:        int num, size;
        !           108: {
        !           109:        register int *p1, *p2, nbyte;
        !           110: 
        !           111:        nbyte = (num*size+( ( sizeof ( int ) ) - 1 ) ) & ~( ( sizeof ( int ) ) - 1 );
        !           112:        if ((p1 = (int *) malloc((unsigned) nbyte)) == 0)
        !           113:                return (0);
        !           114:        p2 =  p1;
        !           115:        nbyte /= sizeof ( int );
        !           116:        do {
        !           117:                *p2++ = 0;
        !           118:        } while (--nbyte);
        !           119:        return (p1);
        !           120: }
        !           121: 
        !           122: /*
        !           123:  * Compare strings:  s1>s2: >0  s1==s2: 0  s1<s2: <0
        !           124:  */
        !           125: pstrcmp(s1, s2)
        !           126:        register char *s1, *s2;
        !           127: {
        !           128: 
        !           129:        while (*s1 == *s2++)
        !           130:                if (*s1++=='\0')
        !           131:                        return (0);
        !           132:        return (*s1 - *--s2);
        !           133: }
        !           134: 
        !           135: /*
        !           136:  * Copy string s2 to s1.
        !           137:  * S1 must be large enough.
        !           138:  * Return s1.
        !           139:  */
        !           140: char *
        !           141: pstrcpy(s1, s2)
        !           142:        register char *s1, *s2;
        !           143: {
        !           144:        register char *os1;
        !           145: 
        !           146:        os1 = s1;
        !           147:        while (*s1++ = *s2++)
        !           148:                continue;
        !           149:        return (os1);
        !           150: }
        !           151: 
        !           152: /*
        !           153:  * Strlen is currently a freebie of perror
        !           154:  * Take the length of a string.
        !           155:  * Note that this does not include the trailing null!
        !           156: strlen(cp)
        !           157:        register char *cp;
        !           158: {
        !           159:        register int i;
        !           160: 
        !           161:        for (i = 0; *cp != 0; cp++)
        !           162:                i++;
        !           163:        return (i);
        !           164: }
        !           165:  */
        !           166: copy(to, from, bytes)
        !           167:        register char *to, *from;
        !           168:        register int bytes;
        !           169: {
        !           170: 
        !           171:        if (bytes != 0)
        !           172:                do
        !           173:                        *to++ = *from++;
        !           174:                while (--bytes);
        !           175: }
        !           176: 
        !           177: /*
        !           178:  * Is ch one of the characters in the string cp ?
        !           179:  */
        !           180: any(cp, ch)
        !           181:        register char *cp;
        !           182:        char ch;
        !           183: {
        !           184: 
        !           185:        while (*cp)
        !           186:                if (*cp++ == ch)
        !           187:                        return (1);
        !           188:        return (0);
        !           189: }
        !           190: 
        !           191: opush(c)
        !           192:        register CHAR c;
        !           193: {
        !           194: 
        !           195:        c -= 'A';
        !           196:        optstk[c] <<= 1;
        !           197:        optstk[c] |= opts[c];
        !           198:        opts[c] = 1;
        !           199: #ifdef PI0
        !           200:        send(ROPUSH, c);
        !           201: #endif
        !           202: }
        !           203: 
        !           204: opop(c)
        !           205:        register CHAR c;
        !           206: {
        !           207: 
        !           208:        c -= 'A';
        !           209:        opts[c] = optstk[c] & 1;
        !           210:        optstk[c] >>= 1;
        !           211: #ifdef PI0
        !           212:        send(ROPOP, c);
        !           213: #endif
        !           214: }

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