mirror of
https://github.com/libretro/scummvm.git
synced 2024-12-14 05:38:56 +00:00
6b1c43f90b
From upstream e3eb59bd4d72148a762ac93d0df36a56e101f257
209 lines
6.3 KiB
C++
209 lines
6.3 KiB
C++
/* ScummVM - Graphic Adventure Engine
|
|
*
|
|
* ScummVM is the legal property of its developers, whose names
|
|
* are too numerous to list here. Please refer to the COPYRIGHT
|
|
* file distributed with this source distribution.
|
|
*
|
|
* 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 3 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, see <http://www.gnu.org/licenses/>.
|
|
*
|
|
*/
|
|
|
|
#include "ags/engine/ac/global_file.h"
|
|
#include "ags/shared/ac/common.h"
|
|
#include "ags/engine/ac/file.h"
|
|
#include "ags/engine/ac/path_helper.h"
|
|
#include "ags/engine/ac/runtime_defines.h"
|
|
#include "ags/engine/ac/string.h"
|
|
#include "ags/engine/debugging/debug_log.h"
|
|
#include "ags/shared/core/asset_manager.h"
|
|
#include "ags/shared/util/directory.h"
|
|
#include "ags/shared/util/path.h"
|
|
#include "ags/shared/util/stream.h"
|
|
#include "ags/globals.h"
|
|
|
|
namespace AGS3 {
|
|
|
|
using namespace AGS::Shared;
|
|
|
|
int32_t FileOpenCMode(const char *fnmm, const char *cmode) {
|
|
Shared::FileOpenMode open_mode;
|
|
Shared::FileWorkMode work_mode;
|
|
// NOTE: here we ignore the text-mode flag. AGS 2.62 did not let
|
|
// game devs to open files in text mode. The file reading and
|
|
// writing logic in AGS makes extra control characters added for
|
|
// security reasons, and FileWriteRawLine adds CR/LF to the end
|
|
// of string on its own.
|
|
if (!Shared::File::GetFileModesFromCMode(cmode, open_mode, work_mode)) {
|
|
return 0;
|
|
}
|
|
return FileOpen(fnmm, open_mode, work_mode);
|
|
}
|
|
|
|
// Find a free file slot to use
|
|
int32_t FindFreeFileSlot() {
|
|
int useindx = 0;
|
|
for (; useindx < num_open_script_files; useindx++) {
|
|
if (valid_handles[useindx].stream == nullptr)
|
|
break;
|
|
}
|
|
|
|
if (useindx >= num_open_script_files &&
|
|
num_open_script_files >= MAX_OPEN_SCRIPT_FILES) {
|
|
quit("!FileOpen: tried to open more than 10 files simultaneously - close some first");
|
|
return -1;
|
|
}
|
|
return useindx;
|
|
}
|
|
|
|
int32_t FileOpen(const char *fnmm, Shared::FileOpenMode open_mode, Shared::FileWorkMode work_mode) {
|
|
debug_script_print(kDbgMsg_Debug, "FileOpen: request: %s", fnmm);
|
|
|
|
int32_t useindx = FindFreeFileSlot();
|
|
if (useindx < 0) {
|
|
debug_script_warn("FileOpen: no free handles: %s", fnmm);
|
|
return 0;
|
|
}
|
|
|
|
ResolvedPath rp;
|
|
if (open_mode == kFile_Open && work_mode == kFile_Read) {
|
|
if (!ResolveScriptPath(fnmm, true, rp))
|
|
return 0;
|
|
} else {
|
|
if (!ResolveWritePathAndCreateDirs(fnmm, rp))
|
|
return 0;
|
|
}
|
|
|
|
Stream *s;
|
|
String resolved_path = rp.FullPath;
|
|
if (rp.AssetMgr) {
|
|
s = _GP(AssetMgr)->OpenAsset(rp.FullPath, "*");
|
|
} else {
|
|
s = File::OpenFile(rp.FullPath, open_mode, work_mode);
|
|
if (!s && !rp.AltPath.IsEmpty() && rp.AltPath.Compare(rp.FullPath) != 0) {
|
|
s = File::OpenFile(rp.AltPath, open_mode, work_mode);
|
|
resolved_path = rp.AltPath;
|
|
}
|
|
}
|
|
|
|
valid_handles[useindx].stream = s;
|
|
if (valid_handles[useindx].stream == nullptr) {
|
|
debug_script_warn("FileOpen: FAILED: %s", resolved_path.GetCStr());
|
|
return 0;
|
|
}
|
|
valid_handles[useindx].handle = useindx + 1; // make handle indexes 1-based
|
|
debug_script_print(kDbgMsg_Info, "FileOpen: success: %s", resolved_path.GetCStr());
|
|
|
|
if (useindx >= num_open_script_files)
|
|
num_open_script_files++;
|
|
return valid_handles[useindx].handle;
|
|
}
|
|
|
|
void FileClose(int32_t handle) {
|
|
ScriptFileHandle *sc_handle = check_valid_file_handle_int32(handle, "FileClose");
|
|
delete sc_handle->stream;
|
|
sc_handle->stream = nullptr;
|
|
sc_handle->handle = 0;
|
|
}
|
|
void FileWrite(int32_t handle, const char *towrite) {
|
|
Stream *out = get_valid_file_stream_from_handle(handle, "FileWrite");
|
|
size_t len = strlen(towrite);
|
|
out->WriteInt32(len + 1); // write with null-terminator
|
|
out->Write(towrite, len + 1);
|
|
}
|
|
void FileWriteRawLine(int32_t handle, const char *towrite) {
|
|
Stream *out = get_valid_file_stream_from_handle(handle, "FileWriteRawLine");
|
|
out->Write(towrite, strlen(towrite));
|
|
out->WriteInt8('\r');
|
|
out->WriteInt8('\n');
|
|
}
|
|
void FileRead(int32_t handle, char *toread) {
|
|
VALIDATE_STRING(toread);
|
|
Stream *in = get_valid_file_stream_from_handle(handle, "FileRead");
|
|
if (in->EOS()) {
|
|
toread[0] = 0;
|
|
return;
|
|
}
|
|
|
|
size_t lle = (uint32_t)in->ReadInt32();
|
|
// This tests for the legacy string (limited by 200 chars)
|
|
if ((lle >= 200) | (lle < 1)) {
|
|
debug_script_warn("FileRead: file was not written by FileWrite");
|
|
return;
|
|
}
|
|
in->Read(toread, lle);
|
|
}
|
|
|
|
int FileIsEOF(int32_t handle) {
|
|
Stream *stream = get_valid_file_stream_from_handle(handle, "FileIsEOF");
|
|
if (stream->EOS())
|
|
return 1;
|
|
|
|
// TODO: stream errors
|
|
if (stream->HasErrors())
|
|
return 1;
|
|
|
|
if (stream->GetPosition() >= stream->GetLength())
|
|
return 1;
|
|
return 0;
|
|
}
|
|
int FileIsError(int32_t handle) {
|
|
Stream *stream = get_valid_file_stream_from_handle(handle, "FileIsError");
|
|
|
|
// TODO: stream errors
|
|
if (stream->HasErrors())
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
void FileWriteInt(int32_t handle, int into) {
|
|
Stream *out = get_valid_file_stream_from_handle(handle, "FileWriteInt");
|
|
out->WriteInt8('I');
|
|
out->WriteInt32(into);
|
|
}
|
|
int FileReadInt(int32_t handle) {
|
|
Stream *in = get_valid_file_stream_from_handle(handle, "FileReadInt");
|
|
if (in->EOS())
|
|
return -1;
|
|
if (in->ReadInt8() != 'I') {
|
|
debug_script_warn("FileReadInt: File read back in wrong order");
|
|
return -1;
|
|
}
|
|
|
|
return in->ReadInt32();
|
|
}
|
|
|
|
int8 FileReadRawChar(int32_t handle) {
|
|
Stream *in = get_valid_file_stream_from_handle(handle, "FileReadRawChar");
|
|
return static_cast<uint8_t>(in->ReadByte());
|
|
// NOTE: this function has incorrect return value for historical reasons;
|
|
// we keep this strictly for backwards compatibility with old scripts
|
|
}
|
|
|
|
int FileReadRawInt(int32_t handle) {
|
|
Stream *in = get_valid_file_stream_from_handle(handle, "FileReadRawInt");
|
|
if (in->EOS())
|
|
return -1;
|
|
return in->ReadInt32();
|
|
}
|
|
|
|
void FileWriteRawChar(int32_t handle, int chartoWrite) {
|
|
Stream *out = get_valid_file_stream_from_handle(handle, "FileWriteRawChar");
|
|
if ((chartoWrite < 0) || (chartoWrite > 255))
|
|
debug_script_warn("!FileWriteRawChar: can only write values 0-255");
|
|
|
|
out->WriteByte(static_cast<uint8_t>(chartoWrite));
|
|
}
|
|
|
|
} // namespace AGS3
|