Return to dumpgame.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / games / trek

Annotation of 43BSDTahoe/games/trek/dumpgame.c, revision 1.1.1.1

1.1       root        1: /*
                      2:  * Copyright (c) 1980 Regents of the University of California.
                      3:  * All rights reserved.
                      4:  *
                      5:  * Redistribution and use in source and binary forms are permitted
                      6:  * provided that the above copyright notice and this paragraph are
                      7:  * duplicated in all such forms and that any documentation,
                      8:  * advertising materials, and other materials related to such
                      9:  * distribution and use acknowledge that the software was developed
                     10:  * by the University of California, Berkeley.  The name of the
                     11:  * University may not be used to endorse or promote products derived
                     12:  * from this software without specific prior written permission.
                     13:  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
                     14:  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
                     15:  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
                     16:  */
                     17: 
                     18: #ifndef lint
                     19: static char sccsid[] = "@(#)dumpgame.c 4.5 (Berkeley) 6/18/88";
                     20: #endif /* not lint */
                     21: 
                     22: # include      "trek.h"
                     23: 
                     24: /***  THIS CONSTANT MUST CHANGE AS THE DATA SPACES CHANGE ***/
                     25: # define       VERSION         2
                     26: 
                     27: struct dump
                     28: {
                     29:        char    *area;
                     30:        int     count;
                     31: };
                     32: 
                     33: 
                     34: struct dump    Dump_template[] =
                     35: {
                     36:        (char *)&Ship,          sizeof (Ship),
                     37:        (char *)&Now,           sizeof (Now),
                     38:        (char *)&Param,         sizeof (Param),
                     39:        (char *)&Etc,           sizeof (Etc),
                     40:        (char *)&Game,          sizeof (Game),
                     41:        (char *)Sect,           sizeof (Sect),
                     42:        (char *)Quad,           sizeof (Quad),
                     43:        (char *)&Move,          sizeof (Move),
                     44:        (char *)Event,          sizeof (Event),
                     45:        0
                     46: };
                     47: 
                     48: /*
                     49: **  DUMP GAME
                     50: **
                     51: **     This routine dumps the game onto the file "trek.dump".  The
                     52: **     first two bytes of the file are a version number, which
                     53: **     reflects whether this image may be used.  Obviously, it must
                     54: **     change as the size, content, or order of the data structures
                     55: **     output change.
                     56: */
                     57: 
                     58: dumpgame()
                     59: {
                     60:        int                     version;
                     61:        register int            fd;
                     62:        register struct dump    *d;
                     63:        register int            i;
                     64: 
                     65:        if ((fd = creat("trek.dump", 0644)) < 0)
                     66:                return (printf("cannot dump\n"));
                     67:        version = VERSION;
                     68:        write(fd, &version, sizeof version);
                     69: 
                     70:        /* output the main data areas */
                     71:        for (d = Dump_template; d->area; d++)
                     72:        {
                     73:                write(fd, &d->area, sizeof d->area);
                     74:                i = d->count;
                     75:                write(fd, d->area, i);
                     76:        }
                     77: 
                     78:        close(fd);
                     79: }
                     80: 
                     81: 
                     82: /*
                     83: **  RESTORE GAME
                     84: **
                     85: **     The game is restored from the file "trek.dump".  In order for
                     86: **     this to succeed, the file must exist and be readable, must
                     87: **     have the correct version number, and must have all the appro-
                     88: **     priate data areas.
                     89: **
                     90: **     Return value is zero for success, one for failure.
                     91: */
                     92: 
                     93: restartgame()
                     94: {
                     95:        register int    fd;
                     96:        int             version;
                     97: 
                     98:        if ((fd = open("trek.dump", 0)) < 0 ||
                     99:            read(fd, &version, sizeof version) != sizeof version ||
                    100:            version != VERSION ||
                    101:            readdump(fd))
                    102:        {
                    103:                printf("cannot restart\n");
                    104:                close(fd);
                    105:                return (1);
                    106:        }
                    107: 
                    108:        close(fd);
                    109:        return (0);
                    110: }
                    111: 
                    112: 
                    113: /*
                    114: **  READ DUMP
                    115: **
                    116: **     This is the business end of restartgame().  It reads in the
                    117: **     areas.
                    118: **
                    119: **     Returns zero for success, one for failure.
                    120: */
                    121: 
                    122: readdump(fd1)
                    123: int    fd1;
                    124: {
                    125:        register int            fd;
                    126:        register struct dump    *d;
                    127:        register int            i;
                    128:        int                     junk;
                    129: 
                    130:        fd = fd1;
                    131: 
                    132:        for (d = Dump_template; d->area; d++)
                    133:        {
                    134:                if (read(fd, &junk, sizeof junk) != (sizeof junk))
                    135:                        return (1);
                    136:                if ((char *)junk != d->area)
                    137:                        return (1);
                    138:                i = d->count;
                    139:                if (read(fd, d->area, i) != i)
                    140:                        return (1);
                    141:        }
                    142: 
                    143:        /* make quite certain we are at EOF */
                    144:        return (read(fd, &junk, 1));
                    145: }

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