Return to dumpgame.c CVS log

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

Annotation of 43BSD/games/trek/dumpgame.c, revision 1.1

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

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