mirror of
https://github.com/1dot13/source.git
synced 2026-08-12 14:10:23 +02:00
*** Merged Code from Multiplayer Branch Revision 2993 ***
- Updated VFS - Fixed Map Editor not properly initialized with VFS - New Map Editor Release (Build: 2993( git-svn-id: https://ja2svn.mooo.com/source/ja2/trunk/GameSource/ja2_v1.13/Build@2994 3b4a5df2-a311-0410-b5c6-a8a6f20db521
This commit is contained in:
Wanne
+3
-533
@@ -6,211 +6,12 @@
|
||||
#include "vfs_file_raii.h"
|
||||
#include "iteratedir.h"
|
||||
|
||||
#include "Tools/Tools.h"
|
||||
#include "Tools/ParserTools.h"
|
||||
|
||||
#include <sstream>
|
||||
#include <vector>
|
||||
|
||||
static const vfs::UInt32 BUFFER_SIZE = 1024;
|
||||
|
||||
class CReadLine
|
||||
{
|
||||
public:
|
||||
CReadLine(vfs::tReadableFile& rFile) : _file(rFile), _buffer_pos(0), _eof(false)
|
||||
{
|
||||
memset(_buffer,0,sizeof(_buffer));
|
||||
FillBuffer();
|
||||
vfs::UByte utf8bom[3] = {0xef,0xbb,0xbf};
|
||||
if(memcmp(utf8bom, &_buffer[0],3) == 0)
|
||||
{
|
||||
_buffer_pos += 3;
|
||||
}
|
||||
};
|
||||
bool FillBuffer()
|
||||
{
|
||||
if(!_eof)
|
||||
{
|
||||
// reading can be done byte-wise or line-wise.
|
||||
// we have no control over this here, so we have to account for both cases.
|
||||
|
||||
vfs::UInt32 read = 0;
|
||||
// fill the buffer from the start, BUFFER_SIZE charactes at max (_buffer has BUFFER_SIZE+1 elements)
|
||||
_eof = !_file.Read(&_buffer[0],BUFFER_SIZE,read);
|
||||
// if read() fails, it means that we are at the end of the file,
|
||||
// but we probably have read a couple of valid bytes, so we need to do one last 'correct' run
|
||||
|
||||
// bite-wise read files usually terminate a line with \n (or \r\n on WIN32)
|
||||
// line-wise read files just returns 0-terminated string
|
||||
|
||||
// always terminate the string with 0
|
||||
_buffer[read] = 0;
|
||||
|
||||
_buffer_pos = 0;
|
||||
_buffer_last = read;
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool FromBuffer(std::string& line)
|
||||
{
|
||||
bool done = false;
|
||||
while(!done)
|
||||
{
|
||||
if(_buffer_pos < _buffer_last)
|
||||
{
|
||||
// start where we left last time
|
||||
vfs::Byte *temp = &_buffer[_buffer_pos];
|
||||
vfs::UInt32 start_pos = _buffer_pos;
|
||||
// go until we hit 0. since our buffer is always 0 terminated, the second test should be redundant.
|
||||
while(*temp && (_buffer_pos < _buffer_last))
|
||||
{
|
||||
// stop when we find a line terminator
|
||||
if(*temp == '\n' || *temp == '\r' /* || *temp == '\0' */)
|
||||
{
|
||||
break;
|
||||
}
|
||||
temp++;
|
||||
_buffer_pos++;
|
||||
}
|
||||
// need to append substring, as we might have refilles the buffer (because there was no \n or \r\n terminator)
|
||||
line.append( (char*)&_buffer[start_pos], _buffer_pos - start_pos );
|
||||
|
||||
// if we reach the (real) end of the buffer (that always terminate with 0), this means
|
||||
// that there was no line terminator and that we have to refill the buffer.
|
||||
if( _buffer_pos < BUFFER_SIZE && (*temp == '\n' || *temp == '\r' || *temp == 0) )
|
||||
{
|
||||
// found the line terminator
|
||||
if(*temp == '\r')
|
||||
{
|
||||
// the \r is most probably followed by \n. 'swallow' both characters
|
||||
*temp++;
|
||||
_buffer_pos++;
|
||||
if( (_buffer_pos < BUFFER_SIZE) && (*temp == '\n' || *temp == 0) )
|
||||
{
|
||||
// increase buffer position, so that we can start with a valid character in the next run
|
||||
_buffer_pos++;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
done = !FillBuffer();
|
||||
}
|
||||
}
|
||||
else if(*temp == '\n' || *temp == 0)
|
||||
{
|
||||
// increase buffer position, so that we can start with a valid character in the next run
|
||||
_buffer_pos++;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
done = !FillBuffer();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
done = !FillBuffer();
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
bool GetLine(std::string& line)
|
||||
{
|
||||
line.clear();
|
||||
return FromBuffer(line);
|
||||
}
|
||||
private:
|
||||
vfs::Byte _buffer[BUFFER_SIZE+1];
|
||||
vfs::tReadableFile& _file;
|
||||
vfs::UInt32 _buffer_pos;
|
||||
vfs::UInt32 _buffer_last;
|
||||
bool _eof;
|
||||
};
|
||||
|
||||
template<typename T_>
|
||||
bool ConvertTo(utf8string const& sStr, T_ &rVal)
|
||||
{
|
||||
std::wstringstream ss;
|
||||
ss.str(sStr.c_wcs());
|
||||
if(!(ss >> rVal))
|
||||
{
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
template<typename T_>
|
||||
utf8string ToStringList(std::list<T_> const& rValList)
|
||||
{
|
||||
std::wstringstream ss;
|
||||
typename std::list<T_>::const_iterator cit = rValList.begin();
|
||||
if(cit != rValList.end())
|
||||
{
|
||||
ss << *cit;
|
||||
cit++;
|
||||
for(;cit != rValList.end(); ++cit)
|
||||
{
|
||||
ss << L" , " << *cit;
|
||||
}
|
||||
}
|
||||
if(!ss)
|
||||
{
|
||||
return L"";
|
||||
}
|
||||
return ss.str();
|
||||
}
|
||||
template<>
|
||||
utf8string ToStringList<utf8string>(std::list<utf8string> const& rValList)
|
||||
{
|
||||
std::wstringstream ss;
|
||||
std::list<utf8string>::const_iterator cit = rValList.begin();
|
||||
if(cit != rValList.end())
|
||||
{
|
||||
ss << (*cit);
|
||||
cit++;
|
||||
for(;cit != rValList.end(); ++cit)
|
||||
{
|
||||
ss << L" , " << (*cit);
|
||||
}
|
||||
}
|
||||
if(!ss)
|
||||
{
|
||||
return L"";
|
||||
}
|
||||
return ss.str();
|
||||
}
|
||||
|
||||
class CSplitStringList
|
||||
{
|
||||
public:
|
||||
CSplitStringList(utf8string const& sList)
|
||||
: m_sList(sList), iCurrent(0),iNext(0)
|
||||
{};
|
||||
~CSplitStringList() {};
|
||||
|
||||
bool NextListEntry(utf8string &sEntry)
|
||||
{
|
||||
if(iNext >= 0)
|
||||
{
|
||||
iNext = m_sList.c_wcs().find_first_of(L",",iCurrent+1);
|
||||
if(iNext > iCurrent)
|
||||
{
|
||||
sEntry.r_wcs().assign(vfs::TrimString(m_sList,iCurrent,iNext-1).c_wcs());
|
||||
iCurrent = iNext+1;
|
||||
}
|
||||
else
|
||||
{
|
||||
// last or only entry
|
||||
sEntry.r_wcs().assign(vfs::TrimString(m_sList,iCurrent,m_sList.length()).c_wcs());
|
||||
}
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
private:
|
||||
const utf8string m_sList;
|
||||
int iCurrent,iNext;
|
||||
};
|
||||
|
||||
|
||||
/*************************************************************************************/
|
||||
/*************************************************************************************/
|
||||
@@ -962,334 +763,3 @@ void CPropertyContainer::SetBoolListProperty(utf8string const& sSection, utf8str
|
||||
/**************************************************************************************************/
|
||||
/**************************************************************************************************/
|
||||
|
||||
bool CTransferRules::InitFromTxtFile(vfs::Path const& sPath)
|
||||
{
|
||||
// try to open via VirtualFileSystem
|
||||
if(GetVFS()->FileExists(sPath))
|
||||
{
|
||||
return InitFromTxtFile(GetVFS()->GetRFile(sPath));
|
||||
}
|
||||
else
|
||||
{
|
||||
// file doesn't exist or VFS not initialized yet
|
||||
vfs::IBaseFile* pFile = new vfs::CTextFile(sPath);
|
||||
if(pFile)
|
||||
{
|
||||
bool success = InitFromTxtFile(vfs::tReadableFile::Cast(pFile));
|
||||
delete pFile;
|
||||
return success;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool CTransferRules::InitFromTxtFile(vfs::tReadableFile* pFile)
|
||||
{
|
||||
if(pFile && pFile->OpenRead())
|
||||
{
|
||||
vfs::COpenReadFile rfile(pFile);
|
||||
std::string sBuffer;
|
||||
vfs::UInt32 line_counter = 0;
|
||||
CReadLine rl(*pFile);
|
||||
while(rl.GetLine(sBuffer))
|
||||
{
|
||||
line_counter++;
|
||||
// very simple parsing : key = value
|
||||
if(!sBuffer.empty())
|
||||
{
|
||||
// remove leading white spaces
|
||||
int iStart = sBuffer.find_first_not_of(" \t",0);
|
||||
char first = sBuffer.at(iStart);
|
||||
switch(first)
|
||||
{
|
||||
case '!':
|
||||
case ';':
|
||||
case '#':
|
||||
// comment -> do nothing
|
||||
break;
|
||||
default:
|
||||
int iEnd = sBuffer.find_first_of(" \t", iStart);
|
||||
if(iEnd != std::string::npos)
|
||||
{
|
||||
SRule rule;
|
||||
std::string action = sBuffer.substr(iStart, iEnd - iStart);
|
||||
if( StrCmp::Equal(action, "deny") )
|
||||
{
|
||||
rule.action = CTransferRules::DENY;
|
||||
}
|
||||
else if( StrCmp::Equal(action, "accept") )
|
||||
{
|
||||
rule.action = CTransferRules::ACCEPT;
|
||||
}
|
||||
else
|
||||
{
|
||||
std::wstring trybuffer = L"Invalid UTF-8 character in string";
|
||||
IGNOREEXCEPTION( trybuffer = utf8string(sBuffer).c_wcs() ); /* just make sure we don't break off when string conversion fails */
|
||||
std::wstringstream wss;
|
||||
wss << L"Unknown action in file \"" << pFile->GetFullPath()().c_wcs()
|
||||
<< L", line " << line_counter << " : " << utf8string(sBuffer).c_wcs();
|
||||
THROWEXCEPTION(wss.str().c_str());
|
||||
}
|
||||
try
|
||||
{
|
||||
rule.pattern = vfs::Path(vfs::TrimString(sBuffer, iEnd, sBuffer.length()));
|
||||
}
|
||||
catch(CBasicException& ex)
|
||||
{
|
||||
std::wstringstream wss;
|
||||
wss << L"Could not convert string, invalid utf8 encoding in file \"" << pFile->GetFullPath()().c_wcs()
|
||||
<< L"\", line " << line_counter;
|
||||
RETHROWEXCEPTION(wss.str().c_str(),&ex);
|
||||
}
|
||||
m_listRules.push_back(rule);
|
||||
}
|
||||
break;
|
||||
}; // end switch
|
||||
} // end if (empty)
|
||||
} // end while(!eof)
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
void CTransferRules::SetDefaultAction(CTransferRules::EAction act)
|
||||
{
|
||||
m_eDefaultAction = act;
|
||||
}
|
||||
|
||||
CTransferRules::EAction CTransferRules::GetDefaultAction()
|
||||
{
|
||||
return m_eDefaultAction;
|
||||
}
|
||||
|
||||
CTransferRules::EAction CTransferRules::ApplyRule(utf8string const& sStr)
|
||||
{
|
||||
tPatternList::iterator sit = m_listRules.begin();
|
||||
for(; sit != m_listRules.end(); ++sit)
|
||||
{
|
||||
if(MatchPattern(sit->pattern(), sStr))
|
||||
{
|
||||
return sit->action;
|
||||
}
|
||||
}
|
||||
return m_eDefaultAction;
|
||||
}
|
||||
|
||||
/********************************************************************/
|
||||
/********************************************************************/
|
||||
#ifdef WIN32
|
||||
const char CLog::endl[] = "\r\n";
|
||||
#else
|
||||
const char CLog::endl[] = "\n";
|
||||
#endif
|
||||
|
||||
std::list<CLog*>& CLog::_logs()
|
||||
{
|
||||
static std::list<CLog*> logs;
|
||||
return logs;
|
||||
}
|
||||
|
||||
CLog* CLog::Create(vfs::Path fileName, bool append, EFlushMode flushMode)
|
||||
{
|
||||
_logs().push_back(new CLog(fileName, append, flushMode));
|
||||
return _logs().back();
|
||||
}
|
||||
void CLog::FlushFinally()
|
||||
{
|
||||
std::list<CLog*>::iterator it = _logs().begin();
|
||||
for(; it != _logs().end(); ++it)
|
||||
{
|
||||
delete *it;
|
||||
}
|
||||
_logs().clear();
|
||||
}
|
||||
|
||||
void CLog::FlushAll()
|
||||
{
|
||||
std::list<CLog*>::iterator it = _logs().begin();
|
||||
for(; it != _logs().end(); ++it)
|
||||
{
|
||||
(*it)->Flush();
|
||||
(*it)->_file = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
CLog::CLog(vfs::Path fileName, bool append, EFlushMode flushMode)
|
||||
: _filename(fileName), _file(NULL), _own_file(false),
|
||||
_first_write(true), _flush_mode(flushMode), _append(append),
|
||||
_buffer_size(0), _buffer_test_size(512)
|
||||
{};
|
||||
|
||||
CLog::~CLog()
|
||||
{
|
||||
_test_flush(true);
|
||||
if(_file && _own_file)
|
||||
{
|
||||
delete _file;
|
||||
}
|
||||
}
|
||||
|
||||
CLog& CLog::operator<<(unsigned int const& t)
|
||||
{
|
||||
return PushNumber(t);
|
||||
}
|
||||
CLog& CLog::operator<<(unsigned short const& t)
|
||||
{
|
||||
return PushNumber(t);
|
||||
}
|
||||
CLog& CLog::operator<<(unsigned char const& t)
|
||||
{
|
||||
return PushNumber(t);
|
||||
}
|
||||
CLog& CLog::operator<<(int const& t)
|
||||
{
|
||||
return PushNumber(t);
|
||||
}
|
||||
CLog& CLog::operator<<(short const& t)
|
||||
{
|
||||
return PushNumber(t);
|
||||
}
|
||||
CLog& CLog::operator<<(char const& t)
|
||||
{
|
||||
return PushNumber(t);
|
||||
}
|
||||
CLog& CLog::operator<<(float const& t)
|
||||
{
|
||||
return PushNumber(t);
|
||||
}
|
||||
CLog& CLog::operator<<(double const& t)
|
||||
{
|
||||
return PushNumber(t);
|
||||
}
|
||||
|
||||
CLog& CLog::operator<<(const char* t)
|
||||
{
|
||||
_buffer << t;
|
||||
_buffer_size += strlen(t);
|
||||
_test_flush();
|
||||
return *this;
|
||||
}
|
||||
CLog& CLog::operator<<(const wchar_t* t)
|
||||
{
|
||||
std::string s = utf8string::as_utf8(t);
|
||||
_buffer << s;
|
||||
_buffer_size += s.length();
|
||||
_test_flush();
|
||||
return *this;
|
||||
}
|
||||
CLog& CLog::operator<<(std::string const& t)
|
||||
{
|
||||
_buffer << t;
|
||||
_buffer_size += t.length();
|
||||
_test_flush();
|
||||
return *this;
|
||||
}
|
||||
CLog& CLog::operator<<(std::wstring const& t)
|
||||
{
|
||||
std::string s = utf8string::as_utf8(t);
|
||||
_buffer << s;
|
||||
_buffer_size += s.length();
|
||||
_test_flush();
|
||||
return *this;
|
||||
}
|
||||
CLog& CLog::operator<<(utf8string const& t)
|
||||
{
|
||||
std::string s = t.utf8();
|
||||
_buffer << s;
|
||||
_buffer_size += s.length();
|
||||
_test_flush();
|
||||
return *this;
|
||||
}
|
||||
|
||||
CLog& CLog::Endl()
|
||||
{
|
||||
_buffer << CLog::endl;
|
||||
_buffer_size += sizeof(CLog::endl)-1;
|
||||
_test_flush();
|
||||
return *this;
|
||||
}
|
||||
|
||||
void CLog::SetAppend(bool append)
|
||||
{
|
||||
_append = append;
|
||||
}
|
||||
|
||||
void CLog::SetBufferSize(vfs::UInt32 bufferSize)
|
||||
{
|
||||
_buffer_test_size = bufferSize;
|
||||
}
|
||||
|
||||
void CLog::_test_flush(bool force)
|
||||
{
|
||||
if( (_flush_mode == FLUSH_IMMEDIATELY) ||
|
||||
(_flush_mode == FLUSH_BUFFER && _buffer_size > _buffer_test_size) ||
|
||||
(/*_flush_mode == FLUSH_ON_DELETE &&*/ force == true) )
|
||||
{
|
||||
Flush();
|
||||
}
|
||||
}
|
||||
|
||||
#include <ctime>
|
||||
void CLog::Flush()
|
||||
{
|
||||
vfs::UInt32 buflen = _buffer.str().length();
|
||||
if(buflen == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
if(!_file)
|
||||
{
|
||||
try
|
||||
{
|
||||
vfs::COpenWriteFile file_raii(_filename,true,!_append);
|
||||
_file = &file_raii.file();
|
||||
file_raii.release();
|
||||
}
|
||||
catch(CBasicException& ex)
|
||||
{
|
||||
LogException(ex);
|
||||
// write file anyway
|
||||
_file = vfs::tWriteableFile::Cast(new vfs::CFile(_filename));
|
||||
_file->OpenWrite(true,!_append);
|
||||
_own_file = true;
|
||||
}
|
||||
}
|
||||
|
||||
vfs::COpenWriteFile wfile(_file);
|
||||
if(_append)
|
||||
{
|
||||
wfile.file().SetWriteLocation(0,vfs::IBaseFile::SD_END);
|
||||
}
|
||||
|
||||
vfs::UInt32 io;
|
||||
if(_first_write)
|
||||
{
|
||||
time_t rawtime;
|
||||
time ( &rawtime );
|
||||
std::string datetime(ctime(&rawtime));
|
||||
std::string s_out;
|
||||
|
||||
vfs::UInt32 wloc = wfile.file().GetWriteLocation();
|
||||
if(wloc > 0)
|
||||
{
|
||||
s_out = CLog::endl;
|
||||
}
|
||||
s_out += " *** ";
|
||||
s_out += datetime.substr(0,datetime.length()-1);
|
||||
s_out += " *** ";
|
||||
s_out += CLog::endl;
|
||||
s_out += CLog::endl;
|
||||
wfile.file().Write(s_out.c_str(), s_out.length(), io);
|
||||
_first_write = false;
|
||||
}
|
||||
|
||||
wfile.file().Write(_buffer.str().c_str(), buflen, io);
|
||||
_buffer.str("");
|
||||
_buffer.clear();
|
||||
_buffer_size = 0;
|
||||
|
||||
_append = true;
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user