#include "tsystem.h"

#include <time.h>

#include <sys/timeb.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <errno.h>

#include <set>

#undef PLATFORM

#ifdef WIN32

#define PLATFORM WIN32

#include <process.h>

#include <io.h>

#include <stdlib.h>

#include <direct.h>

#include "winsock2.h"

#include "lmcons.h"

#include <sys/utime.h>

#endif

#ifdef LINUX

#define PLATFORM LINUX

#include <grp.h>

#include <utime.h>

#include <sys/param.h>

#include <unistd.h>

#include <sys/types.h>

#include <stdio.h>

#include <unistd.h>

#include <dirent.h>

#include <sys/dir.h>

#include <sys/sysinfo.h>

#include <sys/swap.h>

#include <sys/statfs.h>

#include <pwd.h>

#include <mntent.h>

#include <dlfcn.h>

extern "C" {

int gethostname(char *, size_t);

//int L_cuserid;

char *cuserid(char *);

char *tempnam(const char *, const char *);

}

#endif

#ifdef __sgi

#define PLATFORM SGI

#include <sys/param.h>

#include <unistd.h>

#include <grp.h>

#include <sys/dir.h> // dirent.h

#include <sys/utime.h>

#include <sys/swap.h>

#include <sys/statfs.h>

#include <pwd.h>

#include <mntent.h>

#include <dlfcn.h>

#endif

#ifndef PLATFORM

PLATFORM_NOT_SUPPORTED

#endif

using namespace std;

#ifdef WIN32

const int TSystem::MaxPathLen = _MAX_PATH;

const int TSystem::MaxFNameLen = _MAX_FNAME;

const int TSystem::MaxHostNameLen = 64;

const unsigned short TFileStatus::UserReadable = _S_IREAD;

const unsigned short TFileStatus::UserWritable = _S_IWRITE;

const unsigned short TFileStatus::UserExecutable = _S_IEXEC;

const unsigned short TFileStatus::OwnerReadWriteExec = TFileStatus::UserReadable | TFileStatus::UserWritable | TFileStatus::UserExecutable;

const unsigned short TFileStatus::OwnerReadable = TFileStatus::UserReadable;

const unsigned short TFileStatus::OwnerWritable = TFileStatus::UserWritable;

const unsigned short TFileStatus::OwnerExecutable = TFileStatus::UserExecutable;

const unsigned short TFileStatus::GroupReadWriteExec = TFileStatus::OwnerReadWriteExec;

const unsigned short TFileStatus::GroupReadable = TFileStatus::UserReadable;

const unsigned short TFileStatus::GroupWritable = TFileStatus::UserWritable;

const unsigned short TFileStatus::GroupExecutable = TFileStatus::UserExecutable;

const unsigned short TFileStatus::OtherReadWriteExec = TFileStatus::UserReadable | TFileStatus::UserWritable | TFileStatus::UserExecutable;

;

const unsigned short TFileStatus::OtherReadable = TFileStatus::UserReadable;

const unsigned short TFileStatus::OtherWritable = TFileStatus::UserWritable;

const unsigned short TFileStatus::OtherExecutable = TFileStatus::UserReadable;

const unsigned short TFileStatus::IfDir = _S_IFDIR;

#define MKDIR _mkdir

#define RMDIR _rmdir

#define TEMPNAM _tempnam

#define ACCESS _access

#define STAT _stat

#define UTIME _utime

#define FTIME _ftime

using std::ifstream;

using std::ofstream;

using std::filebuf;

#else //these are common for IRIX & LINUX

const int TSystem::MaxPathLen = MAXPATHLEN;

const int TSystem::MaxHostNameLen = MAXHOSTNAMELEN;

const unsigned short TFileStatus::OwnerReadWriteExec = S_IRWXU;

const unsigned short TFileStatus::OwnerReadable = S_IRUSR;

const unsigned short TFileStatus::OwnerWritable = S_IWUSR;

const unsigned short TFileStatus::OwnerExecutable = S_IXUSR;

const unsigned short TFileStatus::GroupReadWriteExec = S_IRWXG;

const unsigned short TFileStatus::GroupReadable = S_IRGRP;

const unsigned short TFileStatus::GroupWritable = S_IWGRP;

const unsigned short TFileStatus::GroupExecutable = S_IXGRP;

const unsigned short TFileStatus::OtherReadWriteExec = S_IRWXO;

const unsigned short TFileStatus::OtherReadable = S_IROTH;

const unsigned short TFileStatus::OtherWritable = S_IWOTH;

const unsigned short TFileStatus::OtherExecutable = S_IXOTH;

#define MKDIR mkdir

#define RMDIR rmdir

#define TEMPNAM tempnam

#define ACCESS access

#define STAT stat

#define UTIME utime

#define FTIME ftime

#ifdef __sgi

const int TSystem::MaxFNameLen = MAXNAMELEN;

const unsigned short TFileStatus::UserReadable = S_IREAD;

const unsigned short TFileStatus::UserWritable = S_IWRITE;

const unsigned short TFileStatus::UserExecutable = S_IEXEC;

const unsigned short TFileStatus::IfDir = S_IFDIR;

#else

const int TSystem::MaxFNameLen = 1024;

const unsigned short TFileStatus::UserReadable = __S_IREAD;

const unsigned short TFileStatus::UserWritable = __S_IWRITE;

const unsigned short TFileStatus::UserExecutable = __S_IEXEC;

const unsigned short TFileStatus::IfDir = __S_IFDIR;

#endif

#endif

//-----------------------------------------------------------------------------------

ostream &operator<<(ostream &out, const TSystemException &e)

{

	return out << "TSystem Exception : " << e.getMessage() << endl;

}

//-----------------------------------------------------------------------------------

//conversion functions

namespace

{

//---------------------------------------------------------

void makeTm(const TTime &t, tm *p)

{

	::memset(p, 0, sizeof(tm));

	p->tm_year = t.getYear() - 1900;

	p->tm_mon = t.getMonth() - 1; //[0,11]

	p->tm_mday = t.getDay();

	p->tm_hour = t.getHour();

	p->tm_min = t.getMinutes();

	p->tm_sec = t.getSeconds();

	p->tm_isdst = -1;

}

//---------------------------------------------------------

TTime makeTTime(const tm &p, int msec = 0)

{

	return TTime(p.tm_year + 1900, p.tm_mon + 1, p.tm_mday,

				 p.tm_hour, p.tm_min, p.tm_sec, msec);

}

//---------------------------------------------------------

time_t makeTimeT(const TTime &t)

{

	tm x;

	makeTm(t, &x);

	time_t tt = mktime(&x);

	return tt;

}

} //namespace

//-----------------------------------------------------------------------------------

TDeltaTime::TDeltaTime(long sec, long msec)

{

	// assert((sec && msec>=0) ||(sec==0 ));

	assert(!((sec < 0 && msec > 0) || (sec > 0 && msec < 0)));

	/*

  0   0   ok

  0   1   ok

  1   0   ok

  1   1   ok

  0  -1   ok

 -1   0   ok

 -1  -1   ok

 -1   1   NO

  1  -1   NO

  */

	m_dsec = sec + msec / 1000;

	m_dmsec = msec % 1000;

}

//------------------------------------------------------------

TDeltaTime TDeltaTime::operator+(const TDeltaTime &tdt)

{

	long sumSec = m_dsec + tdt.m_dsec;

	long sumMsec = m_dmsec + tdt.m_dmsec;

	if (sumSec > 0 && sumMsec < 0)

		return TDeltaTime(sumSec - 1, sumMsec + 1000);

	if (sumSec < 0 && sumMsec > 0)

		return TDeltaTime(sumSec + 1, sumMsec - 1000);

	return TDeltaTime(sumSec, sumMsec);

}

//------------------------------------------------------------

TDeltaTime TDeltaTime::operator-(const TDeltaTime &tdt)

{

	long diffSec = m_dsec - tdt.m_dsec;

	long diffMsec = m_dmsec - tdt.m_dmsec;

	if (diffSec < 0 && diffMsec > 0)

		return TDeltaTime(diffSec + 1, diffMsec - 1000);

	if (diffSec > 0 && diffMsec < 0)

		return TDeltaTime(diffSec - 1, diffMsec + 1000);

	return TDeltaTime(diffSec, diffMsec);

}

//------------------------------------------------------------

ostream &operator<<(ostream &out, const TDeltaTime &dt)

{

	return out << dt.getSeconds() << "." << dt.getMilliSeconds();

}

//-----------------------------------------------------------------------------------

// correggere gli assert => invalid (esiste il metodo bool isValid()const; operazioni con

// un TTIme invalid danno un risultato invalid

//

//

TTime::TTime(int yyyy, int mm, int dd, int hh,

			 int min, int sec, int msec)

{

	if (yyyy < 10)

		yyyy += 2000;

	else if (yyyy < 99)

		yyyy += 1900;

	assert(1970 <= yyyy && yyyy <= 2038);

	m_y = yyyy;

	assert(1 <= mm && mm <= 12);

	m_m = mm;

	int table[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};

	int ddlimit = mm == 2 ? (28 + (isLeap() ? 1 : 0)) : table[mm - 1];

	assert(1 <= dd && dd <= ddlimit);

	m_d = dd;

	assert(0 <= hh && hh <= 23);

	m_h = hh;

	assert(0 <= min && min <= 59);

	m_min = min;

	assert(0 <= sec && sec <= 59);

	m_sec = sec;

	assert(0 <= msec && msec <= 999);

	m_msec = msec;

}

//-----------------------------------------------------------------------------------

TTime::TTime(const TTime &t) : m_y(t.m_y), m_m(t.m_m), m_d(t.m_d), m_h(t.m_h), m_min(t.m_min), m_sec(t.m_sec), m_msec(t.m_msec)

{

}

//-----------------------------------------------------------------------------------

bool TTime::operator==(const TTime &time) const

{

	return (m_y == time.m_y) &&

		   (m_m == time.m_m) &&

		   (m_d == time.m_d) &&

		   (m_h == time.m_h) &&

		   (m_min == time.m_min) &&

		   (m_sec == time.m_sec) &&

		   (m_msec == time.m_msec);

}

//-----------------------------------------------------------------------------------

bool TTime::operator>(const TTime &time) const

{

	return (m_y > time.m_y) ||

		   (m_y == time.m_y && m_m > time.m_m) ||

		   (m_y == time.m_y && m_m == time.m_m && m_d > time.m_d) ||

		   (m_y == time.m_y && m_m == time.m_m && m_d == time.m_d && m_h > time.m_h) ||

		   (m_y == time.m_y && m_m == time.m_m && m_d == time.m_d &&

			m_h == time.m_h && m_min > time.m_min) ||

		   (m_y == time.m_y && m_m == time.m_m && m_d == time.m_d &&

			m_h == time.m_h && m_min == time.m_min && m_sec > time.m_sec) ||

		   (m_y == time.m_y && m_m == time.m_m && m_d == time.m_d &&

			m_h == time.m_h && m_min == time.m_min && m_sec == time.m_sec && m_msec > time.m_msec);

}

//-----------------------------------------------------------------------------------

TDeltaTime TTime::operator-(const TTime &t) const

{

	time_t t2 = makeTimeT(*this);

	assert(t2 != -1);

	time_t t1 = makeTimeT(t);

	assert(t1 != -1);

	double d = difftime(t2, t1);

	if (m_msec >= t.m_msec) {

		if (d <= -1)

			return TDeltaTime((long)(d + 1), -(long)(1000 - (m_msec - t.m_msec)));

		else

			return TDeltaTime((long)d, (long)(m_msec - t.m_msec));

	} else {

		if (d <= 0)

			return TDeltaTime((long)(d), (long)(m_msec - t.m_msec));

		else

			return TDeltaTime((long)(d - 1), (long)(1000 + m_msec - t.m_msec));

	}

}

//-----------------------------------------------------------------------------------

TTime TTime::operator+(const TDeltaTime &tdt) const

{

	tm x;

	makeTm(*this, &x);

	int ms = m_msec + tdt.getMilliSeconds();

	if (ms < 0) {

		ms += 1000;

		x.tm_sec += tdt.getSeconds() - 1;

	} else

		x.tm_sec += tdt.getSeconds() + ms / 1000;

	mktime(&x);

	return makeTTime(x, ms % 1000);

}

//-----------------------------------------------------------------------------------

TTime TTime::operator-(const TDeltaTime &tdt) const

{

	tm x;

	makeTm(*this, &x);

	int ms = m_msec - tdt.getMilliSeconds();

	if (ms < 0) {

		ms += 1000;

		x.tm_sec -= tdt.getSeconds() + 1;

	} else

		x.tm_sec -= tdt.getSeconds() + ms / 1000;

	mktime(&x);

	return makeTTime(x, ms % 1000);

}

//-----------------------------------------------------------------------------------

string TTime::getFormattedString(char *fmt) const

{

	tm x;

	makeTm(*this, &x);

	char strDest[256];

	if (!fmt)

		//fmt="%b %d %Y %X";

		return getDate() + " " + getTime();

	strftime(strDest, 256, fmt, &x);

	return string(strDest);

}

//-----------------------------------------------------------------------------------

string TTime::getDate() const

{

	return getFormattedString("%b %d %Y");

}

//-----------------------------------------------------------------------------------

string TTime::getTime() const

{ // hh:mm:ss

	char buffer[10];

	ostrstream buff_s(buffer, sizeof(buffer));

	buff_s << "." << m_msec << '\0';

	return getFormattedString("%X") + buffer;

}

//-----------------------------------------------------------------------------------

TTime TTime::floor() const

{

	return TTime(m_y, m_m, m_d, m_h, m_min, m_sec, 0);

}

//-----------------------------------------------------------------------------------

TTime TTime::ceil() const

{

	if (m_msec == 0)

		return *this;

	else

		return *this + TDeltaTime(0, 1000 - m_msec);

}

//===================================================================================

TFileStatus::TFileStatus(const TFilePath &path)

{

	int acc = ACCESS(path.getFullPath().c_str(), 00); // 00 == solo esistenza

	m_exist = acc != -1;

	//gestire eccezioni controllando il valore di ritorno di access

	//controllare il valore di errno

	//int ret=

	STAT(path.getFullPath().c_str(), &m_fStatus); //returns 0 if the file-status information is obtained

												  /* if(ret!=0) ::memset(&m_fStatus,0,sizeof(m_fStatus)):*/

}

//-----------------------------------------------------------------------------------

string TFileStatus::getGroup() const

{

#ifndef WIN32

	struct group *grp = getgrgid(m_fStatus.st_gid);

	if (grp)

		return string(grp->gr_name);

#endif

	char buffer[1024];

	ostrstream buff(buffer, sizeof(buffer));

	buff << m_fStatus.st_gid;

	return string(buffer, buff.pcount());

}

//-----------------------------------------------------------------------------------

string TFileStatus::getUser() const

{

#ifndef WIN32

	struct passwd *pw = getpwuid(m_fStatus.st_uid);

	if (pw)

		return string(pw->pw_name);

#endif

	char buffer[1024];

	ostrstream buff(buffer, sizeof(buffer));

	buff << m_fStatus.st_uid;

	return string(buffer, buff.pcount());

}

//-----------------------------------------------------------------------------------

long TFileStatus::getSize() const

{

	return (long)m_fStatus.st_size;

}

//-----------------------------------------------------------------------------------

TTime TFileStatus::getLastAccessTime() const

{

	struct tm *t = localtime(&(m_fStatus.st_atime));

	return TTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour,

				 t->tm_min, t->tm_sec);

}

//-----------------------------------------------------------------------------------

TTime TFileStatus::getLastModificationTime() const

{

	struct tm *t = localtime(&(m_fStatus.st_mtime));

	return TTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour,

				 t->tm_min, t->tm_sec);

}

//-----------------------------------------------------------------------------------

TTime TFileStatus::getCreationTime() const

{

	struct tm *t = localtime(&(m_fStatus.st_ctime));

	return TTime(t->tm_year + 1900, t->tm_mon + 1, t->tm_mday, t->tm_hour,

				 t->tm_min, t->tm_sec);

}

//-----------------------------------------------------------------------------------

unsigned long TFileStatus::getPermissions() const

{

	return m_fStatus.st_mode;

}

//-----------------------------------------------------------------------------------

bool TFileStatus::isDirectory() const

{

	return doesExist() && (getPermissions() & TFileStatus::IfDir) != 0;

}

//-----------------------------------------------------------------------------------

string TSystem::getHostName()

{

	char hostName[MaxHostNameLen];

#ifdef WIN32

	WSADATA wdata;

	int err;

	err = WSAStartup(MAKEWORD(1, 1), &wdata);

	if (!err)

		strcpy(hostName, "localhost"); // la rete non e' partita  ?!?

#endif

	gethostname((char *)&hostName, MaxHostNameLen);

#ifdef WIN32

	if (err)

		WSACleanup();

#endif

	return hostName;

}

//------------------------------------------------------------

string TSystem::getUserName()

{

#ifdef WIN32

#ifndef UNLEN

#define UNLEN (256)

#endif

	const long bufSize = UNLEN;

#else

	const long bufSize = L_cuserid;

#endif

	char userName[bufSize + 1];

#ifdef WIN32

	GetUserName((char *)&userName, (unsigned long *)(&bufSize));

#else

	cuserid(userName);

	if (userName[0] == 0x00)

		strcpy(userName, "User Unknown");

#endif

	return string(userName);

}

//------------------------------------------------------------

string TSystem::getGroupName()

{

#ifdef WIN32

	return string();

#else

	struct group *currentGroup;

	currentGroup = getgrgid(getgid());

	if (currentGroup)

		return string(currentGroup->gr_name);

	else

		return string();

#endif

}

//------------------------------------------------------------

int TSystem::getProcessId()

{

	return getpid();

}

//------------------------------------------------------------

TFilePath TSystem::getHomeDirectory()

{

#ifndef WIN32

	struct passwd *pwd = getpwnam(getUserName().c_str());

	if (!pwd) {

		return TFilePath();

	}

	return TFilePath(pwd->pw_dir);

#else

	char *s = getenv("USERPROFILE");

	if (!s)

		return TFilePath();

	else

		return TFilePath(s);

#endif

}

//------------------------------------------------------------

TFilePath TSystem::getTempDir()

{

#ifdef WIN32

	//gestire eccezioni se dw==0

	DWORD dw = GetTempPath(0, 0); //non include il terminatore

	char *path = new char[dw + 1];

	GetTempPath(dw, path);

	TFilePath tempDir(path);

	delete[] path;

	return tempDir;

#else

	return TFilePath(tmpnam(0)).getParentDir();

#endif

}

//------------------------------------------------------------

TFilePath TSystem::getTestDir()

{

#ifdef WIN32

	return TFilePath("\\\\sirio\\toonz5.0\\TNZCORE_TEST");

#else

	return TFilePath("/ULTRA/toonz5.0/TNZCORE_TEST");

#endif

}

//------------------------------------------------------------

string TSystem::getSystemValue(const TFilePath &name)

{

#ifdef WIN32

	string keyName = name.getParentDir().getFullPath();

	string varName = name.getName();

	HKEY hkey;

	if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, keyName.c_str(), 0, KEY_READ, &hkey) != ERROR_SUCCESS) {

		/*key not defined*/

		return "";

	}

	unsigned char buffer[1024];

	unsigned long bufferSize = sizeof(buffer);

	string value;

	if (RegQueryValueEx(hkey, varName.c_str(), NULL, NULL, buffer, &bufferSize) == ERROR_SUCCESS)

		value = string((char *)buffer);

	RegCloseKey(hkey);

	return value;

#else

	char *s = getenv(name.getFullPath().c_str());

	return string(s ? s : "");

#endif

}

//------------------------------------------------------------

TFilePath TSystem::getBinDir()

{

#ifdef WIN32

	char buf[MaxPathLen];

	GetModuleFileName(0, buf, MaxPathLen);

	return TFilePath(buf).getParentDir();

#else

	string binroot = TSystem::getSystemValue("BINROOT");

	if (binroot == "") {

		assert(!"BINROOT variable undefined");

	}

	return TFilePath(binroot) + "bin";

#endif

}

//------------------------------------------------------------

TFilePath TSystem::getUniqueFile(string field)

{

	char *tempName = TEMPNAM(getTempDir().getFullPath().c_str(), field.c_str());

	if (tempName == 0)

		throw TSystemException(TFilePath(getTempDir().getFullPath() + field), 1);

	TFilePath outPath(tempName);

	free(tempName);

	return outPath;

}

//------------------------------------------------------------

const TDeltaTime TDeltaTime::second = TDeltaTime(1, 0);

const TDeltaTime TDeltaTime::minute = 60 * TDeltaTime::second;

const TDeltaTime TDeltaTime::hour = 60 * TDeltaTime::minute;

const TDeltaTime TDeltaTime::day = 24 * TDeltaTime::hour;

//------------------------------------------------------------

TTime TSystem::getCurrentTime()

{

#ifdef WIN32

	struct _timeb curTime;

#else

	struct timeb curTime;

#endif

	FTIME(&curTime);

	struct tm *localTime = localtime(&(curTime.time));

	return TTime(localTime->tm_year + 1900, localTime->tm_mon + 1, localTime->tm_mday,

				 localTime->tm_hour, localTime->tm_min, localTime->tm_sec, curTime.millitm);

}

//------------------------------------------------------------

//gestire exception

void TSystem::mkDir(const TFilePath &path)

{

	if (path == "") {

		throw TSystemException("mkdir: Empty argument");

	}

	if (TFileStatus(path).doesExist() || path.isRoot())

		return;

	while (!TFileStatus(path.getParentDir()).doesExist() && !path.getParentDir().isRoot()) {

		mkDir(path.getParentDir());

	}

#ifdef WIN32

	int ret = MKDIR(path.getFullPath().c_str()); //ret e' EEXIST o ENOENT

#else

	umask(0);

	mode_t attr = TFileStatus::UserReadable | TFileStatus::UserWritable |

				  TFileStatus::UserExecutable | TFileStatus::OwnerReadWriteExec |

				  TFileStatus::GroupReadWriteExec | TFileStatus::OtherReadWriteExec;

	int ret = MKDIR(path.getFullPath().c_str(), attr); // ret e` EEXIST o ENOENT

#endif

	if (ret == -1)

		throw TSystemException(path, errno);

}

//------------------------------------------------------------

//gestire exception

void TSystem::rmDir(const TFilePath &path)

{

	//  if (!TFileStatus(path).doesExist())

	//	return;

	int ret = RMDIR(path.getFullPath().c_str());

	if (ret == -1) //ret e' ENOTEMPTY o ENOENT

		throw TSystemException(path, errno);

}

//------------------------------------------------------------

void TSystem::rmDirTree(const TFilePath &path)

{

	TFilePathSet pathSet = readDirectory(path);

	for (TFilePathSet::iterator it = pathSet.begin(); it != pathSet.end(); it++) {

		TFilePath path = *it;

		if (TFileStatus(path).isDirectory())

			rmDirTree(path);

		else

			deleteFile(path);

	}

	rmDir(path);

}

//------------------------------------------------------------

void TSystem::copyDir(const TFilePath &dst, const TFilePath &src)

{

	if (!TFileStatus(dst).doesExist())

		mkDir(dst);

	TFilePathSet pathSet = readDirectory(src);

	for (TFilePathSet::iterator it = pathSet.begin(); it != pathSet.end(); it++) {

		TFilePath path = *it;

		if (TFileStatus(path).isDirectory())

			copyDir(path.withParentDir(dst), path);

		else

			copyFile(path.withParentDir(dst), path);

	}

}

//------------------------------------------------------------

void TSystem::touchFile(const TFilePath &path)

{

	string filename = path.getFullPath();

	if (TFileStatus(path).doesExist()) {

		if (0 != UTIME(filename.c_str(), 0))

			throw TSystemException(path, errno);

	} else {

		ofstream file(filename.c_str());

		if (!file) {

			throw TSystemException(path, errno);

		}

		file.close(); // altrimenti il compilatore da' un warning:

					  // variabile non utilizzata

	}

}

//------------------------------------------------------------

#ifdef WIN32

namespace

{

//------------------------------------------------------------

string getFormattedMessage(DWORD lastError)

{

	LPVOID lpMsgBuf;

	FormatMessage(

		FORMAT_MESSAGE_ALLOCATE_BUFFER |

			FORMAT_MESSAGE_FROM_SYSTEM |

			FORMAT_MESSAGE_IGNORE_INSERTS,

		NULL,

		lastError,

		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language

		(LPTSTR)&lpMsgBuf,

		0,

		NULL);

	return (char *)lpMsgBuf;

}

//------------------------------------------------------------

} //namespace

#endif

//------------------------------------------------------------

void TSystem::copyFile(const TFilePath &dst, const TFilePath &src)

{

	assert(dst != src);

#ifdef WIN32

	// o e' meglio usare CopyFileEx??

	BOOL res = CopyFile(src.getFullPath().c_str(), // pointer to name of an existing file

						dst.getFullPath().c_str(), // pointer to filename to copy to

						TRUE);					   // flag for operation if file exists

	if (res == 0) {

		throw TSystemException(src, getFormattedMessage(GetLastError()));

	}

#else

	ifstream fpin(src.getFullPath().c_str(), ios::in);

	ofstream fpout(dst.getFullPath().c_str(), ios::out);

	if (!fpin || !fpout)

		throw TSystemException(src, "unable to copy file");

	int c = fpin.get();

	while (!fpin.eof()) {

		fpout.put(c);

		c = fpin.get();

	}

#endif

}

//------------------------------------------------------------

void TSystem::renameFile(const TFilePath &dst, const TFilePath &src)

{

	int ret = rename(src.getFullPath().c_str(), dst.getFullPath().c_str());

	if (ret != 0)

		throw TSystemException(dst, errno);

}

//------------------------------------------------------------

//gestire gli errori con GetLastError?

void TSystem::deleteFile(const TFilePath &dst)

{