2002-08-31 07:43:34 +00:00
|
|
|
/* ScummVM - Scumm Interpreter
|
2003-03-06 21:46:56 +00:00
|
|
|
* 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"
|
2002-09-08 01:08:12 +00:00
|
|
|
#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) {
|
2002-09-13 18:02:34 +00:00
|
|
|
FILE *file;
|
2002-09-15 19:28:34 +00:00
|
|
|
char buf[256];
|
|
|
|
char *ptr;
|
2002-09-13 18:02:34 +00:00
|
|
|
|
2002-09-15 19:28:34 +00:00
|
|
|
strcpy(buf, directory);
|
|
|
|
if (directory[0] != 0) {
|
2002-09-17 21:45:13 +00:00
|
|
|
#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
|
2002-09-15 19:28:34 +00:00
|
|
|
}
|
|
|
|
strcat(buf, filename);
|
|
|
|
|
|
|
|
file = fopen(buf, mode);
|
2002-09-13 18:02:34 +00:00
|
|
|
if (file)
|
|
|
|
return file;
|
|
|
|
|
2002-10-22 23:36:54 +00:00
|
|
|
const char *dirs[] = {
|
2002-10-22 20:40:51 +00:00
|
|
|
"",
|
2002-10-22 23:36:54 +00:00
|
|
|
"video/",
|
|
|
|
"VIDEO/",
|
|
|
|
"data/",
|
|
|
|
"DATA/",
|
|
|
|
"resource/",
|
2003-01-12 01:06:28 +00:00
|
|
|
"RESOURCE/",
|
|
|
|
"voices/",
|
|
|
|
"VOICES/"
|
2002-10-22 20:40:51 +00:00
|
|
|
};
|
2002-09-15 19:28:34 +00:00
|
|
|
|
2003-01-12 01:06:28 +00:00
|
|
|
for (uint8 l = 0; l < 9; l++) {
|
2002-09-15 19:28:34 +00:00
|
|
|
strcpy(buf, directory);
|
|
|
|
if (directory[0] != 0) {
|
2002-09-17 21:45:13 +00:00
|
|
|
#ifdef __MORPHOS__
|
2003-03-06 16:27:06 +00:00
|
|
|
if (buf[strlen(buf) - 1] != ':' && buf[strlen(buf) - 1] != '/')
|
2002-09-17 21:45:13 +00:00
|
|
|
#endif
|
2003-04-30 12:43:56 +00:00
|
|
|
#ifndef __PALM_OS__
|
|
|
|
strcat(buf, "/"); // PALMOS
|
|
|
|
#endif
|
2002-09-13 18:02:34 +00:00
|
|
|
}
|
2002-10-22 23:36:54 +00:00
|
|
|
strcat(buf, dirs[l]);
|
2002-09-15 19:28:34 +00:00
|
|
|
int8 len = strlen(buf);
|
|
|
|
strcat(buf, filename);
|
|
|
|
|
|
|
|
ptr = buf + len;
|
|
|
|
do
|
2003-05-19 19:19:32 +00:00
|
|
|
*ptr = toupper(*ptr);
|
|
|
|
while (*ptr++);
|
2002-09-15 19:28:34 +00:00
|
|
|
file = fopen(buf, mode);
|
|
|
|
if (file)
|
|
|
|
return file;
|
|
|
|
|
|
|
|
ptr = buf + len;
|
|
|
|
do
|
2003-05-19 19:19:32 +00:00
|
|
|
*ptr = tolower(*ptr);
|
|
|
|
while (*ptr++);
|
2002-09-15 19:28:34 +00:00
|
|
|
file = fopen(buf, mode);
|
|
|
|
if (file)
|
|
|
|
return file;
|
2002-09-13 18:02:34 +00:00
|
|
|
}
|
|
|
|
|
2002-09-15 19:28:34 +00:00
|
|
|
return NULL;
|
2002-09-13 18:02:34 +00:00
|
|
|
}
|
|
|
|
|
2002-08-31 07:43:34 +00:00
|
|
|
File::File() {
|
|
|
|
_handle = NULL;
|
2002-09-02 22:06:26 +00:00
|
|
|
_ioFailed = false;
|
2002-08-31 07:43:34 +00:00
|
|
|
_encbyte = 0;
|
2002-12-24 02:02:53 +00:00
|
|
|
_name = 0;
|
2002-08-31 07:43:34 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
File::~File() {
|
2002-12-24 02:02:53 +00:00
|
|
|
delete [] _name;
|
2002-08-31 07:43:34 +00:00
|
|
|
close();
|
|
|
|
}
|
|
|
|
|
2002-09-15 19:28:34 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2002-11-02 10:51:32 +00:00
|
|
|
if (filename == NULL || *filename == 0)
|
|
|
|
return false;
|
|
|
|
|
2002-09-02 22:06:26 +00:00
|
|
|
clearIOFailed();
|
2002-09-02 20:53:12 +00:00
|
|
|
|
2002-09-13 18:02:34 +00:00
|
|
|
if (mode == kFileReadMode) {
|
2002-09-15 19:28:34 +00:00
|
|
|
_handle = fopenNoCase(filename, directory, "rb");
|
2002-08-31 13:29:10 +00:00
|
|
|
if (_handle == NULL) {
|
|
|
|
debug(2, "File %s not found", filename);
|
|
|
|
return false;
|
|
|
|
}
|
2002-09-02 22:06:26 +00:00
|
|
|
}
|
2002-09-13 18:02:34 +00:00
|
|
|
else if (mode == kFileWriteMode) {
|
2002-09-15 19:28:34 +00:00
|
|
|
_handle = fopenNoCase(filename, directory, "wb");
|
2002-09-02 22:06:26 +00:00
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
2002-09-10 07:34:27 +00:00
|
|
|
_encbyte = encbyte;
|
2003-03-06 16:27:06 +00:00
|
|
|
|
2002-12-24 02:02:53 +00:00
|
|
|
int len = strlen(filename);
|
2003-05-01 12:36:36 +00:00
|
|
|
if (_name != 0)
|
|
|
|
delete [] _name;
|
2002-12-24 02:02:53 +00:00
|
|
|
_name = new char[len+1];
|
|
|
|
memcpy(_name, filename, len+1);
|
2002-09-10 07:34:27 +00:00
|
|
|
|
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
|
|
|
}
|
|
|
|
|
2002-09-02 22:06:26 +00:00
|
|
|
bool File::ioFailed() {
|
|
|
|
return _ioFailed != 0;
|
2002-08-31 07:43:34 +00:00
|
|
|
}
|
|
|
|
|
2002-09-02 22:06:26 +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);
|
|
|
|
}
|
|
|
|
|
2002-09-13 18:02:34 +00:00
|
|
|
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);
|
2003-03-06 16:27:06 +00:00
|
|
|
|
2002-09-13 18:02:34 +00:00
|
|
|
return length;
|
|
|
|
}
|
|
|
|
|
2002-09-13 12:16:03 +00:00
|
|
|
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);
|
2002-09-02 22:06:26 +00:00
|
|
|
_ioFailed = true;
|
2002-08-31 07:43:34 +00:00
|
|
|
}
|
|
|
|
|
2002-09-02 07:53:43 +00:00
|
|
|
if (_encbyte != 0) {
|
2002-10-22 11:34:21 +00:00
|
|
|
uint32 t_size = len;
|
2002-09-02 07:53:43 +00:00
|
|
|
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);
|
2002-09-02 22:06:26 +00:00
|
|
|
_ioFailed = true;
|
2002-08-31 07:43:34 +00:00
|
|
|
}
|
|
|
|
return b ^ _encbyte;
|
|
|
|
}
|
|
|
|
|
2002-10-21 13:23:25 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2002-10-21 13:23:25 +00:00
|
|
|
uint32 File::readUint32LE() {
|
|
|
|
uint32 a = readUint16LE();
|
|
|
|
uint32 b = readUint16LE();
|
2002-08-31 07:43:34 +00:00
|
|
|
return (b << 16) | a;
|
|
|
|
}
|
|
|
|
|
2002-10-21 13:23:25 +00:00
|
|
|
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);
|
|
|
|
}
|
|
|
|
|
2002-10-21 13:23:25 +00:00
|
|
|
uint32 File::readUint32BE() {
|
|
|
|
uint32 b = readUint16BE();
|
|
|
|
uint32 a = readUint16BE();
|
2002-08-31 07:43:34 +00:00
|
|
|
return (b << 16) | a;
|
|
|
|
}
|
2002-09-02 22:06:26 +00:00
|
|
|
|
2002-10-22 11:35:45 +00:00
|
|
|
uint32 File::write(void *ptr, uint32 len) {
|
2002-09-02 22:06:26 +00:00
|
|
|
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)
|
2002-09-02 22:06:26 +00:00
|
|
|
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;
|
2002-09-02 22:06:26 +00:00
|
|
|
do {
|
|
|
|
*ptr2++ ^= _encbyte;
|
|
|
|
} while (--t_size);
|
|
|
|
}
|
|
|
|
|
2002-10-22 11:35:45 +00:00
|
|
|
if ((uint32)fwrite(ptr2, 1, len, _handle) != len) {
|
2002-09-02 22:06:26 +00:00
|
|
|
clearerr(_handle);
|
|
|
|
_ioFailed = true;
|
|
|
|
}
|
|
|
|
|
2002-10-22 11:35:45 +00:00
|
|
|
return len;
|
2002-09-02 22:06:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void File::writeByte(byte value) {
|
|
|
|
value ^= _encbyte;
|
|
|
|
|
|
|
|
if (fwrite(&value, 1, 1, _handle) != 1) {
|
|
|
|
clearerr(_handle);
|
|
|
|
_ioFailed = true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-10-21 13:23:25 +00:00
|
|
|
void File::writeUint16LE(uint16 value) {
|
2002-09-02 22:06:26 +00:00
|
|
|
writeByte((byte)(value & 0xff));
|
|
|
|
writeByte((byte)(value >> 8));
|
|
|
|
}
|
|
|
|
|
2002-10-21 13:23:25 +00:00
|
|
|
void File::writeUint32LE(uint32 value) {
|
|
|
|
writeUint16LE((uint16)(value & 0xffff));
|
|
|
|
writeUint16LE((uint16)(value >> 16));
|
2002-09-02 22:06:26 +00:00
|
|
|
}
|
|
|
|
|
2002-10-21 13:23:25 +00:00
|
|
|
void File::writeUint16BE(uint16 value) {
|
2002-09-02 22:06:26 +00:00
|
|
|
writeByte((byte)(value >> 8));
|
|
|
|
writeByte((byte)(value & 0xff));
|
|
|
|
}
|
|
|
|
|
2002-10-21 13:23:25 +00:00
|
|
|
void File::writeUint32BE(uint32 value) {
|
|
|
|
writeUint16BE((uint16)(value >> 16));
|
|
|
|
writeUint16BE((uint16)(value & 0xffff));
|
2002-09-02 22:06:26 +00:00
|
|
|
}
|