Return to dumpgame.c CVS log

Up to [CSRG BSD Unix] / 42BSD / games / trek

Annotation of 42BSD/games/trek/dumpgame.c, revision 1.1.1.1

1.1       root        1: #ifndef lint
                      2: static char sccsid[] = "@(#)dumpgame.c 4.2     (Berkeley)      5/27/83";
                      3: #endif not lint
                      4: 
                      5: # include      "trek.h"
                      6: 
                      7: /***  THIS CONSTANT MUST CHANGE AS THE DATA SPACES CHANGE ***/
                      8: # define       VERSION         2
                      9: 
                     10: struct dump
                     11: {
                     12:        char    *area;
                     13:        int     count;
                     14: };
                     15: 
                     16: 
                     17: struct dump    Dump_template[] =
                     18: {
                     19:        (char *)&Ship,          sizeof (Ship),
                     20:        (char *)&Now,           sizeof (Now),
                     21:        (char *)&Param,         sizeof (Param),
                     22:        (char *)&Etc,           sizeof (Etc),
                     23:        (char *)&Game,          sizeof (Game),
                     24:        (char *)Sect,           sizeof (Sect),
                     25:        (char *)Quad,           sizeof (Quad),
                     26:        (char *)&Move,          sizeof (Move),
                     27:        (char *)Event,          sizeof (Event),
                     28:        0
                     29: };
                     30: 
                     31: /*
                     32: **  DUMP GAME
                     33: **
                     34: **     This routine dumps the game onto the file "trek.dump".  The
                     35: **     first two bytes of the file are a version number, which
                     36: **     reflects whether this image may be used.  Obviously, it must
                     37: **     change as the size, content, or order of the data structures
                     38: **     output change.
                     39: */
                     40: 
                     41: dumpgame()
                     42: {
                     43:        int                     version;
                     44:        register int            fd;
                     45:        register struct dump    *d;
                     46:        register int            i;
                     47: 
                     48:        if ((fd = creat("trek.dump", 0644)) < 0)
                     49:                return (printf("cannot dump\n"));
                     50:        version = VERSION;
                     51:        write(fd, &version, sizeof version);
                     52: 
                     53:        /* output the main data areas */
                     54:        for (d = Dump_template; d->area; d++)
                     55:        {
                     56:                write(fd, &d->area, sizeof d->area);
                     57:                i = d->count;
                     58:                write(fd, d->area, i);
                     59:        }
                     60: 
                     61:        close(fd);
                     62: }
                     63: 
                     64: 
                     65: /*
                     66: **  RESTORE GAME
                     67: **
                     68: **     The game is restored from the file "trek.dump".  In order for
                     69: **     this to succeed, the file must exist and be readable, must
                     70: **     have the correct version number, and must have all the appro-
                     71: **     priate data areas.
                     72: **
                     73: **     Return value is zero for success, one for failure.
                     74: */
                     75: 
                     76: restartgame()
                     77: {
                     78:        register int    fd;
                     79:        int             version;
                     80: 
                     81:        if ((fd = open("trek.dump", 0)) < 0 ||
                     82:            read(fd, &version, sizeof version) != sizeof version ||
                     83:            version != VERSION ||
                     84:            readdump(fd))
                     85:        {
                     86:                printf("cannot restart\n");
                     87:                close(fd);
                     88:                return (1);
                     89:        }
                     90: 
                     91:        close(fd);
                     92:        return (0);
                     93: }
                     94: 
                     95: 
                     96: /*
                     97: **  READ DUMP
                     98: **
                     99: **     This is the business end of restartgame().  It reads in the
                    100: **     areas.
                    101: **
                    102: **     Returns zero for success, one for failure.
                    103: */
                    104: 
                    105: readdump(fd1)
                    106: int    fd1;
                    107: {
                    108:        register int            fd;
                    109:        register struct dump    *d;
                    110:        register int            i;
                    111:        int                     junk;
                    112: 
                    113:        fd = fd1;
                    114: 
                    115:        for (d = Dump_template; d->area; d++)
                    116:        {
                    117:                if (read(fd, &junk, sizeof junk) != (sizeof junk))
                    118:                        return (1);
                    119:                if ((char *)junk != d->area)
                    120:                        return (1);
                    121:                i = d->count;
                    122:                if (read(fd, d->area, i) != i)
                    123:                        return (1);
                    124:        }
                    125: 
                    126:        /* make quite certain we are at EOF */
                    127:        return (read(fd, &junk, 1));
                    128: }

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