1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
|
/* ScummVM - Scumm Interpreter
* Copyright (C) 2002-2005 The ScummVM project
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* as published by the Free Software Foundation; either version 2
* of the License, or (at your option) any later version.
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*
* $Header$
*
*/
#ifndef SAVELOAD_H
#define SAVELOAD_H
#include "common/scummsys.h"
namespace Common {
class InSaveFile;
class OutSaveFile;
}
namespace Scumm {
/**
* The current savegame format version.
* Our save/load system uses an elaborate scheme to allow us to modify the
* savegame while keeping full backward compatibility, in the sense that newer
* ScummVM versions always are able to load old savegames.
* In order to achieve that, we store a version in the savegame files, and whenever
* the savegame layout is modified, the version is incremented.
*
* This roughly works by marking each savegame entry with a range of versions
* for which it is valid; the save/load code iterates over all entries, but
* only saves/loads those which are valid for the version of the savegame
* which is being loaded/saved currently.
*/
#define CURRENT_VER 62
/**
* An auxillary macro, used to specify savegame versions. We use this instead
* of just writing the raw version, because this way they stand out more to
* the reading eye, making it a bit easier to navigate through the code.
*/
#define VER(x) x
/**
* The OFFS macro essentially provides the functionality of offsetof(), that
* is, it determines the offset of a struct/class member within instances of
* that class.
*
* This is a place where we cheat a bit and sacrifice some potential portability
* (although so far we haven't encountered any platform where this matters).
*
* To work around a warning in GCC 3.2 (and 3.1 ?) regarding non-POD types,
* we use a small trick: instead of 0 we use 42. Why? Well, it seems newer GCC
* versions have a heuristic built in to detect "offset-of" patterns - which is exactly
* what our OFFS macro does. Now, for non-POD types this is not really legal, because
* member need not be at a fixed offset relative to the variable, even if they are in
* current reality (many of our complex structs are non-POD; for an explanation of
* what POD means refer to http://www-cpd.fnal.gov/personal/wb/boost/ISOcxx/doc/POD.html)
*/
#define OFFS(type,item) (((long)(&((type*)42)->type::item))-42)
/**
* Similar to the OFFS macro, this macro computes the size (in bytes) of a
* member of a given struct/class type.
*/
#define SIZE(type,item) sizeof(((type*)42)->type::item)
// Any item that is still in use automatically gets a maxVersion equal to CURRENT_VER
#define MKLINE(type,item,saveas,minVer) {OFFS(type,item),saveas,SIZE(type,item),minVer,CURRENT_VER}
#define MKARRAY(type,item,saveas,dim,minVer) {OFFS(type,item),128|saveas,SIZE(type,item),minVer,CURRENT_VER}, {dim,1,0,0,0}
#define MKARRAY2(type,item,saveas,dim,dim2,rowlen,minVer) {OFFS(type,item),128|saveas,SIZE(type,item),minVer,CURRENT_VER}, {dim,dim2,rowlen,0,0}
// Use this if you have an entry that used to be smaller:
#define MKLINE_OLD(type,item,saveas,minVer,maxVer) {OFFS(type,item),saveas,SIZE(type,item),minVer,maxVer}
#define MKARRAY_OLD(type,item,saveas,dim,minVer,maxVer) {OFFS(type,item),128|saveas,SIZE(type,item),minVer,maxVer}, {dim,1,0,0,0}
#define MKARRAY2_OLD(type,item,saveas,dim,dim2,rowlen,minVer,maxVer) {OFFS(type,item),128|saveas,SIZE(type,item),minVer,maxVer}, {dim,dim2,rowlen,0,0}
// An obsolete item/array, to be ignored upon load. We retain the type/item params to make it easier to debug.
// Obsolete items have size == 0.
#define MK_OBSOLETE(type,item,saveas,minVer,maxVer) {0,saveas,0,minVer,maxVer}
#define MK_OBSOLETE_ARRAY(type,item,saveas,dim,minVer,maxVer) {0,128|saveas,0,minVer,maxVer}, {dim,1,0,0,0}
#define MK_OBSOLETE_ARRAY2(type,item,saveas,dim,dim2,rowlen,minVer,maxVer) {0,128|saveas,0,minVer,maxVer}, {dim,dim2,rowlen,0,0}
// End marker
#define MKEND() {0xFFFF,0xFF,0xFF,0,0}
enum {
sleByte = 1,
sleUint8 = 1,
sleInt8 = 1,
sleInt16 = 2,
sleUint16 = 3,
sleInt32 = 4,
sleUint32 = 5
};
struct SaveLoadEntry {
uint32 offs; // or: array dimension
uint16 type; // or: array dimension 2
uint16 size; // or: array row length
uint8 minVersion;
uint8 maxVersion;
};
class Serializer {
public:
Serializer(Common::InSaveFile *in, Common::OutSaveFile *out, uint32 savegameVersion)
: _loadStream(in), _saveStream(out),
_savegameVersion(savegameVersion)
{ }
void saveLoadArrayOf(void *b, int len, int datasize, byte filetype);
void saveLoadArrayOf(void *b, int num, int datasize, const SaveLoadEntry *sle);
void saveLoadEntries(void *d, const SaveLoadEntry *sle);
bool isSaving() { return (_saveStream != 0); }
bool isLoading() { return (_loadStream != 0); }
uint32 getVersion() { return _savegameVersion; }
void saveUint32(uint32 d);
void saveUint16(uint16 d);
void saveByte(byte b);
byte loadByte();
uint16 loadUint16();
uint32 loadUint32();
void saveBytes(void *b, int len);
void loadBytes(void *b, int len);
protected:
Common::InSaveFile *_loadStream;
Common::OutSaveFile *_saveStream;
uint32 _savegameVersion;
void saveArrayOf(void *b, int len, int datasize, byte filetype);
void loadArrayOf(void *b, int len, int datasize, byte filetype);
void saveEntries(void *d, const SaveLoadEntry *sle);
void loadEntries(void *d, const SaveLoadEntry *sle);
};
// Mixin class / interface. Maybe call it ISerializable or SerializableMixin ?
class Serializable {
public:
virtual ~Serializable() {}
virtual void saveLoadWithSerializer(Serializer *ser) = 0;
};
} // End of namespace Scumm
#endif
|
