isledecomp/isle
1
0
Fork 0
mirror of https://github.com/isledecomp/isle.git synced 2026-01-20 14:51:15 +00:00
Code Issues Actions 4 Packages Projects Releases Wiki Activity

Use more Mx* types and param style convention

Browse Source
This commit is contained in:
disinvite 2023-07-04 11:11:57 -04:00
parent 66a6b3bab2
commit f86a653817
2 changed files with 74 additions and 74 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

132
LEGO1/mxioinfo.cpp
View File

@ -18,7 +18,7 @@ MXIOINFO::~MXIOINFO()
}
// OFFSET: LEGO1 0x100cc830
MxU16 MXIOINFO::Open(const char *filename, DWORD fdwOpen)
MxU16 MXIOINFO::Open(const char *p_filename, MxULong p_flags)
{
OFSTRUCT _unused;
MxU16 result = 0;
@ -26,12 +26,12 @@ MxU16 MXIOINFO::Open(const char *filename, DWORD fdwOpen)
m_lBufOffset = 0;
m_lDiskOffset = 0;
// Cast of fdWOpen to u16 forces the `movzx` instruction
m_hmmio = OpenFile(filename, &_unused, (MxU16)fdwOpen);
// Cast of p_flags to u16 forces the `movzx` instruction
m_hmmio = OpenFile(p_filename, &_unused, (MxU16)p_flags);
if (m_hmmio != HFILE_ERROR) {
m_dwFlags = fdwOpen;
if (fdwOpen & MMIO_ALLOCBUF) {
m_dwFlags = p_flags;
if (p_flags & MMIO_ALLOCBUF) {
// Default buffer length of 8k if none specified
int len = m_cchBuffer ? m_cchBuffer : 8192;
@ -59,7 +59,7 @@ MxU16 MXIOINFO::Open(const char *filename, DWORD fdwOpen)
}
// OFFSET: LEGO1 0x100cc8e0
MxU16 MXIOINFO::Close(MxLong arg)
MxU16 MXIOINFO::Close(MxLong p_unused)
{
MxU16 result = 0;
@ -81,35 +81,35 @@ MxU16 MXIOINFO::Close(MxLong arg)
}
// OFFSET: LEGO1 0x100cc930
MxLong MXIOINFO::Read(void *pch, LONG cch)
MxLong MXIOINFO::Read(void *p_buf, MxLong p_len)
{
MxLong bytes_read = 0;
if (m_pchBuffer) {
int bytes_left = m_pchEndRead - m_pchNext;
while (cch > 0) {
while (p_len > 0) {
if (bytes_left > 0) {
if (cch < bytes_left)
bytes_left = cch;
if (p_len < bytes_left)
bytes_left = p_len;
memcpy(pch, m_pchNext, bytes_left);
cch -= bytes_left;
memcpy(p_buf, m_pchNext, bytes_left);
p_len -= bytes_left;
m_pchNext += bytes_left;
bytes_read += bytes_left;
}
if (cch <= 0 || Advance(0))
if (p_len <= 0 || Advance(0))
break;
bytes_left = m_pchEndRead - m_pchNext;
if (bytes_left <= 0)
break;
}
} else if (m_hmmio && cch > 0) {
bytes_read = _hread(m_hmmio, pch, cch);
} else if (m_hmmio && p_len > 0) {
bytes_read = _hread(m_hmmio, p_buf, p_len);
if (bytes_read == -1) {
bytes_read = 0;
@ -123,50 +123,50 @@ MxLong MXIOINFO::Read(void *pch, LONG cch)
}
// OFFSET: LEGO1 0x100cca00
MxLong MXIOINFO::Seek(LONG lOffset, int iOrigin)
MxLong MXIOINFO::Seek(MxLong p_offset, int p_origin)
{
MxLong result = -1;
// If buffered I/O
if (m_pchBuffer) {
if (iOrigin == SEEK_CUR) {
if (!lOffset) {
if (p_origin == SEEK_CUR) {
if (!p_offset) {
// don't seek at all and just return where we are.
return m_lBufOffset + (m_pchNext - m_pchBuffer);
} else {
// With SEEK_CUR, lOffset is a relative offset.
// With SEEK_CUR, p_offset is a relative offset.
// Get the absolute position instead and use SEEK_SET.
lOffset += m_lBufOffset + (m_pchNext - m_pchBuffer);
iOrigin = SEEK_SET;
p_offset += m_lBufOffset + (m_pchNext - m_pchBuffer);
p_origin = SEEK_SET;
}
} else if (iOrigin == SEEK_END) {
} else if (p_origin == SEEK_END) {
// not possible with buffered I/O
return -1;
}
// else iOrigin == SEEK_SET.
// else p_origin == SEEK_SET.
// is lOffset between the start and end of the buffer?
// is p_offset between the start and end of the buffer?
// i.e. can we do the seek without reading more from disk?
if (lOffset >= m_lBufOffset && lOffset < m_lBufOffset + m_cchBuffer) {
m_pchNext = m_pchBuffer + (lOffset - m_lBufOffset);
result = lOffset;
if (p_offset >= m_lBufOffset && p_offset < m_lBufOffset + m_cchBuffer) {
m_pchNext = m_pchBuffer + (p_offset - m_lBufOffset);
result = p_offset;
} else {
// we have to read another chunk from disk.
if (m_hmmio && !Flush(0)) {
m_lDiskOffset = _llseek(m_hmmio, lOffset, iOrigin);
m_lDiskOffset = _llseek(m_hmmio, p_offset, p_origin);
if (m_lDiskOffset == -1) {
m_lDiskOffset = _llseek(m_hmmio, 0, SEEK_CUR);
} else {
// align offset to buffer size
int new_offset = lOffset - (lOffset % m_cchBuffer);
int new_offset = p_offset - (p_offset % m_cchBuffer);
m_lBufOffset = new_offset;
// do we need to seek again?
// (i.e. are we already aligned to buffer size?)
if (lOffset != new_offset) {
if (p_offset != new_offset) {
m_lDiskOffset = _llseek(m_hmmio, new_offset, SEEK_SET);
if (m_lDiskOffset == -1) {
@ -179,9 +179,9 @@ MxLong MXIOINFO::Seek(LONG lOffset, int iOrigin)
if ((m_dwFlags & MMIO_RWMODE) &&
((m_dwFlags & MMIO_RWMODE) != MMIO_READWRITE)) {
m_pchNext = m_pchBuffer - m_lBufOffset + lOffset;
m_pchNext = m_pchBuffer - m_lBufOffset + p_offset;
result = lOffset;
result = p_offset;
} else {
// We can read from the file. Fill the buffer.
int bytes_read = _hread(m_hmmio, m_pchBuffer, m_cchBuffer);
@ -190,11 +190,11 @@ MxLong MXIOINFO::Seek(LONG lOffset, int iOrigin)
m_lDiskOffset = _llseek(m_hmmio, 0, SEEK_CUR);
} else {
m_lDiskOffset += bytes_read;
m_pchNext = lOffset - m_lBufOffset + m_pchBuffer;
m_pchNext = p_offset - m_lBufOffset + m_pchBuffer;
m_pchEndRead = m_pchBuffer + bytes_read;
if (m_pchNext < m_pchEndRead) {
result = lOffset;
result = p_offset;
}
}
}
@ -206,10 +206,10 @@ MxLong MXIOINFO::Seek(LONG lOffset, int iOrigin)
// No buffer so just seek the file directly (if we have a valid handle)
if (m_hmmio) {
// i.e. if we just want to get the current file position
if (iOrigin == SEEK_CUR && lOffset == 0) {
if (p_origin == SEEK_CUR && p_offset == 0) {
return m_lDiskOffset;
} else {
m_lDiskOffset = _llseek(m_hmmio, lOffset, iOrigin);
m_lDiskOffset = _llseek(m_hmmio, p_offset, p_origin);
result = m_lDiskOffset;
@ -224,7 +224,7 @@ MxLong MXIOINFO::Seek(LONG lOffset, int iOrigin)
}
// OFFSET: LEGO1 0x100ccbc0
MxU16 MXIOINFO::SetBuffer(LPSTR pchBuffer, LONG cchBuffer, LONG unk)
MxU16 MXIOINFO::SetBuffer(char *p_buf, MxLong p_len, MxLong p_unused)
{
MxU16 result = Flush(0);
@ -233,8 +233,8 @@ MxU16 MXIOINFO::SetBuffer(LPSTR pchBuffer, LONG cchBuffer, LONG unk)
delete[] m_pchBuffer;
}
m_pchBuffer = pchBuffer;
m_cchBuffer = cchBuffer;
m_pchBuffer = p_buf;
m_cchBuffer = p_len;
m_pchEndWrite = m_pchBuffer + m_cchBuffer;
m_pchEndRead = m_pchBuffer;
@ -242,7 +242,7 @@ MxU16 MXIOINFO::SetBuffer(LPSTR pchBuffer, LONG cchBuffer, LONG unk)
}
// OFFSET: LEGO1 0x100ccc10
MxU16 MXIOINFO::Flush(UINT fuFlush)
MxU16 MXIOINFO::Flush(MxU16 p_unused)
{
MxU16 result = 0;
@ -253,7 +253,7 @@ MxU16 MXIOINFO::Flush(UINT fuFlush)
// if we have a file open for writing
if (m_hmmio && (m_dwFlags & MMIO_RWMODE)) {
// (pulling this value out into a variable forces it into EBX)
LONG cchBuffer = m_cchBuffer;
MxLong cchBuffer = m_cchBuffer;
if (cchBuffer > 0) {
if (m_lBufOffset != m_lDiskOffset) {
m_lDiskOffset = _llseek(m_hmmio, m_lBufOffset, SEEK_SET);
@ -264,7 +264,7 @@ MxU16 MXIOINFO::Flush(UINT fuFlush)
result = MMIOERR_CANNOTSEEK;
m_lDiskOffset = _llseek(m_hmmio, 0, SEEK_CUR);
} else {
long bytes_written = _hwrite(m_hmmio, m_pchBuffer, cchBuffer);
MxLong bytes_written = _hwrite(m_hmmio, m_pchBuffer, cchBuffer);
if (bytes_written != -1 && bytes_written == cchBuffer) {
m_lDiskOffset += bytes_written;
@ -288,20 +288,20 @@ MxU16 MXIOINFO::Flush(UINT fuFlush)
}
// OFFSET: LEGO1 0x100ccd00
MxU16 MXIOINFO::Advance(UINT fuAdvance)
MxU16 MXIOINFO::Advance(MxU16 p_option)
{
MxU16 result = 0;
DWORD rwmode = m_dwFlags & MMIO_RWMODE;
MxULong rwmode = m_dwFlags & MMIO_RWMODE;
if (m_pchBuffer) {
long cch = m_cchBuffer;
MxLong cch = m_cchBuffer;
// If we can and should write to the file,
// if we are being asked to write to the file,
// and if there is a buffer *to* write:
if ((rwmode == MMIO_WRITE || rwmode == MMIO_READWRITE) &&
(m_dwFlags & MMIO_DIRTY) &&
((fuAdvance & MMIO_WRITE) || (rwmode == MMIO_READWRITE)) &&
((p_option & MMIO_WRITE) || (rwmode == MMIO_READWRITE)) &&
cch > 0) {
if (m_lBufOffset != m_lDiskOffset) {
@ -311,7 +311,7 @@ MxU16 MXIOINFO::Advance(UINT fuAdvance)
if (m_lBufOffset != m_lDiskOffset) {
result = MMIOERR_CANNOTSEEK;
} else {
long bytes_written = _hwrite(m_hmmio, m_pchBuffer, cch);
MxLong bytes_written = _hwrite(m_hmmio, m_pchBuffer, cch);
if (bytes_written != -1 && bytes_written == cch) {
m_lDiskOffset += bytes_written;
@ -358,39 +358,39 @@ MxU16 MXIOINFO::Advance(UINT fuAdvance)
}
// OFFSET: LEGO1 0x100cce60
MxU16 MXIOINFO::Descend(MMCKINFO *pmmcki, const MMCKINFO *pmmckiParent, unsigned short fuDescend)
MxU16 MXIOINFO::Descend(MMCKINFO *p_chunkInfo, const MMCKINFO *p_parentInfo, MxU16 p_descend)
{
unsigned short result = 0;
MxU16 result = 0;
if (!pmmcki)
if (!p_chunkInfo)
return MMIOERR_BASE; // ?
if (!fuDescend) {
pmmcki->dwFlags = 0;
if (Read(pmmcki, 8) != 8) {
if (!p_descend) {
p_chunkInfo->dwFlags = 0;
if (Read(p_chunkInfo, 8) != 8) {
result = MMIOERR_CANNOTREAD;
} else {
if (m_pchBuffer) {
pmmcki->dwDataOffset = m_pchNext - m_pchBuffer + m_lBufOffset;
p_chunkInfo->dwDataOffset = m_pchNext - m_pchBuffer + m_lBufOffset;
} else {
pmmcki->dwDataOffset = m_lDiskOffset;
p_chunkInfo->dwDataOffset = m_lDiskOffset;
}
if (pmmcki->ckid == FOURCC_RIFF || pmmcki->ckid == FOURCC_LIST) {
if (Read(&pmmcki->fccType, 4) != 4) {
if (p_chunkInfo->ckid == FOURCC_RIFF || p_chunkInfo->ckid == FOURCC_LIST) {
if (Read(&p_chunkInfo->fccType, 4) != 4) {
result = MMIOERR_CANNOTREAD;
}
}
}
} else {
DWORD ofs = MAXLONG;
MxLong ofs = MAXLONG;
if (pmmckiParent)
ofs = pmmckiParent->cksize + pmmckiParent->dwDataOffset;
if (p_parentInfo)
ofs = p_parentInfo->cksize + p_parentInfo->dwDataOffset;
BOOL running = TRUE;
MMCKINFO tmp;
BOOL read_ok = FALSE;
MMCKINFO tmp;
tmp.dwFlags = 0;
// This loop is... something
@ -411,17 +411,17 @@ MxU16 MXIOINFO::Descend(MMCKINFO *pmmcki, const MMCKINFO *pmmckiParent, unsigned
result = MMIOERR_CHUNKNOTFOUND;
running = FALSE;
} else {
if ((fuDescend == MMIO_FINDLIST && tmp.ckid == FOURCC_LIST) ||
(fuDescend == MMIO_FINDRIFF && tmp.ckid == FOURCC_RIFF)) {
if ((p_descend == MMIO_FINDLIST && tmp.ckid == FOURCC_LIST) ||
(p_descend == MMIO_FINDRIFF && tmp.ckid == FOURCC_RIFF)) {
if (Read(&tmp.fccType, 4) != 4) {
result = MMIOERR_CANNOTREAD;
} else {
if (pmmcki->fccType != tmp.fccType)
if (p_chunkInfo->fccType != tmp.fccType)
continue;
}
running = FALSE;
} else {
if (pmmcki->ckid != tmp.ckid) {
if (p_chunkInfo->ckid != tmp.ckid) {
if (Seek((tmp.cksize&1)+tmp.cksize, SEEK_CUR) != -1) {
continue;
} else {
@ -436,7 +436,7 @@ MxU16 MXIOINFO::Descend(MMCKINFO *pmmcki, const MMCKINFO *pmmckiParent, unsigned
} while (running);
if (!result)
memcpy(pmmcki, &tmp, sizeof(MMCKINFO));
memcpy(p_chunkInfo, &tmp, sizeof(MMCKINFO));
}

16
LEGO1/mxioinfo.h
View File

@ -12,14 +12,14 @@ class MXIOINFO
MXIOINFO();
__declspec(dllexport) ~MXIOINFO();
MxU16 Open(const char *filename, DWORD fdwOpen);
MxU16 Close(MxLong arg);
MxLong Read(void *pch, LONG cch);
MxLong Seek(LONG lOffset, int iOrigin);
MxU16 SetBuffer(LPSTR pchBuffer, LONG cchBuffer, LONG unk);
MxU16 Flush(UINT);
MxU16 Advance(UINT);
MxU16 Descend(MMCKINFO *pmmcki, const MMCKINFO *pmmckiParent, MxU16 fuDescend);
MxU16 Open(const char *, MxULong);
MxU16 Close(MxLong);
MxLong Read(void *, MxLong);
MxLong Seek(MxLong, int);
MxU16 SetBuffer(char *, MxLong, MxLong);
MxU16 Flush(MxU16);
MxU16 Advance(MxU16);
MxU16 Descend(MMCKINFO *, const MMCKINFO *, MxU16);
// The following is the MMIOINFO struct but with h_mmio set to type HFILE.