Return to fortune.c CVS log

Up to [CSRG BSD Unix] / 43BSDReno / games / larn

Annotation of 43BSDReno/games/larn/fortune.c, revision 1.1

1.1     ! root        1: /* fortune.c            Larn is copyrighted 1986 by Noah Morgan. */
        !             2: #include <sys/types.h>
        !             3: #include <sys/stat.h>
        !             4: 
        !             5: #ifndef BSD4.1
        !             6: #include <fcntl.h>
        !             7: #else BSD4.1
        !             8: #define O_RDONLY 0
        !             9: #endif BSD4.1
        !            10: 
        !            11: #include "header.h"
        !            12: /*
        !            13:  *     function to return a random fortune from the fortune file
        !            14:  */
        !            15: static char *base=0;   /* pointer to the fortune text */
        !            16: static char **flines=0;        /* array of pointers to each fortune */
        !            17: static int fd=0;               /* true if we have load the fortune info */
        !            18: static int nlines=0;   /* # lines in fortune database */
        !            19: 
        !            20: char *fortune(file)
        !            21:        char *file;
        !            22:        {
        !            23:        register char *p;
        !            24:        register int lines,tmp;
        !            25:        struct stat stat;
        !            26:        char *malloc();
        !            27:        if (fd==0)
        !            28:                {
        !            29:                if ((fd=open(file,O_RDONLY)) < 0)       /* open the file */
        !            30:                        return(0); /* can't find file */
        !            31: 
        !            32:        /* find out how big fortune file is and get memory for it */
        !            33:                stat.st_size = 16384;
        !            34:                if ((fstat(fd,&stat) < 0) || ((base=malloc(1+stat.st_size)) == 0))
        !            35:                        {
        !            36:                        close(fd); fd= -1; free((char*)base); return(0);        /* can't stat file */
        !            37:                        }
        !            38: 
        !            39:        /* read in the entire fortune file */
        !            40:                if (read(fd,base,stat.st_size) != stat.st_size)
        !            41:                        {
        !            42:                        close(fd); fd= -1; free((char*)base); return(0);        /* can't read file */
        !            43:                        }
        !            44:                close(fd);  base[stat.st_size]=0;       /* final NULL termination */
        !            45: 
        !            46:        /* count up all the lines (and NULL terminate) to know memory needs */
        !            47:                for (p=base,lines=0; p<base+stat.st_size; p++) /* count lines */
        !            48:                        if (*p == '\n') *p=0,lines++;
        !            49:                nlines = lines;
        !            50: 
        !            51:        /* get memory for array of pointers to each fortune */
        !            52:                if ((flines=(char**)malloc(nlines*sizeof(char*))) == 0)
        !            53:                        {
        !            54:                        free((char*)base); fd= -1; return(0); /* malloc() failure */
        !            55:                        }
        !            56: 
        !            57:        /* now assign each pointer to a line */
        !            58:                for (p=base,tmp=0; tmp<nlines; tmp++)
        !            59:                        {
        !            60:                        flines[tmp]=p;  while (*p++); /* advance to next line */
        !            61:                        }
        !            62:                }
        !            63: 
        !            64:        if (fd > 2)     /* if we have a database to look at */
        !            65:                return(flines[rund((nlines<=0)?1:nlines)]);
        !            66:        else 
        !            67:                return(0);
        !            68:        }

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