Return to subr.c CVS log

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

Annotation of 43BSDTahoe/ucb/pascal/src/subr.c, revision 1.1.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.1 (Berkeley) 6/5/85";
                      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: extern int errno;
                     96: extern char *sys_errlist[];
                     97: 
                     98: /*
                     99:  * Boom!
                    100:  */
                    101: Perror(file, error)
                    102:        char *file, *error;
                    103: {
                    104: 
                    105:        fprintf( stderr , "%s: %s\n" , file , error );
                    106: }
                    107: 
                    108: int *
                    109: pcalloc(num, size)
                    110:        int num, size;
                    111: {
                    112:        register int *p1, *p2, nbyte;
                    113: 
                    114:        nbyte = (num*size+( ( sizeof ( int ) ) - 1 ) ) & ~( ( sizeof ( int ) ) - 1 );
                    115:        if ((p1 = (int *) malloc((unsigned) nbyte)) == 0)
                    116:                return (0);
                    117:        p2 =  p1;
                    118:        nbyte /= sizeof ( int );
                    119:        do {
                    120:                *p2++ = 0;
                    121:        } while (--nbyte);
                    122:        return (p1);
                    123: }
                    124: 
                    125: /*
                    126:  * Compare strings:  s1>s2: >0  s1==s2: 0  s1<s2: <0
                    127:  */
                    128: pstrcmp(s1, s2)
                    129:        register char *s1, *s2;
                    130: {
                    131: 
                    132:        while (*s1 == *s2++)
                    133:                if (*s1++=='\0')
                    134:                        return (0);
                    135:        return (*s1 - *--s2);
                    136: }
                    137: 
                    138: /*
                    139:  * Copy string s2 to s1.
                    140:  * S1 must be large enough.
                    141:  * Return s1.
                    142:  */
                    143: char *
                    144: pstrcpy(s1, s2)
                    145:        register char *s1, *s2;
                    146: {
                    147:        register char *os1;
                    148: 
                    149:        os1 = s1;
                    150:        while (*s1++ = *s2++)
                    151:                continue;
                    152:        return (os1);
                    153: }
                    154: 
                    155: /*
                    156:  * Strlen is currently a freebie of perror
                    157:  * Take the length of a string.
                    158:  * Note that this does not include the trailing null!
                    159: strlen(cp)
                    160:        register char *cp;
                    161: {
                    162:        register int i;
                    163: 
                    164:        for (i = 0; *cp != 0; cp++)
                    165:                i++;
                    166:        return (i);
                    167: }
                    168:  */
                    169: copy(to, from, bytes)
                    170:        register char *to, *from;
                    171:        register int bytes;
                    172: {
                    173: 
                    174:        if (bytes != 0)
                    175:                do
                    176:                        *to++ = *from++;
                    177:                while (--bytes);
                    178: }
                    179: 
                    180: /*
                    181:  * Is ch one of the characters in the string cp ?
                    182:  */
                    183: any(cp, ch)
                    184:        register char *cp;
                    185:        char ch;
                    186: {
                    187: 
                    188:        while (*cp)
                    189:                if (*cp++ == ch)
                    190:                        return (1);
                    191:        return (0);
                    192: }
                    193: 
                    194: opush(c)
                    195:        register CHAR c;
                    196: {
                    197: 
                    198:        c -= 'A';
                    199:        optstk[c] <<= 1;
                    200:        optstk[c] |= opts[c];
                    201:        opts[c] = 1;
                    202: #ifdef PI0
                    203:        send(ROPUSH, c);
                    204: #endif
                    205: }
                    206: 
                    207: opop(c)
                    208:        register CHAR c;
                    209: {
                    210: 
                    211:        c -= 'A';
                    212:        opts[c] = optstk[c] & 1;
                    213:        optstk[c] >>= 1;
                    214: #ifdef PI0
                    215:        send(ROPOP, c);
                    216: #endif
                    217: }

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