scummvm/common/file.cpp

321 lines
5.9 KiB
C++
Raw Normal View History

2002-08-31 07:43:34 +00:00
/* ScummVM - Scumm Interpreter
* Copyright (C) 2002-2003 The ScummVM project
2002-08-31 07:43:34 +00:00
*
* 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*
* $Header$
*
*/
#include "file.h"
#include "engine.h" // For debug/warning/error
2002-08-31 07:43:34 +00:00
2003-01-09 14:50:35 +00:00
FILE *File::fopenNoCase(const char *filename, const char *directory, const char *mode) {
FILE *file;
char buf[256];
char *ptr;
strcpy(buf, directory);
if (directory[0] != 0) {
#ifdef __MORPHOS__
if (buf[strlen(buf)-1] != ':' && buf[strlen(buf)-1] != '/')
#endif
2003-04-10 13:44:50 +00:00
2003-04-30 12:43:56 +00:00
#if !defined(__GP32__) && !defined(__PALM_OS__)
strcat(buf, "/"); // prevent double /
2003-04-10 13:44:50 +00:00
#endif
}
strcat(buf, filename);
file = fopen(buf, mode);
if (file)
return file;
const char *dirs[] = {
2002-10-22 20:40:51 +00:00
"",
"video/",
"VIDEO/",
"data/",
"DATA/",
"resource/",
"RESOURCE/",
"voices/",
"VOICES/"
2002-10-22 20:40:51 +00:00
};
for (uint8 l = 0; l < 9; l++) {
strcpy(buf, directory);
if (directory[0] != 0) {
#ifdef __MORPHOS__
if (buf[strlen(buf) - 1] != ':' && buf[strlen(buf) - 1] != '/')
#endif
2003-04-30 12:43:56 +00:00
#ifndef __PALM_OS__
strcat(buf, "/"); // PALMOS
#endif
}
strcat(buf, dirs[l]);
int8 len = strlen(buf);
strcat(buf, filename);
ptr = buf + len;
do
*ptr = toupper(*ptr);
while (*ptr++);
file = fopen(buf, mode);
if (file)
return file;
ptr = buf + len;
do
*ptr = tolower(*ptr);
while (*ptr++);
file = fopen(buf, mode);
if (file)
return file;
}
return NULL;
}
2002-08-31 07:43:34 +00:00
File::File() {
_handle = NULL;
_ioFailed = false;
2002-08-31 07:43:34 +00:00
_encbyte = 0;
_name = 0;
2002-08-31 07:43:34 +00:00
}
File::~File() {
delete [] _name;
2002-08-31 07:43:34 +00:00
close();
}
bool File::open(const char *filename, const char *directory, int mode, byte encbyte) {
2002-08-31 07:43:34 +00:00
if (_handle) {
debug(2, "File %s already opened", filename);
return false;
}
if (filename == NULL || *filename == 0)
return false;
clearIOFailed();
if (mode == kFileReadMode) {
_handle = fopenNoCase(filename, directory, "rb");
if (_handle == NULL) {
debug(2, "File %s not found", filename);
return false;
}
}
else if (mode == kFileWriteMode) {
_handle = fopenNoCase(filename, directory, "wb");
if (_handle == NULL) {
debug(2, "File %s not opened", filename);
return false;
}
} else {
warning("Only read/write mode supported!");
2002-08-31 07:43:34 +00:00
return false;
}
_encbyte = encbyte;
int len = strlen(filename);
2003-05-01 12:36:36 +00:00
if (_name != 0)
delete [] _name;
_name = new char[len+1];
memcpy(_name, filename, len+1);
2002-08-31 07:43:34 +00:00
return true;
}
void File::close() {
if (_handle)
fclose(_handle);
2002-08-31 09:55:58 +00:00
_handle = NULL;
}
bool File::isOpen() {
return _handle != NULL;
2002-08-31 07:43:34 +00:00
}
bool File::ioFailed() {
return _ioFailed != 0;
2002-08-31 07:43:34 +00:00
}
void File::clearIOFailed() {
_ioFailed = false;
2002-08-31 07:43:34 +00:00
}
bool File::eof() {
if (_handle == NULL) {
error("File is not open!");
return false;
}
return feof(_handle) != 0;
}
uint32 File::pos() {
if (_handle == NULL) {
error("File is not open!");
return 0;
}
return ftell(_handle);
}
uint32 File::size() {
if (_handle == NULL) {
error("File is not open!");
return 0;
}
uint32 oldPos = ftell(_handle);
fseek(_handle, 0, SEEK_END);
uint32 length = ftell(_handle);
fseek(_handle, oldPos, SEEK_SET);
return length;
}
void File::seek(int32 offs, int whence) {
2002-08-31 07:43:34 +00:00
if (_handle == NULL) {
error("File is not open!");
return;
}
if (fseek(_handle, offs, whence) != 0)
clearerr(_handle);
}
2002-10-22 11:34:21 +00:00
uint32 File::read(void *ptr, uint32 len) {
2002-08-31 07:43:34 +00:00
byte *ptr2 = (byte *)ptr;
if (_handle == NULL) {
error("File is not open!");
2002-09-02 20:15:14 +00:00
return 0;
2002-08-31 07:43:34 +00:00
}
2002-10-22 11:34:21 +00:00
if (len == 0)
2002-09-02 20:15:14 +00:00
return 0;
2002-08-31 07:43:34 +00:00
2002-10-22 11:34:21 +00:00
if ((uint32)fread(ptr2, 1, len, _handle) != len) {
2002-08-31 07:43:34 +00:00
clearerr(_handle);
_ioFailed = true;
2002-08-31 07:43:34 +00:00
}
if (_encbyte != 0) {
2002-10-22 11:34:21 +00:00
uint32 t_size = len;
do {
*ptr2++ ^= _encbyte;
} while (--t_size);
}
2002-10-22 11:34:21 +00:00
return len;
2002-08-31 07:43:34 +00:00
}
2002-08-31 09:55:58 +00:00
byte File::readByte() {
2002-08-31 07:43:34 +00:00
byte b;
if (fread(&b, 1, 1, _handle) != 1) {
clearerr(_handle);
_ioFailed = true;
2002-08-31 07:43:34 +00:00
}
return b ^ _encbyte;
}
uint16 File::readUint16LE() {
2002-08-31 09:55:58 +00:00
uint16 a = readByte();
uint16 b = readByte();
2002-08-31 07:43:34 +00:00
return a | (b << 8);
}
uint32 File::readUint32LE() {
uint32 a = readUint16LE();
uint32 b = readUint16LE();
2002-08-31 07:43:34 +00:00
return (b << 16) | a;
}
uint16 File::readUint16BE() {
2002-08-31 09:55:58 +00:00
uint16 b = readByte();
uint16 a = readByte();
2002-08-31 07:43:34 +00:00
return a | (b << 8);
}
uint32 File::readUint32BE() {
uint32 b = readUint16BE();
uint32 a = readUint16BE();
2002-08-31 07:43:34 +00:00
return (b << 16) | a;
}
2002-10-22 11:35:45 +00:00
uint32 File::write(void *ptr, uint32 len) {
byte *ptr2 = (byte *)ptr;
if (_handle == NULL) {
error("File is not open!");
return 0;
}
2002-10-22 11:35:45 +00:00
if (len == 0)
return 0;
if (_encbyte != 0) {
2003-05-21 17:29:51 +00:00
// Maybe FIXME: while it's efficient to do the encoding here,
// it not really nice for a write function to modify its input.
// Maybe we should work on a copy here...
2002-10-22 11:35:45 +00:00
uint32 t_size = len;
do {
*ptr2++ ^= _encbyte;
} while (--t_size);
}
2002-10-22 11:35:45 +00:00
if ((uint32)fwrite(ptr2, 1, len, _handle) != len) {
clearerr(_handle);
_ioFailed = true;
}
2002-10-22 11:35:45 +00:00
return len;
}
void File::writeByte(byte value) {
value ^= _encbyte;
if (fwrite(&value, 1, 1, _handle) != 1) {
clearerr(_handle);
_ioFailed = true;
}
}
void File::writeUint16LE(uint16 value) {
writeByte((byte)(value & 0xff));
writeByte((byte)(value >> 8));
}
void File::writeUint32LE(uint32 value) {
writeUint16LE((uint16)(value & 0xffff));
writeUint16LE((uint16)(value >> 16));
}
void File::writeUint16BE(uint16 value) {
writeByte((byte)(value >> 8));
writeByte((byte)(value & 0xff));
}
void File::writeUint32BE(uint32 value) {
writeUint16BE((uint16)(value >> 16));
writeUint16BE((uint16)(value & 0xffff));
}