# 2.11BSD#431 - /usr/src/games/trek/dumpgame.c

##### Functions

    dumpgame          X
    readdump          X
    restartgame       X

##### Variables

    Dump_template     X

##### Macros

    VERSION           X

##### struct's

    dump              X

       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: }

#### Defined functions

dumpgame defined in line 47; used 2 times

- in /usr/src/games/trek/play.c line 27, 45

readdump defined in line 111; used 1 times

- in line 90

restartgame defined in line 82; used 1 times

- in /usr/src/games/trek/setup.c line 63

#### Defined variables

Dump_template defined in line 23; used 2 times

- in line 60, 121

sccsid defined in line 8; never used

#### Defined struct's

dump defined in line 16; used 6 times

- in line 23(2), 51(2), 115(2)

#### Defined macros

VERSION defined in line 14; used 2 times

- in line 56, 89

Last modified: 1986-02-01 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 507 |