port 2D step 5a: EterPack/EterPackManager + EterBase file units against the real 40250 packs

- Mirror copies: EterPack (EterPack, EterPackManager, EterPackCursor, CSHybridCrypt policy, Inline.h)
  and EterBase logic units tea/lzo/Timer/Stl/Random, with PORT-tagged width fixes (LONG index
  fields, static_assert(sizeof(TEterPackIndex) == 192), tea_word = Win32 unsigned long).
- TEA pack keys are extracted from the reference EterPack.cpp at configure time into
  build/.../EterPackKeys.generated.h; nothing key-bearing is tracked.
- Platform EterBase: FileBase (stdio, case-insensitive fallback), MappedFile (mmap /
  MapViewOfFile), CRC32, Debug, Utils StringPath/StringLowers.
- Win32Crt: CreateDirectory/DeleteFile/_access/MAKEFOURCC; Win32MinMax.h min/max (force-included
  on MinGW, whose windows.h omits them in C++).
- tests/port_eterpack_test: registers pack/Index like PackInitialize and checks 119
  registrations / 103 packs + root / 54891 entries / 52609 paths / 2282 overrides with
  first-registered-wins, and that exactly the 4 short-layout SECURITY files fail to load.
- 2R count corrected (136 -> 119 registrations, 103 distinct packs + root).

Not runtime-reachable yet (asset_io pack backend is step 5b), so port-map statuses stay TODO.
port_gate: macos/android/ios/windows PASS.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

extension/src/platform/EterBase/CRC32.cpp

@@ -1,36 +1,146 @@
-// Platform skeleton for EterBase/CRC32.h (40250 EterBase/CRC32.cpp), generated by platform_stub.py.
-// Every MT_PLATFORM_STUB() body is unimplemented: replace it with the platform implementation.
+// Platform implementation of EterBase/CRC32.h (40250 EterBase/CRC32.cpp). GetCRC32/GetCaseCRC32 are the 40250
+// loops; CRCTable is the reflected IEEE 802.3 table (polynomial 0xEDB88320), which is what 40250 spells out
+// literally (checked entry for entry). The file variants read through a CFileBase-style FILE* handle.
 #include "EterBase/StdAfx.h"
 #include "EterBase/CRC32.h"
 
-#include "../PlatformStub.h"
+#include <cstdio>
+#include <vector>
 
-auto GetCRC32(const char *, size_t) -> DWORD
+namespace
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+struct CrcTable
+{
+	DWORD v[256];
+	CrcTable()
+	{
+		for (DWORD n = 0; n < 256; ++n)
+		{
+			DWORD c = n;
+			for (int k = 0; k < 8; ++k)
+				c = (c & 1) ? (0xEDB88320u ^ (c >> 1)) : (c >> 1);
+			v[n] = c;
+		}
+	}
+};
+const CrcTable s_crcTable;
 }
 
-auto GetCaseCRC32(const char *, size_t) -> DWORD
+#define CRCTable (s_crcTable.v)
+
+#define DO1(buf, i)     crc = CRCTable[(crc ^ buf[i]) & 0xff] ^ (crc >> 8)
+#define DO2(buf, i)     DO1(buf, i); DO1(buf, i + 1);
+#define DO4(buf, i)     DO2(buf, i); DO2(buf, i + 2);
+#define DO8(buf, i)     DO4(buf, i); DO4(buf, i + 4);
+#define DO16(buf, i)    DO8(buf, i); DO8(buf, i + 8);
+
+DWORD GetCRC32(const char * buf, size_t len)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+    DWORD crc = 0xffffffff;
+
+    if (len >= 16)
+    {
+        do
+        {
+            DO16(buf, 0);
+
+            buf += 16;
+            len -= 16;
+        } while (len >= 16);
+    }
+
+    if (len != 0)
+    {
+        do
+        {
+            DO1(buf, 0);
+            ++buf;
+            --len;
+        } while (len > 0);
+    }
+
+	crc ^= 0xffffffff;
+	return crc;
 }
 
-auto GetHFILECRC32(HANDLE) -> DWORD
+#ifndef UPPER
+#define UPPER(c)        (((c)>='a'  && (c) <= 'z') ? ((c)+('A'-'a')) : (c))
+#endif
+
+#define DO1CI(buf, i)   crc = CRCTable[(crc ^ UPPER(buf[i])) & 0xff] ^ (crc >> 8)
+#define DO2CI(buf, i)   DO1CI(buf, i); DO1CI(buf, i + 1);
+#define DO4CI(buf, i)   DO2CI(buf, i); DO2CI(buf, i + 2);
+#define DO8CI(buf, i)   DO4CI(buf, i); DO4CI(buf, i + 4);
+#define DO16CI(buf, i)  DO8CI(buf, i); DO8CI(buf, i + 8);
+
+DWORD GetCaseCRC32(const char * buf, size_t len)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+    DWORD crc = 0xffffffff;
+
+    if (16 <= len)
+    {
+        do
+        {
+            DO16CI(buf, 0);
+
+            buf += 16;
+            len -= 16;
+        } while (len >= 16);
+    }
+
+    if (0 != len)
+    {
+        do
+        {
+            DO1CI(buf, 0);
+
+            ++buf;
+            --len;
+        } while (len > 0);
+    }
+
+    crc ^= 0xffffffff;
+    return crc;
 }
 
-auto GetFileCRC32(const char *) -> DWORD
+DWORD GetHFILECRC32(HANDLE hFile)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+	// 40250 maps the whole file from offset 0 and CRCs it; the stream position is left where it was.
+	FILE* fp = static_cast<FILE*>(hFile);
+	const long pos = std::ftell(fp);
+	std::fseek(fp, 0, SEEK_END);
+	const long size = std::ftell(fp);
+	std::fseek(fp, 0, SEEK_SET);
+	std::vector<char> data(size > 0 ? size : 0);
+	const size_t got = data.empty() ? 0 : std::fread(data.data(), 1, data.size(), fp);
+	std::fseek(fp, pos, SEEK_SET);
+	if (got != data.size() || data.empty())
+		return 0;
+	return GetCRC32(data.data(), data.size());
 }
 
-auto GetFileSize(const char *) -> DWORD
+DWORD GetFileCRC32(const char* c_szFileName)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+	FILE* fp = std::fopen(c_szFileName, "rb");
+	if (!fp)
+		return 0;
+
+	DWORD dwRetCRC32=GetHFILECRC32(fp);
+
+	std::fclose(fp);
+
+	return dwRetCRC32;
+}
+
+DWORD GetFileSize(const char* c_szFileName)
+{
+	FILE* fp = std::fopen(c_szFileName, "rb");
+	if (!fp)
+		return 0;
+
+	std::fseek(fp, 0, SEEK_END);
+	const long size = std::ftell(fp);
+	std::fclose(fp);
+
+	return size < 0 ? 0 : static_cast<DWORD>(size);
 }

extension/src/platform/EterBase/Debug.cpp

@@ -1,9 +1,17 @@
 // Platform skeleton for EterBase/Debug.h (40250 EterBase/Debug.cpp), generated by platform_stub.py.
-// Every MT_PLATFORM_STUB() body is unimplemented: replace it with the platform implementation.
+// Every MT_PLATFORM_STUB() body is unimplemented: replace it with the platform implementation. Implemented
+// bodies follow the 40250 non-_DEBUG build (batch 2D: Trace*, TraceError to stderr).
 #include "EterBase/StdAfx.h"
 #include "EterBase/Debug.h"
 
 #include "../PlatformStub.h"
+#include "EterBase/Timer.h"
+
+#include <cstdarg>
+#include <cstdio>
+#include <ctime>
+
+const DWORD DEBUG_STRING_MAX_LEN = 1024;
 
 auto SetLogLevel(UINT) -> void
 {
@@ -30,29 +38,58 @@ auto Lognf(UINT, const char *, ...) -> void
 	MT_PLATFORM_STUB();
 }
 
-auto Trace(const char *) -> void
+void Trace(const char *)
 {
-	MT_PLATFORM_STUB();
+	// Non-_DEBUG 40250: written only to the log file (OpenLogFile, not implemented yet).
 }
 
-auto Tracen(const char *) -> void
+void Tracen(const char *)
 {
-	MT_PLATFORM_STUB();
+	// Non-_DEBUG 40250: written only to the log file (OpenLogFile, not implemented yet).
 }
 
-auto Tracenf(const char *, ...) -> void
+void Tracenf(const char *, ...)
 {
-	MT_PLATFORM_STUB();
+	// Non-_DEBUG 40250: written only to the log file (OpenLogFile, not implemented yet).
 }
 
-auto Tracef(const char *, ...) -> void
+void Tracef(const char *, ...)
 {
-	MT_PLATFORM_STUB();
+	// Non-_DEBUG 40250: written only to the log file (OpenLogFile, not implemented yet).
 }
 
-auto TraceError(const char *, ...) -> void
+void TraceError(const char* c_szFormat, ...)
 {
-	MT_PLATFORM_STUB();
+#ifndef _DISTRIBUTE
+	char szBuf[DEBUG_STRING_MAX_LEN+2];
+
+	strncpy(szBuf, "SYSERR: ", DEBUG_STRING_MAX_LEN);
+	int len = strlen(szBuf);
+
+	va_list args;
+	va_start(args, c_szFormat);
+	len = _vsnprintf(szBuf + len, sizeof(szBuf) - (len + 1), c_szFormat, args) + len;
+	va_end(args);
+
+	// PORT: _vsnprintf returns -1 on truncation; 40250 then writes the terminator before the buffer.
+	if (len < 8)
+		len = DEBUG_STRING_MAX_LEN;
+
+	szBuf[len] = '\n';
+	szBuf[len + 1] = '\0';
+
+	time_t ct = time(0);
+	struct tm ctm = *localtime(&ct);
+
+	fprintf(stderr, "%02d%02d %02d:%02d:%05d :: %s",
+					ctm.tm_mon + 1,
+					ctm.tm_mday,
+					ctm.tm_hour,
+					ctm.tm_min,
+					ELTimer_GetMSec() % 60000,
+					szBuf + 8);
+	fflush(stderr);
+#endif
 }
 
 auto TraceErrorWithoutEnter(const char *, ...) -> void

extension/src/platform/EterBase/FileBase.cpp

@@ -1,78 +1,189 @@
-// Platform skeleton for EterBase/FileBase.h (40250 EterBase/FileBase.cpp), generated by platform_stub.py.
-// Every MT_PLATFORM_STUB() body is unimplemented: replace it with the platform implementation.
+// Platform implementation of EterBase/FileBase.h (40250 EterBase/FileBase.cpp). 40250 wraps a Win32 file
+// HANDLE; here m_hFile holds a stdio FILE* on every target, with the same open modes (read: existing file,
+// shared for reading; write: read/write, created when missing, not truncated) and the same size bookkeeping.
+// Names are case-insensitive as on NTFS: 40250's pack/Index says "Etc" for ETC.eix, which a case-sensitive
+// file system (Android, Linux) only finds through the fallback below.
 #include "EterBase/StdAfx.h"
 #include "EterBase/FileBase.h"
 
-#include "../PlatformStub.h"
+#include <cstdio>
+#include <string>
 
-CFileBase::CFileBase()
+#if !defined(_WIN32)
+#include <dirent.h>
+#include <strings.h>
+#endif
+
+// fopen, then (POSIX) resolve each path component case-insensitively when the exact spelling is missing.
+static FILE* open_nocase(const char* filename, const char* mode)
+{
+	FILE* fp = std::fopen(filename, mode);
+#if !defined(_WIN32)
+	if (fp || !filename[0])
+		return fp;
+
+	std::string path(filename);
+	for (char& c : path)
+		if (c == '\\')
+			c = '/';
+
+	std::string resolved = path[0] == '/' ? "/" : "";
+	size_t pos = path[0] == '/' ? 1 : 0;
+	while (pos <= path.size())
+	{
+		size_t end = path.find('/', pos);
+		if (end == std::string::npos)
+			end = path.size();
+		const std::string part = path.substr(pos, end - pos);
+		pos = end + 1;
+		if (part.empty() || part == "." || part == "..")
+		{
+			if (!part.empty())
+				resolved += part + "/";
+			continue;
+		}
+
+		DIR* dir = opendir(resolved.empty() ? "." : resolved.c_str());
+		if (!dir)
+			return NULL;
+		std::string match;
+		while (dirent* e = readdir(dir))
+		{
+			if (strcasecmp(e->d_name, part.c_str()) == 0)
+			{
+				match = e->d_name;
+				if (match == part)
+					break;
+			}
+		}
+		closedir(dir);
+		if (match.empty())
+			return NULL;
+		resolved += match;
+		if (end != path.size())
+			resolved += "/";
+	}
+	fp = std::fopen(resolved.c_str(), mode);
+#endif
+	return fp;
+}
+
+static FILE* file_of(HANDLE h)
+{
+	return static_cast<FILE*>(h);
+}
+
+static DWORD stream_size(FILE* fp)
+{
+	const long pos = std::ftell(fp);
+	std::fseek(fp, 0, SEEK_END);
+	const long size = std::ftell(fp);
+	std::fseek(fp, pos, SEEK_SET);
+	return size < 0 ? 0 : static_cast<DWORD>(size);
+}
+
+CFileBase::CFileBase() : m_hFile(NULL), m_dwSize(0)
 {
-	MT_PLATFORM_STUB();
 }
 
 CFileBase::~CFileBase()
 {
-	MT_PLATFORM_STUB();
+	Destroy();
 }
 
-auto CFileBase::Destroy() -> void
+char * CFileBase::GetFileName()
 {
-	MT_PLATFORM_STUB();
+	return m_filename;
 }
 
-auto CFileBase::Close() -> void
+void CFileBase::Destroy()
 {
-	MT_PLATFORM_STUB();
+	Close();
+	m_dwSize = 0;
 }
 
-auto CFileBase::Create(const char *, EFileMode) -> BOOL
+void CFileBase::Close()
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<BOOL>();
+	if (m_hFile)
+	{
+		std::fclose(file_of(m_hFile));
+		m_hFile = NULL;
+	}
 }
 
-auto CFileBase::Size() -> DWORD
+BOOL CFileBase::Create(const char* filename, EFileMode mode)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+	Destroy();
+
+	strncpy(m_filename, filename, MAX_PATH);
+
+	FILE* fp = NULL;
+	if (mode == FILEMODE_WRITE)
+	{
+		// OPEN_ALWAYS + GENERIC_READ|GENERIC_WRITE: open without truncating, create when missing.
+		fp = open_nocase(filename, "r+b");
+		if (!fp)
+			fp = std::fopen(filename, "w+b");
+	}
+	else
+		fp = open_nocase(filename, "rb");
+
+	if (fp)
+	{
+		m_hFile = fp;
+		m_dwSize = stream_size(fp);
+		m_mode = mode;
+		return true;
+	}
+
+	m_hFile = NULL;
+	return false;
 }
 
-auto CFileBase::SeekCur(DWORD) -> void
+DWORD CFileBase::Size()
 {
-	MT_PLATFORM_STUB();
+	return (m_dwSize);
 }
 
-auto CFileBase::Seek(DWORD) -> void
+void CFileBase::SeekCur(DWORD size)
 {
-	MT_PLATFORM_STUB();
+	// SetFilePointer takes the low DWORD as a signed distance when the high part is NULL.
+	std::fseek(file_of(m_hFile), static_cast<LONG>(size), SEEK_CUR);
 }
 
-auto CFileBase::GetPosition() -> DWORD
+void CFileBase::Seek(DWORD offset)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+	if (offset > m_dwSize)
+		offset = m_dwSize;
+
+	std::fseek(file_of(m_hFile), static_cast<long>(offset), SEEK_SET);
 }
 
-auto CFileBase::Write(const void *, int) -> BOOL
+DWORD CFileBase::GetPosition()
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<BOOL>();
+	return static_cast<DWORD>(std::ftell(file_of(m_hFile)));
 }
 
-auto CFileBase::Read(void *, int) -> BOOL
+BOOL CFileBase::Write(const void* src, int bytes)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<BOOL>();
+	FILE* fp = file_of(m_hFile);
+	if (std::fwrite(src, 1, bytes, fp) != static_cast<size_t>(bytes))
+		return false;
+
+	std::fflush(fp);
+	m_dwSize = stream_size(fp);
+	return true;
 }
 
-auto CFileBase::GetFileName() -> char *
+BOOL CFileBase::Read(void* dest, int bytes)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<char *>();
+	// ReadFile succeeds on a short read (end of file); only an I/O error fails.
+	FILE* fp = file_of(m_hFile);
+	std::fread(dest, 1, bytes, fp);
+	return !std::ferror(fp);
 }
 
-auto CFileBase::IsNull() -> BOOL
+BOOL CFileBase::IsNull()
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<BOOL>();
+	return !m_hFile ? true : false;
 }

extension/src/platform/EterBase/MappedFile.cpp

@@ -1,107 +1,272 @@
-// Platform skeleton for EterBase/MappedFile.h (40250 EterBase/MappedFile.cpp), generated by platform_stub.py.
-// Every MT_PLATFORM_STUB() body is unimplemented: replace it with the platform implementation.
+// Platform implementation of EterBase/MappedFile.h (40250 EterBase/MappedFile.cpp). Everything but Map/Unmap
+// is the 40250 code; the view is a POSIX mmap (CreateFileMapping/MapViewOfFile on Windows) of the CFileBase
+// stream, aligned down to the allocation granularity exactly as 40250 does.
 #include "EterBase/StdAfx.h"
 #include "EterBase/MappedFile.h"
+#include "EterBase/Debug.h"
 
-#include "../PlatformStub.h"
+#include <cstdio>
 
-CMappedFile::CMappedFile()
+#if defined(_WIN32)
+#include <io.h>
+#else
+#include <sys/mman.h>
+#include <unistd.h>
+#endif
+
+static DWORD allocation_granularity()
+{
+#if defined(_WIN32)
+	SYSTEM_INFO SysInfo;
+	GetSystemInfo(&SysInfo);
+	return SysInfo.dwAllocationGranularity;
+#else
+	return static_cast<DWORD>(sysconf(_SC_PAGESIZE));
+#endif
+}
+
+CMappedFile::CMappedFile() :
+m_hFM(NULL),
+m_lpMapData(NULL),
+m_dataOffset(0),
+m_mapSize(0),
+m_seekPosition(0),
+m_pLZObj(NULL),
+m_pbBufLinkData(NULL),
+m_dwBufLinkSize(0),
+m_pbAppendResultDataBlock(NULL),
+m_dwAppendResultDataSize(0)
 {
-	MT_PLATFORM_STUB();
 }
 
 CMappedFile::~CMappedFile()
 {
-	MT_PLATFORM_STUB();
+	Destroy();
 }
 
-auto CMappedFile::Link(DWORD, const void *) -> void
+BOOL CMappedFile::Create(const char * filename)
 {
-	MT_PLATFORM_STUB();
+	Destroy();
+	return CFileBase::Create(filename, FILEMODE_READ);
 }
 
-auto CMappedFile::Create(const char *) -> BOOL
+BOOL CMappedFile::Create(const char * filename, const void** dest, int offset, int size)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<BOOL>();
+	if (!CMappedFile::Create(filename))
+		return FALSE;
+
+	int ret = Map(dest, offset, size);
+	return (ret) > 0;
 }
 
-auto CMappedFile::Create(const char *, const void **, int, int) -> BOOL
+LPCVOID CMappedFile::Get()
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<BOOL>();
+	return m_lpData;
 }
 
-auto CMappedFile::Get() -> LPCVOID
+void CMappedFile::Link(DWORD dwBufSize, const void* c_pvBufData)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<LPCVOID>();
+	m_dwBufLinkSize=dwBufSize;
+	m_pbBufLinkData=(BYTE*)c_pvBufData;
 }
 
-auto CMappedFile::Destroy() -> void
+void CMappedFile::BindLZObject(CLZObject * pLZObj)
 {
-	MT_PLATFORM_STUB();
+	assert(m_pLZObj == NULL);
+	m_pLZObj = pLZObj;
+
+	Link(m_pLZObj->GetSize(), m_pLZObj->GetBuffer());
 }
 
-auto CMappedFile::Seek(DWORD, int) -> int
+void CMappedFile::BindLZObjectWithBufferedSize(CLZObject * pLZObj)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<int>();
+	assert(m_pLZObj == NULL);
+	m_pLZObj = pLZObj;
+
+	Link(m_pLZObj->GetBufferSize(), m_pLZObj->GetBuffer());
 }
 
-auto CMappedFile::Map(const void **, int, int) -> int
+BYTE* CMappedFile::AppendDataBlock( const void* pBlock, DWORD dwBlockSize )
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<int>();
+	if( m_pbAppendResultDataBlock )
+	{
+		delete []m_pbAppendResultDataBlock;
+	}
+
+	//realloc
+	m_dwAppendResultDataSize  = m_dwBufLinkSize+dwBlockSize;
+	m_pbAppendResultDataBlock = new BYTE[m_dwAppendResultDataSize];
+
+	memcpy(m_pbAppendResultDataBlock, m_pbBufLinkData, m_dwBufLinkSize );
+	memcpy(m_pbAppendResultDataBlock + m_dwBufLinkSize, pBlock, dwBlockSize );
+
+	//redirect
+	Link(m_dwAppendResultDataSize, m_pbAppendResultDataBlock);
+
+	return m_pbAppendResultDataBlock;
 }
 
-auto CMappedFile::Size() -> DWORD
+void CMappedFile::Destroy()
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+	if (m_pLZObj)
+	{
+		delete m_pLZObj;
+		m_pLZObj = NULL;
+	}
+
+	if (NULL != m_lpMapData)
+	{
+		Unmap(m_lpMapData);
+		m_lpMapData = NULL;
+	}
+
+#if defined(_WIN32)
+	if (NULL != m_hFM)
+	{
+		CloseHandle(m_hFM);
+		m_hFM = NULL;
+	}
+#endif
+
+	if( m_pbAppendResultDataBlock )
+	{
+		delete []m_pbAppendResultDataBlock;
+		m_pbAppendResultDataBlock = NULL;
+	}
+
+	m_dwAppendResultDataSize = 0;
+
+	m_pbBufLinkData = NULL;
+	m_dwBufLinkSize = 0;
+
+	m_seekPosition = 0;
+	m_dataOffset = 0;
+	m_mapSize = 0;
+
+	CFileBase::Destroy();
 }
 
-auto CMappedFile::GetPosition() -> DWORD
+int CMappedFile::Seek(DWORD offset, int iSeekType)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+	switch (iSeekType)
+	{
+		case SEEK_TYPE_BEGIN:
+			if (offset > m_dwSize)
+				offset = m_dwSize;
+
+			m_seekPosition = offset;
+			break;
+
+		case SEEK_TYPE_CURRENT:
+			m_seekPosition = min(m_seekPosition + offset, Size());
+			break;
+
+		case SEEK_TYPE_END:
+			m_seekPosition = max(0, Size() - offset);
+			break;
+	}
+
+	return m_seekPosition;
 }
 
-auto CMappedFile::Read(void *, int) -> BOOL
+int CMappedFile::Map(const void **dest, int offset, int size)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<BOOL>();
+	m_dataOffset = offset;
+
+	if (size == 0)
+		m_mapSize = m_dwSize;
+	else
+		m_mapSize = size;
+
+	if (m_dataOffset + m_mapSize > m_dwSize)
+		return 0;
+
+	DWORD dwSysGran = allocation_granularity();
+	DWORD dwFileMapStart = (m_dataOffset / dwSysGran) * dwSysGran;
+	DWORD dwMapViewSize = (m_dataOffset % dwSysGran) + m_mapSize;
+	INT iViewDelta = m_dataOffset - dwFileMapStart;
+
+	FILE* fp = static_cast<FILE*>(m_hFile);
+#if defined(_WIN32)
+	m_hFM = CreateFileMapping((HANDLE) _get_osfhandle(_fileno(fp)), NULL, PAGE_READONLY, 0,
+							  m_dataOffset + m_mapSize, NULL);
+	if (!m_hFM)
+	{
+		OutputDebugString("CMappedFile::Map !m_hFM\n");
+		return 0;
+	}
+
+	m_lpMapData = MapViewOfFile(m_hFM, FILE_MAP_READ, 0, dwFileMapStart, dwMapViewSize);
+	if (!m_lpMapData)
+	{
+		TraceError("CMappedFile::Map !m_lpMapData %lu", GetLastError());
+		return 0;
+	}
+#else
+	// A zero-length view (empty file) is a valid 40250 map; mmap rejects length 0.
+	if (dwMapViewSize == 0)
+		dwMapViewSize = 1;
+	void* p = mmap(NULL, dwMapViewSize, PROT_READ, MAP_PRIVATE, fileno(fp), static_cast<off_t>(dwFileMapStart));
+	if (p == MAP_FAILED)
+	{
+		TraceError("CMappedFile::Map !m_lpMapData %s", GetFileName());
+		return 0;
+	}
+	m_lpMapData = p;
+#endif
+
+	m_lpData = (char*) m_lpMapData + iViewDelta;
+	*dest = (char*) m_lpData;
+	m_seekPosition = 0;
+
+	Link(m_mapSize, m_lpData);
+
+	return (m_mapSize);
 }
 
-auto CMappedFile::GetSeekPosition() -> DWORD
+BYTE * CMappedFile::GetCurrentSeekPoint()
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<DWORD>();
+	return m_pbBufLinkData+m_seekPosition;
 }
 
-auto CMappedFile::BindLZObject(CLZObject *) -> void
+DWORD CMappedFile::Size()
 {
-	MT_PLATFORM_STUB();
+	return m_dwBufLinkSize;
 }
 
-auto CMappedFile::BindLZObjectWithBufferedSize(CLZObject *) -> void
+DWORD CMappedFile::GetPosition()
 {
-	MT_PLATFORM_STUB();
+	return m_dataOffset;
 }
 
-auto CMappedFile::AppendDataBlock(const void *, DWORD) -> BYTE *
+BOOL CMappedFile::Read(void * dest, int bytes)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<BYTE *>();
+	if (m_seekPosition + bytes > Size())
+		return FALSE;
+
+	memcpy(dest, GetCurrentSeekPoint(), bytes);
+	m_seekPosition += bytes;
+	return TRUE;
 }
 
-auto CMappedFile::GetCurrentSeekPoint() -> BYTE *
+DWORD CMappedFile::GetSeekPosition(void)
 {
-	MT_PLATFORM_STUB();
-	return mt_platform_stub_return<BYTE *>();
+	return m_seekPosition;
 }
 
-auto CMappedFile::Unmap(LPCVOID) -> void
+void CMappedFile::Unmap(LPCVOID data)
 {
-	MT_PLATFORM_STUB();
+#if defined(_WIN32)
+	if (!UnmapViewOfFile(data))
+		TraceError("CMappedFile::Unmap - Error");
+#else
+	// Same view length Map computed from the (unchanged) offset and size.
+	const DWORD dwSysGran = allocation_granularity();
+	DWORD dwMapViewSize = (m_dataOffset % dwSysGran) + m_mapSize;
+	if (dwMapViewSize == 0)
+		dwMapViewSize = 1;
+	if (munmap(const_cast<void*>(data), dwMapViewSize) != 0)
+		TraceError("CMappedFile::Unmap - Error");
+#endif
+	m_lpData = NULL;
 }

extension/src/platform/EterBase/Utils.cpp

@@ -1,7 +1,9 @@
 // Platform skeleton for EterBase/Utils.h (40250 EterBase/Utils.cpp), generated by platform_stub.py.
-// Every MT_PLATFORM_STUB() body is unimplemented: replace it with the platform implementation.
+// Every MT_PLATFORM_STUB() body is unimplemented: replace it with the platform implementation. Implemented
+// bodies are the 40250 code (batch 2D: the path helpers EterPack uses); stl_lowers lives in EterBase/Stl.cpp.
 #include "EterBase/StdAfx.h"
 #include "EterBase/Utils.h"
+#include "EterBase/Stl.h"
 
 #include "../PlatformStub.h"
 
@@ -36,11 +38,6 @@ auto GetIndexingName(char *, DWORD) -> void
 	MT_PLATFORM_STUB();
 }
 
-auto stl_lowers(std::string &) -> void
-{
-	MT_PLATFORM_STUB();
-}
-
 auto GetOnlyFileName(const char *, std::string &) -> void
 {
 	MT_PLATFORM_STUB();
@@ -73,29 +70,59 @@ auto GetWorkingFolder(std::string &) -> void
 	MT_PLATFORM_STUB();
 }
 
-auto StringLowers(char *) -> void
+void StringLowers(char * String)
 {
-	MT_PLATFORM_STUB();
+	for (DWORD i = 0; i < strlen(String); ++i)
+	{
+		String[i] = korean_tolower(String[i]);
+	}
 }
 
-auto StringPath(std::string &) -> void
+void StringPath(std::string & rString)
 {
-	MT_PLATFORM_STUB();
+	for (DWORD i = 0; i < rString.length(); ++i)
+	{
+		if (rString[i] == '\\')
+			rString[i] = '/';
+		else
+			rString[i] = korean_tolower(rString[i]);
+	}
 }
 
-auto StringPath(char *) -> void
+void StringPath(char * pString)
 {
-	MT_PLATFORM_STUB();
+	for (DWORD i = 0; i < strlen(pString); ++i)
+	{
+		if (pString[i] == '\\')
+			pString[i] = '/';
+		else
+			pString[i] = korean_tolower(pString[i]);
+	}
 }
 
-auto StringPath(const char *, char *) -> void
+void StringPath(const char * c_szSrc, char * szDest)
 {
-	MT_PLATFORM_STUB();
+	for (DWORD i = 0; i < strlen(c_szSrc); ++i)
+	{
+		if (c_szSrc[i] == '\\')
+			szDest[i] = '/';
+		else
+			szDest[i] = korean_tolower(c_szSrc[i]);
+	}
 }
 
-auto StringPath(const char *, std::string &) -> void
+void StringPath(const char * c_szSrc, std::string & rString)
 {
-	MT_PLATFORM_STUB();
+	rString = "";
+	rString.resize(strlen(c_szSrc));
+
+	for (DWORD i = 0; i < strlen(c_szSrc); ++i)
+	{
+		if (c_szSrc[i] == '\\')
+			rString[i] = '/';
+		else
+			rString[i] = korean_tolower(c_szSrc[i]);
+	}
 }
 
 auto PrintAsciiData(const void *, int) -> void