ShuriZma
/
project64
mirror of https://github.com/project64/project64.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Common: Code clean up of common

This commit is contained in:
zilmar 2022-10-03 18:34:42 +10:30
parent 82d9027374
commit 92054583d4
31 changed files with 878 additions and 668 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
Source/Common/CriticalSection.h
View File

@ -3,32 +3,34 @@
class CriticalSection class CriticalSection
{ {
public: public:
CriticalSection(); CriticalSection();
~CriticalSection(void); ~CriticalSection(void);
void enter(void); void enter(void);
void leave(void); void leave(void);
private: private:
CriticalSection(const CriticalSection&); CriticalSection(const CriticalSection &);
CriticalSection& operator=(const CriticalSection&); CriticalSection & operator=(const CriticalSection &);
void * m_cs; void * m_cs;
}; };
class CGuard class CGuard
{ {
public: public:
CGuard(CriticalSection& sectionName) : m_cs(sectionName) CGuard(CriticalSection & sectionName) :
{ m_cs(sectionName)
m_cs.enter(); {
} m_cs.enter();
~CGuard() }
{ ~CGuard()
m_cs.leave(); {
} m_cs.leave();
}
private: private:
CriticalSection& m_cs; CriticalSection & m_cs;
CGuard(const CGuard& copy); CGuard(const CGuard & copy);
CGuard &operator=(const CGuard& rhs); CGuard & operator=(const CGuard & rhs);
}; };

4
Source/Common/DateTime.h
View File

@ -6,8 +6,8 @@ class CDateTime
{ {
public: public:
CDateTime(); CDateTime();
CDateTime & SetToNow (void); CDateTime & SetToNow(void);
std::string Format (const char * format); std::string Format(const char * format);
private: private:
time_t m_time; time_t m_time;

5
Source/Common/DynamicLibrary.cpp
View File

@ -2,12 +2,12 @@
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>
#else #else
#include <unistd.h>
#include <dlfcn.h> #include <dlfcn.h>
#include <errno.h> #include <errno.h>
#include <unistd.h>
#endif #endif
DynLibHandle DynamicLibraryOpen(const char *pccLibraryPath, bool ShowErrors) DynLibHandle DynamicLibraryOpen(const char * pccLibraryPath, bool ShowErrors)
{ {
if (pccLibraryPath == nullptr) if (pccLibraryPath == nullptr)
{ {
@ -48,4 +48,3 @@ void * DynamicLibraryGetProc(DynLibHandle Lib, const char * ProcedureName)
return dlsym(Lib, ProcedureName); return dlsym(Lib, ProcedureName);
#endif #endif
} }

31
Source/Common/File.cpp
View File

@ -13,7 +13,7 @@
#if defined(_MSC_VER) #if defined(_MSC_VER)
#include <crtdbg.h> #include <crtdbg.h>
#else #else
#define _ASSERTE(expr) ((void)0) #define _ASSERTE(expr) ((void)0)
#endif #endif
CFile::CFile() : CFile::CFile() :
@ -95,9 +95,18 @@ bool CFile::Open(const char * lpszFileName, uint32_t nOpenFlags)
ULONG dwShareMode = 0; ULONG dwShareMode = 0;
dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE; dwShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
if ((nOpenFlags & shareDenyWrite) == shareDenyWrite) { dwShareMode &= ~FILE_SHARE_WRITE; } if ((nOpenFlags & shareDenyWrite) == shareDenyWrite)
if ((nOpenFlags & shareDenyRead) == shareDenyRead) { dwShareMode &= ~FILE_SHARE_READ; } {
if ((nOpenFlags & shareExclusive) == shareExclusive) { dwShareMode = 0; } dwShareMode &= ~FILE_SHARE_WRITE;
}
if ((nOpenFlags & shareDenyRead) == shareDenyRead)
{
dwShareMode &= ~FILE_SHARE_READ;
}
if ((nOpenFlags & shareExclusive) == shareExclusive)
{
dwShareMode = 0;
}
// Map modeNoInherit flag // Map modeNoInherit flag
SECURITY_ATTRIBUTES sa; SECURITY_ATTRIBUTES sa;
@ -138,7 +147,7 @@ bool CFile::Open(const char * lpszFileName, uint32_t nOpenFlags)
CPath file(lpszFileName); CPath file(lpszFileName);
if (!file.Exists()) if (!file.Exists())
{ {
FILE * fp = fopen(lpszFileName,"wb"); FILE * fp = fopen(lpszFileName, "wb");
if (fp) if (fp)
{ {
fclose(fp); fclose(fp);
@ -231,11 +240,11 @@ bool CFile::Flush()
#endif #endif
} }
bool CFile::Write(const void* lpBuf, uint32_t nCount) bool CFile::Write(const void * lpBuf, uint32_t nCount)
{ {
if (nCount == 0) if (nCount == 0)
{ {
return true; // Avoid Win32 "null-write" option return true; // Avoid Win32 "null-write" option
} }
#ifdef USE_WINDOWS_API #ifdef USE_WINDOWS_API
@ -259,11 +268,11 @@ bool CFile::Write(const void* lpBuf, uint32_t nCount)
return true; return true;
} }
uint32_t CFile::Read(void* lpBuf, uint32_t nCount) uint32_t CFile::Read(void * lpBuf, uint32_t nCount)
{ {
if (nCount == 0) if (nCount == 0)
{ {
return 0; // Avoid Win32 "null-read" return 0; // Avoid Win32 "null-read"
} }
#ifdef USE_WINDOWS_API #ifdef USE_WINDOWS_API
@ -345,9 +354,9 @@ bool CFile::SetEndOfFile()
#else #else
Flush(); Flush();
#ifdef _WIN32 #ifdef _WIN32
return _chsize(_fileno((FILE *)m_hFile),GetPosition()) == 0; return _chsize(_fileno((FILE *)m_hFile), GetPosition()) == 0;
#else #else
return ftruncate(fileno((FILE *)m_hFile),GetPosition()) == 0; return ftruncate(fileno((FILE *)m_hFile), GetPosition()) == 0;
#endif #endif
#endif #endif
} }

30
Source/Common/File.h
View File

@ -20,21 +20,21 @@ public:
}; };
enum SeekPosition enum SeekPosition
{ {
begin = 0x0, begin = 0x0,
current = 0x1, current = 0x1,
end = 0x2 end = 0x2
}; };
virtual bool Open(const char * lpszFileName, uint32_t nOpenFlags ) = 0; virtual bool Open(const char * lpszFileName, uint32_t nOpenFlags) = 0;
virtual uint32_t GetPosition() const = 0; virtual uint32_t GetPosition() const = 0;
virtual int32_t Seek(int32_t lOff, SeekPosition nFrom) = 0; virtual int32_t Seek(int32_t lOff, SeekPosition nFrom) = 0;
virtual bool SetLength(uint32_t dwNewLen) = 0; virtual bool SetLength(uint32_t dwNewLen) = 0;
virtual uint32_t GetLength() const = 0; virtual uint32_t GetLength() const = 0;
virtual uint32_t Read(void* lpBuf, uint32_t nCount) = 0; virtual uint32_t Read(void * lpBuf, uint32_t nCount) = 0;
virtual bool Write(const void* lpBuf, uint32_t nCount) = 0; virtual bool Write(const void * lpBuf, uint32_t nCount) = 0;
virtual bool Flush() = 0; virtual bool Flush() = 0;
virtual bool Close() = 0; virtual bool Close() = 0;
@ -51,18 +51,18 @@ public:
virtual ~CFile(); virtual ~CFile();
virtual bool Open(const char * lpszFileName, uint32_t nOpenFlags ); virtual bool Open(const char * lpszFileName, uint32_t nOpenFlags);
uint32_t SeekToEnd ( void ); uint32_t SeekToEnd(void);
void SeekToBegin ( void ); void SeekToBegin(void);
virtual uint32_t GetPosition() const; virtual uint32_t GetPosition() const;
virtual int32_t Seek(int32_t lOff, SeekPosition nFrom); virtual int32_t Seek(int32_t lOff, SeekPosition nFrom);
virtual bool SetLength(uint32_t dwNewLen); virtual bool SetLength(uint32_t dwNewLen);
virtual uint32_t GetLength() const; virtual uint32_t GetLength() const;
virtual uint32_t Read(void* lpBuf, uint32_t nCount); virtual uint32_t Read(void * lpBuf, uint32_t nCount);
virtual bool Write(const void* lpBuf, uint32_t nCount); virtual bool Write(const void * lpBuf, uint32_t nCount);
virtual bool Flush(); virtual bool Flush();
virtual bool Close(); virtual bool Close();
@ -70,8 +70,8 @@ public:
virtual bool SetEndOfFile(); virtual bool SetEndOfFile();
private: private:
CFile(const CFile&); CFile(const CFile &);
CFile& operator=(const CFile&); CFile & operator=(const CFile &);
void * m_hFile; void * m_hFile;
bool m_bCloseOnDelete; bool m_bCloseOnDelete;

4
Source/Common/HighResTimeStamp.cpp
View File

@ -1,7 +1,7 @@
#include "HighResTimeStamp.h" #include "HighResTimeStamp.h"
#include <time.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <time.h>
#ifdef _WIN32 #ifdef _WIN32
#include <Windows.h> #include <Windows.h>
#else #else
@ -10,7 +10,7 @@
#ifdef _WIN32 #ifdef _WIN32
bool HighResTimeStamp::m_GotFreq = false; bool HighResTimeStamp::m_GotFreq = false;
uint64_t HighResTimeStamp::m_Freq = { 0 }; uint64_t HighResTimeStamp::m_Freq = {0};
#endif #endif
HighResTimeStamp::HighResTimeStamp() HighResTimeStamp::HighResTimeStamp()

2
Source/Common/HighResTimeStamp.h
View File

@ -5,7 +5,7 @@ class HighResTimeStamp
{ {
public: public:
HighResTimeStamp(); HighResTimeStamp();
HighResTimeStamp & SetToNow (void); HighResTimeStamp & SetToNow(void);
uint64_t GetMicroSeconds(void); uint64_t GetMicroSeconds(void);
void SetMicroSeconds(uint64_t MicroSeconds); void SetMicroSeconds(uint64_t MicroSeconds);

136
Source/Common/IniFile.cpp
View File

@ -1,7 +1,7 @@
#include "IniFile.h" #include "IniFile.h"
#include "StdString.h" #include "StdString.h"
#include <stdlib.h>
#include <stdarg.h> #include <stdarg.h>
#include <stdlib.h>
CIniFileBase::CIniFileBase(CFileBase & FileObject, const char * FileName) : CIniFileBase::CIniFileBase(CFileBase & FileObject, const char * FileName) :
m_lastSectionSearch(0), m_lastSectionSearch(0),
@ -23,7 +23,10 @@ CIniFileBase::~CIniFileBase(void)
void CIniFileBase::fInsertSpaces(int Pos, int NoOfSpaces) void CIniFileBase::fInsertSpaces(int Pos, int NoOfSpaces)
{ {
enum { fIS_MvSize = 0x2000 }; enum
{
fIS_MvSize = 0x2000
};
unsigned char Data[fIS_MvSize + 1]; unsigned char Data[fIS_MvSize + 1];
int SizeToRead, result; int SizeToRead, result;
@ -39,7 +42,10 @@ void CIniFileBase::fInsertSpaces(int Pos, int NoOfSpaces)
do do
{ {
SizeToRead = end - Pos; SizeToRead = end - Pos;
if (SizeToRead > fIS_MvSize) { SizeToRead = fIS_MvSize; } if (SizeToRead > fIS_MvSize)
{
SizeToRead = fIS_MvSize;
}
if (SizeToRead > 0) if (SizeToRead > 0)
{ {
m_File.Seek(SizeToRead * -1, CFileBase::current); m_File.Seek(SizeToRead * -1, CFileBase::current);
@ -63,7 +69,10 @@ void CIniFileBase::fInsertSpaces(int Pos, int NoOfSpaces)
do do
{ {
SizeToRead = end - ReadPos; SizeToRead = end - ReadPos;
if (SizeToRead > fIS_MvSize) { SizeToRead = fIS_MvSize; } if (SizeToRead > fIS_MvSize)
{
SizeToRead = fIS_MvSize;
}
m_File.Seek(ReadPos, CFileBase::begin); m_File.Seek(ReadPos, CFileBase::begin);
m_File.Read(Data, SizeToRead); m_File.Read(Data, SizeToRead);
m_File.Seek(WritePos, CFileBase::begin); m_File.Seek(WritePos, CFileBase::begin);
@ -82,9 +91,12 @@ void CIniFileBase::fInsertSpaces(int Pos, int NoOfSpaces)
} }
} }
int CIniFileBase::GetStringFromFile(char * & String, std::unique_ptr<char> &Data, int & MaxDataSize, int & DataSize, int & ReadPos) int CIniFileBase::GetStringFromFile(char *& String, std::unique_ptr<char> & Data, int & MaxDataSize, int & DataSize, int & ReadPos)
{ {
enum { BufferIncrease = 0x2000 }; enum
{
BufferIncrease = 0x2000
};
if (MaxDataSize == 0) if (MaxDataSize == 0)
{ {
ReadPos = 0; ReadPos = 0;
@ -209,7 +221,7 @@ void CIniFileBase::SaveCurrentSection(void)
int MaxDataSize = 0, DataSize = 0, ReadPos = 0, result; int MaxDataSize = 0, DataSize = 0, ReadPos = 0, result;
std::unique_ptr<char> Data; std::unique_ptr<char> Data;
char *Input = nullptr; char * Input = nullptr;
// Skip first line as it is the section name // Skip first line as it is the section name
int StartPos = m_CurrentSectionFilePos; int StartPos = m_CurrentSectionFilePos;
@ -217,7 +229,10 @@ void CIniFileBase::SaveCurrentSection(void)
do do
{ {
result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos); result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos);
if (result <= 1) { continue; } if (result <= 1)
{
continue;
}
if (strlen(CleanLine(Input)) <= 1 || Input[0] != '[') if (strlen(CleanLine(Input)) <= 1 || Input[0] != '[')
{ {
EndPos = (long)((m_File.GetPosition() - DataSize) + ReadPos); EndPos = (long)((m_File.GetPosition() - DataSize) + ReadPos);
@ -298,7 +313,7 @@ bool CIniFileBase::MoveToSectionNameData(const char * lpSectionName, bool Change
} }
std::unique_ptr<char> Data; std::unique_ptr<char> Data;
char *Input = nullptr; char * Input = nullptr;
int MaxDataSize = 0, DataSize = 0, ReadPos = 0, result; int MaxDataSize = 0, DataSize = 0, ReadPos = 0, result;
FILELOC_ITR iter = m_SectionsPos.find(std::string(lpSectionName)); FILELOC_ITR iter = m_SectionsPos.find(std::string(lpSectionName));
@ -326,8 +341,14 @@ bool CIniFileBase::MoveToSectionNameData(const char * lpSectionName, bool Change
do do
{ {
result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos); result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos);
if (result <= 1) { continue; } if (result <= 1)
if (strlen(CleanLine(Input)) <= 1) { continue; } {
continue;
}
if (strlen(CleanLine(Input)) <= 1)
{
continue;
}
// We only care about sections // We only care about sections
char * CurrentSection = Input; char * CurrentSection = Input;
@ -337,9 +358,15 @@ bool CIniFileBase::MoveToSectionNameData(const char * lpSectionName, bool Change
CurrentSection += 3; CurrentSection += 3;
} }
if (CurrentSection[0] != '[') { continue; } if (CurrentSection[0] != '[')
{
continue;
}
int lineEndPos = (int)strlen(CurrentSection) - 1; int lineEndPos = (int)strlen(CurrentSection) - 1;
if (CurrentSection[lineEndPos] != ']') { continue; } if (CurrentSection[lineEndPos] != ']')
{
continue;
}
// Take off the ']' from the end of the string // Take off the ']' from the end of the string
CurrentSection[lineEndPos] = 0; CurrentSection[lineEndPos] = 0;
CurrentSection += 1; CurrentSection += 1;
@ -383,11 +410,23 @@ bool CIniFileBase::MoveToSectionNameData(const char * lpSectionName, bool Change
do do
{ {
result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos); result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos);
if (result <= 1) { continue; } if (result <= 1)
if (strlen(CleanLine(Input)) <= 1) { continue; } {
if (Input[0] == '[') { break; } continue;
}
if (strlen(CleanLine(Input)) <= 1)
{
continue;
}
if (Input[0] == '[')
{
break;
}
char * Pos = strchr(Input, '='); char * Pos = strchr(Input, '=');
if (Pos == nullptr) { continue; } if (Pos == nullptr)
{
continue;
}
char * Value = &Pos[1]; char * Value = &Pos[1];
char * Pos1 = Pos - 1; char * Pos1 = Pos - 1;
@ -442,7 +481,10 @@ const char * CIniFileBase::CleanLine(char * Line)
// Strip any spaces or line feeds from the end of the line // Strip any spaces or line feeds from the end of the line
for (int count = (int)strlen(&Line[0]) - 1; count >= 0; count--) for (int count = (int)strlen(&Line[0]) - 1; count >= 0; count--)
{ {
if (Line[count] != ' ' && Line[count] != '\r') { break; } if (Line[count] != ' ' && Line[count] != '\r')
{
break;
}
Line[count] = 0; Line[count] = 0;
} }
return Line; return Line;
@ -502,7 +544,10 @@ bool CIniFileBase::DeleteSection(const char * lpSectionName)
{ {
CGuard Guard(m_CS); CGuard Guard(m_CS);
if (!m_File.IsOpen()) { return false; } if (!m_File.IsOpen())
{
return false;
}
SaveCurrentSection(); SaveCurrentSection();
if (!MoveToSectionNameData(lpSectionName, true)) if (!MoveToSectionNameData(lpSectionName, true))
@ -515,13 +560,19 @@ bool CIniFileBase::DeleteSection(const char * lpSectionName)
{ {
int MaxDataSize = 0, DataSize = 0, ReadPos = 0, NextLine = 0, result; int MaxDataSize = 0, DataSize = 0, ReadPos = 0, NextLine = 0, result;
std::unique_ptr <char> Data; std::unique_ptr<char> Data;
char *Input = nullptr; char * Input = nullptr;
do do
{ {
result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos); result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos);
if (result <= 1) { continue; } if (result <= 1)
if (strlen(CleanLine(Input)) <= 1) { continue; } {
continue;
}
if (strlen(CleanLine(Input)) <= 1)
{
continue;
}
if (Input[0] != '[') if (Input[0] != '[')
{ {
@ -540,13 +591,19 @@ bool CIniFileBase::DeleteSection(const char * lpSectionName)
long ReadPos = NextSectionStart; long ReadPos = NextSectionStart;
long WritePos = DeleteSectionStart; long WritePos = DeleteSectionStart;
enum { fIS_MvSize = 0x2000 }; enum
{
fIS_MvSize = 0x2000
};
unsigned char Data[fIS_MvSize + 1]; unsigned char Data[fIS_MvSize + 1];
int SizeToRead; int SizeToRead;
do do
{ {
SizeToRead = end - ReadPos; SizeToRead = end - ReadPos;
if (SizeToRead > fIS_MvSize) { SizeToRead = fIS_MvSize; } if (SizeToRead > fIS_MvSize)
{
SizeToRead = fIS_MvSize;
}
m_File.Seek(ReadPos, CFileBase::begin); m_File.Seek(ReadPos, CFileBase::begin);
m_File.Read(Data, SizeToRead); m_File.Read(Data, SizeToRead);
m_File.Seek(WritePos, CFileBase::begin); m_File.Seek(WritePos, CFileBase::begin);
@ -774,7 +831,7 @@ void CIniFileBase::SetAutoFlush(bool AutoFlush)
} }
} }
void CIniFileBase::GetKeyList(const char * lpSectionName, strlist &List) void CIniFileBase::GetKeyList(const char * lpSectionName, strlist & List)
{ {
List.clear(); List.clear();
@ -817,19 +874,34 @@ void CIniFileBase::GetKeyValueData(const char * lpSectionName, KeyValueData & Li
strSection = lpSectionName; strSection = lpSectionName;
} }
if (!MoveToSectionNameData(strSection.c_str(), false)) { return; } if (!MoveToSectionNameData(strSection.c_str(), false))
{
return;
}
int MaxDataSize = 0, DataSize = 0, ReadPos = 0, result; int MaxDataSize = 0, DataSize = 0, ReadPos = 0, result;
std::unique_ptr<char> Data; std::unique_ptr<char> Data;
char *Input = nullptr; char * Input = nullptr;
do do
{ {
result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos); result = GetStringFromFile(Input, Data, MaxDataSize, DataSize, ReadPos);
if (result <= 1) { continue; } if (result <= 1)
if (strlen(CleanLine(Input)) <= 1) { continue; } {
if (Input[0] == '[') { break; } continue;
}
if (strlen(CleanLine(Input)) <= 1)
{
continue;
}
if (Input[0] == '[')
{
break;
}
char * Pos = strchr(Input, '='); char * Pos = strchr(Input, '=');
if (Pos == nullptr) { continue; } if (Pos == nullptr)
{
continue;
}
Pos[0] = 0; Pos[0] = 0;
List.insert(KeyValueData::value_type(stdstr(Input).Trim(), &Pos[1])); List.insert(KeyValueData::value_type(stdstr(Input).Trim(), &Pos[1]));

27
Source/Common/IniFile.h
View File

@ -4,15 +4,15 @@
#include <strings.h> #include <strings.h>
#endif #endif
#include "Platform.h"
#include "File.h"
#include "CriticalSection.h" #include "CriticalSection.h"
#include <string> #include "File.h"
#include <map> #include "Platform.h"
#include <vector>
#include <list> #include <list>
#include <set> #include <map>
#include <memory> #include <memory>
#include <set>
#include <string>
#include <vector>
class CIniFileBase class CIniFileBase
{ {
@ -22,7 +22,7 @@ public:
typedef std::list<std::string> strlist; typedef std::list<std::string> strlist;
typedef std::pair<const std::string *, const std::string *> KeyValueItem; typedef std::pair<const std::string *, const std::string *> KeyValueItem;
typedef std::vector<KeyValueItem> KeyValueVector; typedef std::vector<KeyValueItem> KeyValueVector;
typedef void(*SortData)(KeyValueVector &); typedef void (*SortData)(KeyValueVector &);
CIniFileBase(CFileBase & FileObject, const char * FileName); CIniFileBase(CFileBase & FileObject, const char * FileName);
virtual ~CIniFileBase(void); virtual ~CIniFileBase(void);
@ -42,12 +42,15 @@ public:
void SetAutoFlush(bool AutoFlush); void SetAutoFlush(bool AutoFlush);
void FlushChanges(void); void FlushChanges(void);
bool EntryExists(const char * lpSectionName, const char * lpKeyName); bool EntryExists(const char * lpSectionName, const char * lpKeyName);
void GetKeyList(const char * lpSectionName, strlist &List); void GetKeyList(const char * lpSectionName, strlist & List);
void GetKeyValueData(const char * lpSectionName, KeyValueData & List); void GetKeyValueData(const char * lpSectionName, KeyValueData & List);
void SetCustomSort(SortData SortFunction); void SetCustomSort(SortData SortFunction);
void GetVectorOfSections(SectionList & sections); void GetVectorOfSections(SectionList & sections);
const std::string &GetFileName() { return m_FileName; } const std::string & GetFileName()
{
return m_FileName;
}
protected: protected:
void OpenIniFileReadOnly(); void OpenIniFileReadOnly();
@ -62,7 +65,7 @@ protected:
private: private:
struct insensitive_compare struct insensitive_compare
{ {
bool operator() (const std::string & a, const std::string & b) const bool operator()(const std::string & a, const std::string & b) const
{ {
return _stricmp(a.c_str(), b.c_str()) < 0; return _stricmp(a.c_str(), b.c_str()) < 0;
} }
@ -88,7 +91,7 @@ private:
SortData m_SortFunction; SortData m_SortFunction;
void fInsertSpaces(int Pos, int NoOfSpaces); void fInsertSpaces(int Pos, int NoOfSpaces);
int GetStringFromFile(char * & String, std::unique_ptr<char> &Data, int & MaxDataSize, int & DataSize, int & ReadPos); int GetStringFromFile(char *& String, std::unique_ptr<char> & Data, int & MaxDataSize, int & DataSize, int & ReadPos);
bool MoveToSectionNameData(const char * lpSectionName, bool ChangeCurrentSection); bool MoveToSectionNameData(const char * lpSectionName, bool ChangeCurrentSection);
const char * CleanLine(char * Line); const char * CleanLine(char * Line);
void ClearSectionPosList(long FilePos); void ClearSectionPosList(long FilePos);
@ -125,7 +128,7 @@ public:
} }
protected: protected:
CFileStorage m_FileObject; CFileStorage m_FileObject;
}; };
typedef CIniFileT<CFile> CIniFile; typedef CIniFileT<CFile> CIniFile;

268
Source/Common/Log.cpp
View File

@ -1,178 +1,196 @@
#include "Log.h" #include "Log.h"
#include "path.h"
#include "Platform.h" #include "Platform.h"
#include <stdio.h> #include "path.h"
#include <stdarg.h> #include <stdarg.h>
#include <stdio.h>
CLog::CLog (void ) : CLog::CLog(void) :
m_FlushOnWrite(false), m_FlushOnWrite(false),
m_TruncateFileLog(true), m_TruncateFileLog(true),
m_MaxFileSize(MAX_FILE_SIZE), m_MaxFileSize(MAX_FILE_SIZE),
m_FileChangeSize(0), m_FileChangeSize(0),
m_FileSize(0) m_FileSize(0)
{ {
} }
CLog::~CLog (void) CLog::~CLog(void)
{ {
} }
bool CLog::Open( const char * FileName, LOG_OPEN_MODE mode /* = Log_New */) bool CLog::Open(const char * FileName, LOG_OPEN_MODE mode /* = Log_New */)
{ {
if (FileName == nullptr) if (FileName == nullptr)
{ {
return false; return false;
} }
CPath File(FileName); CPath File(FileName);
if (m_hLogFile.IsOpen()) if (m_hLogFile.IsOpen())
{ {
m_hLogFile.Close(); m_hLogFile.Close();
} }
uint32_t nOpenFlags = CFile::modeReadWrite | CFile::modeCreate; uint32_t nOpenFlags = CFile::modeReadWrite | CFile::modeCreate;
if (mode == Log_Append) { nOpenFlags |= CFile::modeNoTruncate; } if (mode == Log_Append)
{
nOpenFlags |= CFile::modeNoTruncate;
}
if (!m_hLogFile.Open(File, nOpenFlags)) if (!m_hLogFile.Open(File, nOpenFlags))
{ {
return false; return false;
} }
m_FileName = (const char *)File; m_FileName = (const char *)File;
m_hLogFile.Seek(0,mode == Log_Append ? CFile::end : CFile::begin); m_hLogFile.Seek(0, mode == Log_Append ? CFile::end : CFile::begin);
m_FileSize = mode == Log_Append ? (uint32_t)m_hLogFile.GetLength() : 0; m_FileSize = mode == Log_Append ? (uint32_t)m_hLogFile.GetLength() : 0;
return true; return true;
} }
void CLog::Close ( void ) void CLog::Close(void)
{ {
if (m_hLogFile.IsOpen()) if (m_hLogFile.IsOpen())
{ {
m_hLogFile.Close(); m_hLogFile.Close();
} }
} }
void CLog::LogF(const char * Message, ...) void CLog::LogF(const char * Message, ...)
{ {
va_list ap; va_list ap;
va_start( ap, Message ); va_start(ap, Message);
LogArgs(Message,ap); LogArgs(Message, ap);
va_end( ap ); va_end(ap);
} }
void CLog::LogArgs(const char * Message, va_list & args ) void CLog::LogArgs(const char * Message, va_list & args)
{ {
if (!m_hLogFile.IsOpen()) { return; } if (!m_hLogFile.IsOpen())
{
return;
}
try try
{ {
size_t nlen = _vscprintf(Message, args) + 1; size_t nlen = _vscprintf(Message, args) + 1;
char * Msg = (char *)alloca(nlen * sizeof(char)); char * Msg = (char *)alloca(nlen * sizeof(char));
Msg[nlen - 1] = 0; Msg[nlen - 1] = 0;
if (Msg != nullptr) if (Msg != nullptr)
{ {
vsprintf(Msg, Message, args); vsprintf(Msg, Message, args);
Log(Msg); Log(Msg);
} }
} }
catch(...) catch (...)
{ {
Log("Invalid message format"); Log("Invalid message format");
} }
} }
void CLog::Log( const char * Message ) void CLog::Log(const char * Message)
{ {
if (!m_hLogFile.IsOpen()) { return; } if (!m_hLogFile.IsOpen())
{
return;
}
uint32_t message_len = (uint32_t)strlen(Message); uint32_t message_len = (uint32_t)strlen(Message);
m_hLogFile.Write(Message, message_len); m_hLogFile.Write(Message, message_len);
if (m_FlushOnWrite) if (m_FlushOnWrite)
{ {
m_hLogFile.Flush(); m_hLogFile.Flush();
} }
m_FileSize += message_len; m_FileSize += message_len;
if (m_TruncateFileLog && m_FileSize > m_MaxFileSize) if (m_TruncateFileLog && m_FileSize > m_MaxFileSize)
{ {
// Check file size // Check file size
m_FileSize = (uint32_t)m_hLogFile.GetLength(); m_FileSize = (uint32_t)m_hLogFile.GetLength();
// If larger then maximum size then // If larger then maximum size then
if (m_FileSize > m_MaxFileSize) if (m_FileSize > m_MaxFileSize)
{ {
if (!m_FlushOnWrite) if (!m_FlushOnWrite)
{ {
m_hLogFile.Flush(); m_hLogFile.Flush();
m_FileSize = (uint32_t)m_hLogFile.GetLength(); m_FileSize = (uint32_t)m_hLogFile.GetLength();
} }
uint32_t end = (uint32_t)m_hLogFile.SeekToEnd(); uint32_t end = (uint32_t)m_hLogFile.SeekToEnd();
// Move to reduce size // Move to reduce size
m_hLogFile.Seek((end - m_MaxFileSize) + m_FileChangeSize,CFile::begin); m_hLogFile.Seek((end - m_MaxFileSize) + m_FileChangeSize, CFile::begin);
// Find next end of line // Find next end of line
uint32_t NextEnter = 0, dwRead = 0; uint32_t NextEnter = 0, dwRead = 0;
do do
{ {
uint8_t Data[300]; uint8_t Data[300];
dwRead = m_hLogFile.Read(Data,sizeof(Data)); dwRead = m_hLogFile.Read(Data, sizeof(Data));
if (dwRead == 0) if (dwRead == 0)
{ {
break; break;
} }
for (int i = 0; i < sizeof(Data); i++) for (int i = 0; i < sizeof(Data); i++)
{ {
if (Data[i] == '\n') if (Data[i] == '\n')
{ {
NextEnter += (i + 1); NextEnter += (i + 1);
dwRead = 0; dwRead = 0;
break; break;
} }
} }
NextEnter += dwRead; NextEnter += dwRead;
} while(dwRead != 0); } while (dwRead != 0);
// Copy content of log to the new file // Copy content of log to the new file
uint32_t ReadPos = (end - m_MaxFileSize) + m_FileChangeSize + NextEnter; uint32_t ReadPos = (end - m_MaxFileSize) + m_FileChangeSize + NextEnter;
uint32_t SizeToRead, WritePos = 0; uint32_t SizeToRead, WritePos = 0;
do do
{ {
enum { fIS_MvSize = 0x5000 }; enum
unsigned char Data[fIS_MvSize + 1]; {
fIS_MvSize = 0x5000
};
unsigned char Data[fIS_MvSize + 1];
SizeToRead = end - ReadPos; SizeToRead = end - ReadPos;
if (SizeToRead > fIS_MvSize) { SizeToRead = fIS_MvSize; } if (SizeToRead > fIS_MvSize)
{
SizeToRead = fIS_MvSize;
}
m_hLogFile.Seek(ReadPos,CFile::begin); m_hLogFile.Seek(ReadPos, CFile::begin);
dwRead = m_hLogFile.Read(Data,SizeToRead); dwRead = m_hLogFile.Read(Data, SizeToRead);
m_hLogFile.Seek(WritePos,CFile::begin); m_hLogFile.Seek(WritePos, CFile::begin);
if (!m_hLogFile.Write(Data,dwRead)) if (!m_hLogFile.Write(Data, dwRead))
{ {
//BreakPoint(__FILE__,__LINE__); //BreakPoint(__FILE__,__LINE__);
break; break;
} }
ReadPos += dwRead; ReadPos += dwRead;
WritePos += dwRead; WritePos += dwRead;
} while (SizeToRead > 0); } while (SizeToRead > 0);
// Clean up // Clean up
m_hLogFile.SetEndOfFile(); m_hLogFile.SetEndOfFile();
m_hLogFile.Flush(); m_hLogFile.Flush();
m_FileSize = (uint32_t)m_hLogFile.GetLength(); m_FileSize = (uint32_t)m_hLogFile.GetLength();
} // end if } // end if
} }
} }
bool CLog::Empty(void) bool CLog::Empty(void)
{ {
if (!m_hLogFile.IsOpen()) { return true; } if (!m_hLogFile.IsOpen())
if (m_hLogFile.GetLength() == 0) {
{ return true;
return true; }
} if (m_hLogFile.GetLength() == 0)
return false; {
return true;
}
return false;
} }

44
Source/Common/Log.h
View File

@ -1,18 +1,25 @@
#pragma once #pragma once
#include "File.h"
#include <stdarg.h> #include <stdarg.h>
#include <string> #include <string>
#include "File.h"
class CLog class CLog
{ {
public: public:
enum LOG_OPEN_MODE enum LOG_OPEN_MODE
{ {
Log_New, Log_Append Log_New,
Log_Append
}; };
enum { MB = 1024 * 1024 }; enum
enum { MAX_FILE_SIZE = 10 * MB }; {
MB = 1024 * 1024
};
enum
{
MAX_FILE_SIZE = 10 * MB
};
CLog(void); CLog(void);
~CLog(void); ~CLog(void);
@ -29,15 +36,30 @@ public:
m_MaxFileSize = Size; m_MaxFileSize = Size;
m_FileChangeSize = (uint32_t)(Size * 0.1); m_FileChangeSize = (uint32_t)(Size * 0.1);
} }
inline void SetTruncateFile(bool Truncate) { m_TruncateFileLog = Truncate; } inline void SetTruncateFile(bool Truncate)
inline void SetFlush(bool Always) { m_FlushOnWrite = Always; } {
inline bool IsOpen(void) const { return m_hLogFile.IsOpen(); } m_TruncateFileLog = Truncate;
inline bool Flush(void) { return m_hLogFile.Flush(); } }
inline const std::string & FileName(void) const { return m_FileName; } inline void SetFlush(bool Always)
{
m_FlushOnWrite = Always;
}
inline bool IsOpen(void) const
{
return m_hLogFile.IsOpen();
}
inline bool Flush(void)
{
return m_hLogFile.Flush();
}
inline const std::string & FileName(void) const
{
return m_FileName;
}
private: private:
CLog(const CLog&); CLog(const CLog &);
CLog& operator=(const CLog&); CLog & operator=(const CLog &);
CFile m_hLogFile; CFile m_hLogFile;
bool m_FlushOnWrite; bool m_FlushOnWrite;

26
Source/Common/MemTest.cpp
View File

@ -38,7 +38,7 @@ private:
uint32_t m_NextOrder; uint32_t m_NextOrder;
}; };
CMemList *MemList(void) CMemList * MemList(void)
{ {
static CMemList m_MemList; static CMemList m_MemList;
@ -118,8 +118,8 @@ void CMemList::removeItem(void * ptr)
void CMemList::DumpItems(void) void CMemList::DumpItems(void)
{ {
char path_buffer[_MAX_PATH] = { 0 }, drive[_MAX_DRIVE] = { 0 }, dir[_MAX_DIR] = { 0 }; char path_buffer[_MAX_PATH] = {0}, drive[_MAX_DRIVE] = {0}, dir[_MAX_DIR] = {0};
char fname[_MAX_FNAME] = { 0 }, ext[_MAX_EXT] = { 0 }, LogFileName[_MAX_PATH] = { 0 }; char fname[_MAX_FNAME] = {0}, ext[_MAX_EXT] = {0}, LogFileName[_MAX_PATH] = {0};
GetModuleFileNameA(m_hModule, path_buffer, sizeof(path_buffer)); GetModuleFileNameA(m_hModule, path_buffer, sizeof(path_buffer));
_splitpath(path_buffer, drive, dir, fname, ext); _splitpath(path_buffer, drive, dir, fname, ext);
@ -128,7 +128,7 @@ void CMemList::DumpItems(void)
HANDLE hLogFile = INVALID_HANDLE_VALUE; HANDLE hLogFile = INVALID_HANDLE_VALUE;
do do
{ {
hLogFile = CreateFileA( LogFileName, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, nullptr ); hLogFile = CreateFileA(LogFileName, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, nullptr, CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, nullptr);
if (hLogFile == INVALID_HANDLE_VALUE) if (hLogFile == INVALID_HANDLE_VALUE)
{ {
if (GetLastError() == ERROR_SHARING_VIOLATION) if (GetLastError() == ERROR_SHARING_VIOLATION)
@ -149,7 +149,7 @@ void CMemList::DumpItems(void)
SetFilePointer(hLogFile, 0, nullptr, FILE_BEGIN); SetFilePointer(hLogFile, 0, nullptr, FILE_BEGIN);
DWORD dwWritten = 0; DWORD dwWritten = 0;
char Msg[800]; char Msg[800];
_snprintf(Msg, sizeof(Msg), "Order, Source File, Line Number, Mem Size\r\n"); _snprintf(Msg, sizeof(Msg), "Order, Source File, Line Number, Mem Size\r\n");
WriteFile(hLogFile, Msg, (DWORD)strlen(Msg), &dwWritten, nullptr); WriteFile(hLogFile, Msg, (DWORD)strlen(Msg), &dwWritten, nullptr);
@ -169,7 +169,7 @@ void CMemList::DumpItems(void)
} }
} }
void* AllocateMemory(size_t size, const char* filename, unsigned int line) void * AllocateMemory(size_t size, const char * filename, unsigned int line)
{ {
void * res = malloc(size); void * res = malloc(size);
if (res == nullptr) if (res == nullptr)
@ -183,22 +183,22 @@ void* AllocateMemory(size_t size, const char* filename, unsigned int line)
return res; return res;
} }
void* operator new (size_t size, const char* filename, unsigned int line) void * operator new(size_t size, const char * filename, unsigned int line)
{ {
return AllocateMemory(size, filename, line); return AllocateMemory(size, filename, line);
} }
void* operator new[] (size_t size, const char* filename, unsigned int line) void * operator new[](size_t size, const char * filename, unsigned int line)
{ {
return AllocateMemory(size, filename, line); return AllocateMemory(size, filename, line);
} }
void* operator new (size_t size) void * operator new(size_t size)
{ {
return AllocateMemory(size, "Unknown", 0); return AllocateMemory(size, "Unknown", 0);
} }
void operator delete (void* ptr) void operator delete(void * ptr)
{ {
free(ptr); free(ptr);
if (!InInit) if (!InInit)
@ -207,17 +207,17 @@ void operator delete (void* ptr)
} }
} }
void operator delete[](void* ptr) void operator delete[](void * ptr)
{ {
delete ptr; delete ptr;
} }
void operator delete (void* ptr, const char* /*filename*/, unsigned int /*line*/) void operator delete(void * ptr, const char * /*filename*/, unsigned int /*line*/)
{ {
delete ptr; delete ptr;
} }
void operator delete[](void* ptr, const char* /*filename*/, unsigned int /*line*/) void operator delete[](void * ptr, const char * /*filename*/, unsigned int /*line*/)
{ {
delete ptr; delete ptr;
} }

10
Source/Common/MemTest.h
View File

@ -6,11 +6,11 @@
#ifdef MEM_LEAK_TEST #ifdef MEM_LEAK_TEST
void* operator new (size_t size, const char* filename, unsigned int line); void * operator new(size_t size, const char * filename, unsigned int line);
void* operator new[](size_t size, const char* filename, unsigned int line); void * operator new[](size_t size, const char * filename, unsigned int line);
void operator delete (void* ptr, const char* filename, unsigned int line); void operator delete(void * ptr, const char * filename, unsigned int line);
void operator delete[](void* ptr, const char* filename, unsigned int line); void operator delete[](void * ptr, const char * filename, unsigned int line);
#define new new(__FILE__, __LINE__) #define new new (__FILE__, __LINE__)
#endif #endif

14
Source/Common/MemoryManagement.cpp
View File

@ -48,12 +48,12 @@ static bool TranslateToMemProtect(int OsMemProtection, MEM_PROTECTION & memProte
} }
#endif #endif
void* AllocateAddressSpace(size_t size, void * base_address) void * AllocateAddressSpace(size_t size, void * base_address)
{ {
#ifdef _WIN32 #ifdef _WIN32
return VirtualAlloc(base_address, size, MEM_RESERVE | MEM_TOP_DOWN, PAGE_NOACCESS); return VirtualAlloc(base_address, size, MEM_RESERVE | MEM_TOP_DOWN, PAGE_NOACCESS);
#else #else
void * ptr = mmap((void*)0, size, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0); void * ptr = mmap((void *)0, size, PROT_NONE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (ptr == MAP_FAILED) if (ptr == MAP_FAILED)
{ {
return nullptr; return nullptr;
@ -63,7 +63,7 @@ void* AllocateAddressSpace(size_t size, void * base_address)
#endif #endif
} }
bool FreeAddressSpace(void* addr, size_t size) bool FreeAddressSpace(void * addr, size_t size)
{ {
#ifdef _WIN32 #ifdef _WIN32
size = 0; // Unused size = 0; // Unused
@ -75,7 +75,7 @@ bool FreeAddressSpace(void* addr, size_t size)
#endif #endif
} }
void* CommitMemory(void* addr, size_t size, MEM_PROTECTION memProtection) void * CommitMemory(void * addr, size_t size, MEM_PROTECTION memProtection)
{ {
int OsMemProtection; int OsMemProtection;
if (!TranslateFromMemProtect(memProtection, OsMemProtection)) if (!TranslateFromMemProtect(memProtection, OsMemProtection))
@ -91,10 +91,10 @@ void* CommitMemory(void* addr, size_t size, MEM_PROTECTION memProtection)
#endif #endif
} }
bool DecommitMemory(void* addr, size_t size) bool DecommitMemory(void * addr, size_t size)
{ {
#ifdef _WIN32 #ifdef _WIN32
return VirtualFree((void*)addr, size, MEM_DECOMMIT) != 0; return VirtualFree((void *)addr, size, MEM_DECOMMIT) != 0;
#else #else
// Instead of unmapping the address, we're just gonna trick // Instead of unmapping the address, we're just gonna trick
// the TLB to mark this as a new mapped area which, due to // the TLB to mark this as a new mapped area which, due to
@ -107,7 +107,7 @@ bool DecommitMemory(void* addr, size_t size)
#endif #endif
} }
bool ProtectMemory(void* addr, size_t size, MEM_PROTECTION memProtection, MEM_PROTECTION * OldProtect) bool ProtectMemory(void * addr, size_t size, MEM_PROTECTION memProtection, MEM_PROTECTION * OldProtect)
{ {
int OsMemProtection; int OsMemProtection;
if (!TranslateFromMemProtect(memProtection, OsMemProtection)) if (!TranslateFromMemProtect(memProtection, OsMemProtection))

10
Source/Common/MemoryManagement.h
View File

@ -9,8 +9,8 @@ enum MEM_PROTECTION
MEM_EXECUTE_READWRITE, MEM_EXECUTE_READWRITE,
}; };
void* AllocateAddressSpace(size_t size, void * base_address = 0); void * AllocateAddressSpace(size_t size, void * base_address = 0);
bool FreeAddressSpace(void* addr, size_t size); bool FreeAddressSpace(void * addr, size_t size);
void* CommitMemory(void* addr, size_t size, MEM_PROTECTION memProtection); void * CommitMemory(void * addr, size_t size, MEM_PROTECTION memProtection);
bool DecommitMemory(void* addr, size_t size); bool DecommitMemory(void * addr, size_t size);
bool ProtectMemory(void* addr, size_t size, MEM_PROTECTION memProtection, MEM_PROTECTION * OldProtect = nullptr); bool ProtectMemory(void * addr, size_t size, MEM_PROTECTION memProtection, MEM_PROTECTION * OldProtect = nullptr);

24
Source/Common/Platform.cpp
View File

@ -1,7 +1,7 @@
#include "Platform.h" #include "Platform.h"
#include <stdarg.h>
#include <stdint.h> #include <stdint.h>
#include <stdio.h> #include <stdio.h>
#include <stdarg.h>
#ifndef _WIN32 #ifndef _WIN32
int _vscprintf(const char * format, va_list pargs) int _vscprintf(const char * format, va_list pargs)
@ -20,12 +20,24 @@ int _vscprintf(const char * format, va_list pargs)
int fesetround(int RoundType) int fesetround(int RoundType)
{ {
static const unsigned int msRound[4] = { _RC_NEAR, _RC_CHOP, _RC_UP, _RC_DOWN }; static const unsigned int msRound[4] = {_RC_NEAR, _RC_CHOP, _RC_UP, _RC_DOWN};
int32_t res = _controlfp(msRound[RoundType], _MCW_RC); int32_t res = _controlfp(msRound[RoundType], _MCW_RC);
if (res == _RC_NEAR) { return FE_TONEAREST; } if (res == _RC_NEAR)
if (res == _RC_CHOP) { return FE_TOWARDZERO; } {
if (res == _RC_UP) { return FE_UPWARD; } return FE_TONEAREST;
if (res == _RC_DOWN) { return FE_DOWNWARD; } }
if (res == _RC_CHOP)
{
return FE_TOWARDZERO;
}
if (res == _RC_UP)
{
return FE_UPWARD;
}
if (res == _RC_DOWN)
{
return FE_DOWNWARD;
}
return FE_TONEAREST; return FE_TONEAREST;
} }
#endif #endif

10
Source/Common/Platform.h
View File

@ -10,13 +10,19 @@
#define _snprintf snprintf #define _snprintf snprintf
#define _isnan isnan #define _isnan isnan
int _vscprintf (const char * format, va_list pargs); int _vscprintf(const char * format, va_list pargs);
#endif #endif
// FPU rounding code // FPU rounding code
#ifdef _WIN32 #ifdef _WIN32
typedef enum { FE_TONEAREST = 0, FE_TOWARDZERO, FE_UPWARD, FE_DOWNWARD } eRoundType; typedef enum
{
FE_TONEAREST = 0,
FE_TOWARDZERO,
FE_UPWARD,
FE_DOWNWARD,
} eRoundType;
int fesetround(int RoundType); int fesetround(int RoundType);
#else #else
#include <fenv.h> #include <fenv.h>

20
Source/Common/StdString.cpp
View File

@ -1,7 +1,7 @@
#include "StdString.h" #include "StdString.h"
#include "Platform.h" #include "Platform.h"
#include <malloc.h>
#include <algorithm> #include <algorithm>
#include <malloc.h>
#ifdef _WIN32 #ifdef _WIN32
#include <Windows.h> #include <Windows.h>
#endif #endif
@ -67,7 +67,7 @@ strvector stdstr::Tokenize(char delimiter) const
void stdstr::ArgFormat(const char * strFormat, va_list & args) void stdstr::ArgFormat(const char * strFormat, va_list & args)
{ {
#pragma warning(push) #pragma warning(push)
#pragma warning(disable:4996) #pragma warning(disable : 4996)
size_t nlen = _vscprintf(strFormat, args) + 1; size_t nlen = _vscprintf(strFormat, args) + 1;
char * buffer = (char *)alloca(nlen * sizeof(char)); char * buffer = (char *)alloca(nlen * sizeof(char));
@ -88,21 +88,21 @@ void stdstr::Format(const char * strFormat, ...)
va_end(args); va_end(args);
} }
stdstr& stdstr::ToLower(void) stdstr & stdstr::ToLower(void)
{ {
std::transform(begin(), end(), begin(), (char(*)(int)) tolower); std::transform(begin(), end(), begin(), (char (*)(int))tolower);
return *this; return *this;
} }
stdstr& stdstr::ToUpper(void) stdstr & stdstr::ToUpper(void)
{ {
std::transform(begin(), end(), begin(), (char(*)(int)) toupper); std::transform(begin(), end(), begin(), (char (*)(int))toupper);
return *this; return *this;
} }
void stdstr::Replace(const char search, const char replace) void stdstr::Replace(const char search, const char replace)
{ {
std::string& str = *this; std::string & str = *this;
std::string::size_type pos = str.find(search); std::string::size_type pos = str.find(search);
while (pos != std::string::npos) while (pos != std::string::npos)
{ {
@ -113,7 +113,7 @@ void stdstr::Replace(const char search, const char replace)
void stdstr::Replace(const char * search, const char replace) void stdstr::Replace(const char * search, const char replace)
{ {
std::string& str = *this; std::string & str = *this;
std::string::size_type pos = str.find(search); std::string::size_type pos = str.find(search);
size_t SearchSize = strlen(search); size_t SearchSize = strlen(search);
while (pos != std::string::npos) while (pos != std::string::npos)
@ -123,9 +123,9 @@ void stdstr::Replace(const char * search, const char replace)
} }
} }
void stdstr::Replace(const std::string& search, const std::string& replace) void stdstr::Replace(const std::string & search, const std::string & replace)
{ {
std::string& str = *this; std::string & str = *this;
std::string::size_type pos = str.find(search); std::string::size_type pos = str.find(search);
size_t SearchSize = search.size(); size_t SearchSize = search.size();
while (pos != std::string::npos) while (pos != std::string::npos)

34
Source/Common/StdString.h
View File

@ -2,10 +2,10 @@
class stdstr; class stdstr;
#include <stdarg.h>
#include <vector>
#include <string>
#include <list> #include <list>
#include <stdarg.h>
#include <string>
#include <vector>
typedef std::vector<stdstr> strvector; typedef std::vector<stdstr> strvector;
@ -24,22 +24,22 @@ public:
stdstr(const stdstr & str); stdstr(const stdstr & str);
stdstr(const char * str); stdstr(const char * str);
strvector Tokenize(char delimiter) const; strvector Tokenize(char delimiter) const;
strvector Tokenize(const char * delimiter) const; strvector Tokenize(const char * delimiter) const;
void Format(const char * strFormat, ...); void Format(const char * strFormat, ...);
stdstr& ToLower(void); stdstr & ToLower(void);
stdstr& ToUpper(void); stdstr & ToUpper(void);
void Replace(const char search, const char replace); void Replace(const char search, const char replace);
void Replace(const char * search, const char replace); void Replace(const char * search, const char replace);
void Replace(const std::string & search, const std::string & replace); void Replace(const std::string & search, const std::string & replace);
stdstr & Trim(const char * chars2remove = "\t "); stdstr & Trim(const char * chars2remove = "\t ");
stdstr & TrimLeft(const char * chars2remove = "\t "); stdstr & TrimLeft(const char * chars2remove = "\t ");
stdstr & TrimRight(const char * chars2remove = "\t "); stdstr & TrimRight(const char * chars2remove = "\t ");
#ifdef _WIN32 #ifdef _WIN32
stdstr & FromUTF16(const wchar_t * UTF16Source, bool * bSuccess = nullptr); stdstr & FromUTF16(const wchar_t * UTF16Source, bool * bSuccess = nullptr);
std::wstring ToUTF16(unsigned int CodePage = CODEPAGE_UTF8, bool * bSuccess = nullptr) const; std::wstring ToUTF16(unsigned int CodePage = CODEPAGE_UTF8, bool * bSuccess = nullptr) const;
#endif #endif
@ -49,14 +49,14 @@ public:
class stdstr_f : public stdstr class stdstr_f : public stdstr
{ {
public: public:
stdstr_f(const char * strFormat, ...); stdstr_f(const char * strFormat, ...);
}; };
#ifdef _WIN32 #ifdef _WIN32
class stdwstr_f : public std::wstring class stdwstr_f : public std::wstring
{ {
public: public:
stdwstr_f(const wchar_t * strFormat, ... ); stdwstr_f(const wchar_t * strFormat, ...);
}; };
#endif #endif

28
Source/Common/SyncEvent.cpp
View File

@ -13,8 +13,8 @@ SyncEvent::SyncEvent(bool bManualReset)
m_signalled = false; m_signalled = false;
m_Event = new pthread_mutex_t; m_Event = new pthread_mutex_t;
m_cond = new pthread_cond_t; m_cond = new pthread_cond_t;
pthread_mutex_init((pthread_mutex_t*)m_Event, nullptr); pthread_mutex_init((pthread_mutex_t *)m_Event, nullptr);
pthread_cond_init((pthread_cond_t*)m_cond, nullptr); pthread_cond_init((pthread_cond_t *)m_cond, nullptr);
#endif #endif
} }
@ -23,10 +23,10 @@ SyncEvent::~SyncEvent()
#ifdef _WIN32 #ifdef _WIN32
CloseHandle(m_Event); CloseHandle(m_Event);
#else #else
pthread_mutex_destroy((pthread_mutex_t*)m_Event); pthread_mutex_destroy((pthread_mutex_t *)m_Event);
pthread_cond_destroy((pthread_cond_t*)m_cond); pthread_cond_destroy((pthread_cond_t *)m_cond);
delete (pthread_mutex_t*)m_Event; delete (pthread_mutex_t *)m_Event;
delete (pthread_cond_t*)m_cond; delete (pthread_cond_t *)m_cond;
#endif #endif
} }
@ -35,10 +35,10 @@ void SyncEvent::Trigger()
#ifdef _WIN32 #ifdef _WIN32
SetEvent(m_Event); SetEvent(m_Event);
#else #else
pthread_mutex_lock((pthread_mutex_t*)m_Event); pthread_mutex_lock((pthread_mutex_t *)m_Event);
m_signalled = true; m_signalled = true;
pthread_mutex_unlock((pthread_mutex_t*)m_Event); pthread_mutex_unlock((pthread_mutex_t *)m_Event);
pthread_cond_signal((pthread_cond_t*)m_cond); pthread_cond_signal((pthread_cond_t *)m_cond);
#endif #endif
} }
@ -47,12 +47,12 @@ bool SyncEvent::IsTriggered(int32_t iWaitTime) const
#ifdef _WIN32 #ifdef _WIN32
return (WAIT_OBJECT_0 == WaitForSingleObject(m_Event, iWaitTime)); return (WAIT_OBJECT_0 == WaitForSingleObject(m_Event, iWaitTime));
#else #else
pthread_mutex_lock((pthread_mutex_t*)m_Event); pthread_mutex_lock((pthread_mutex_t *)m_Event);
while (!m_signalled) while (!m_signalled)
{ {
pthread_cond_wait((pthread_cond_t*)m_cond, (pthread_mutex_t*)m_Event); pthread_cond_wait((pthread_cond_t *)m_cond, (pthread_mutex_t *)m_Event);
} }
pthread_mutex_unlock((pthread_mutex_t*)m_Event); pthread_mutex_unlock((pthread_mutex_t *)m_Event);
return true; return true;
#endif #endif
} }
@ -62,9 +62,9 @@ void SyncEvent::Reset()
#ifdef _WIN32 #ifdef _WIN32
ResetEvent(m_Event); ResetEvent(m_Event);
#else #else
pthread_mutex_lock((pthread_mutex_t*)m_Event); pthread_mutex_lock((pthread_mutex_t *)m_Event);
m_signalled = false; m_signalled = false;
pthread_mutex_unlock((pthread_mutex_t*)m_Event); pthread_mutex_unlock((pthread_mutex_t *)m_Event);
#endif #endif
} }

13
Source/Common/SyncEvent.h
View File

@ -4,19 +4,22 @@
class SyncEvent class SyncEvent
{ {
public: public:
enum { INFINITE_TIMEOUT = 0xFFFFFFFF }; enum
{
INFINITE_TIMEOUT = 0xFFFFFFFF
};
SyncEvent(bool bManualReset = true); SyncEvent(bool bManualReset = true);
~SyncEvent(void); ~SyncEvent(void);
void Trigger (void); void Trigger(void);
bool IsTriggered (int32_t iWaitTime = 0) const; bool IsTriggered(int32_t iWaitTime = 0) const;
void Reset(); void Reset();
void * GetHandle(); void * GetHandle();
protected: protected:
SyncEvent(const SyncEvent&); SyncEvent(const SyncEvent &);
SyncEvent& operator=(const SyncEvent&); SyncEvent & operator=(const SyncEvent &);
void * m_Event; void * m_Event;
#ifndef _WIN32 #ifndef _WIN32

8
Source/Common/Thread.cpp
View File

@ -4,9 +4,9 @@
#ifdef _WIN32 #ifdef _WIN32
#include <Windows.h> #include <Windows.h>
#else #else
#include <unistd.h>
#include <pthread.h> #include <pthread.h>
#include <sys/syscall.h> #include <sys/syscall.h>
#include <unistd.h>
#endif #endif
CThread::CThread(CTHREAD_START_ROUTINE lpStartAddress) : CThread::CThread(CTHREAD_START_ROUTINE lpStartAddress) :
@ -48,15 +48,15 @@ bool CThread::Start(void * lpThreadParameter)
#else #else
pthread_t * thread_id = new pthread_t; pthread_t * thread_id = new pthread_t;
m_thread = (void*)thread_id; m_thread = (void *)thread_id;
int res = pthread_create(thread_id, nullptr, (void *(*)(void *))ThreadWrapper, this); int res = pthread_create(thread_id, nullptr, (void * (*)(void *))ThreadWrapper, this);
#endif #endif
WriteTrace(TraceThread, TraceDebug, "Done"); WriteTrace(TraceThread, TraceDebug, "Done");
return true; return true;
} }
void * CThread::ThreadWrapper (CThread * _this) void * CThread::ThreadWrapper(CThread * _this)
{ {
WriteTrace(TraceThread, TraceDebug, "Start"); WriteTrace(TraceThread, TraceDebug, "Start");
_this->m_threadID = CThread::GetCurrentThreadId(); _this->m_threadID = CThread::GetCurrentThreadId();

15
Source/Common/Thread.h
View File

@ -5,16 +5,19 @@ class CThread
{ {
public: public:
#ifdef _WIN32 #ifdef _WIN32
typedef uint32_t(*CTHREAD_START_ROUTINE)(void * lpThreadParameter); typedef uint32_t (*CTHREAD_START_ROUTINE)(void * lpThreadParameter);
#else #else
typedef void *(*CTHREAD_START_ROUTINE)(void *); typedef void * (*CTHREAD_START_ROUTINE)(void *);
#endif #endif
CThread(CTHREAD_START_ROUTINE lpStartAddress); CThread(CTHREAD_START_ROUTINE lpStartAddress);
~CThread(); ~CThread();
bool Start(void * lpThreadParameter); bool Start(void * lpThreadParameter);
inline uint32_t ThreadID(void) const { return m_threadID; } inline uint32_t ThreadID(void) const
{
return m_threadID;
}
bool isRunning(void) const; bool isRunning(void) const;
void Terminate(void); void Terminate(void);
@ -22,10 +25,10 @@ public:
private: private:
CThread(void); CThread(void);
CThread(const CThread&); CThread(const CThread &);
CThread& operator=(const CThread&); CThread & operator=(const CThread &);
static void * ThreadWrapper (CThread * _this); static void * ThreadWrapper(CThread * _this);
CTHREAD_START_ROUTINE m_StartAddress; CTHREAD_START_ROUTINE m_StartAddress;
void * m_lpThreadParameter; void * m_lpThreadParameter;

28
Source/Common/Trace.cpp
View File

@ -1,8 +1,8 @@
#include "Trace.h" #include "Trace.h"
#include "StdString.h"
#include "CriticalSection.h" #include "CriticalSection.h"
#include "Thread.h"
#include "Platform.h" #include "Platform.h"
#include "StdString.h"
#include "Thread.h"
#include <map> #include <map>
#include <vector> #include <vector>
#ifdef _WIN32 #ifdef _WIN32
@ -26,7 +26,10 @@ public:
CTraceLog() CTraceLog()
{ {
} }
~CTraceLog() { CloseTrace(); } ~CTraceLog()
{
CloseTrace();
}
void TraceMessage(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char * Message); void TraceMessage(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char * Message);
@ -47,7 +50,7 @@ void TraceSetModuleName(uint8_t module, const char * Name)
g_ModuleNames.insert(ModuleNameMap::value_type(module, Name)); g_ModuleNames.insert(ModuleNameMap::value_type(module, Name));
} }
void WriteTraceFull(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char *format, ...) void WriteTraceFull(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char * format, ...)
{ {
va_list args; va_list args;
va_start(args, format); va_start(args, format);
@ -142,7 +145,6 @@ void CTraceLog::FlushTrace(void)
{ {
m_Modules[i]->FlushTrace(); m_Modules[i]->FlushTrace();
} }
} }
void CTraceLog::TraceMessage(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char * Message) void CTraceLog::TraceMessage(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char * Message)
@ -202,7 +204,10 @@ const char * TraceModule(uint32_t module)
CTraceFileLog::CTraceFileLog(const char * FileName, bool FlushFile, CLog::LOG_OPEN_MODE eMode, size_t dwMaxFileSize) : CTraceFileLog::CTraceFileLog(const char * FileName, bool FlushFile, CLog::LOG_OPEN_MODE eMode, size_t dwMaxFileSize) :
m_FlushFile(FlushFile) m_FlushFile(FlushFile)
{ {
enum { MB = 1024 * 1024 }; enum
{
MB = 1024 * 1024
};
m_hLogFile.SetFlush(false); m_hLogFile.SetFlush(false);
m_hLogFile.SetTruncateFile(true); m_hLogFile.SetTruncateFile(true);
@ -222,7 +227,10 @@ CTraceFileLog::~CTraceFileLog()
void CTraceFileLog::Write(uint32_t module, uint8_t severity, const char * /*file*/, int /*line*/, const char * function, const char * Message) void CTraceFileLog::Write(uint32_t module, uint8_t severity, const char * /*file*/, int /*line*/, const char * function, const char * Message)
{ {
if (!m_hLogFile.IsOpen()) { return; } if (!m_hLogFile.IsOpen())
{
return;
}
#ifdef _WIN32 #ifdef _WIN32
SYSTEMTIME sysTime; SYSTEMTIME sysTime;
@ -230,16 +238,16 @@ void CTraceFileLog::Write(uint32_t module, uint8_t severity, const char * /*file
stdstr_f timestamp("%04d/%02d/%02d %02d:%02d:%02d.%03d %05d,", sysTime.wYear, sysTime.wMonth, sysTime.wDay, sysTime.wHour, sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds, CThread::GetCurrentThreadId()); stdstr_f timestamp("%04d/%02d/%02d %02d:%02d:%02d.%03d %05d,", sysTime.wYear, sysTime.wMonth, sysTime.wDay, sysTime.wHour, sysTime.wMinute, sysTime.wSecond, sysTime.wMilliseconds, CThread::GetCurrentThreadId());
#else #else
time_t ltime; time_t ltime;
ltime=time(&ltime); ltime = time(&ltime);
struct tm result={0}; struct tm result = {0};
localtime_r(&ltime, &result); localtime_r(&ltime, &result);
struct timeval curTime; struct timeval curTime;
gettimeofday(&curTime, nullptr); gettimeofday(&curTime, nullptr);
int milliseconds = curTime.tv_usec / 1000; int milliseconds = curTime.tv_usec / 1000;
stdstr_f timestamp("%04d/%02d/%02d %02d:%02d:%02d.%03d %05d,", result.tm_year+1900, result.tm_mon+1, result.tm_mday, result.tm_hour, result.tm_min, result.tm_sec, milliseconds, CThread::GetCurrentThreadId()); stdstr_f timestamp("%04d/%02d/%02d %02d:%02d:%02d.%03d %05d,", result.tm_year + 1900, result.tm_mon + 1, result.tm_mday, result.tm_hour, result.tm_min, result.tm_sec, milliseconds, CThread::GetCurrentThreadId());
#endif #endif
m_hLogFile.Log(timestamp.c_str()); m_hLogFile.Log(timestamp.c_str());

16
Source/Common/Trace.h
View File

@ -29,7 +29,7 @@ public:
void SetFlushFile(bool bFlushFile); void SetFlushFile(bool bFlushFile);
void Write(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char * Message); void Write(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char * Message);
void FlushTrace (void); void FlushTrace(void);
private: private:
CLog m_hLogFile; CLog m_hLogFile;
@ -37,9 +37,17 @@ private:
}; };
#ifdef _WIN32 #ifdef _WIN32
#define WriteTrace(m, s, format, ...) if(g_ModuleLogLevel[(m)] >= (s)) { WriteTraceFull((m), (s), __FILE__, __LINE__, __FUNCTION__, (format), ## __VA_ARGS__); } #define WriteTrace(m, s, format, ...) \
if (g_ModuleLogLevel[(m)] >= (s)) \
{ \
WriteTraceFull((m), (s), __FILE__, __LINE__, __FUNCTION__, (format), ##__VA_ARGS__); \
}
#else #else
#define WriteTrace(m, s, format, ...) if(g_ModuleLogLevel[(m)] >= (s)) { WriteTraceFull((m), (s), __FILE__, __LINE__, __PRETTY_FUNCTION__, (format), ## __VA_ARGS__); } #define WriteTrace(m, s, format, ...) \
if (g_ModuleLogLevel[(m)] >= (s)) \
{ \
WriteTraceFull((m), (s), __FILE__, __LINE__, __PRETTY_FUNCTION__, (format), ##__VA_ARGS__); \
}
#endif #endif
CTraceModule * TraceAddModule(CTraceModule * TraceModule); CTraceModule * TraceAddModule(CTraceModule * TraceModule);
@ -49,7 +57,7 @@ const char * TraceModule(uint32_t module);
void TraceSetModuleName(uint8_t module, const char * Name); void TraceSetModuleName(uint8_t module, const char * Name);
void CloseTrace(void); void CloseTrace(void);
void WriteTraceFull(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char *format, ...); void WriteTraceFull(uint32_t module, uint8_t severity, const char * file, int line, const char * function, const char * format, ...);
void TraceFlushLog(void); void TraceFlushLog(void);
void TraceSetMaxModule(uint32_t MaxModule, uint8_t DefaultSeverity); void TraceSetMaxModule(uint32_t MaxModule, uint8_t DefaultSeverity);

6
Source/Common/Util.cpp
View File

@ -3,6 +3,7 @@
#include "path.h" #include "path.h"
#ifdef _WIN32 #ifdef _WIN32
#include <windows.h> #include <windows.h>
#include <Tlhelp32.h> #include <Tlhelp32.h>
#else #else
#include <time.h> #include <time.h>
@ -17,7 +18,8 @@ void pjutil::Sleep(uint32_t timeout)
struct timespec elapsed, tv; struct timespec elapsed, tv;
elapsed.tv_sec = timeout / 1000; elapsed.tv_sec = timeout / 1000;
elapsed.tv_nsec = (timeout % 1000) * 1000000; elapsed.tv_nsec = (timeout % 1000) * 1000000;
do { do
{
errno = 0; errno = 0;
tv.tv_sec = elapsed.tv_sec; tv.tv_sec = elapsed.tv_sec;
tv.tv_nsec = elapsed.tv_nsec; tv.tv_nsec = elapsed.tv_nsec;
@ -63,7 +65,7 @@ bool pjutil::TerminatedExistingExe()
break; break;
} }
} }
HANDLE hHandle = OpenProcess(SYNCHRONIZE|PROCESS_TERMINATE, FALSE, lppe.th32ProcessID); HANDLE hHandle = OpenProcess(SYNCHRONIZE | PROCESS_TERMINATE, FALSE, lppe.th32ProcessID);
if (hHandle != nullptr) if (hHandle != nullptr)
{ {
if (TerminateProcess(hHandle, 0)) if (TerminateProcess(hHandle, 0))

4
Source/Common/Util.h
View File

@ -9,6 +9,6 @@ public:
private: private:
pjutil(void); pjutil(void);
pjutil(const pjutil&); pjutil(const pjutil &);
pjutil& operator=(const pjutil&); pjutil & operator=(const pjutil &);
}; };

124
Source/Common/md5.cpp
View File

@ -56,7 +56,7 @@ MD5::~MD5()
// operation, processing another message block, and updating the // operation, processing another message block, and updating the
// context. // context.
void MD5::update(const uint1 *input, uint4 input_length) void MD5::update(const uint1 * input, uint4 input_length)
{ {
uint4 input_index, buffer_index; uint4 input_index, buffer_index;
uint4 buffer_space; uint4 buffer_space;
@ -107,7 +107,7 @@ void MD5::update(const uint1 *input, uint4 input_length)
// MD5 update for files // MD5 update for files
// Like above, except that it works on files (and uses above as a primitive) // Like above, except that it works on files (and uses above as a primitive)
void MD5::update(FILE *file) void MD5::update(FILE * file)
{ {
unsigned char update_buffer[1024]; unsigned char update_buffer[1024];
int len; int len;
@ -166,7 +166,7 @@ void MD5::finalize()
MD5::MD5(CPath File) MD5::MD5(CPath File)
{ {
init(); // Must be called by all constructors init(); // Must be called by all constructors
if (File.Exists()) if (File.Exists())
{ {
FILE * fp = fopen((const char *)File, "rb"); FILE * fp = fopen((const char *)File, "rb");
@ -178,38 +178,38 @@ MD5::MD5(CPath File)
finalize(); finalize();
} }
MD5::MD5(FILE *file) MD5::MD5(FILE * file)
{ {
init(); // Must be called by all constructors init(); // Must be called by all constructors
update(file); update(file);
finalize(); finalize();
} }
MD5::MD5(const unsigned char *input, unsigned int input_length) MD5::MD5(const unsigned char * input, unsigned int input_length)
{ {
init(); // Must be called by all constructors init(); // Must be called by all constructors
update(input, input_length); update(input, input_length);
finalize(); finalize();
} }
MD5::MD5(const stdstr & string) MD5::MD5(const stdstr & string)
{ {
init(); // Must be called by all constructors init(); // Must be called by all constructors
update((const unsigned char *)string.c_str(), (uint4)string.length()); update((const unsigned char *)string.c_str(), (uint4)string.length());
finalize(); finalize();
} }
const unsigned char *MD5::raw_digest() const unsigned char * MD5::raw_digest()
{ {
if (!finalized) if (!finalized)
{ {
WriteTrace(TraceMD5, TraceError, "Can't get digest if you haven't finalized the digest!"); WriteTrace(TraceMD5, TraceError, "Can't get digest if you haven't finalized the digest!");
return ((unsigned char*) ""); return ((unsigned char *)"");
} }
return digest; return digest;
} }
void MD5::get_digest(MD5Digest& extdigest) void MD5::get_digest(MD5Digest & extdigest)
{ {
if (!finalized) if (!finalized)
{ {
@ -221,7 +221,7 @@ void MD5::get_digest(MD5Digest& extdigest)
memcpy(extdigest.digest, digest, 16); memcpy(extdigest.digest, digest, 16);
} }
const char *MD5::hex_digest() const char * MD5::hex_digest()
{ {
if (m_hex_digest.length()) if (m_hex_digest.length())
{ {
@ -250,7 +250,7 @@ const char *MD5::hex_digest()
void MD5::init() void MD5::init()
{ {
finalized = 0; // We just started! finalized = 0; // We just started!
// Nothing counted, so count=0 // Nothing counted, so count=0
count[0] = 0; count[0] = 0;
@ -300,16 +300,16 @@ void MD5::transform(uint1 block[64])
//ATLASSERT(!finalized); // Not just a user error, since the method is private //ATLASSERT(!finalized); // Not just a user error, since the method is private
// Round 1 // Round 1
FF(a, b, c, d, x[0], S11, 0xd76aa478); // 1 FF(a, b, c, d, x[0], S11, 0xd76aa478); // 1
FF(d, a, b, c, x[1], S12, 0xe8c7b756); // 2 FF(d, a, b, c, x[1], S12, 0xe8c7b756); // 2
FF(c, d, a, b, x[2], S13, 0x242070db); // 3 FF(c, d, a, b, x[2], S13, 0x242070db); // 3
FF(b, c, d, a, x[3], S14, 0xc1bdceee); // 4 FF(b, c, d, a, x[3], S14, 0xc1bdceee); // 4
FF(a, b, c, d, x[4], S11, 0xf57c0faf); // 5 FF(a, b, c, d, x[4], S11, 0xf57c0faf); // 5
FF(d, a, b, c, x[5], S12, 0x4787c62a); // 6 FF(d, a, b, c, x[5], S12, 0x4787c62a); // 6
FF(c, d, a, b, x[6], S13, 0xa8304613); // 7 FF(c, d, a, b, x[6], S13, 0xa8304613); // 7
FF(b, c, d, a, x[7], S14, 0xfd469501); // 8 FF(b, c, d, a, x[7], S14, 0xfd469501); // 8
FF(a, b, c, d, x[8], S11, 0x698098d8); // 9 FF(a, b, c, d, x[8], S11, 0x698098d8); // 9
FF(d, a, b, c, x[9], S12, 0x8b44f7af); // 10 FF(d, a, b, c, x[9], S12, 0x8b44f7af); // 10
FF(c, d, a, b, x[10], S13, 0xffff5bb1); // 11 FF(c, d, a, b, x[10], S13, 0xffff5bb1); // 11
FF(b, c, d, a, x[11], S14, 0x895cd7be); // 12 FF(b, c, d, a, x[11], S14, 0x895cd7be); // 12
FF(a, b, c, d, x[12], S11, 0x6b901122); // 13 FF(a, b, c, d, x[12], S11, 0x6b901122); // 13
@ -318,58 +318,58 @@ void MD5::transform(uint1 block[64])
FF(b, c, d, a, x[15], S14, 0x49b40821); // 16 FF(b, c, d, a, x[15], S14, 0x49b40821); // 16
// Round 2 // Round 2
GG(a, b, c, d, x[1], S21, 0xf61e2562); // 17 GG(a, b, c, d, x[1], S21, 0xf61e2562); // 17
GG(d, a, b, c, x[6], S22, 0xc040b340); // 18 GG(d, a, b, c, x[6], S22, 0xc040b340); // 18
GG(c, d, a, b, x[11], S23, 0x265e5a51); // 19 GG(c, d, a, b, x[11], S23, 0x265e5a51); // 19
GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); // 20 GG(b, c, d, a, x[0], S24, 0xe9b6c7aa); // 20
GG(a, b, c, d, x[5], S21, 0xd62f105d); // 21 GG(a, b, c, d, x[5], S21, 0xd62f105d); // 21
GG(d, a, b, c, x[10], S22, 0x2441453); // 22 GG(d, a, b, c, x[10], S22, 0x2441453); // 22
GG(c, d, a, b, x[15], S23, 0xd8a1e681); // 23 GG(c, d, a, b, x[15], S23, 0xd8a1e681); // 23
GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); // 24 GG(b, c, d, a, x[4], S24, 0xe7d3fbc8); // 24
GG(a, b, c, d, x[9], S21, 0x21e1cde6); // 25 GG(a, b, c, d, x[9], S21, 0x21e1cde6); // 25
GG(d, a, b, c, x[14], S22, 0xc33707d6); // 26 GG(d, a, b, c, x[14], S22, 0xc33707d6); // 26
GG(c, d, a, b, x[3], S23, 0xf4d50d87); // 27 GG(c, d, a, b, x[3], S23, 0xf4d50d87); // 27
GG(b, c, d, a, x[8], S24, 0x455a14ed); // 28 GG(b, c, d, a, x[8], S24, 0x455a14ed); // 28
GG(a, b, c, d, x[13], S21, 0xa9e3e905); // 29 GG(a, b, c, d, x[13], S21, 0xa9e3e905); // 29
GG(d, a, b, c, x[2], S22, 0xfcefa3f8); // 30 GG(d, a, b, c, x[2], S22, 0xfcefa3f8); // 30
GG(c, d, a, b, x[7], S23, 0x676f02d9); // 31 GG(c, d, a, b, x[7], S23, 0x676f02d9); // 31
GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); // 32 GG(b, c, d, a, x[12], S24, 0x8d2a4c8a); // 32
// Round 3 // Round 3
HH(a, b, c, d, x[5], S31, 0xfffa3942); // 33 HH(a, b, c, d, x[5], S31, 0xfffa3942); // 33
HH(d, a, b, c, x[8], S32, 0x8771f681); // 34 HH(d, a, b, c, x[8], S32, 0x8771f681); // 34
HH(c, d, a, b, x[11], S33, 0x6d9d6122); // 35 HH(c, d, a, b, x[11], S33, 0x6d9d6122); // 35
HH(b, c, d, a, x[14], S34, 0xfde5380c); // 36 HH(b, c, d, a, x[14], S34, 0xfde5380c); // 36
HH(a, b, c, d, x[1], S31, 0xa4beea44); // 37 HH(a, b, c, d, x[1], S31, 0xa4beea44); // 37
HH(d, a, b, c, x[4], S32, 0x4bdecfa9); // 38 HH(d, a, b, c, x[4], S32, 0x4bdecfa9); // 38
HH(c, d, a, b, x[7], S33, 0xf6bb4b60); // 39 HH(c, d, a, b, x[7], S33, 0xf6bb4b60); // 39
HH(b, c, d, a, x[10], S34, 0xbebfbc70); // 40 HH(b, c, d, a, x[10], S34, 0xbebfbc70); // 40
HH(a, b, c, d, x[13], S31, 0x289b7ec6); // 41 HH(a, b, c, d, x[13], S31, 0x289b7ec6); // 41
HH(d, a, b, c, x[0], S32, 0xeaa127fa); // 42 HH(d, a, b, c, x[0], S32, 0xeaa127fa); // 42
HH(c, d, a, b, x[3], S33, 0xd4ef3085); // 43 HH(c, d, a, b, x[3], S33, 0xd4ef3085); // 43
HH(b, c, d, a, x[6], S34, 0x4881d05); // 44 HH(b, c, d, a, x[6], S34, 0x4881d05); // 44
HH(a, b, c, d, x[9], S31, 0xd9d4d039); // 45 HH(a, b, c, d, x[9], S31, 0xd9d4d039); // 45
HH(d, a, b, c, x[12], S32, 0xe6db99e5); // 46 HH(d, a, b, c, x[12], S32, 0xe6db99e5); // 46
HH(c, d, a, b, x[15], S33, 0x1fa27cf8); // 47 HH(c, d, a, b, x[15], S33, 0x1fa27cf8); // 47
HH(b, c, d, a, x[2], S34, 0xc4ac5665); // 48 HH(b, c, d, a, x[2], S34, 0xc4ac5665); // 48
// Round 4 // Round 4
II(a, b, c, d, x[0], S41, 0xf4292244); // 49 II(a, b, c, d, x[0], S41, 0xf4292244); // 49
II(d, a, b, c, x[7], S42, 0x432aff97); // 50 II(d, a, b, c, x[7], S42, 0x432aff97); // 50
II(c, d, a, b, x[14], S43, 0xab9423a7); // 51 II(c, d, a, b, x[14], S43, 0xab9423a7); // 51
II(b, c, d, a, x[5], S44, 0xfc93a039); // 52 II(b, c, d, a, x[5], S44, 0xfc93a039); // 52
II(a, b, c, d, x[12], S41, 0x655b59c3); // 53 II(a, b, c, d, x[12], S41, 0x655b59c3); // 53
II(d, a, b, c, x[3], S42, 0x8f0ccc92); // 54 II(d, a, b, c, x[3], S42, 0x8f0ccc92); // 54
II(c, d, a, b, x[10], S43, 0xffeff47d); // 55 II(c, d, a, b, x[10], S43, 0xffeff47d); // 55
II(b, c, d, a, x[1], S44, 0x85845dd1); // 56 II(b, c, d, a, x[1], S44, 0x85845dd1); // 56
II(a, b, c, d, x[8], S41, 0x6fa87e4f); // 57 II(a, b, c, d, x[8], S41, 0x6fa87e4f); // 57
II(d, a, b, c, x[15], S42, 0xfe2ce6e0); // 58 II(d, a, b, c, x[15], S42, 0xfe2ce6e0); // 58
II(c, d, a, b, x[6], S43, 0xa3014314); // 59 II(c, d, a, b, x[6], S43, 0xa3014314); // 59
II(b, c, d, a, x[13], S44, 0x4e0811a1); // 60 II(b, c, d, a, x[13], S44, 0x4e0811a1); // 60
II(a, b, c, d, x[4], S41, 0xf7537e82); // 61 II(a, b, c, d, x[4], S41, 0xf7537e82); // 61
II(d, a, b, c, x[11], S42, 0xbd3af235); // 62 II(d, a, b, c, x[11], S42, 0xbd3af235); // 62
II(c, d, a, b, x[2], S43, 0x2ad7d2bb); // 63 II(c, d, a, b, x[2], S43, 0x2ad7d2bb); // 63
II(b, c, d, a, x[9], S44, 0xeb86d391); // 64 II(b, c, d, a, x[9], S44, 0xeb86d391); // 64
state[0] += a; state[0] += a;
state[1] += b; state[1] += b;
@ -383,7 +383,7 @@ void MD5::transform(uint1 block[64])
// Encodes input (UINT4) into output (unsigned char). Assumes len is // Encodes input (UINT4) into output (unsigned char). Assumes len is
// a multiple of 4. // a multiple of 4.
void MD5::encode(uint1 *output, uint4 *input, uint4 len) void MD5::encode(uint1 * output, uint4 * input, uint4 len)
{ {
unsigned int i, j; unsigned int i, j;
@ -399,7 +399,7 @@ void MD5::encode(uint1 *output, uint4 *input, uint4 len)
// Decodes input (unsigned char) into output (UINT4). Assumes len is // Decodes input (unsigned char) into output (UINT4). Assumes len is
// a multiple of 4. // a multiple of 4.
void MD5::decode(uint4 *output, uint1 *input, uint4 len) void MD5::decode(uint4 * output, uint1 * input, uint4 len)
{ {
unsigned int i, j; unsigned int i, j;
@ -411,7 +411,7 @@ void MD5::decode(uint4 *output, uint1 *input, uint4 len)
// Note: Replace "for loop" with standard memcpy if possible // Note: Replace "for loop" with standard memcpy if possible
void MD5::memcpy(uint1 *output, uint1 *input, uint4 len) void MD5::memcpy(uint1 * output, uint1 * input, uint4 len)
{ {
unsigned int i; unsigned int i;
@ -423,7 +423,7 @@ void MD5::memcpy(uint1 *output, uint1 *input, uint4 len)
// Note: Replace "for loop" with standard memset if possible // Note: Replace "for loop" with standard memset if possible
void MD5::memset(uint1 *output, uint1 value, uint4 len) void MD5::memset(uint1 * output, uint1 value, uint4 len)
{ {
unsigned int i; unsigned int i;
@ -465,25 +465,25 @@ inline unsigned int MD5::I(uint4 x, uint4 y, uint4 z)
// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4. // FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
// Rotation is separate from addition to prevent recomputation. // Rotation is separate from addition to prevent recomputation.
inline void MD5::FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) inline void MD5::FF(uint4 & a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
{ {
a += F(b, c, d) + x + ac; a += F(b, c, d) + x + ac;
a = rotate_left(a, s) + b; a = rotate_left(a, s) + b;
} }
inline void MD5::GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) inline void MD5::GG(uint4 & a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
{ {
a += G(b, c, d) + x + ac; a += G(b, c, d) + x + ac;
a = rotate_left(a, s) + b; a = rotate_left(a, s) + b;
} }
inline void MD5::HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) inline void MD5::HH(uint4 & a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
{ {
a += H(b, c, d) + x + ac; a += H(b, c, d) + x + ac;
a = rotate_left(a, s) + b; a = rotate_left(a, s) + b;
} }
inline void MD5::II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) inline void MD5::II(uint4 & a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac)
{ {
a += I(b, c, d) + x + ac; a += I(b, c, d) + x + ac;
a = rotate_left(a, s) + b; a = rotate_left(a, s) + b;

93
Source/Common/md5.h
View File

@ -41,19 +41,25 @@ documentation and/or software.
#pragma once #pragma once
#include <string.h>
#include <stdio.h>
#include <string>
#include <functional>
#include "path.h"
#include "StdString.h" #include "StdString.h"
#include "path.h"
#include <functional>
#include <stdio.h>
#include <string.h>
#include <string>
struct MD5Digest struct MD5Digest
{ {
MD5Digest() { Reset(); } MD5Digest()
{
Reset();
}
unsigned char digest[16]; unsigned char digest[16];
void Reset() { ::memset(digest, 0, sizeof(digest)); } void Reset()
{
::memset(digest, 0, sizeof(digest));
}
bool IsClear() bool IsClear()
{ {
int isClear = 0; int isClear = 0;
@ -79,9 +85,9 @@ struct MD5Digest
} }
}; };
struct MD5Digest_less : std::binary_function < MD5Digest, MD5Digest, bool > struct MD5Digest_less : std::binary_function<MD5Digest, MD5Digest, bool>
{ {
bool operator()(const MD5Digest& x, const MD5Digest& y) const bool operator()(const MD5Digest & x, const MD5Digest & y) const
{ {
return (memcmp(x.digest, y.digest, sizeof(x.digest)) < 0); return (memcmp(x.digest, y.digest, sizeof(x.digest)) < 0);
} }
@ -91,59 +97,58 @@ class MD5
{ {
public: public:
// Methods for controlled operation: // Methods for controlled operation:
MD5(); // Simple initializer MD5(); // Simple initializer
~MD5(); ~MD5();
void update(const unsigned char *input, unsigned int input_length); void update(const unsigned char * input, unsigned int input_length);
void update(FILE *file); void update(FILE * file);
void finalize(); void finalize();
// Constructors for special circumstances. All these constructors finalize the MD5 context. // Constructors for special circumstances. All these constructors finalize the MD5 context.
MD5(CPath File); // Digest file, finalize MD5(CPath File); // Digest file, finalize
MD5(const unsigned char *string); // Digest string, finalize MD5(const unsigned char * string); // Digest string, finalize
MD5(FILE *file); // Digest file, close, finalize MD5(FILE * file); // Digest file, close, finalize
MD5(const unsigned char *input, unsigned int input_length); MD5(const unsigned char * input, unsigned int input_length);
MD5(const stdstr & string); MD5(const stdstr & string);
// Methods to acquire finalized result // Methods to acquire finalized result
void get_digest(MD5Digest& extdigest); // Digest into a digest structure void get_digest(MD5Digest & extdigest); // Digest into a digest structure
const unsigned char *raw_digest(); // Digest as a 16-byte binary array const unsigned char * raw_digest(); // Digest as a 16-byte binary array
const char * hex_digest(); // Digest as a 33-byte ascii-hex string const char * hex_digest(); // Digest as a 33-byte ascii-hex string
private: private:
// First, some types: // First, some types:
typedef unsigned int uint4; // Assumes integer is 4 words long typedef unsigned int uint4; // Assumes integer is 4 words long
typedef unsigned short int uint2; // Assumes short integer is 2 words long typedef unsigned short int uint2; // Assumes short integer is 2 words long
typedef unsigned char uint1; // Assumes char is 1 word long typedef unsigned char uint1; // Assumes char is 1 word long
// Next, the private data: // Next, the private data:
uint4 state[4]; uint4 state[4];
uint4 count[2]; // Number of *bits*, mod 2^64 uint4 count[2]; // Number of *bits*, mod 2^64
uint1 buffer[64]; // Input buffer uint1 buffer[64]; // Input buffer
uint1 digest[16]; uint1 digest[16];
uint1 finalized; uint1 finalized;
stdstr m_hex_digest; stdstr m_hex_digest;
// Last, the private methods, mostly static: // Last, the private methods, mostly static:
void init(); // Called by all constructors void init(); // Called by all constructors
void transform(uint1 *buffer); // Does the real update work. Note that length is implied to be 64. void transform(uint1 * buffer); // Does the real update work. Note that length is implied to be 64.
static void encode(uint1 *dest, uint4 *src, uint4 length); static void encode(uint1 * dest, uint4 * src, uint4 length);
static void decode(uint4 *dest, uint1 *src, uint4 length); static void decode(uint4 * dest, uint1 * src, uint4 length);
static void memcpy(uint1 *dest, uint1 *src, uint4 length); static void memcpy(uint1 * dest, uint1 * src, uint4 length);
static void memset(uint1 *start, uint1 val, uint4 length); static void memset(uint1 * start, uint1 val, uint4 length);
static inline uint4 rotate_left(uint4 x, uint4 n); static inline uint4 rotate_left(uint4 x, uint4 n);
static inline uint4 F(uint4 x, uint4 y, uint4 z); static inline uint4 F(uint4 x, uint4 y, uint4 z);
static inline uint4 G(uint4 x, uint4 y, uint4 z); static inline uint4 G(uint4 x, uint4 y, uint4 z);
static inline uint4 H(uint4 x, uint4 y, uint4 z); static inline uint4 H(uint4 x, uint4 y, uint4 z);
static inline uint4 I(uint4 x, uint4 y, uint4 z); static inline uint4 I(uint4 x, uint4 y, uint4 z);
static inline void FF(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, static inline void FF(uint4 & a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac); uint4 s, uint4 ac);
static inline void GG(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, static inline void GG(uint4 & a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac); uint4 s, uint4 ac);
static inline void HH(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, static inline void HH(uint4 & a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac); uint4 s, uint4 ac);
static inline void II(uint4& a, uint4 b, uint4 c, uint4 d, uint4 x, static inline void II(uint4 & a, uint4 b, uint4 c, uint4 d, uint4 x,
uint4 s, uint4 ac); uint4 s, uint4 ac);
}; };

340
Source/Common/path.cpp
View File

@ -1,7 +1,7 @@
#include "path.h" #include "path.h"
#include "StdString.h"
#include "Trace.h" #include "Trace.h"
#include "TraceModulesCommon.h" #include "TraceModulesCommon.h"
#include "StdString.h"
#ifdef _WIN32 #ifdef _WIN32
#pragma warning(push) #pragma warning(push)
@ -9,13 +9,14 @@
#pragma warning(disable : 4996) // warning C4091: 'typedef ': ignored on left of 'tagGPFIDL_FLAGS' when no variable is declared #pragma warning(disable : 4996) // warning C4091: 'typedef ': ignored on left of 'tagGPFIDL_FLAGS' when no variable is declared
#include <Shlobj.h> #include <Shlobj.h>
#include <dos.h> #include <dos.h>
#include <CommDlg.h> #include <CommDlg.h>
#pragma warning(pop) #pragma warning(pop)
#else #else
#include <sys/stat.h>
#include <dirent.h> #include <dirent.h>
#include <unistd.h>
#include <errno.h> #include <errno.h>
#include <sys/stat.h>
#include <unistd.h>
#endif #endif
#include "Platform.h" #include "Platform.h"
@ -24,9 +25,17 @@
#undef WriteTrace #undef WriteTrace
#ifdef _WIN32 #ifdef _WIN32
#define WriteTrace(m, s, format, ...) if (g_ModuleLogLevel != nullptr && g_ModuleLogLevel[(m)] >= (s)) { WriteTraceFull((m), (s), __FILE__, __LINE__, __FUNCTION__, (format), ## __VA_ARGS__); } #define WriteTrace(m, s, format, ...) \
if (g_ModuleLogLevel != nullptr && g_ModuleLogLevel[(m)] >= (s)) \
{ \
WriteTraceFull((m), (s), __FILE__, __LINE__, __FUNCTION__, (format), ##__VA_ARGS__); \
}
#else #else
#define WriteTrace(m, s, format, ...) if (g_ModuleLogLevel != nullptr && g_ModuleLogLevel[(m)] >= (s)) { WriteTraceFull((m), (s), __FILE__, __LINE__, __PRETTY_FUNCTION__, (format), ## __VA_ARGS__); } #define WriteTrace(m, s, format, ...) \
if (g_ModuleLogLevel != nullptr && g_ModuleLogLevel[(m)] >= (s)) \
{ \
WriteTraceFull((m), (s), __FILE__, __LINE__, __PRETTY_FUNCTION__, (format), ##__VA_ARGS__); \
}
#endif #endif
// Constants // Constants
@ -89,7 +98,7 @@ inline void CPath::Exit()
#else #else
if (m_OpenedDir != nullptr) if (m_OpenedDir != nullptr)
{ {
closedir((DIR*)m_OpenedDir); closedir((DIR *)m_OpenedDir);
m_OpenedDir = nullptr; m_OpenedDir = nullptr;
} }
#endif #endif
@ -107,7 +116,7 @@ CPath::CPath()
// Task: Constructs a path as copy of another // Task: Constructs a path as copy of another
CPath::CPath(const CPath& rPath) CPath::CPath(const CPath & rPath)
{ {
Init(); Init();
m_strPath = rPath.m_strPath; m_strPath = rPath.m_strPath;
@ -137,7 +146,7 @@ CPath::CPath(const char * lpszPath, const char * NameExten)
// Task: Constructs a path and points it to strPath // Task: Constructs a path and points it to strPath
CPath::CPath(const std::string& strPath) CPath::CPath(const std::string & strPath)
{ {
Init(); Init();
m_strPath = strPath; m_strPath = strPath;
@ -146,26 +155,26 @@ CPath::CPath(const std::string& strPath)
// Task: Constructs a path and points it to strPath // Task: Constructs a path and points it to strPath
CPath::CPath(const std::string& strPath, const char * NameExten) CPath::CPath(const std::string & strPath, const char * NameExten)
{ {
Init(); Init();
#ifdef _WIN32 #ifdef _WIN32
SetDriveDirectory(strPath.c_str()); SetDriveDirectory(strPath.c_str());
#else #else
SetDirectory(strPath.c_str(),true); SetDirectory(strPath.c_str(), true);
#endif #endif
SetNameExtension(NameExten); SetNameExtension(NameExten);
} }
// Task: Constructs a path and points it to strPath // Task: Constructs a path and points it to strPath
CPath::CPath(const std::string& strPath, const std::string& NameExten) CPath::CPath(const std::string & strPath, const std::string & NameExten)
{ {
Init(); Init();
#ifdef _WIN32 #ifdef _WIN32
SetDriveDirectory(strPath.c_str()); SetDriveDirectory(strPath.c_str());
#else #else
SetDirectory(strPath.c_str(),true); SetDirectory(strPath.c_str(), true);
#endif #endif
SetNameExtension(NameExten.c_str()); SetNameExtension(NameExten.c_str());
} }
@ -180,7 +189,7 @@ CPath::~CPath()
// Post: Return TRUE if paths are equal // Post: Return TRUE if paths are equal
// Task: Check if the two path are the same // Task: Check if the two path are the same
bool CPath::operator ==(const CPath& rPath) const bool CPath::operator==(const CPath & rPath) const
{ {
// Get fully qualified versions of the paths // Get fully qualified versions of the paths
std::string FullyQualified1; std::string FullyQualified1;
@ -196,14 +205,14 @@ bool CPath::operator ==(const CPath& rPath) const
// Post: Return TRUE if paths are different // Post: Return TRUE if paths are different
// Task: Check if the two path are different // Task: Check if the two path are different
bool CPath::operator !=(const CPath& rPath) const bool CPath::operator!=(const CPath & rPath) const
{ {
return !(*this == rPath); return !(*this == rPath);
} }
// Task: Assign a path to another // Task: Assign a path to another
CPath& CPath::operator =(const CPath& rPath) CPath & CPath::operator=(const CPath & rPath)
{ {
if (this != &rPath) if (this != &rPath)
{ {
@ -215,7 +224,7 @@ CPath& CPath::operator =(const CPath& rPath)
// Post: Return the path, so that assignments can be chained // Post: Return the path, so that assignments can be chained
// Task: Assign a string to a path // Task: Assign a string to a path
CPath& CPath::operator =(const char * lpszPath) CPath & CPath::operator=(const char * lpszPath)
{ {
m_strPath = lpszPath ? lpszPath : ""; m_strPath = lpszPath ? lpszPath : "";
return *this; return *this;
@ -224,7 +233,7 @@ CPath& CPath::operator =(const char * lpszPath)
// Post: Return the path, so that assignments can be chained // Post: Return the path, so that assignments can be chained
// Task: Assign a string to a path // Task: Assign a string to a path
CPath& CPath::operator =(const std::string& strPath) CPath & CPath::operator=(const std::string & strPath)
{ {
m_strPath = strPath; m_strPath = strPath;
return *this; return *this;
@ -249,7 +258,10 @@ CPath::CPath(DIR_CURRENT_DIRECTORY /*sdt*/, const char * NameExten)
// Application's current directory // Application's current directory
Init(); Init();
CurrentDirectory(); CurrentDirectory();
if (NameExten) { SetNameExtension(NameExten); } if (NameExten)
{
SetNameExtension(NameExten);
}
} }
#ifdef _WIN32 #ifdef _WIN32
@ -258,7 +270,10 @@ CPath::CPath(DIR_MODULE_DIRECTORY /*sdt*/, const char * NameExten)
// The directory where the executable of this app is // The directory where the executable of this app is
Init(); Init();
ModuleDirectory(); ModuleDirectory();
if (NameExten) { SetNameExtension(NameExten); } if (NameExten)
{
SetNameExtension(NameExten);
}
} }
CPath::CPath(DIR_MODULE_FILE /*sdt*/) CPath::CPath(DIR_MODULE_FILE /*sdt*/)
@ -285,14 +300,14 @@ being <= 3 characters, or drives being 1 character.
*/ */
#ifdef _WIN32 #ifdef _WIN32
void CPath::GetComponents(std::string* pDrive, std::string* pDirectory, std::string* pName, std::string* pExtension) const void CPath::GetComponents(std::string * pDrive, std::string * pDirectory, std::string * pName, std::string * pExtension) const
{ {
WriteTrace(TracePath, TraceDebug, "Start (m_strPath: \"%s\")", m_strPath.c_str()); WriteTrace(TracePath, TraceDebug, "Start (m_strPath: \"%s\")", m_strPath.c_str());
char buff_drive[_MAX_DRIVE + 1] = { 0 }; char buff_drive[_MAX_DRIVE + 1] = {0};
char buff_dir[_MAX_DIR + 1] = { 0 }; char buff_dir[_MAX_DIR + 1] = {0};
char buff_name[_MAX_FNAME + 1] = { 0 }; char buff_name[_MAX_FNAME + 1] = {0};
char buff_ext[_MAX_EXT + 1] = { 0 }; char buff_ext[_MAX_EXT + 1] = {0};
const char * BasePath = m_strPath.c_str(); const char * BasePath = m_strPath.c_str();
const char * DriveDir = strrchr(BasePath, DRIVE_DELIMITER); const char * DriveDir = strrchr(BasePath, DRIVE_DELIMITER);
@ -348,9 +363,9 @@ void CPath::GetComponents(std::string* pDrive, std::string* pDirectory, std::str
WriteTrace(TracePath, TraceDebug, "Done (dir: \"%s\" name: \"%s\" ext: \"%s\")", buff_dir, buff_name, buff_ext); WriteTrace(TracePath, TraceDebug, "Done (dir: \"%s\" name: \"%s\" ext: \"%s\")", buff_dir, buff_name, buff_ext);
} }
#else #else
void CPath::GetComponents(std::string* pDirectory, std::string* pName, std::string* pExtension) const void CPath::GetComponents(std::string * pDirectory, std::string * pName, std::string * pExtension) const
{ {
WriteTrace(TracePath, TraceDebug, "Start (m_strPath: \"%s\")",m_strPath.c_str()); WriteTrace(TracePath, TraceDebug, "Start (m_strPath: \"%s\")", m_strPath.c_str());
char buff_dir[260]; char buff_dir[260];
char buff_name[260]; char buff_name[260];
@ -361,29 +376,29 @@ void CPath::GetComponents(std::string* pDirectory, std::string* pName, std::stri
memset(buff_ext, 0, sizeof(buff_ext)); memset(buff_ext, 0, sizeof(buff_ext));
const char * BasePath = m_strPath.c_str(); const char * BasePath = m_strPath.c_str();
const char * last = strrchr(BasePath,DIRECTORY_DELIMITER); const char * last = strrchr(BasePath, DIRECTORY_DELIMITER);
if (last != nullptr) if (last != nullptr)
{ {
int len = sizeof(buff_dir) < (last - BasePath) ? sizeof(buff_dir) : last - BasePath; int len = sizeof(buff_dir) < (last - BasePath) ? sizeof(buff_dir) : last - BasePath;
if (len > 0) if (len > 0)
{ {
strncpy(buff_dir,BasePath,len); strncpy(buff_dir, BasePath, len);
} }
else else
{ {
buff_dir[0] = DIRECTORY_DELIMITER; buff_dir[0] = DIRECTORY_DELIMITER;
buff_dir[1] = '\0'; buff_dir[1] = '\0';
} }
strncpy(buff_name,last + 1,sizeof(buff_name)); strncpy(buff_name, last + 1, sizeof(buff_name));
} }
else else
{ {
strncpy(buff_dir,BasePath,sizeof(buff_dir)); strncpy(buff_dir, BasePath, sizeof(buff_dir));
} }
char * ext = strrchr(buff_name,'.'); char * ext = strrchr(buff_name, '.');
if (ext != nullptr) if (ext != nullptr)
{ {
strncpy(buff_ext,ext + 1,sizeof(buff_ext)); strncpy(buff_ext, ext + 1, sizeof(buff_ext));
*ext = '\0'; *ext = '\0';
} }
@ -399,14 +414,14 @@ void CPath::GetComponents(std::string* pDirectory, std::string* pName, std::stri
{ {
*pExtension = buff_ext; *pExtension = buff_ext;
} }
WriteTrace(TracePath, TraceDebug, "Done (dir: \"%s\" name: \"%s\" ext: \"%s\")",buff_dir,buff_name,buff_ext); WriteTrace(TracePath, TraceDebug, "Done (dir: \"%s\" name: \"%s\" ext: \"%s\")", buff_dir, buff_name, buff_ext);
} }
#endif #endif
// Task: Get drive and directory from path // Task: Get drive and directory from path
#ifdef _WIN32 #ifdef _WIN32
void CPath::GetDriveDirectory(std::string& rDriveDirectory) const void CPath::GetDriveDirectory(std::string & rDriveDirectory) const
{ {
std::string Drive; std::string Drive;
std::string Directory; std::string Directory;
@ -430,7 +445,7 @@ std::string CPath::GetDriveDirectory(void) const
// Task: Get directory from path // Task: Get directory from path
void CPath::GetDirectory(std::string& rDirectory) const void CPath::GetDirectory(std::string & rDirectory) const
{ {
#ifdef _WIN32 #ifdef _WIN32
GetComponents(nullptr, &rDirectory); GetComponents(nullptr, &rDirectory);
@ -448,7 +463,7 @@ std::string CPath::GetDirectory(void) const
// Task: Get filename and extension from path // Task: Get filename and extension from path
void CPath::GetNameExtension(std::string& rNameExtension) const void CPath::GetNameExtension(std::string & rNameExtension) const
{ {
std::string Name; std::string Name;
std::string Extension; std::string Extension;
@ -475,7 +490,7 @@ std::string CPath::GetNameExtension(void) const
// Task: Get filename from path // Task: Get filename from path
void CPath::GetName(std::string& rName) const void CPath::GetName(std::string & rName) const
{ {
#ifdef _WIN32 #ifdef _WIN32
GetComponents(nullptr, nullptr, &rName); GetComponents(nullptr, nullptr, &rName);
@ -493,7 +508,7 @@ std::string CPath::GetName(void) const
// Task: Get file extension from path // Task: Get file extension from path
void CPath::GetExtension(std::string& rExtension) const void CPath::GetExtension(std::string & rExtension) const
{ {
#ifdef _WIN32 #ifdef _WIN32
GetComponents(nullptr, nullptr, nullptr, &rExtension); GetComponents(nullptr, nullptr, nullptr, &rExtension);
@ -511,7 +526,7 @@ std::string CPath::GetExtension(void) const
// Task: Get current directory // Task: Get current directory
void CPath::GetLastDirectory(std::string& rDirectory) const void CPath::GetLastDirectory(std::string & rDirectory) const
{ {
std::string Directory; std::string Directory;
@ -538,7 +553,7 @@ std::string CPath::GetLastDirectory(void) const
// Task: Get fully qualified path // Task: Get fully qualified path
void CPath::GetFullyQualified(std::string& rFullyQualified) const void CPath::GetFullyQualified(std::string & rFullyQualified) const
{ {
#ifdef _WIN32 #ifdef _WIN32
char buff_fullname[MAX_PATH]; char buff_fullname[MAX_PATH];
@ -560,15 +575,15 @@ bool CPath::IsRelative() const
{ {
return false; return false;
} }
if (m_strPath.length() > 2 && m_strPath[0] == DIRECTORY_DELIMITER && m_strPath[1] == DIRECTORY_DELIMITER) if (m_strPath.length() > 2 && m_strPath[0] == DIRECTORY_DELIMITER && m_strPath[1] == DIRECTORY_DELIMITER)
{ {
return false; return false;
} }
#else #else
if (m_strPath.length() > 1 && m_strPath[0] == DIRECTORY_DELIMITER) if (m_strPath.length() > 1 && m_strPath[0] == DIRECTORY_DELIMITER)
{ {
return false; return false;
} }
#endif #endif
return true; return true;
} }
@ -583,7 +598,7 @@ void CPath::SetComponents(const char * lpszDrive, const char * lpszDirectory, co
memset(buff_fullname, 0, sizeof(buff_fullname)); memset(buff_fullname, 0, sizeof(buff_fullname));
if (lpszDirectory == nullptr || strlen(lpszDirectory) == 0) if (lpszDirectory == nullptr || strlen(lpszDirectory) == 0)
{ {
static char empty_dir[] = { DIRECTORY_DELIMITER, '\0' }; static char empty_dir[] = {DIRECTORY_DELIMITER, '\0'};
lpszDirectory = empty_dir; lpszDirectory = empty_dir;
} }
@ -599,25 +614,28 @@ void CPath::SetComponents(const char * lpszDirectory, const char * lpszName, con
memset(buff_fullname, 0, sizeof(buff_fullname)); memset(buff_fullname, 0, sizeof(buff_fullname));
if (lpszDirectory != nullptr && lpszDirectory[0] != '\0') if (lpszDirectory != nullptr && lpszDirectory[0] != '\0')
{ {
if (lpszDirectory[0] != DIRECTORY_DELIMITER) { buff_fullname[0] = DIRECTORY_DELIMITER; } if (lpszDirectory[0] != DIRECTORY_DELIMITER)
strncat(buff_fullname,lpszDirectory,sizeof(buff_fullname) - 1); {
buff_fullname[0] = DIRECTORY_DELIMITER;
}
strncat(buff_fullname, lpszDirectory, sizeof(buff_fullname) - 1);
std::string::size_type nLength = strlen(buff_fullname); std::string::size_type nLength = strlen(buff_fullname);
if (buff_fullname[nLength - 1] != DIRECTORY_DELIMITER && nLength < sizeof(buff_fullname)) if (buff_fullname[nLength - 1] != DIRECTORY_DELIMITER && nLength < sizeof(buff_fullname))
{ {
buff_fullname[nLength] = DIRECTORY_DELIMITER; buff_fullname[nLength] = DIRECTORY_DELIMITER;
} }
} }
if (lpszName != nullptr) if (lpszName != nullptr)
{ {
strncat(buff_fullname,lpszName,sizeof(buff_fullname) - 1); strncat(buff_fullname, lpszName, sizeof(buff_fullname) - 1);
} }
if (lpszExtension != nullptr && lpszExtension[0] != '\0') if (lpszExtension != nullptr && lpszExtension[0] != '\0')
{ {
if (lpszExtension[0] != '.') if (lpszExtension[0] != '.')
{ {
strncat(buff_fullname,".",sizeof(buff_fullname)-1); strncat(buff_fullname, ".", sizeof(buff_fullname) - 1);
} }
strncat(buff_fullname,lpszExtension,sizeof(buff_fullname)-1); strncat(buff_fullname, lpszExtension, sizeof(buff_fullname) - 1);
} }
buff_fullname[sizeof(buff_fullname) - 1] = 0; // Make sure it is null terminated buff_fullname[sizeof(buff_fullname) - 1] = 0; // Make sure it is null terminated
m_strPath.erase(); m_strPath.erase();
@ -631,9 +649,9 @@ void CPath::SetComponents(const char * lpszDirectory, const char * lpszName, con
void CPath::SetDrive(char chDrive) void CPath::SetDrive(char chDrive)
{ {
stdstr_f Drive("%c", chDrive); stdstr_f Drive("%c", chDrive);
std::string Directory; std::string Directory;
std::string Name; std::string Name;
std::string Extension; std::string Extension;
GetComponents(nullptr, &Directory, &Name, &Extension); GetComponents(nullptr, &Directory, &Name, &Extension);
SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), Extension.c_str()); SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), Extension.c_str());
@ -645,9 +663,9 @@ void CPath::SetDrive(char chDrive)
void CPath::SetDirectory(const char * lpszDirectory, bool bEnsureAbsolute /*= false*/) void CPath::SetDirectory(const char * lpszDirectory, bool bEnsureAbsolute /*= false*/)
{ {
WriteTrace(TracePath, TraceDebug, "Start (lpszDirectory: \"%s\" bEnsureAbsolute: %s)", lpszDirectory ? lpszDirectory : "(null)", bEnsureAbsolute ? "true" : "false"); WriteTrace(TracePath, TraceDebug, "Start (lpszDirectory: \"%s\" bEnsureAbsolute: %s)", lpszDirectory ? lpszDirectory : "(null)", bEnsureAbsolute ? "true" : "false");
std::string Directory = lpszDirectory; std::string Directory = lpszDirectory;
std::string Name; std::string Name;
std::string Extension; std::string Extension;
if (bEnsureAbsolute) if (bEnsureAbsolute)
{ {
@ -659,7 +677,7 @@ void CPath::SetDirectory(const char * lpszDirectory, bool bEnsureAbsolute /*= fa
} }
#ifdef _WIN32 #ifdef _WIN32
std::string Drive; std::string Drive;
GetComponents(&Drive, nullptr, &Name, &Extension); GetComponents(&Drive, nullptr, &Name, &Extension);
SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), Extension.c_str()); SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), Extension.c_str());
#else #else
@ -675,9 +693,9 @@ void CPath::SetDirectory(const char * lpszDirectory, bool bEnsureAbsolute /*= fa
void CPath::SetDriveDirectory(const char * lpszDriveDirectory) void CPath::SetDriveDirectory(const char * lpszDriveDirectory)
{ {
std::string DriveDirectory = lpszDriveDirectory; std::string DriveDirectory = lpszDriveDirectory;
std::string Name; std::string Name;
std::string Extension; std::string Extension;
if (DriveDirectory.length() > 0) if (DriveDirectory.length() > 0)
{ {
@ -694,11 +712,11 @@ void CPath::SetDriveDirectory(const char * lpszDriveDirectory)
void CPath::SetName(const char * lpszName) void CPath::SetName(const char * lpszName)
{ {
std::string Directory; std::string Directory;
std::string Extension; std::string Extension;
#ifdef _WIN32 #ifdef _WIN32
std::string Drive; std::string Drive;
GetComponents(&Drive, &Directory, nullptr, &Extension); GetComponents(&Drive, &Directory, nullptr, &Extension);
SetComponents(Drive.c_str(), Directory.c_str(), lpszName, Extension.c_str()); SetComponents(Drive.c_str(), Directory.c_str(), lpszName, Extension.c_str());
#else #else
@ -711,16 +729,16 @@ void CPath::SetName(const char * lpszName)
void CPath::SetName(int iName) void CPath::SetName(int iName)
{ {
std::string Directory; std::string Directory;
std::string Extension; std::string Extension;
char sName[33]; char sName[33];
memset(sName, 0, sizeof(sName)); memset(sName, 0, sizeof(sName));
_snprintf(sName, sizeof(sName), "%d", iName); _snprintf(sName, sizeof(sName), "%d", iName);
#ifdef _WIN32 #ifdef _WIN32
std::string Drive; std::string Drive;
GetComponents(&Drive, &Directory, nullptr, &Extension); GetComponents(&Drive, &Directory, nullptr, &Extension);
SetComponents(Drive.c_str(), Directory.c_str(), sName, Extension.c_str()); SetComponents(Drive.c_str(), Directory.c_str(), sName, Extension.c_str());
#else #else
@ -733,11 +751,11 @@ void CPath::SetName(int iName)
void CPath::SetExtension(const char * lpszExtension) void CPath::SetExtension(const char * lpszExtension)
{ {
std::string Directory; std::string Directory;
std::string Name; std::string Name;
#ifdef _WIN32 #ifdef _WIN32
std::string Drive; std::string Drive;
GetComponents(&Drive, &Directory, &Name); GetComponents(&Drive, &Directory, &Name);
SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), lpszExtension); SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), lpszExtension);
#else #else
@ -750,8 +768,8 @@ void CPath::SetExtension(const char * lpszExtension)
void CPath::SetExtension(int iExtension) void CPath::SetExtension(int iExtension)
{ {
std::string Directory; std::string Directory;
std::string Name; std::string Name;
char sExtension[20]; char sExtension[20];
memset(sExtension, 0, sizeof(sExtension)); memset(sExtension, 0, sizeof(sExtension));
@ -759,7 +777,7 @@ void CPath::SetExtension(int iExtension)
_snprintf(sExtension, sizeof(sExtension), "%d", iExtension); _snprintf(sExtension, sizeof(sExtension), "%d", iExtension);
#ifdef _WIN32 #ifdef _WIN32
std::string Drive; std::string Drive;
GetComponents(&Drive, &Directory, &Name); GetComponents(&Drive, &Directory, &Name);
SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), sExtension); SetComponents(Drive.c_str(), Directory.c_str(), Name.c_str(), sExtension);
#else #else
@ -772,10 +790,10 @@ void CPath::SetExtension(int iExtension)
void CPath::SetNameExtension(const char * lpszNameExtension) void CPath::SetNameExtension(const char * lpszNameExtension)
{ {
std::string Directory; std::string Directory;
#ifdef _WIN32 #ifdef _WIN32
std::string Drive; std::string Drive;
GetComponents(&Drive, &Directory); GetComponents(&Drive, &Directory);
SetComponents(Drive.c_str(), Directory.c_str(), lpszNameExtension, nullptr); SetComponents(Drive.c_str(), Directory.c_str(), lpszNameExtension, nullptr);
#else #else
@ -788,10 +806,10 @@ void CPath::SetNameExtension(const char * lpszNameExtension)
void CPath::AppendDirectory(const char * lpszSubDirectory) void CPath::AppendDirectory(const char * lpszSubDirectory)
{ {
std::string Directory; std::string Directory;
std::string SubDirectory = lpszSubDirectory; std::string SubDirectory = lpszSubDirectory;
std::string Name; std::string Name;
std::string Extension; std::string Extension;
if (SubDirectory.empty()) if (SubDirectory.empty())
{ {
@ -803,7 +821,7 @@ void CPath::AppendDirectory(const char * lpszSubDirectory)
EnsureTrailingBackslash(SubDirectory); EnsureTrailingBackslash(SubDirectory);
#ifdef _WIN32 #ifdef _WIN32
std::string Drive; std::string Drive;
GetComponents(&Drive, &Directory, &Name, &Extension); GetComponents(&Drive, &Directory, &Name, &Extension);
#else #else
GetComponents(&Directory, &Name, &Extension); GetComponents(&Directory, &Name, &Extension);
@ -824,7 +842,7 @@ deepest directory (the one we're exiting) in it
Task: Remove deepest subdirectory from path Task: Remove deepest subdirectory from path
*/ */
void CPath::UpDirectory(std::string *pLastDirectory /*= nullptr*/) void CPath::UpDirectory(std::string * pLastDirectory /*= nullptr*/)
{ {
std::string Directory; std::string Directory;
@ -927,7 +945,7 @@ use CPath::FindFirst() because that routine parses out
bool CPath::DirectoryExists() const bool CPath::DirectoryExists() const
{ {
WriteTrace(TracePath, TraceDebug, "m_strPath = %s",m_strPath.c_str()); WriteTrace(TracePath, TraceDebug, "m_strPath = %s", m_strPath.c_str());
#ifdef _WIN32 #ifdef _WIN32
// Create test path // Create test path
CPath TestPath(m_strPath.c_str()); CPath TestPath(m_strPath.c_str());
@ -940,21 +958,21 @@ bool CPath::DirectoryExists() const
HANDLE hFindFile = FindFirstFileA((const char *)TestPath, &FindData); // Find anything HANDLE hFindFile = FindFirstFileA((const char *)TestPath, &FindData); // Find anything
bool res = (hFindFile != INVALID_HANDLE_VALUE); bool res = (hFindFile != INVALID_HANDLE_VALUE);
if (hFindFile != nullptr) // Make sure we close the search if (hFindFile != nullptr) // Make sure we close the search
{ {
FindClose(hFindFile); FindClose(hFindFile);
} }
#else #else
std::string PathText; std::string PathText;
GetDirectory(PathText); GetDirectory(PathText);
StripTrailingBackslash(PathText); StripTrailingBackslash(PathText);
WriteTrace(TracePath, TraceDebug, "Checking if directory \"%s\" exists",PathText.c_str()); WriteTrace(TracePath, TraceDebug, "Checking if directory \"%s\" exists", PathText.c_str());
struct stat fileinfo; struct stat fileinfo;
bool res = stat(PathText.c_str(), &fileinfo) == 0 && S_ISDIR(fileinfo.st_mode); bool res = stat(PathText.c_str(), &fileinfo) == 0 && S_ISDIR(fileinfo.st_mode);
#endif #endif
WriteTrace(TracePath, TraceDebug, "Exist = %s",res ? "True" : "False"); WriteTrace(TracePath, TraceDebug, "Exist = %s", res ? "True" : "False");
return res; return res;
} }
@ -968,7 +986,7 @@ bool CPath::Exists() const
HANDLE hFindFile = FindFirstFileA(m_strPath.c_str(), &FindData); HANDLE hFindFile = FindFirstFileA(m_strPath.c_str(), &FindData);
bool bSuccess = (hFindFile != INVALID_HANDLE_VALUE); bool bSuccess = (hFindFile != INVALID_HANDLE_VALUE);
if (hFindFile != nullptr) // Make sure we close the search if (hFindFile != nullptr) // Make sure we close the search
{ {
FindClose(hFindFile); FindClose(hFindFile);
} }
@ -1053,7 +1071,7 @@ bool CPath::CopyTo(const char * lpcszTargetFile, bool bOverwrite)
{ {
return false; return false;
} }
WriteTrace(TracePath, TraceDebug, "Copy \"%s\" to \"%s\"",m_strPath.c_str(),lpcszTargetFile); WriteTrace(TracePath, TraceDebug, "Copy \"%s\" to \"%s\"", m_strPath.c_str(), lpcszTargetFile);
#ifdef _WIN32 #ifdef _WIN32
// Check if the target file exists // Check if the target file exists
CPath TargetFile(lpcszTargetFile); CPath TargetFile(lpcszTargetFile);
@ -1079,31 +1097,31 @@ bool CPath::CopyTo(const char * lpcszTargetFile, bool bOverwrite)
#else #else
bool res = true; bool res = true;
WriteTrace(TracePath, TraceDebug, "Opening \"%s\" for reading",m_strPath.c_str()); WriteTrace(TracePath, TraceDebug, "Opening \"%s\" for reading", m_strPath.c_str());
FILE * infile = fopen(m_strPath.c_str(), "rb"); FILE * infile = fopen(m_strPath.c_str(), "rb");
if(infile == nullptr) if (infile == nullptr)
{ {
WriteTrace(TracePath, TraceWarning, "Failed to open m_strPath = %s",m_strPath.c_str()); WriteTrace(TracePath, TraceWarning, "Failed to open m_strPath = %s", m_strPath.c_str());
res = false; res = false;
} }
else else
{ {
WriteTrace(TracePath, TraceDebug, "Opened \"%s\"",m_strPath.c_str()); WriteTrace(TracePath, TraceDebug, "Opened \"%s\"", m_strPath.c_str());
} }
FILE * outfile = nullptr; FILE * outfile = nullptr;
if (res) if (res)
{ {
WriteTrace(TracePath, TraceDebug, "Opening \"%s\" for writing",lpcszTargetFile); WriteTrace(TracePath, TraceDebug, "Opening \"%s\" for writing", lpcszTargetFile);
outfile = fopen(lpcszTargetFile, "wb"); outfile = fopen(lpcszTargetFile, "wb");
if (outfile == nullptr) if (outfile == nullptr)
{ {
WriteTrace(TracePath, TraceWarning, "Failed to open m_strPath = %s errno=%d",lpcszTargetFile, errno); WriteTrace(TracePath, TraceWarning, "Failed to open m_strPath = %s errno=%d", lpcszTargetFile, errno);
res = false; res = false;
} }
else else
{ {
WriteTrace(TracePath, TraceDebug, "Opened \"%s\"",lpcszTargetFile); WriteTrace(TracePath, TraceDebug, "Opened \"%s\"", lpcszTargetFile);
} }
} }
@ -1144,7 +1162,7 @@ bool CPath::CopyTo(const char * lpcszTargetFile, bool bOverwrite)
} }
if (res) if (res)
{ {
if (fchmod(fileno(outfile),ts.st_mode) != 0) if (fchmod(fileno(outfile), ts.st_mode) != 0)
{ {
WriteTrace(TracePath, TraceWarning, "fchmod failed on %s, errno = %X", lpcszTargetFile, errno); WriteTrace(TracePath, TraceWarning, "fchmod failed on %s, errno = %X", lpcszTargetFile, errno);
res = false; res = false;
@ -1158,7 +1176,7 @@ bool CPath::CopyTo(const char * lpcszTargetFile, bool bOverwrite)
{ {
fclose(outfile); fclose(outfile);
} }
WriteTrace(TracePath, TraceDebug, "Done, res: %s",res ? "true" : "false"); WriteTrace(TracePath, TraceDebug, "Done, res: %s", res ? "true" : "false");
return res; return res;
#endif #endif
} }
@ -1334,20 +1352,20 @@ bool CPath::FindNext()
} }
} }
#else #else
dirent* pEntry; dirent * pEntry;
while ((pEntry = readdir((DIR*)m_OpenedDir))) while ((pEntry = readdir((DIR *)m_OpenedDir)))
{ {
uint32_t dwFileAttributes = pEntry->d_type == DT_DIR ? FIND_ATTRIBUTE_SUBDIR : FIND_ATTRIBUTE_FILES; uint32_t dwFileAttributes = pEntry->d_type == DT_DIR ? FIND_ATTRIBUTE_SUBDIR : FIND_ATTRIBUTE_FILES;
WriteTrace(TracePath, TraceVerbose, "m_dwFindFileAttributes = %X dwFileAttributes = %X AttributesMatch: %s",m_dwFindFileAttributes, dwFileAttributes, AttributesMatch(m_dwFindFileAttributes, dwFileAttributes) ? "true" : "false"); WriteTrace(TracePath, TraceVerbose, "m_dwFindFileAttributes = %X dwFileAttributes = %X AttributesMatch: %s", m_dwFindFileAttributes, dwFileAttributes, AttributesMatch(m_dwFindFileAttributes, dwFileAttributes) ? "true" : "false");
// Compare candidate to attributes, and filter out the "." and ".." folders // Compare candidate to attributes, and filter out the "." and ".." folders
if (!AttributesMatch(m_dwFindFileAttributes, dwFileAttributes) || if (!AttributesMatch(m_dwFindFileAttributes, dwFileAttributes) ||
strcmp(pEntry->d_name,".") == 0 || strcmp(pEntry->d_name, ".") == 0 ||
strcmp(pEntry->d_name,"..") == 0 || strcmp(pEntry->d_name, "..") == 0 ||
!wildcmp(m_FindWildcard.c_str(),pEntry->d_name)) !wildcmp(m_FindWildcard.c_str(), pEntry->d_name))
{ {
WriteTrace(TracePath, TraceVerbose, "Continue, d_name = %s",pEntry->d_name); WriteTrace(TracePath, TraceVerbose, "Continue, d_name = %s", pEntry->d_name);
continue; continue;
} }
if ((FIND_ATTRIBUTE_SUBDIR & dwFileAttributes) == FIND_ATTRIBUTE_SUBDIR) if ((FIND_ATTRIBUTE_SUBDIR & dwFileAttributes) == FIND_ATTRIBUTE_SUBDIR)
@ -1407,48 +1425,48 @@ bool CPath::ChangeDirectory()
void CPath::NormalizePath(CPath BaseDir) void CPath::NormalizePath(CPath BaseDir)
{ {
#ifdef _WIN32 #ifdef _WIN32
stdstr Directory = BaseDir.GetDriveDirectory(); stdstr Directory = BaseDir.GetDriveDirectory();
#else #else
stdstr Directory = BaseDir.GetDirectory(); stdstr Directory = BaseDir.GetDirectory();
#endif #endif
bool Changed = false; bool Changed = false;
if (IsRelative()) if (IsRelative())
{ {
EnsureTrailingBackslash(Directory); EnsureTrailingBackslash(Directory);
Directory += GetDirectory(); Directory += GetDirectory();
Changed = true; Changed = true;
} }
strvector Parts = Directory.Tokenize(DIRECTORY_DELIMITER); strvector Parts = Directory.Tokenize(DIRECTORY_DELIMITER);
strvector NormalizesParts; strvector NormalizesParts;
for (strvector::const_iterator itr = Parts.begin(); itr != Parts.end(); itr++) for (strvector::const_iterator itr = Parts.begin(); itr != Parts.end(); itr++)
{ {
if (*itr == ".") if (*itr == ".")
{ {
Changed = true; Changed = true;
} }
else if (*itr == "..") else if (*itr == "..")
{ {
NormalizesParts.pop_back(); NormalizesParts.pop_back();
Changed = true; Changed = true;
} }
else else
{ {
NormalizesParts.push_back(*itr); NormalizesParts.push_back(*itr);
} }
} }
if (Changed) if (Changed)
{ {
Directory.clear(); Directory.clear();
for (strvector::const_iterator itr = NormalizesParts.begin(); itr != NormalizesParts.end(); itr++) for (strvector::const_iterator itr = NormalizesParts.begin(); itr != NormalizesParts.end(); itr++)
{ {
Directory += *itr + DIRECTORY_DELIMITER; Directory += *itr + DIRECTORY_DELIMITER;
} }
#ifdef _WIN32 #ifdef _WIN32
SetDriveDirectory(Directory.c_str()); SetDriveDirectory(Directory.c_str());
#else #else
SetDirectory(Directory.c_str()); SetDirectory(Directory.c_str());
#endif #endif
} }
} }
// Pre: If bCreateIntermediates is TRUE, create all eventually missing parent directories too // Pre: If bCreateIntermediates is TRUE, create all eventually missing parent directories too
@ -1457,9 +1475,9 @@ void CPath::NormalizePath(CPath BaseDir)
bool CPath::DirectoryCreate(bool bCreateIntermediates /*= TRUE*/) bool CPath::DirectoryCreate(bool bCreateIntermediates /*= TRUE*/)
{ {
WriteTrace(TracePath, TraceDebug, "m_strPath = %s bCreateIntermediates = %s",m_strPath.c_str(),bCreateIntermediates ? "true" : "false"); WriteTrace(TracePath, TraceDebug, "m_strPath = %s bCreateIntermediates = %s", m_strPath.c_str(), bCreateIntermediates ? "true" : "false");
std::string PathText; std::string PathText;
bool bSuccess; bool bSuccess;
if (DirectoryExists()) if (DirectoryExists())
{ {
@ -1470,16 +1488,16 @@ bool CPath::DirectoryCreate(bool bCreateIntermediates /*= TRUE*/)
#ifdef _WIN32 #ifdef _WIN32
GetDriveDirectory(PathText); GetDriveDirectory(PathText);
StripTrailingBackslash(PathText); StripTrailingBackslash(PathText);
WriteTrace(TracePath, TraceDebug, "Create %s",PathText.c_str()); WriteTrace(TracePath, TraceDebug, "Create %s", PathText.c_str());
bSuccess = ::CreateDirectoryA(PathText.c_str(), nullptr) != 0; bSuccess = ::CreateDirectoryA(PathText.c_str(), nullptr) != 0;
#else #else
GetDirectory(PathText); GetDirectory(PathText);
StripTrailingBackslash(PathText); StripTrailingBackslash(PathText);
WriteTrace(TracePath, TraceDebug, "Create %s",PathText.c_str()); WriteTrace(TracePath, TraceDebug, "Create %s", PathText.c_str());
bSuccess = mkdir(PathText.c_str(), S_IRWXU) == 0; bSuccess = mkdir(PathText.c_str(), S_IRWXU) == 0;
if (!bSuccess) if (!bSuccess)
{ {
WriteTrace(TracePath, TraceWarning, "Failed to create \"%s\" errno: %d",PathText.c_str(), errno); WriteTrace(TracePath, TraceWarning, "Failed to create \"%s\" errno: %d", PathText.c_str(), errno);
} }
#endif #endif
if (!bSuccess && bCreateIntermediates) if (!bSuccess && bCreateIntermediates)
@ -1496,7 +1514,7 @@ bool CPath::DirectoryCreate(bool bCreateIntermediates /*= TRUE*/)
return SubPath.DirectoryCreate() ? DirectoryCreate(false) : false; return SubPath.DirectoryCreate() ? DirectoryCreate(false) : false;
} }
WriteTrace(TracePath, TraceDebug, "res = %s",bSuccess ? "true" : "false"); WriteTrace(TracePath, TraceDebug, "res = %s", bSuccess ? "true" : "false");
return bSuccess; return bSuccess;
} }
@ -1504,7 +1522,7 @@ bool CPath::DirectoryCreate(bool bCreateIntermediates /*= TRUE*/)
// Task: Remove first character (if any) if it's chLeading // Task: Remove first character (if any) if it's chLeading
void CPath::cleanPathString(std::string& rDirectory) const void CPath::cleanPathString(std::string & rDirectory) const
{ {
std::string::size_type pos = rDirectory.find(DIRECTORY_DELIMITER2); std::string::size_type pos = rDirectory.find(DIRECTORY_DELIMITER2);
while (pos != std::string::npos) while (pos != std::string::npos)
@ -1526,7 +1544,7 @@ void CPath::cleanPathString(std::string& rDirectory) const
} }
} }
void CPath::StripLeadingChar(std::string& rText, char chLeading) const void CPath::StripLeadingChar(std::string & rText, char chLeading) const
{ {
std::string::size_type nLength = rText.length(); std::string::size_type nLength = rText.length();
if (nLength == 0) if (nLength == 0)
@ -1538,7 +1556,7 @@ void CPath::StripLeadingChar(std::string& rText, char chLeading) const
// Task: Remove first character if '\' // Task: Remove first character if '\'
void CPath::StripLeadingBackslash(std::string& Directory) const void CPath::StripLeadingBackslash(std::string & Directory) const
{ {
std::string::size_type nLength = Directory.length(); std::string::size_type nLength = Directory.length();
@ -1552,7 +1570,7 @@ void CPath::StripLeadingBackslash(std::string& Directory) const
// Task: Remove last character (if any) if it's chTrailing // Task: Remove last character (if any) if it's chTrailing
void CPath::StripTrailingChar(std::string& rText, char chTrailing) const void CPath::StripTrailingChar(std::string & rText, char chTrailing) const
{ {
std::string::size_type nLength = rText.length(); std::string::size_type nLength = rText.length();
if (nLength == 0) if (nLength == 0)
@ -1564,7 +1582,7 @@ void CPath::StripTrailingChar(std::string& rText, char chTrailing) const
// Task: Remove last character if '\' // Task: Remove last character if '\'
void CPath::StripTrailingBackslash(std::string& rDirectory) const void CPath::StripTrailingBackslash(std::string & rDirectory) const
{ {
for (;;) for (;;)
{ {
@ -1585,7 +1603,7 @@ void CPath::StripTrailingBackslash(std::string& rDirectory) const
// Task: Add a backslash to the end of the directory if there is not already one there // Task: Add a backslash to the end of the directory if there is not already one there
void CPath::EnsureTrailingBackslash(std::string& Directory) const void CPath::EnsureTrailingBackslash(std::string & Directory) const
{ {
std::string::size_type nLength = Directory.length(); std::string::size_type nLength = Directory.length();
@ -1606,7 +1624,7 @@ void CPath::EnsureLeadingBackslash(std::string & Directory) const
} }
#ifndef _WIN32 #ifndef _WIN32
bool CPath::wildcmp(const char *wild, const char *string) bool CPath::wildcmp(const char * wild, const char * string)
{ {
const char *cp = nullptr, *mp = nullptr; const char *cp = nullptr, *mp = nullptr;
@ -1629,7 +1647,7 @@ bool CPath::wildcmp(const char *wild, const char *string)
return 1; return 1;
} }
mp = wild; mp = wild;
cp = string+1; cp = string + 1;
} }
else if ((*wild == *string) || (*wild == '?')) else if ((*wild == *string) || (*wild == '?'))
{ {

106
Source/Common/path.h
View File

@ -1,30 +1,38 @@
#pragma once #pragma once
#include <string>
#include <stdint.h> #include <stdint.h>
#include <string>
class CPath class CPath
{ {
// Enums // Enums
public: public:
enum DIR_CURRENT_DIRECTORY
enum DIR_CURRENT_DIRECTORY { CURRENT_DIRECTORY = 1 }; {
CURRENT_DIRECTORY = 1
};
#ifdef _WIN32 #ifdef _WIN32
enum DIR_MODULE_DIRECTORY { MODULE_DIRECTORY = 2 }; enum DIR_MODULE_DIRECTORY
enum DIR_MODULE_FILE { MODULE_FILE = 3 }; {
MODULE_DIRECTORY = 2
};
enum DIR_MODULE_FILE
{
MODULE_FILE = 3
};
#endif #endif
enum enum
{ {
FIND_ATTRIBUTE_ALLFILES = 0xFFFF, // Search include all files FIND_ATTRIBUTE_ALLFILES = 0xFFFF, // Search include all files
FIND_ATTRIBUTE_FILES = 0x0000, // File can be read or written to without restriction FIND_ATTRIBUTE_FILES = 0x0000, // File can be read or written to without restriction
FIND_ATTRIBUTE_SUBDIR = 0x0010, // Subdirectories FIND_ATTRIBUTE_SUBDIR = 0x0010, // Subdirectories
}; };
// Attributes // Attributes
private: private:
std::string m_strPath; std::string m_strPath;
#ifdef _WIN32 #ifdef _WIN32
void * m_hFindFile; void * m_hFindFile;
static void * m_hInst; static void * m_hInst;
#else #else
void * m_OpenedDir; void * m_OpenedDir;
@ -37,12 +45,12 @@ public:
// Construction / destruction // Construction / destruction
CPath(); CPath();
CPath(const CPath& rPath); CPath(const CPath & rPath);
CPath(const char * lpszPath); CPath(const char * lpszPath);
CPath(const char * lpszPath, const char * NameExten); CPath(const char * lpszPath, const char * NameExten);
CPath(const std::string& strPath); CPath(const std::string & strPath);
CPath(const std::string& strPath, const char * NameExten); CPath(const std::string & strPath, const char * NameExten);
CPath(const std::string& strPath, const std::string& NameExten); CPath(const std::string & strPath, const std::string & NameExten);
CPath(DIR_CURRENT_DIRECTORY sdt, const char * NameExten = nullptr); CPath(DIR_CURRENT_DIRECTORY sdt, const char * NameExten = nullptr);
#ifdef _WIN32 #ifdef _WIN32
@ -52,37 +60,43 @@ public:
virtual ~CPath(); virtual ~CPath();
// Operators // Operators
CPath& operator = (const CPath& rPath); CPath & operator=(const CPath & rPath);
CPath& operator = (const char * lpszPath); CPath & operator=(const char * lpszPath);
CPath& operator = (const std::string & strPath); CPath & operator=(const std::string & strPath);
bool operator == (const CPath& rPath) const; bool operator==(const CPath & rPath) const;
bool operator != (const CPath& rPath) const; bool operator!=(const CPath & rPath) const;
operator const char *() const; operator const char *() const;
operator const std::string &() { return m_strPath; } operator const std::string &()
{
return m_strPath;
}
// Get path components // Get path components
#ifdef _WIN32 #ifdef _WIN32
void GetDriveDirectory(std::string & rDriveDirectory) const; void GetDriveDirectory(std::string & rDriveDirectory) const;
std::string GetDriveDirectory(void) const; std::string GetDriveDirectory(void) const;
#endif #endif
void GetDirectory(std::string& rDirectory) const; void GetDirectory(std::string & rDirectory) const;
std::string GetDirectory(void) const; std::string GetDirectory(void) const;
void GetName(std::string& rName) const; void GetName(std::string & rName) const;
std::string GetName(void) const; std::string GetName(void) const;
void GetNameExtension(std::string& rNameExtension) const; void GetNameExtension(std::string & rNameExtension) const;
std::string GetNameExtension(void) const; std::string GetNameExtension(void) const;
void GetExtension(std::string& rExtension) const; void GetExtension(std::string & rExtension) const;
std::string GetExtension(void) const; std::string GetExtension(void) const;
void GetLastDirectory(std::string& rDirectory) const; void GetLastDirectory(std::string & rDirectory) const;
std::string GetLastDirectory(void) const; std::string GetLastDirectory(void) const;
void GetFullyQualified(std::string& rFullyQualified) const; void GetFullyQualified(std::string & rFullyQualified) const;
#ifdef _WIN32 #ifdef _WIN32
void GetComponents(std::string* pDrive = nullptr, std::string* pDirectory = nullptr, std::string* pName = nullptr, std::string* pExtension = nullptr) const; void GetComponents(std::string * pDrive = nullptr, std::string * pDirectory = nullptr, std::string * pName = nullptr, std::string * pExtension = nullptr) const;
#else #else
void GetComponents(std::string* pDirectory = nullptr, std::string* pName = nullptr, std::string* pExtension = nullptr) const; void GetComponents(std::string * pDirectory = nullptr, std::string * pName = nullptr, std::string * pExtension = nullptr) const;
#endif #endif
// Get other state // Get other state
bool IsEmpty() const { return m_strPath.empty(); } bool IsEmpty() const
{
return m_strPath.empty();
}
bool IsRelative() const; bool IsRelative() const;
// Set path components // Set path components
@ -97,14 +111,17 @@ public:
void SetExtension(const char * lpszExtension); void SetExtension(const char * lpszExtension);
void SetExtension(int iExtension); void SetExtension(int iExtension);
void AppendDirectory(const char * lpszSubDirectory); void AppendDirectory(const char * lpszSubDirectory);
void UpDirectory(std::string* pLastDirectory = nullptr); void UpDirectory(std::string * pLastDirectory = nullptr);
#ifdef _WIN32 #ifdef _WIN32
void SetComponents(const char * lpszDrive, const char * lpszDirectory, const char * lpszName, const char * lpszExtension); void SetComponents(const char * lpszDrive, const char * lpszDirectory, const char * lpszName, const char * lpszExtension);
#else #else
void SetComponents(const char * lpszDirectory, const char * lpszName, const char * lpszExtension); void SetComponents(const char * lpszDirectory, const char * lpszName, const char * lpszExtension);
#endif #endif
// Set whole path // Set whole path
void Empty() { m_strPath.erase(); } void Empty()
{
m_strPath.erase();
}
void CurrentDirectory(); void CurrentDirectory();
#ifdef _WIN32 #ifdef _WIN32
void Module(); void Module();
@ -118,7 +135,10 @@ public:
bool DirectoryExists() const; bool DirectoryExists() const;
// File information // File information
bool IsFile() const { return !IsDirectory(); } bool IsFile() const
{
return !IsDirectory();
}
bool Exists() const; bool Exists() const;
#ifdef _WIN32 #ifdef _WIN32
bool SelectFile(void * hwndOwner, const char * InitialDir, const char * FileFilter, bool FileMustExist); bool SelectFile(void * hwndOwner, const char * InitialDir, const char * FileFilter, bool FileMustExist);
@ -127,7 +147,7 @@ public:
// Directory operations // Directory operations
bool DirectoryCreate(bool bCreateIntermediates = true); bool DirectoryCreate(bool bCreateIntermediates = true);
bool ChangeDirectory(); bool ChangeDirectory();
void NormalizePath(CPath BaseDir); void NormalizePath(CPath BaseDir);
// File operations // File operations
bool Delete(bool bEvenIfReadOnly = true) const; bool Delete(bool bEvenIfReadOnly = true) const;
@ -151,14 +171,14 @@ private:
bool AttributesMatch(uint32_t dwTargetAttributes, uint32_t dwFileAttributes); bool AttributesMatch(uint32_t dwTargetAttributes, uint32_t dwFileAttributes);
void cleanPathString(std::string& rDirectory) const; void cleanPathString(std::string & rDirectory) const;
void StripLeadingChar(std::string& rText, char chLeading) const; void StripLeadingChar(std::string & rText, char chLeading) const;
void StripLeadingBackslash(std::string& Directory) const; void StripLeadingBackslash(std::string & Directory) const;
void StripTrailingChar(std::string& rText, char chTrailing) const; void StripTrailingChar(std::string & rText, char chTrailing) const;
void StripTrailingBackslash(std::string& rDirectory) const; void StripTrailingBackslash(std::string & rDirectory) const;
void EnsureTrailingBackslash(std::string& Directory) const; void EnsureTrailingBackslash(std::string & Directory) const;
void EnsureLeadingBackslash(std::string& Directory) const; void EnsureLeadingBackslash(std::string & Directory) const;
#ifndef _WIN32 #ifndef _WIN32
bool wildcmp(const char *wild, const char *string); bool wildcmp(const char * wild, const char * string);
#endif #endif
}; };