SCI: Rename some members of class Resource

svn-id: r48085

4 files changed, 118 insertions, 110 deletions

diff --git a/engines/sci/console.cpp b/engines/sci/console.cpp
index 3b42a36bb9..c568aa6b49 100644
--- a/engines/sci/console.cpp
+++ b/engines/sci/console.cpp
@@ -617,11 +617,7 @@ bool Console::cmdDiskDump(int argc, const char **argv) {
 			sprintf(outFileName, "%s.%03d", getResourceTypeName(res), resNum);
 			Common::DumpFile *outFile = new Common::DumpFile();
 			outFile->open(outFileName);
-			outFile->writeByte(res);
-			outFile->writeByte(resource->headerSize);
-			if (resource->headerSize > 0)
-				outFile->write(resource->header, resource->headerSize);
-			outFile->write(resource->data, resource->size);
+			resource->writeToStream(outFile);
 			outFile->finalize();
 			outFile->close();
 			delete outFile;
diff --git a/engines/sci/resource.cpp b/engines/sci/resource.cpp
index 9aaff7433a..0eec195214 100644
--- a/engines/sci/resource.cpp
+++ b/engines/sci/resource.cpp
@@ -147,24 +147,32 @@ const char *getResourceTypeName(ResourceType restype) {
 Resource::Resource() {
 	data = NULL;
 	size = 0;
-	file_offset = 0;
-	status = kResStatusNoMalloc;
-	lockers = 0;
-	source = NULL;
-	header = NULL;
-	headerSize = 0;
+	_fileOffset = 0;
+	_status = kResStatusNoMalloc;
+	_lockers = 0;
+	_source = NULL;
+	_header = NULL;
+	_headerSize = 0;
 }
 
 Resource::~Resource() {
 	delete[] data;
-	if (source && source->source_type == kSourcePatch)
-		delete source;
+	if (_source && _source->source_type == kSourcePatch)
+		delete _source;
 }
 
 void Resource::unalloc() {
 	delete[] data;
 	data = NULL;
-	status = kResStatusNoMalloc;
+	_status = kResStatusNoMalloc;
+}
+
+void Resource::writeToStream(Common::WriteStream *stream) const {
+	stream->writeByte(_id.type);
+	stream->writeByte(_headerSize);
+	if (_headerSize > 0)
+		stream->write(_header, _headerSize);
+	stream->write(data, size);
 }
 
 //-- resMan helper functions --
@@ -253,35 +261,35 @@ ResourceSource *ResourceManager::getVolume(ResourceSource *map, int volume_nr) {
 
 bool ResourceManager::loadPatch(Resource *res, Common::File &file) {
 	// We assume that the resource type matches res->type
-	file.seek(res->file_offset + 2, SEEK_SET);
+	file.seek(res->_fileOffset + 2, SEEK_SET);
 
 	res->data = new byte[res->size];
 
-	if (res->headerSize > 0)
-		res->header = new byte[res->headerSize];
+	if (res->_headerSize > 0)
+		res->_header = new byte[res->_headerSize];
 
-	if ((res->data == NULL) || ((res->headerSize > 0) && (res->header == NULL))) {
-		error("Can't allocate %d bytes needed for loading %s", res->size + res->headerSize, res->id.toString().c_str());
+	if ((res->data == NULL) || ((res->_headerSize > 0) && (res->_header == NULL))) {
+		error("Can't allocate %d bytes needed for loading %s", res->size + res->_headerSize, res->_id.toString().c_str());
 	}
 
 	unsigned int really_read;
-	if (res->headerSize > 0) {
-		really_read = file.read(res->header, res->headerSize);
-		if (really_read != res->headerSize)
-			error("Read %d bytes from %s but expected %d", really_read, res->id.toString().c_str(), res->headerSize);
+	if (res->_headerSize > 0) {
+		really_read = file.read(res->_header, res->_headerSize);
+		if (really_read != res->_headerSize)
+			error("Read %d bytes from %s but expected %d", really_read, res->_id.toString().c_str(), res->_headerSize);
 	}
 
 	really_read = file.read(res->data, res->size);
 	if (really_read != res->size)
-		error("Read %d bytes from %s but expected %d", really_read, res->id.toString().c_str(), res->size);
+		error("Read %d bytes from %s but expected %d", really_read, res->_id.toString().c_str(), res->size);
 
-	res->status = kResStatusAllocated;
+	res->_status = kResStatusAllocated;
 	return true;
 }
 
 bool ResourceManager::loadFromPatchFile(Resource *res) {
 	Common::File file;
-	const char *filename = res->source->location_name.c_str();
+	const char *filename = res->_source->location_name.c_str();
 	if (file.open(filename) == false) {
 		warning("Failed to open patch file %s", filename);
 		res->unalloc();
@@ -296,9 +304,9 @@ bool ResourceManager::loadFromWaveFile(Resource *res, Common::File &file) {
 
 	uint32 really_read = file.read(res->data, res->size);
 	if (really_read != res->size)
-		error("Read %d bytes from %s but expected %d", really_read, res->id.toString().c_str(), res->size);
+		error("Read %d bytes from %s but expected %d", really_read, res->_id.toString().c_str(), res->size);
 
-	res->status = kResStatusAllocated;
+	res->_status = kResStatusAllocated;
 	return true;
 }
 
@@ -306,7 +314,7 @@ bool ResourceManager::loadFromAudioVolumeSCI11(Resource *res, Common::File &file
 	// Check for WAVE files here
 	uint32 riffTag = file.readUint32BE();
 	if (riffTag == MKID_BE('RIFF')) {
-		res->headerSize = 0;
+		res->_headerSize = 0;
 		res->size = file.readUint32LE();
 		file.seek(-8, SEEK_CUR);
 		return loadFromWaveFile(res, file);
@@ -314,17 +322,17 @@ bool ResourceManager::loadFromAudioVolumeSCI11(Resource *res, Common::File &file
 	file.seek(-4, SEEK_CUR);
 
 	ResourceType type = (ResourceType)(file.readByte() & 0x7f);
-	if (((res->id.type == kResourceTypeAudio || res->id.type == kResourceTypeAudio36) && (type != kResourceTypeAudio))
-		|| ((res->id.type == kResourceTypeSync || res->id.type == kResourceTypeSync36) && (type != kResourceTypeSync))) {
-		warning("Resource type mismatch loading %s from %s", res->id.toString().c_str(), file.getName());
+	if (((res->_id.type == kResourceTypeAudio || res->_id.type == kResourceTypeAudio36) && (type != kResourceTypeAudio))
+		|| ((res->_id.type == kResourceTypeSync || res->_id.type == kResourceTypeSync36) && (type != kResourceTypeSync))) {
+		warning("Resource type mismatch loading %s from %s", res->_id.toString().c_str(), file.getName());
 		res->unalloc();
 		return false;
 	}
 
-	res->headerSize = file.readByte();
+	res->_headerSize = file.readByte();
 
 	if (type == kResourceTypeAudio) {
-		if (res->headerSize != 11 && res->headerSize != 12) {
+		if (res->_headerSize != 11 && res->_headerSize != 12) {
 			warning("Unsupported audio header");
 			res->unalloc();
 			return false;
@@ -342,14 +350,14 @@ bool ResourceManager::loadFromAudioVolumeSCI1(Resource *res, Common::File &file)
 	res->data = new byte[res->size];
 
 	if (res->data == NULL) {
-		error("Can't allocate %d bytes needed for loading %s", res->size, res->id.toString().c_str());
+		error("Can't allocate %d bytes needed for loading %s", res->size, res->_id.toString().c_str());
 	}
 
 	unsigned int really_read = file.read(res->data, res->size);
 	if (really_read != res->size)
-		warning("Read %d bytes from %s but expected %d", really_read, res->id.toString().c_str(), res->size);
+		warning("Read %d bytes from %s but expected %d", really_read, res->_id.toString().c_str(), res->size);
 
-	res->status = kResStatusAllocated;
+	res->_status = kResStatusAllocated;
 	return true;
 }
 
@@ -389,22 +397,22 @@ Common::File *ResourceManager::getVolumeFile(const char *filename) {
 void ResourceManager::loadResource(Resource *res) {
 	Common::File *file;
 
-	if (res->source->source_type == kSourcePatch && loadFromPatchFile(res))
+	if (res->_source->source_type == kSourcePatch && loadFromPatchFile(res))
 		return;
 
 	// Either loading from volume or patch loading failed
-	file = getVolumeFile(res->source->location_name.c_str());
+	file = getVolumeFile(res->_source->location_name.c_str());
 	if (!file) {
-		warning("Failed to open %s", res->source->location_name.c_str());
+		warning("Failed to open %s", res->_source->location_name.c_str());
 		res->unalloc();
 		return;
 	}
-	file->seek(res->file_offset, SEEK_SET);
+	file->seek(res->_fileOffset, SEEK_SET);
 
-	if (res->source->source_type == kSourceWave && loadFromWaveFile(res, *file))
+	if (res->_source->source_type == kSourceWave && loadFromWaveFile(res, *file))
 		return;
 
-	if (res->source->source_type == kSourceAudioVolume) {
+	if (res->_source->source_type == kSourceAudioVolume) {
 		if (getSciVersion() < SCI_VERSION_1_1)
 			loadFromAudioVolumeSCI1(res, *file);
 		else
@@ -413,16 +421,14 @@ void ResourceManager::loadResource(Resource *res) {
 		int error = decompress(res, file);
 		if (error) {
 			warning("Error %d occured while reading %s from resource file: %s",
-				    error, res->id.toString().c_str(), sci_error_types[error]);
+				    error, res->_id.toString().c_str(), sci_error_types[error]);
 			res->unalloc();
 		}
 	}
 }
 
 Resource *ResourceManager::testResource(ResourceId id) {
-	if (_resMap.contains(id))
-		return _resMap.getVal(id);
-	return NULL;
+	return _resMap.getVal(id, NULL);
 }
 
 int sci0_get_compression_method(Common::ReadStream &stream) {
@@ -715,18 +721,18 @@ ResourceManager::~ResourceManager() {
 }
 
 void ResourceManager::removeFromLRU(Resource *res) {
-	if (res->status != kResStatusEnqueued) {
+	if (res->_status != kResStatusEnqueued) {
 		warning("resMan: trying to remove resource that isn't enqueued");
 		return;
 	}
 	_LRU.remove(res);
 	_memoryLRU -= res->size;
-	res->status = kResStatusAllocated;
+	res->_status = kResStatusAllocated;
 }
 
 void ResourceManager::addToLRU(Resource *res) {
-	if (res->status != kResStatusAllocated) {
-		warning("resMan: trying to enqueue resource with state %d", res->status);
+	if (res->_status != kResStatusAllocated) {
+		warning("resMan: trying to enqueue resource with state %d", res->_status);
 		return;
 	}
 	_LRU.push_front(res);
@@ -736,7 +742,7 @@ void ResourceManager::addToLRU(Resource *res) {
 	      getResourceTypeName(res->type), res->number, res->size,
 	      mgr->_memoryLRU);
 #endif
-	res->status = kResStatusEnqueued;
+	res->_status = kResStatusEnqueued;
 }
 
 void ResourceManager::printLRU() {
@@ -747,7 +753,7 @@ void ResourceManager::printLRU() {
 
 	while (it != _LRU.end()) {
 		res = *it;
-		debug("\t%s: %d bytes", res->id.toString().c_str(), res->size);
+		debug("\t%s: %d bytes", res->_id.toString().c_str(), res->size);
 		mem += res->size;
 		++entries;
 		++it;
@@ -773,8 +779,8 @@ Common::List<ResourceId> *ResourceManager::listResources(ResourceType type, int
 
 	ResourceMap::iterator itr = _resMap.begin();
 	while (itr != _resMap.end()) {
-		if ((itr->_value->id.type == type) && ((mapNumber == -1) || (itr->_value->id.number == mapNumber)))
-			resources->push_back(itr->_value->id);
+		if ((itr->_value->_id.type == type) && ((mapNumber == -1) || (itr->_value->_id.number == mapNumber)))
+			resources->push_back(itr->_value->_id);
 		++itr;
 	}
 
@@ -787,9 +793,9 @@ Resource *ResourceManager::findResource(ResourceId id, bool lock) {
 	if (!retval)
 		return NULL;
 
-	if (retval->status == kResStatusNoMalloc)
+	if (retval->_status == kResStatusNoMalloc)
 		loadResource(retval);
-	else if (retval->status == kResStatusEnqueued)
+	else if (retval->_status == kResStatusEnqueued)
 		removeFromLRU(retval);
 	// Unless an error occured, the resource is now either
 	// locked or allocated, but never queued or freed.
@@ -797,21 +803,21 @@ Resource *ResourceManager::findResource(ResourceId id, bool lock) {
 	freeOldResources();
 
 	if (lock) {
-		if (retval->status == kResStatusAllocated) {
-			retval->status = kResStatusLocked;
-			retval->lockers = 0;
+		if (retval->_status == kResStatusAllocated) {
+			retval->_status = kResStatusLocked;
+			retval->_lockers = 0;
 			_memoryLocked += retval->size;
 		}
-		retval->lockers++;
-	} else if (retval->status != kResStatusLocked) { // Don't lock it
-		if (retval->status == kResStatusAllocated)
+		retval->_lockers++;
+	} else if (retval->_status != kResStatusLocked) { // Don't lock it
+		if (retval->_status == kResStatusAllocated)
 			addToLRU(retval);
 	}
 
 	if (retval->data)
 		return retval;
 	else {
-		warning("resMan: Failed to read %s", retval->id.toString().c_str());
+		warning("resMan: Failed to read %s", retval->_id.toString().c_str());
 		return NULL;
 	}
 }
@@ -819,13 +825,13 @@ Resource *ResourceManager::findResource(ResourceId id, bool lock) {
 void ResourceManager::unlockResource(Resource *res) {
 	assert(res);
 
-	if (res->status != kResStatusLocked) {
-		warning("[resMan] Attempt to unlock unlocked resource %s", res->id.toString().c_str());
+	if (res->_status != kResStatusLocked) {
+		warning("[resMan] Attempt to unlock unlocked resource %s", res->_id.toString().c_str());
 		return;
 	}
 
-	if (!--res->lockers) { // No more lockers?
-		res->status = kResStatusAllocated;
+	if (!--res->_lockers) { // No more lockers?
+		res->_status = kResStatusAllocated;
 		_memoryLocked -= res->size;
 		addToLRU(res);
 	}
@@ -1093,12 +1099,12 @@ void ResourceManager::processPatch(ResourceSource *source, ResourceType restype,
 	} else
 		newrsc = _resMap.getVal(resId);
 	// Overwrite everything, because we're patching
-	newrsc->id = resId;
-	newrsc->status = kResStatusNoMalloc;
-	newrsc->source = source;
+	newrsc->_id = resId;
+	newrsc->_status = kResStatusNoMalloc;
+	newrsc->_source = source;
 	newrsc->size = fsize - patch_data_offset - 2;
-	newrsc->headerSize = patch_data_offset;
-	newrsc->file_offset = 0;
+	newrsc->_headerSize = patch_data_offset;
+	newrsc->_fileOffset = 0;
 	debugC(1, kDebugLevelResMan, "Patching %s - OK", source->location_name.c_str());
 }
 
@@ -1187,11 +1193,11 @@ void ResourceManager::readWaveAudioPatches() {
 			delete stream;
 
 			// Overwrite everything, because we're patching
-			newrsc->id = resId;
-			newrsc->status = kResStatusNoMalloc;
-			newrsc->source = psrcPatch;
+			newrsc->_id = resId;
+			newrsc->_status = kResStatusNoMalloc;
+			newrsc->_source = psrcPatch;
 			newrsc->size = fileSize;
-			newrsc->headerSize = 0;
+			newrsc->_headerSize = 0;
 			debugC(1, kDebugLevelResMan, "Patching %s - OK", psrcPatch->location_name.c_str());
 		}
 	}
@@ -1229,8 +1235,8 @@ int ResourceManager::readResourceMapSCI0(ResourceSource *map) {
 		// adding a new resource
 		if (_resMap.contains(resId) == false) {
 			res = new Resource;
-			res->source = getVolume(map, offset >> bShift);
-			if (!res->source) {
+			res->_source = getVolume(map, offset >> bShift);
+			if (!res->_source) {
 				warning("Could not get volume for resource %d, VolumeID %d", id, offset >> bShift);
 				if (_mapVersion != _volVersion) {
 					warning("Retrying with the detected volume version instead");
@@ -1238,11 +1244,11 @@ int ResourceManager::readResourceMapSCI0(ResourceSource *map) {
 					_mapVersion = _volVersion;
 					bMask = (_mapVersion == kResVersionSci1Middle) ? 0xF0 : 0xFC;
 					bShift = (_mapVersion == kResVersionSci1Middle) ? 28 : 26;
-					res->source = getVolume(map, offset >> bShift);
+					res->_source = getVolume(map, offset >> bShift);
 				}
 			}
-			res->file_offset = offset & (((~bMask) << 24) | 0xFFFFFF);
-			res->id = resId;
+			res->_fileOffset = offset & (((~bMask) << 24) | 0xFFFFFF);
+			res->_id = resId;
 			_resMap.setVal(resId, res);
 		}
 	} while (!file.eos());
@@ -1304,14 +1310,14 @@ int ResourceManager::readResourceMapSCI1(ResourceSource *map) {
 			if (_resMap.contains(resId) == false) {
 				res = new Resource;
 				_resMap.setVal(resId, res);
-				res->id = resId;
+				res->_id = resId;
 				
 				// NOTE: We add the map's volume number here to the specified volume number
 				// for SCI2.1 and SCI3 maps that are not RESMAP.000. The RESMAP.* files' numbers
 				// need to be used in concurrence with the volume specified in the map to get
 				// the actual resource file.
-				res->source = getVolume(map, volume_nr + map->volume_number);
-				res->file_offset = off;
+				res->_source = getVolume(map, volume_nr + map->volume_number);
+				res->_fileOffset = off;
 			}
 		}
 	}
@@ -1323,9 +1329,9 @@ void ResourceManager::addResource(ResourceId resId, ResourceSource *src, uint32
 	if (_resMap.contains(resId) == false) {
 		Resource *res = new Resource;
 		_resMap.setVal(resId, res);
-		res->id = resId;
-		res->source = src;
-		res->file_offset = offset;
+		res->_id = resId;
+		res->_source = src;
+		res->_fileOffset = offset;
 		res->size = size;
 	}
 }
@@ -1335,11 +1341,11 @@ void ResourceManager::removeAudioResource(ResourceId resId) {
 	if (_resMap.contains(resId)) {
 		Resource *res = _resMap.getVal(resId);
 
-		if (res->source->source_type == kSourceAudioVolume) {
-			if (res->status == kResStatusLocked) {
+		if (res->_source->source_type == kSourceAudioVolume) {
+			if (res->_status == kResStatusLocked) {
 				warning("Failed to remove resource %s (still in use)", resId.toString().c_str());
 			} else {
-				if (res->status == kResStatusEnqueued)
+				if (res->_status == kResStatusEnqueued)
 					removeFromLRU(res);
 
 				_resMap.erase(resId);
@@ -1634,7 +1640,7 @@ int ResourceManager::readResourceInfo(Resource *res, Common::File *file,
 	// check if there were errors while reading
 	if ((file->eos() || file->err()))
 		return SCI_ERROR_IO_ERROR;
-	res->id = ResourceId(type, number);
+	res->_id = ResourceId(type, number);
 	res->size = szUnpacked;
 	// checking compression method
 	switch (wCompression) {
@@ -1703,12 +1709,12 @@ int ResourceManager::decompress(Resource *res, Common::File *file) {
 		break;
 #endif
 	default:
-		warning("Resource %s: Compression method %d not supported", res->id.toString().c_str(), compression);
+		warning("Resource %s: Compression method %d not supported", res->_id.toString().c_str(), compression);
 		return SCI_ERROR_UNKNOWN_COMPRESSION;
 	}
 
 	res->data = new byte[res->size];
-	res->status = kResStatusAllocated;
+	res->_status = kResStatusAllocated;
 	error = res->data ? dec->unpack(file, res->data, szPacked, res->size) : SCI_ERROR_RESOURCE_TOO_BIG;
 	if (error)
 		res->unalloc();
@@ -1728,13 +1734,13 @@ ResourceCompression ResourceManager::getViewCompression() {
 		if (!res)
 			continue;
 
-		if (res->source->source_type != kSourceVolume)
+		if (res->_source->source_type != kSourceVolume)
 			continue;
 
-		file = getVolumeFile(res->source->location_name.c_str());
+		file = getVolumeFile(res->_source->location_name.c_str());
 		if (!file)
 			continue;
-		file->seek(res->file_offset, SEEK_SET);
+		file->seek(res->_fileOffset, SEEK_SET);
 
 		uint32 szPacked;
 		ResourceCompression compression;
diff --git a/engines/sci/resource.h b/engines/sci/resource.h
index 43b4b37f4a..94ffe176d9 100644
--- a/engines/sci/resource.h
+++ b/engines/sci/resource.h
@@ -34,6 +34,7 @@
 
 namespace Common {
 class ReadStream;
+class WriteStream;
 class File;
 class FSNode;
 }
@@ -122,12 +123,14 @@ public:
 
 	ResourceId() : type(kResourceTypeInvalid), number(0), tuple(0) { };
 
-	ResourceId(ResourceType type_, uint16 number_, uint32 tuple_ = 0) : type(type_), number(number_), tuple(tuple_) {
+	ResourceId(ResourceType type_, uint16 number_, uint32 tuple_ = 0)
+			: type(type_), number(number_), tuple(tuple_) {
 		if ((type < kResourceTypeView) || (type > kResourceTypeInvalid))
 			type = kResourceTypeInvalid;
 	}
 
-	ResourceId(ResourceType type_, uint16 number_, byte noun, byte verb, byte cond, byte seq) : type(type_), number(number_) {
+	ResourceId(ResourceType type_, uint16 number_, byte noun, byte verb, byte cond, byte seq)
+			: type(type_), number(number_) {
 		tuple = (noun << 24) | (verb << 16) | (cond << 8) | seq;
 
 		if ((type < kResourceTypeView) || (type > kResourceTypeInvalid))
@@ -175,16 +178,19 @@ public:
 // NOTE : Currently all member data has the same name and public visibility
 // to let the rest of the engine compile without changes
 public:
+	ResourceId _id;
 	byte *data;
-	ResourceId id;
 	uint32 size;
-	byte *header;
-	uint32 headerSize;
+	byte *_header;
+	uint32 _headerSize;
+
+	void writeToStream(Common::WriteStream *stream) const;
+
 protected:
-	int32 file_offset; /**< Offset in file */
-	ResourceStatus status;
-	uint16 lockers; /**< Number of places where this resource was locked */
-	ResourceSource *source;
+	int32 _fileOffset; /**< Offset in file */
+	ResourceStatus _status;
+	uint16 _lockers; /**< Number of places where this resource was locked */
+	ResourceSource *_source;
 };
 
 typedef Common::HashMap<ResourceId, Resource *, ResourceIdHash, ResourceIdEqualTo> ResourceMap;
diff --git a/engines/sci/sound/audio.cpp b/engines/sci/sound/audio.cpp
index 336aa04aef..4643448dc4 100644
--- a/engines/sci/sound/audio.cpp
+++ b/engines/sci/sound/audio.cpp
@@ -205,7 +205,7 @@ Audio::RewindableAudioStream *AudioPlayer::getAudioStream(uint32 number, uint32
 	uint32 size = 0;
 	byte *data = 0;
 	byte flags = 0;
-	Sci::Resource* audioRes;
+	Sci::Resource *audioRes;
 
 	if (volume == 65535) {
 		audioRes = _resMan->findResource(ResourceId(kResourceTypeAudio, number), false);
@@ -224,11 +224,11 @@ Audio::RewindableAudioStream *AudioPlayer::getAudioStream(uint32 number, uint32
 
 	byte audioFlags;
 
-	if (audioRes->headerSize > 0) {
+	if (audioRes->_headerSize > 0) {
 		// SCI1.1
-		Common::MemoryReadStream headerStream(audioRes->header, audioRes->headerSize, DisposeAfterUse::NO);
+		Common::MemoryReadStream headerStream(audioRes->_header, audioRes->_headerSize, DisposeAfterUse::NO);
 
-		if (readSOLHeader(&headerStream, audioRes->headerSize, size, _audioRate, audioFlags)) {
+		if (readSOLHeader(&headerStream, audioRes->_headerSize, size, _audioRate, audioFlags)) {
 			Common::MemoryReadStream dataStream(audioRes->data, audioRes->size, DisposeAfterUse::NO);
 			data = readSOLAudio(&dataStream, size, audioFlags, flags);
 		}