4.3BSD - /usr/src/ucb/pascal/src/subr.c

   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: }

Defined functions

Defined variables