Menu
▾
▴
[OMPT-svn-commit] SF.net SVN: modplug:[2398] trunk/OpenMPT
|
From: <man...@us...> - 2013-06-21 14:41:07
|
Revision: 2398
http://sourceforge.net/p/modplug/code/2398
Author: manxorist
Date: 2013-06-21 14:40:59 +0000 (Fri, 21 Jun 2013)
Log Message:
-----------
Merged revision(s) 2382-2386, 2395 from branches/manx/serialization-utils-cleanup:
[Ref] De-obfuscate iostreams types.
........
[Fix] Basic endian-safety in serialization_utils.h (at least kill reinterpret_cast).
........
[Ref] Kill void pointers in serialization_utils.
[Fix] Correctly pass little endian id values on big endian.
........
[Ref] Remove unneeded reinterpret_cast.
........
[Fix] Basic endian-safety in serialization_utils.cpp (at least kill reinterpret_cast).
........
[Fix] Trivial build fix.
........
Modified Paths:
--------------
trunk/OpenMPT/common/serialization_utils.cpp
trunk/OpenMPT/common/serialization_utils.h
trunk/OpenMPT/soundlib/Load_it.cpp
trunk/OpenMPT/soundlib/ModSequence.cpp
trunk/OpenMPT/soundlib/patternContainer.cpp
trunk/OpenMPT/soundlib/tuning.cpp
trunk/OpenMPT/soundlib/tuningCollection.cpp
trunk/OpenMPT/soundlib/tuningbase.cpp
Property Changed:
----------------
trunk/OpenMPT/
Index: trunk/OpenMPT
===================================================================
--- trunk/OpenMPT 2013-06-21 11:26:46 UTC (rev 2397)
+++ trunk/OpenMPT 2013-06-21 14:40:59 UTC (rev 2398)
Property changes on: trunk/OpenMPT
___________________________________________________________________
Modified: svn:mergeinfo
## -6,5 +6,6 ##
/branches/manx/nonglobal-mixer:1715-1841
/branches/manx/profiler:1813
/branches/manx/project-files-cleanups:1378-1382
+/branches/manx/serialization-utils-cleanup:2382-2386,2395
/branches/manx/snddev-fixes:1605-1713
/branches/manx/unarchiver:1887-1888
\ No newline at end of property
Modified: trunk/OpenMPT/common/serialization_utils.cpp
===================================================================
--- trunk/OpenMPT/common/serialization_utils.cpp 2013-06-21 11:26:46 UTC (rev 2397)
+++ trunk/OpenMPT/common/serialization_utils.cpp 2013-06-21 14:40:59 UTC (rev 2398)
@@ -30,10 +30,9 @@
}
-bool IsPrintableId(const void* pvId, const size_t nLength)
+bool IsPrintableId(const char* pId, const size_t nLength)
//--------------------------------------------------------
{
- const char* pId = static_cast<const char*>(pvId);
for(size_t i = 0; i < nLength; i++)
{
if (pId[i] <= 0 || isprint(pId[i]) == 0)
@@ -63,7 +62,7 @@
}
-void WriteAdaptive12(OutStream& oStrm, const uint16 num)
+void WriteAdaptive12(std::ostream& oStrm, const uint16 num)
//------------------------------------------------------
{
if(num >> 7 == 0)
@@ -73,7 +72,7 @@
}
-void WriteAdaptive1234(OutStream& oStrm, const uint32 num)
+void WriteAdaptive1234(std::ostream& oStrm, const uint32 num)
//--------------------------------------------------------
{
const uint8 bc = GetByteReq1234(num);
@@ -83,7 +82,7 @@
//Format: First bit tells whether the size indicator is 1 or 2 bytes.
-void WriteAdaptive12String(OutStream& oStrm, const std::string& str)
+void WriteAdaptive12String(std::ostream& oStrm, const std::string& str)
//------------------------------------------------------------------
{
uint16 s = static_cast<uint16>(str.size());
@@ -103,7 +102,7 @@
else return 3;
}
-void WriteAdaptive1248(OutStream& oStrm, const uint64& num)
+void WriteAdaptive1248(std::ostream& oStrm, const uint64& num)
//---------------------------------------------------------
{
const uint8 bc = GetByteReq1248(num);
@@ -112,21 +111,34 @@
}
-void ReadAdaptive12(InStream& iStrm, uint16& val)
+void ReadAdaptive12(std::istream& iStrm, uint16& val)
//-----------------------------------------------
{
Binaryread<uint16>(iStrm, val, 1);
- if(val & 1) iStrm.read(reinterpret_cast<char*>(&val) + 1, 1);
+ if(val & 1)
+ {
+ uint8 hi = 0;
+ Binaryread(iStrm, hi);
+ val &= 0xff;
+ val |= hi << 8;
+ }
val >>= 1;
}
-void ReadAdaptive1234(InStream& iStrm, uint32& val)
+void ReadAdaptive1234(std::istream& iStrm, uint32& val)
//-------------------------------------------------
{
Binaryread<uint32>(iStrm, val, 1);
const uint8 bc = 1 + static_cast<uint8>(val & 3);
- if(bc > 1) iStrm.read(reinterpret_cast<char*>(&val)+1, bc-1);
+ uint8 v2 = 0;
+ uint8 v3 = 0;
+ uint8 v4 = 0;
+ if(bc >= 2) Binaryread(iStrm, v2);
+ if(bc >= 3) Binaryread(iStrm, v3);
+ if(bc >= 4) Binaryread(iStrm, v4);
+ val &= 0xff;
+ val |= (v2 << 8) | (v3 << 16) | (v4 << 24);
val >>= 2;
}
@@ -135,17 +147,29 @@
// Returns 2^n. n must be within {0,...,7}.
inline uint8 Pow2xSmall(const uint8& exp) {ASSERT(exp <= 7); return pow2xTable[exp];}
-void ReadAdaptive1248(InStream& iStrm, uint64& val)
+void ReadAdaptive1248(std::istream& iStrm, uint64& val)
//-------------------------------------------------
{
Binaryread<uint64>(iStrm, val, 1);
- const uint8 bc = Pow2xSmall(static_cast<uint8>(val & 3));
- if(bc > 1) iStrm.read(reinterpret_cast<char*>(&val)+1, bc-1);
+ uint8 bc = Pow2xSmall(static_cast<uint8>(val & 3));
+ int byte = 1;
+ val &= 0xff;
+ while(bc > 1)
+ {
+ uint8 v = 0;
+ Binaryread(iStrm, v);
+ if(byte < 8)
+ {
+ val |= uint64(v) << (byte*8);
+ }
+ byte++;
+ bc--;
+ }
val >>= 2;
}
-void WriteItemString(OutStream& oStrm, const char* const pStr, const size_t nSize)
+void WriteItemString(std::ostream& oStrm, const char* const pStr, const size_t nSize)
//--------------------------------------------------------------------------------
{
uint32 id = std::min<size_t>(nSize, (uint32_max >> 4)) << 4;
@@ -157,7 +181,7 @@
}
-void ReadItemString(InStream& iStrm, std::string& str, const DataSize)
+void ReadItemString(std::istream& iStrm, std::string& str, const DataSize)
//--------------------------------------------------------------------
{
// bits 0,1: Bytes per char type: 1,2,3,4.
@@ -166,7 +190,17 @@
Binaryread(iStrm, id, 1);
const uint8 nSizeBytes = (id & 12) >> 2; // 12 == 1100b
if (nSizeBytes > 0)
- iStrm.read(reinterpret_cast<char*>(&id) + 1, MIN(3, nSizeBytes));
+ {
+ uint8 bytes = MIN(3, nSizeBytes);
+ uint8 v2 = 0;
+ uint8 v3 = 0;
+ uint8 v4 = 0;
+ if(bytes >= 1) Binaryread(iStrm, v2);
+ if(bytes >= 2) Binaryread(iStrm, v3);
+ if(bytes >= 3) Binaryread(iStrm, v4);
+ id &= 0xff;
+ id |= (v2 << 8) | (v3 << 16) | (v4 << 24);
+ }
// Limit to 1 MB.
str.resize(MIN(id >> 4, 1000000));
for(size_t i = 0; i < str.size(); i++)
@@ -178,15 +212,15 @@
}
-String IdToString(const void* const pvId, const size_t nLength)
+std::string IdToString(const char* const pvId, const size_t nLength)
//-------------------------------------------------------------
{
const char* pId = static_cast<const char*>(pvId);
if (nLength == 0)
return "";
- String str;
+ std::string str;
if (IsPrintableId(pId, nLength))
- std::copy(pId, pId + nLength, std::back_inserter<String>(str));
+ std::copy(pId, pId + nLength, std::back_inserter<std::string>(str));
else if (nLength <= 4) // Interpret ID as integer value.
{
int32 val = 0;
@@ -246,21 +280,21 @@
m_posMapStart(0) \
-Ssb::Ssb(InStream* pIstrm, OutStream* pOstrm) :
+Ssb::Ssb(std::istream* pIstrm, std::ostream* pOstrm) :
m_pOstrm(pOstrm),
m_pIstrm(pIstrm),
SSB_INITIALIZATION_LIST
//-----------------------------------------------
{}
-Ssb::Ssb(IoStream& ioStrm) :
+Ssb::Ssb(std::iostream& ioStrm) :
m_pOstrm(&ioStrm),
m_pIstrm(&ioStrm),
SSB_INITIALIZATION_LIST
//------------------------------
{}
-Ssb::Ssb(OutStream& oStrm) :
+Ssb::Ssb(std::ostream& oStrm) :
m_pOstrm(&oStrm),
m_pIstrm(nullptr),
SSB_INITIALIZATION_LIST
@@ -268,7 +302,7 @@
{}
-Ssb::Ssb(InStream& iStrm) :
+Ssb::Ssb(std::istream& iStrm) :
m_pOstrm(nullptr),
m_pIstrm(&iStrm),
SSB_INITIALIZATION_LIST
@@ -308,7 +342,7 @@
// Called after writing an entry.
-void Ssb::AddWriteNote(const void* pId, const size_t nIdSize, const NumType nEntryNum, const DataSize nBytecount, const RposType rposStart)
+void Ssb::AddWriteNote(const char* pId, const size_t nIdSize, const NumType nEntryNum, const DataSize nBytecount, const RposType rposStart)
//----------------------------------------------------------------------------
{
m_Status |= SNT_PROGRESS;
@@ -331,7 +365,7 @@
}
-void Ssb::WriteMapItem( const void* pId,
+void Ssb::WriteMapItem( const char* pId,
const size_t nIdSize,
const RposType& rposDataStart,
const DataSize& nDatasize,
@@ -353,7 +387,7 @@
WriteAdaptive12(m_MapStream, static_cast<uint16>(nIdSize));
if(nIdSize > 0)
- m_MapStream.write(reinterpret_cast<const char*>(pId), static_cast<Streamsize>(nIdSize));
+ m_MapStream.write(pId, nIdSize);
}
if (GetFlag(RwfWMapStartPosEntry)) //Startpos
@@ -361,14 +395,14 @@
if (GetFlag(RwfWMapSizeEntry)) //Entrysize
WriteAdaptive1248(m_MapStream, nDatasize);
if (GetFlag(RwfWMapDescEntry)) //Entry descriptions
- WriteAdaptive12String(m_MapStream, String(pszDesc));
+ WriteAdaptive12String(m_MapStream, std::string(pszDesc));
}
void Ssb::ReserveMapSize(uint32 nSize)
//------------------------------------
{
- OutStream& oStrm = *m_pOstrm;
+ std::ostream& oStrm = *m_pOstrm;
m_nMapReserveSize = nSize;
if (nSize > 0)
{
@@ -399,7 +433,7 @@
}
-Ssb* Ssb::CreateReadSubEntry(const void* pId, const size_t nLength)
+Ssb* Ssb::CreateReadSubEntry(const char* pId, const size_t nLength)
//-----------------------------------------------------------------
{
const ReadEntry* pE = Find(pId, nLength);
@@ -431,7 +465,7 @@
}
-void Ssb::ReleaseWriteSubEntry(const void* pId, const size_t nIdLength)
+void Ssb::ReleaseWriteSubEntry(const char* pId, const size_t nIdLength)
//---------------------------------------------------------------------
{
if ((m_pSubEntry->m_Status & SNT_FAILURE) != 0)
@@ -443,10 +477,10 @@
}
-void Ssb::BeginWrite(const void* pId, const size_t nIdSize, const uint64& nVersion)
+void Ssb::BeginWrite(const char* pId, const size_t nIdSize, const uint64& nVersion)
//---------------------------------------------------------------------------------
{
- OutStream& oStrm = *m_pOstrm;
+ std::ostream& oStrm = *m_pOstrm;
if (m_fpLogFunc)
m_fpLogFunc(tstrWriteHeader, IdToString(pId, nIdSize).c_str());
@@ -465,7 +499,7 @@
{
uint8 idsize = static_cast<uint8>(nIdSize);
Binarywrite<uint8>(oStrm, idsize);
- if(idsize > 0) oStrm.write(reinterpret_cast<const char*>(pId), nIdSize);
+ if(idsize > 0) oStrm.write(pId, nIdSize);
}
// Form header.
@@ -522,7 +556,7 @@
}
-Ssb::ReadRv Ssb::OnReadEntry(const ReadEntry* pE, const void* pId, const size_t nIdSize, const Postype& posReadBegin)
+Ssb::ReadRv Ssb::OnReadEntry(const ReadEntry* pE, const char* pId, const size_t nIdSize, const Postype& posReadBegin)
//-------------------------------------------------------------------------------------------------------------------
{
if (pE != nullptr)
@@ -545,7 +579,7 @@
}
-void Ssb::OnWroteItem(const void* pId, const size_t nIdSize, const Postype& posBeforeWrite)
+void Ssb::OnWroteItem(const char* pId, const size_t nIdSize, const Postype& posBeforeWrite)
//-----------------------------------------------------------------------------------------
{
const Offtype nRawEntrySize = m_pOstrm->tellp() - posBeforeWrite;
@@ -579,7 +613,7 @@
}
-void Ssb::CompareId(InStream& iStrm, const void* pId, const size_t nIdlength)
+void Ssb::CompareId(std::istream& iStrm, const char* pId, const size_t nIdlength)
//---------------------------------------------------------------------------
{
uint8 tempU8 = 0;
@@ -598,10 +632,10 @@
}
-void Ssb::BeginRead(const void* pId, const size_t nLength, const uint64& nVersion)
+void Ssb::BeginRead(const char* pId, const size_t nLength, const uint64& nVersion)
//---------------------------------------------------------------------------------
{
- InStream& iStrm = *m_pIstrm;
+ std::istream& iStrm = *m_pIstrm;
if (m_fpLogFunc)
m_fpLogFunc(tstrReadingHeader, IdToString(pId, nLength).c_str());
@@ -616,7 +650,7 @@
// Start bytes.
{
char temp[sizeof(s_EntryID)];
- Binaryread<char[sizeof(s_EntryID)]>(iStrm, temp);
+ ArrayReader<char>(sizeof(s_EntryID))(iStrm, temp, sizeof(s_EntryID));
if (memcmp(temp, s_EntryID, sizeof(s_EntryID)))
{
AddReadNote(SNR_STARTBYTE_MISMATCH);
@@ -746,7 +780,7 @@
void Ssb::CacheMap()
//------------------
{
- InStream& iStrm = *m_pIstrm;
+ std::istream& iStrm = *m_pIstrm;
if(GetFlag(RwfRwHasMap) || m_nFixedEntrySize > 0)
{
iStrm.seekg(m_posStart + m_rposMapBegin);
@@ -837,7 +871,7 @@
}
-const ReadEntry* Ssb::Find(const void* pId, const size_t nIdLength)
+const ReadEntry* Ssb::Find(const char* pId, const size_t nIdLength)
//-----------------------------------------------------------------
{
m_pIstrm->clear();
@@ -870,7 +904,7 @@
void Ssb::FinishWrite()
//---------------------
{
- OutStream& oStrm = *m_pOstrm;
+ std::ostream& oStrm = *m_pOstrm;
const Postype posDataEnd = oStrm.tellp();
std::string mapStreamStr = m_MapStream.str();
if (m_posMapStart != Postype(0) && ((uint32)mapStreamStr.length() > m_nMapReserveSize))
Modified: trunk/OpenMPT/common/serialization_utils.h
===================================================================
--- trunk/OpenMPT/common/serialization_utils.h 2013-06-21 11:26:46 UTC (rev 2397)
+++ trunk/OpenMPT/common/serialization_utils.h 2013-06-21 14:40:59 UTC (rev 2398)
@@ -26,14 +26,8 @@
namespace srlztn //SeRiaLiZaTioN
{
-typedef std::ostream OutStream;
-typedef std::istream InStream;
-typedef std::iostream IoStream;
-typedef std::istringstream IstrStream;
-typedef std::ostringstream OstrStream;
-typedef OutStream::off_type Offtype;
+typedef std::ostream::off_type Offtype;
typedef Offtype Postype;
-typedef std::streamsize Streamsize;
typedef uintptr_t DataSize; // Data size type.
typedef uintptr_t RposType; // Relative position type.
@@ -41,8 +35,6 @@
const DataSize invalidDatasize = DataSize(-1);
-typedef std::basic_string<TCHAR> String;
-
enum
{
SNT_PROGRESS = 0x80000000, // = 1 << 31
@@ -79,9 +71,9 @@
SNW_INSUFFICIENT_DATASIZETYPE = (0x16) | SNT_FAILURE
};
-bool IsPrintableId(const void* pvId, const size_t nLength); // Return true if given id is printable, false otherwise.
-void ReadAdaptive1248(InStream& iStrm, uint64& val);
-void WriteAdaptive1248(OutStream& oStrm, const uint64& val);
+bool IsPrintableId(const char* pvId, const size_t nLength); // Return true if given id is printable, false otherwise.
+void ReadAdaptive1248(std::istream& iStrm, uint64& val);
+void WriteAdaptive1248(std::ostream& oStrm, const uint64& val);
enum
{
@@ -124,22 +116,42 @@
template<class T>
-inline void Binarywrite(OutStream& oStrm, const T& data)
+inline void Binarywrite(std::ostream& oStrm, const T& data)
//------------------------------------------------------
{
- oStrm.write(reinterpret_cast<const char*>(&data), sizeof(data));
+ union {
+ T t;
+ char b[sizeof(T)];
+ } conv;
+ STATIC_ASSERT(sizeof(conv) == sizeof(T));
+ STATIC_ASSERT(sizeof(conv.b) == sizeof(T));
+ conv.t = data;
+ #ifdef PLATFORM_BIG_ENDIAN
+ std::reverse(conv.b, conv.b+sizeof(T));
+ #endif
+ oStrm.write(conv.b, sizeof(data));
}
//Write only given number of bytes from the beginning.
template<class T>
-inline void Binarywrite(OutStream& oStrm, const T& data, const Offtype bytecount)
+inline void Binarywrite(std::ostream& oStrm, const T& data, const Offtype bytecount)
//--------------------------------------------------------------------------
{
- oStrm.write(reinterpret_cast<const char*>(&data), MIN(bytecount, sizeof(data)));
+ union {
+ T t;
+ char b[sizeof(T)];
+ } conv;
+ STATIC_ASSERT(sizeof(conv) == sizeof(T));
+ STATIC_ASSERT(sizeof(conv.b) == sizeof(T));
+ conv.t = data;
+ #ifdef PLATFORM_BIG_ENDIAN
+ std::reverse(conv.b, conv.b+sizeof(T));
+ #endif
+ oStrm.write(conv.b, MIN(bytecount, sizeof(data)));
}
template <class T>
-inline void WriteItem(OutStream& oStrm, const T& data)
+inline void WriteItem(std::ostream& oStrm, const T& data)
//----------------------------------------------------
{
#ifdef HAS_TYPE_TRAITS
@@ -148,37 +160,57 @@
Binarywrite(oStrm, data);
}
-void WriteItemString(OutStream& oStrm, const char* const pStr, const size_t nSize);
+void WriteItemString(std::ostream& oStrm, const char* const pStr, const size_t nSize);
template <>
-inline void WriteItem<std::string>(OutStream& oStrm, const std::string& str) {WriteItemString(oStrm, str.c_str(), str.length());}
+inline void WriteItem<std::string>(std::ostream& oStrm, const std::string& str) {WriteItemString(oStrm, str.c_str(), str.length());}
template <>
-inline void WriteItem<LPCSTR>(OutStream& oStrm, const LPCSTR& psz) {WriteItemString(oStrm, psz, strlen(psz));}
+inline void WriteItem<LPCSTR>(std::ostream& oStrm, const LPCSTR& psz) {WriteItemString(oStrm, psz, strlen(psz));}
template<class T>
-inline void Binaryread(InStream& iStrm, T& data)
+inline void Binaryread(std::istream& iStrm, T& data)
//----------------------------------------------
{
- iStrm.read(reinterpret_cast<char*>(&data), sizeof(T));
+ union {
+ T t;
+ char b[sizeof(T)];
+ } conv;
+ STATIC_ASSERT(sizeof(conv) == sizeof(T));
+ STATIC_ASSERT(sizeof(conv.b) == sizeof(T));
+ iStrm.read(conv.b, sizeof(T));
+ #ifdef PLATFORM_BIG_ENDIAN
+ std::reverse(conv.b, conv.b+sizeof(T));
+ #endif
+ data = conv.t;
}
//Read only given number of bytes to the beginning of data; data bytes are memset to 0 before reading.
template <class T>
-inline void Binaryread(InStream& iStrm, T& data, const Offtype bytecount)
+inline void Binaryread(std::istream& iStrm, T& data, const Offtype bytecount)
//-----------------------------------------------------------------------
{
#ifdef HAS_TYPE_TRAITS
static_assert(std::is_trivial<T>::value == true, "");
#endif
- memset(&data, 0, sizeof(data));
- iStrm.read(reinterpret_cast<char*>(&data), (std::min)((size_t)bytecount, sizeof(data)));
+ union {
+ T t;
+ char b[sizeof(T)];
+ } conv;
+ STATIC_ASSERT(sizeof(conv) == sizeof(T));
+ STATIC_ASSERT(sizeof(conv.b) == sizeof(T));
+ memset(conv.b, 0, sizeof(T));
+ iStrm.read(conv.b, (std::min)((size_t)bytecount, sizeof(data)));
+ #ifdef PLATFORM_BIG_ENDIAN
+ std::reverse(conv.b, conv.b+sizeof(T));
+ #endif
+ data = conv.t;
}
template <class T>
-inline void ReadItem(InStream& iStrm, T& data, const DataSize nSize)
+inline void ReadItem(std::istream& iStrm, T& data, const DataSize nSize)
//------------------------------------------------------------------
{
#ifdef HAS_TYPE_TRAITS
@@ -192,7 +224,7 @@
// Read specialization for float. If data size is 8, read double and assign it to given float.
template <>
-inline void ReadItem<float>(InStream& iStrm, float& f, const DataSize nSize)
+inline void ReadItem<float>(std::istream& iStrm, float& f, const DataSize nSize)
//--------------------------------------------------------------------------
{
if (nSize == 8)
@@ -207,7 +239,7 @@
// Read specialization for double. If data size is 4, read float and assign it to given double.
template <>
-inline void ReadItem<double>(InStream& iStrm, double& d, const DataSize nSize)
+inline void ReadItem<double>(std::istream& iStrm, double& d, const DataSize nSize)
//----------------------------------------------------------------------------
{
if (nSize == 4)
@@ -220,10 +252,10 @@
Binaryread(iStrm, d);
}
-void ReadItemString(InStream& iStrm, std::string& str, const DataSize);
+void ReadItemString(std::istream& iStrm, std::string& str, const DataSize);
template <>
-inline void ReadItem<std::string>(InStream& iStrm, std::string& str, const DataSize nSize)
+inline void ReadItem<std::string>(std::istream& iStrm, std::string& str, const DataSize nSize)
//----------------------------------------------------------------------------------------
{
ReadItemString(iStrm, str, nSize);
@@ -247,10 +279,10 @@
};
typedef std::vector<ReadEntry>::const_iterator ReadIterator;
- Ssb(InStream* pIstrm, OutStream* pOstrm);
- Ssb(IoStream& ioStrm);
- Ssb(OutStream& oStrm);
- Ssb(InStream& iStrm);
+ Ssb(std::istream* pIstrm, std::ostream* pOstrm);
+ Ssb(std::iostream& ioStrm);
+ Ssb(std::ostream& oStrm);
+ Ssb(std::istream& iStrm);
~Ssb() {delete m_pSubEntry;}
@@ -258,12 +290,12 @@
void SetIdSize(uint16 idSize);
// Write header
- void BeginWrite(const void* pId, const size_t nIdSize, const uint64& nVersion);
- void BeginWrite(const LPCSTR pszId, const uint64& nVersion) {BeginWrite(pszId, strlen(pszId), nVersion);}
+ void BeginWrite(const char* pId, const size_t nIdSize, const uint64& nVersion);
+ void BeginWrite(const char* pszId, const uint64& nVersion) {BeginWrite(pszId, strlen(pszId), nVersion);}
// Call this to begin reading: must be called before other read functions.
- void BeginRead(const void* pId, const size_t nLength, const uint64& nVersion);
- void BeginRead(const LPCSTR pszId, const uint64& nVersion) {return BeginRead(pszId, strlen(pszId), nVersion);}
+ void BeginRead(const char* pId, const size_t nLength, const uint64& nVersion);
+ void BeginRead(const char* pszId, const uint64& nVersion) {return BeginRead(pszId, strlen(pszId), nVersion);}
// Reserves space for map to current position. Call after BeginWrite and before writing any entries.
void ReserveMapSize(uint32 nSize);
@@ -278,13 +310,13 @@
Ssb& SubEntry() {return *m_pSubEntry;}
// Releases write subentry and writes corresponding map information.
- void ReleaseWriteSubEntry(const void* pId, const size_t nIdLength);
- void ReleaseWriteSubEntry(const LPCSTR pszId) {ReleaseWriteSubEntry(pszId, strlen(pszId));}
+ void ReleaseWriteSubEntry(const char* pId, const size_t nIdLength);
+ void ReleaseWriteSubEntry(const char* pszId) {ReleaseWriteSubEntry(pszId, strlen(pszId));}
// If ID was found, returns pointer to Ssb object, nullptr if not found.
// Note: All reading on subentry must be done before calling ReadItem with 'this'.
- Ssb* CreateReadSubEntry(const void* pId, const size_t nLength);
- Ssb* CreateReadSubEntry(const LPCSTR pszId) {return CreateReadSubEntry(pszId, strlen(pszId));}
+ Ssb* CreateReadSubEntry(const char* pId, const size_t nLength);
+ Ssb* CreateReadSubEntry(const char* pszId) {return CreateReadSubEntry(pszId, strlen(pszId));}
// After calling BeginRead(), this returns number of entries in the file.
NumType GetNumEntries() const {return m_nReadEntrycount;}
@@ -298,8 +330,8 @@
ReadIterator GetReadEnd();
// Compares given id with read entry id
- IdMatchStatus CompareId(const ReadIterator& iter, LPCSTR pszId) {return CompareId(iter, pszId, strlen(pszId));}
- IdMatchStatus CompareId(const ReadIterator& iter, const void* pId, const size_t nIdSize);
+ IdMatchStatus CompareId(const ReadIterator& iter, const char* pszId) {return CompareId(iter, pszId, strlen(pszId));}
+ IdMatchStatus CompareId(const ReadIterator& iter, const char* pId, const size_t nIdSize);
// When writing, returns the number of entries written.
// When reading, returns the number of entries read not including unrecognized entries.
@@ -309,14 +341,14 @@
// Read item using default read implementation.
template <class T>
- ReadRv ReadItem(T& obj, const LPCSTR pszId) {return ReadItem(obj, pszId, strlen(pszId), srlztn::ReadItem<T>);}
+ ReadRv ReadItem(T& obj, const char* pszId) {return ReadItem(obj, pszId, strlen(pszId), srlztn::ReadItem<T>);}
template <class T>
- ReadRv ReadItem(T& obj, const void* pId, const size_t nIdSize) {return ReadItem(obj, pId, nIdSize, srlztn::ReadItem<T>);}
+ ReadRv ReadItem(T& obj, const char* pId, const size_t nIdSize) {return ReadItem(obj, pId, nIdSize, srlztn::ReadItem<T>);}
// Read item using given function.
template <class T, class FuncObj>
- ReadRv ReadItem(T& obj, const void* pId, const size_t nIdSize, FuncObj);
+ ReadRv ReadItem(T& obj, const char* pId, const size_t nIdSize, FuncObj);
// Read item using read iterator.
template <class T>
@@ -326,14 +358,14 @@
// Write item using default write implementation.
template <class T>
- void WriteItem(const T& obj, const LPCSTR pszId) {WriteItem(obj, pszId, strlen(pszId), &srlztn::WriteItem<T>);}
+ void WriteItem(const T& obj, const char* pszId) {WriteItem(obj, pszId, strlen(pszId), &srlztn::WriteItem<T>);}
template <class T>
- void WriteItem(const T& obj, const void* pId, const size_t nIdSize) {WriteItem(obj, pId, nIdSize, &srlztn::WriteItem<T>);}
+ void WriteItem(const T& obj, const char* pId, const size_t nIdSize) {WriteItem(obj, pId, nIdSize, &srlztn::WriteItem<T>);}
// Write item using given function.
template <class T, class FuncObj>
- void WriteItem(const T& obj, const void* pId, const size_t nIdSize, FuncObj);
+ void WriteItem(const T& obj, const char* pId, const size_t nIdSize, FuncObj);
// Writes mapping.
void FinishWrite();
@@ -349,18 +381,18 @@
void CacheMap();
// Compares ID in file with expected ID.
- void CompareId(InStream& iStrm, const void* pId, const size_t nLength);
+ void CompareId(std::istream& iStrm, const char* pId, const size_t nLength);
// Searches for entry with given ID. If found, returns pointer to corresponding entry, else
// returns nullptr.
- const ReadEntry* Find(const void* pId, const size_t nLength);
- const ReadEntry* Find(const LPCSTR pszId) {return Find(pszId, strlen(pszId));}
+ const ReadEntry* Find(const char* pId, const size_t nLength);
+ const ReadEntry* Find(const char* pszId) {return Find(pszId, strlen(pszId));}
// Called after reading an object.
- ReadRv OnReadEntry(const ReadEntry* pE, const void* pId, const size_t nIdSize, const Postype& posReadBegin);
+ ReadRv OnReadEntry(const ReadEntry* pE, const char* pId, const size_t nIdSize, const Postype& posReadBegin);
// Called after writing an item.
- void OnWroteItem(const void* pId, const size_t nIdSize, const Postype& posBeforeWrite);
+ void OnWroteItem(const char* pId, const size_t nIdSize, const Postype& posBeforeWrite);
void AddNote(const SsbStatus s, const SsbStatus mask, const TCHAR* sz);
@@ -370,14 +402,14 @@
void AddReadNote(const ReadEntry* const pRe, const NumType nNum);
void AddWriteNote(const SsbStatus s);
- void AddWriteNote(const void* pId,
+ void AddWriteNote(const char* pId,
const size_t nIdLength,
const NumType nEntryNum,
const DataSize nBytecount,
const RposType rposStart);
// Writes mapping item to mapstream.
- void WriteMapItem(const void* pId,
+ void WriteMapItem(const char* pId,
const size_t nIdSize,
const RposType& rposDataStart,
const DataSize& nDatasize,
@@ -390,8 +422,8 @@
private:
- OutStream* m_pOstrm; // Write: Pointer to write stream.
- InStream* m_pIstrm; // Read: Pointer to read stream.
+ std::ostream* m_pOstrm; // Write: Pointer to write stream.
+ std::istream* m_pIstrm; // Read: Pointer to read stream.
public:
@@ -427,7 +459,7 @@
Postype m_posEntrycount; // Write: Pos of entrycount field.
Postype m_posMapPosField; // Write: Pos of map position field.
Postype m_posMapStart; // Write: Pos of map start.
- OstrStream m_MapStream; // Write: Map stream.
+ std::ostringstream m_MapStream; // Write: Map stream.
public:
static const uint8 s_DefaultFlagbyte = 0;
@@ -440,9 +472,29 @@
(1 << RwfRPartialIdMatch);
};
+template<typename T>
+struct IdLE
+{
+ union {
+ char b[sizeof(T)];
+ T t;
+ } conv;
+ IdLE(T val)
+ {
+ conv.t = val;
+ #ifdef PLATFORM_BIG_ENDIAN
+ std::reverse(conv.b, conv.b+sizeof(T));
+ #endif
+ }
+ const char* GetChars() const
+ {
+ return conv.b;
+ }
+};
+
template <class T, class FuncObj>
-void Ssb::WriteItem(const T& obj, const void* pId, const size_t nIdSize, FuncObj Func)
+void Ssb::WriteItem(const T& obj, const char* pId, const size_t nIdSize, FuncObj Func)
//------------------------------------------------------------------------------------
{
const Postype pos = m_pOstrm->tellp();
@@ -451,7 +503,7 @@
}
template <class T, class FuncObj>
-Ssb::ReadRv Ssb::ReadItem(T& obj, const void* pId, const size_t nIdSize, FuncObj Func)
+Ssb::ReadRv Ssb::ReadItem(T& obj, const char* pId, const size_t nIdSize, FuncObj Func)
//------------------------------------------------------------------------------------
{
const ReadEntry* pE = Find(pId, nIdSize);
@@ -475,7 +527,7 @@
}
-inline Ssb::IdMatchStatus Ssb::CompareId(const ReadIterator& iter, const void* pId, const size_t nIdSize)
+inline Ssb::IdMatchStatus Ssb::CompareId(const ReadIterator& iter, const char* pId, const size_t nIdSize)
//-------------------------------------------------------------------------------------------------------
{
if (nIdSize == iter->nIdLength && memcmp(&m_Idarray[iter->nIdpos], pId, iter->nIdLength) == 0)
@@ -509,7 +561,12 @@
//================
{
ArrayWriter(size_t nCount) : m_nCount(nCount) {}
- void operator()(srlztn::OutStream& oStrm, const T* pData) {oStrm.write(reinterpret_cast<const char*>(pData), m_nCount * sizeof(T));}
+ void operator()(std::ostream& oStrm, const T* pData) {
+ for(std::size_t i=0; i<m_nCount; ++i)
+ {
+ Binarywrite(oStrm, pData[i]);
+ }
+ }
size_t m_nCount;
};
@@ -518,13 +575,15 @@
//================
{
ArrayReader(size_t nCount) : m_nCount(nCount) {}
- void operator()(srlztn::InStream& iStrm, T* pData, const size_t) {iStrm.read(reinterpret_cast<char*>(pData), m_nCount * sizeof(T));}
+ void operator()(std::istream& iStrm, T* pData, const size_t) {
+ for(std::size_t i=0; i<m_nCount; ++i)
+ {
+ Binaryread(iStrm, pData[i]);
+ }
+ }
size_t m_nCount;
};
-} //namespace srlztn.
-
-
template<class SIZETYPE>
bool StringToBinaryStream(std::ostream& oStrm, const std::string& str)
//--------------------------------------------------------------------
@@ -532,7 +591,7 @@
if(!oStrm.good()) return true;
if((std::numeric_limits<SIZETYPE>::max)() < str.size()) return true;
SIZETYPE size = static_cast<SIZETYPE>(str.size());
- oStrm.write(reinterpret_cast<char*>(&size), sizeof(size));
+ Binarywrite(oStrm, size);
oStrm.write(str.c_str(), size);
if(oStrm.good()) return false;
else return true;
@@ -545,7 +604,7 @@
{
if(!iStrm.good()) return true;
SIZETYPE strSize;
- iStrm.read(reinterpret_cast<char*>(&strSize), sizeof(strSize));
+ Binaryread(iStrm, strSize);
if(strSize > maxSize)
return true;
str.resize(strSize);
@@ -554,3 +613,6 @@
if(iStrm.good()) return false;
else return true;
}
+
+
+} //namespace srlztn.
Modified: trunk/OpenMPT/soundlib/Load_it.cpp
===================================================================
--- trunk/OpenMPT/soundlib/Load_it.cpp 2013-06-21 11:26:46 UTC (rev 2397)
+++ trunk/OpenMPT/soundlib/Load_it.cpp 2013-06-21 14:40:59 UTC (rev 2398)
@@ -102,9 +102,9 @@
for(TNTS_MAP_ITER iter = tNameToShort_Map.begin(); iter != tNameToShort_Map.end(); iter++)
{
if(iter->first)
- StringToBinaryStream<uint8>(oStrm, iter->first->GetName());
+ srlztn::StringToBinaryStream<uint8>(oStrm, iter->first->GetName());
else //Case: Using original IT tuning.
- StringToBinaryStream<uint8>(oStrm, "->MPT_ORIGINAL_IT<-");
+ srlztn::StringToBinaryStream<uint8>(oStrm, "->MPT_ORIGINAL_IT<-");
srlztn::Binarywrite<uint16>(oStrm, iter->second);
}
@@ -143,7 +143,7 @@
{
string temp;
uint16 ui;
- if(StringFromBinaryStream<STRSIZETYPE>(iStrm, temp, 255))
+ if(srlztn::StringFromBinaryStream<STRSIZETYPE>(iStrm, temp, 255))
return true;
iStrm.read(reinterpret_cast<char*>(&ui), sizeof(ui));
Modified: trunk/OpenMPT/soundlib/ModSequence.cpp
===================================================================
--- trunk/OpenMPT/soundlib/ModSequence.cpp 2013-06-21 11:26:46 UTC (rev 2397)
+++ trunk/OpenMPT/soundlib/ModSequence.cpp 2013-06-21 14:40:59 UTC (rev 2398)
@@ -838,9 +838,9 @@
for(uint8 i = 0; i < nSeqs; i++)
{
if (i == seq.GetCurrentSequenceIndex())
- ssb.WriteItem(seq, &i, sizeof(i), &WriteModSequence);
+ ssb.WriteItem(seq, srlztn::IdLE<uint8>(i).GetChars(), sizeof(i), &WriteModSequence);
else
- ssb.WriteItem(seq.m_Sequences[i], &i, sizeof(i), &WriteModSequence);
+ ssb.WriteItem(seq.m_Sequences[i], srlztn::IdLE<uint8>(i).GetChars(), sizeof(i), &WriteModSequence);
}
ssb.FinishWrite();
}
@@ -864,7 +864,9 @@
seq.m_Sequences.resize(nSeqs, ModSequence(seq.m_sndFile, seq.s_nCacheSize));
for(uint8 i = 0; i < nSeqs; i++)
- ssb.ReadItem(seq.m_Sequences[i], &i, sizeof(i), &ReadModSequence);
+ {
+ ssb.ReadItem(seq.m_Sequences[i], srlztn::IdLE<uint8>(i).GetChars(), sizeof(i), &ReadModSequence);
+ }
seq.m_nCurrentSeq = (nCurrent < seq.GetNumSequences()) ? nCurrent : 0;
seq.CopyStorageToCache();
}
Modified: trunk/OpenMPT/soundlib/patternContainer.cpp
===================================================================
--- trunk/OpenMPT/soundlib/patternContainer.cpp 2013-06-21 11:26:46 UTC (rev 2397)
+++ trunk/OpenMPT/soundlib/patternContainer.cpp 2013-06-21 14:40:59 UTC (rev 2398)
@@ -201,7 +201,7 @@
uint16 nCount = 0;
for(uint16 i = 0; i < nPatterns; i++) if (patc[i])
{
- ssb.WriteItem(patc[i], &i, sizeof(i), &WriteModPattern);
+ ssb.WriteItem(patc[i], srlztn::IdLE<uint16>(i).GetChars(), sizeof(i), &WriteModPattern);
nCount = i + 1;
}
ssb.WriteItem<uint16>(nCount, "num"); // Index of last pattern + 1.
@@ -225,7 +225,7 @@
patc.ResizeArray(nPatterns);
for(uint16 i = 0; i < nPatterns; i++)
{
- ssb.ReadItem(patc[i], &i, sizeof(i), &ReadModPattern);
+ ssb.ReadItem(patc[i], srlztn::IdLE<uint16>(i).GetChars(), sizeof(i), &ReadModPattern);
}
}
Modified: trunk/OpenMPT/soundlib/tuning.cpp
===================================================================
--- trunk/OpenMPT/soundlib/tuning.cpp 2013-06-21 11:26:46 UTC (rev 2397)
+++ trunk/OpenMPT/soundlib/tuning.cpp 2013-06-21 14:40:59 UTC (rev 2398)
@@ -27,19 +27,19 @@
namespace CTuningS11n
{
- void ReadStr(srlztn::InStream& iStrm, std::string& str, const size_t);
- void ReadNoteMap(srlztn::InStream& iStrm, CTuningBase::NOTENAMEMAP& m, const size_t);
- void ReadRatioTable(srlztn::InStream& iStrm, vector<CTuningRTI::RATIOTYPE>& v, const size_t);
+ void ReadStr(std::istream& iStrm, std::string& str, const size_t);
+ void ReadNoteMap(std::istream& iStrm, CTuningBase::NOTENAMEMAP& m, const size_t);
+ void ReadRatioTable(std::istream& iStrm, vector<CTuningRTI::RATIOTYPE>& v, const size_t);
- void WriteNoteMap(srlztn::OutStream& oStrm, const CTUNINGBASE::NOTENAMEMAP& m);
- void WriteStr(srlztn::OutStream& oStrm, const std::string& str);
+ void WriteNoteMap(std::ostream& oStrm, const CTUNINGBASE::NOTENAMEMAP& m);
+ void WriteStr(std::ostream& oStrm, const std::string& str);
struct RatioWriter
//================
{
RatioWriter(uint16 nWriteCount = s_nDefaultWriteCount) : m_nWriteCount(nWriteCount) {}
- void operator()(srlztn::OutStream& oStrm, const std::vector<float>& v);
+ void operator()(std::ostream& oStrm, const std::vector<float>& v);
uint16 m_nWriteCount;
static const uint16 s_nDefaultWriteCount = (uint16_max >> 2);
};
@@ -509,7 +509,7 @@
namespace CTuningS11n
{
-void RatioWriter::operator()(srlztn::OutStream& oStrm, const std::vector<float>& v)
+void RatioWriter::operator()(std::ostream& oStrm, const std::vector<float>& v)
//---------------------------------------------------------------------------------
{
const size_t nWriteCount = MIN(v.size(), m_nWriteCount);
@@ -519,7 +519,7 @@
}
-void ReadNoteMap(srlztn::InStream& iStrm, CTuningBase::NOTENAMEMAP& m, const size_t)
+void ReadNoteMap(std::istream& iStrm, CTuningBase::NOTENAMEMAP& m, const size_t)
//----------------------------------------------------------------------------------
{
uint64 val;
@@ -530,13 +530,13 @@
int16 key;
srlztn::Binaryread<int16>(iStrm, key);
std::string str;
- StringFromBinaryStream<uint8>(iStrm, str);
+ srlztn::StringFromBinaryStream<uint8>(iStrm, str);
m[key] = str;
}
}
-void ReadRatioTable(srlztn::InStream& iStrm, vector<CTuningRTI::RATIOTYPE>& v, const size_t)
+void ReadRatioTable(std::istream& iStrm, vector<CTuningRTI::RATIOTYPE>& v, const size_t)
//------------------------------------------------------------------------------------------
{
uint64 val;
@@ -547,7 +547,7 @@
}
-void ReadStr(srlztn::InStream& iStrm, std::string& str, const size_t)
+void ReadStr(std::istream& iStrm, std::string& str, const size_t)
//-------------------------------------------------------------------
{
uint64 val;
@@ -559,7 +559,7 @@
}
-void WriteNoteMap(srlztn::OutStream& oStrm, const CTUNINGBASE::NOTENAMEMAP& m)
+void WriteNoteMap(std::ostream& oStrm, const CTUNINGBASE::NOTENAMEMAP& m)
//---------------------------------------------------------------------------
{
srlztn::WriteAdaptive1248(oStrm, m.size());
@@ -568,12 +568,12 @@
for(; iter != end; iter++)
{
srlztn::Binarywrite<int16>(oStrm, iter->first);
- StringToBinaryStream<uint8>(oStrm, iter->second);
+ srlztn::StringToBinaryStream<uint8>(oStrm, iter->second);
}
}
-void WriteStr(srlztn::OutStream& oStrm, const std::string& str)
+void WriteStr(std::ostream& oStrm, const std::string& str)
//-----------------------------------------------------------------
{
srlztn::WriteAdaptive1248(oStrm, str.size());
Modified: trunk/OpenMPT/soundlib/tuningCollection.cpp
===================================================================
--- trunk/OpenMPT/soundlib/tuningCollection.cpp 2013-06-21 11:26:46 UTC (rev 2397)
+++ trunk/OpenMPT/soundlib/tuningCollection.cpp 2013-06-21 14:40:59 UTC (rev 2398)
@@ -33,15 +33,15 @@
namespace CTuningS11n
{
- void WriteNoteMap(srlztn::OutStream& oStrm, const CTUNINGBASE::NOTENAMEMAP& m);
- void ReadStr(srlztn::InStream& iStrm, std::string& str, const size_t);
+ void WriteNoteMap(std::ostream& oStrm, const CTUNINGBASE::NOTENAMEMAP& m);
+ void ReadStr(std::istream& iStrm, std::string& str, const size_t);
- void ReadNoteMap(srlztn::InStream& iStrm, CTuningBase::NOTENAMEMAP& m, const size_t);
- void ReadRatioTable(srlztn::InStream& iStrm, vector<CTuningRTI::RATIOTYPE>& v, const size_t);
- void WriteStr(srlztn::OutStream& oStrm, const std::string& str);
+ void ReadNoteMap(std::istream& iStrm, CTuningBase::NOTENAMEMAP& m, const size_t);
+ void ReadRatioTable(std::istream& iStrm, vector<CTuningRTI::RATIOTYPE>& v, const size_t);
+ void WriteStr(std::ostream& oStrm, const std::string& str);
void ReadTuning(istream& iStrm, CTuningCollection& Tc, const size_t) {Tc.AddTuning(iStrm, true);}
- void WriteTuning(srlztn::OutStream& oStrm, const CTuning& t) {t.Serialize(oStrm);}
+ void WriteTuning(std::ostream& oStrm, const CTuning& t) {t.Serialize(oStrm);}
} // namespace CTuningS11n
using namespace CTuningS11n;
@@ -215,12 +215,12 @@
//3. Name
if(version < 2)
{
- if(StringFromBinaryStream<uint32>(inStrm, m_Name, 256))
+ if(srlztn::StringFromBinaryStream<uint32>(inStrm, m_Name, 256))
return false;
}
else
{
- if(StringFromBinaryStream<uint8>(inStrm, m_Name))
+ if(srlztn::StringFromBinaryStream<uint8>(inStrm, m_Name))
return false;
}
Modified: trunk/OpenMPT/soundlib/tuningbase.cpp
===================================================================
--- trunk/OpenMPT/soundlib/tuningbase.cpp 2013-06-21 11:26:46 UTC (rev 2397)
+++ trunk/OpenMPT/soundlib/tuningbase.cpp 2013-06-21 14:40:59 UTC (rev 2398)
@@ -438,7 +438,7 @@
if(version != 4) return SERIALIZATION_FAILURE;
//Tuning name
- if(StringFromBinaryStream<uint8>(inStrm, m_TuningName))
+ if(srlztn::StringFromBinaryStream<uint8>(inStrm, m_TuningName))
return SERIALIZATION_FAILURE;
//Const mask
@@ -459,7 +459,7 @@
NOTEINDEXTYPE n;
string str;
inStrm.read(reinterpret_cast<char*>(&n), sizeof(n));
- if(StringFromBinaryStream<uint8>(inStrm, str))
+ if(srlztn::StringFromBinaryStream<uint8>(inStrm, str))
return SERIALIZATION_FAILURE;
m_NoteNameMap[n] = str;
}
This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.
|
