Return to yow.c CVS log

Up to [CSRG BSD Unix] / 43BSD / contrib / emacs / etc

Annotation of 43BSD/contrib/emacs/etc/yow.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include <ctype.h>
                      3: #include "../src/paths.h"
                      4: 
                      5: /* zippy.c
                      6:  * 
                      7:  * Print a quotation from Zippy the Pinhead.
                      8:  * Qux <Kaufman-David@Yale> March 6, 1986
                      9:  * 
                     10:  */
                     11: 
                     12: #define BUFSIZE  2000
                     13: #define SEP      '\0'
                     14: #define YOW_FILE "yow.lines"
                     15: 
                     16: main (argc, argv)
                     17:      int argc;
                     18:      char *argv[];
                     19: {
                     20:   FILE *fp;
                     21:   char file[BUFSIZ];
                     22:   void yow();
                     23: 
                     24:   sprintf(file, "%s/%s", PATH_EXEC, YOW_FILE);
                     25: 
                     26:   if ((fp = fopen(file, "r")) == NULL) {
                     27:     perror(file);
                     28:     exit(1);
                     29:   }
                     30: 
                     31:   /* initialize random seed */
                     32:   srand((int) (getpid() + time((long *) 0)));
                     33: 
                     34:   yow(fp);
                     35:   fclose(fp);
                     36:   exit(0);
                     37: }
                     38: 
                     39: void yow (fp)
                     40:      FILE *fp;
                     41: {
                     42:   static long len = -1;
                     43:   long offset;
                     44:   int c, i = 0;
                     45:   char buf[BUFSIZE];
                     46: 
                     47:   /* Get length of file, go to a random place in it */
                     48:   if (len == -1) {
                     49:     if (fseek(fp, 0, 2) == -1) {
                     50:       perror("fseek 1");
                     51:       exit(1);
                     52:     }
                     53:     len = ftell(fp);
                     54:   }
                     55:   offset = rand() % len;
                     56:   if (fseek(fp, offset, 0) == -1) {
                     57:     perror("fseek 2");
                     58:     exit(1);
                     59:   }
                     60: 
                     61:   /* Read until SEP, read next line, print it.
                     62:      (Note that we will never print anything before the first seperator.)
                     63:      If we hit EOF looking for the first SEP, just recurse. */
                     64:   while ((c = getc(fp)) != SEP)
                     65:     if (c == EOF) {
                     66:       yow(fp);
                     67:       return;
                     68:     }
                     69: 
                     70:   /* Skip leading whitespace, then read in a quotation.
                     71:      If we hit EOF before we find a non-whitespace char, recurse. */
                     72:   while (isspace(c = getc(fp)))
                     73:     ;
                     74:   if (c == EOF) {
                     75:     yow(fp);
                     76:     return;
                     77:   }
                     78:   buf[i++] = c;
                     79:   while ((c = getc(fp)) != SEP && c != EOF) {
                     80:     buf[i++] = c;
                     81: 
                     82:     if (i == BUFSIZ-1)
                     83:       /* Yow! Is this quotation too long yet? */
                     84:       break;
                     85:   }
                     86:   buf[i++] = 0;
                     87:   printf("%s\n", buf);
                     88: }
                     89: 

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