#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) {
#ifdef WIN32
BOOL res = DeleteFile(
dst.getFullPath().c_str()); // pointer to name of file to delete
// se fallisce perche' un file e' aperto chiudiamo prima il file?
// To close an open file, use the CloseHandle function.
if (res == 0)
throw TSystemException(dst, getFormattedMessage(GetLastError()));
#else
int ret = remove(dst.getFullPath().c_str());
if (ret != 0) throw TSystemException(dst, errno);
#endif
}
//------------------------------------------------------------
void TSystem::moveFileToRecycleBin(const TFilePath &fp) {
#ifdef WIN32
//
// from http://msdn.microsoft.com/msdnmag/issues/01/04/c/default.aspx
//
// Copy pathname to double-NULL-terminated string.
//
char buf[_MAX_PATH + 1]; // allow one more character
strcpy(buf, fp.getFullPath().c_str()); // copy caller's path name
buf[strlen(buf) + 1] = 0; // need two NULLs at end
SHFILEOPSTRUCT data;
memset(&data, 0, sizeof(SHFILEOPSTRUCT));
data.fFlags |= FOF_SILENT; // don't report progress
data.fFlags |= FOF_NOERRORUI; // don't report errors
data.fFlags |= FOF_NOCONFIRMATION; // don't confirm delete
data.wFunc = FO_DELETE; // REQUIRED: delete operation
data.pFrom = buf; // REQUIRED: which file(s)
data.pTo = NULL; // MUST be NULL
data.fFlags |= FOF_ALLOWUNDO; // ..send to Recycle Bin
SHFileOperation(&data); // do it!
#else
assert(!"Not implemented yet");
#endif
}
//------------------------------------------------------------
void TSystem::readDirectory(TFilePathSet &dst, const TFilePath &path) {
if (!TFileStatus(path).isDirectory()) {
throw TSystemException(path, " is not a directory");
}
#ifdef WIN32
WIN32_FIND_DATA findFileData;
string search = (path + "*").getFullPath();
HANDLE h = FindFirstFile(search.c_str(), &findFileData);
if (h == INVALID_HANDLE_VALUE)
throw TSystemException(path, getFormattedMessage(GetLastError()));
do {
string filename(findFileData.cFileName);
if (filename == "." || filename == "..") continue;
TFilePath son = path + filename;
dst.push_back(son);
} while (FindNextFile(h, &findFileData));
FindClose(h);
#else
DIR *dirp;
struct direct *directp;
dirp = opendir(path.getFullPath().c_str());
if (dirp == 0) throw TSystemException(path, errno);
while (directp = readdir(dirp)) {
string filename(directp->d_name);
if (filename == "." || filename == "..") continue;
TFilePath son = path + filename;
dst.push_back(son);
}
closedir(dirp);
#endif
}
//------------------------------------------------------------
void TSystem::readDirectory(TFilePathSet &dst, const TFilePathSet &pathSet) {
for (TFilePathSet::const_iterator it = pathSet.begin(); it != pathSet.end();
it++)
readDirectory(dst, *it);
}
//------------------------------------------------------------
TFilePathSet TSystem::readDirectory(const TFilePath &path) {
TFilePathSet filePathSet;
readDirectory(filePathSet, path);
return filePathSet;
}
//------------------------------------------------------------
TFilePathSet TSystem::readDirectory(const TFilePathSet &pathSet) {
TFilePathSet dst;
readDirectory(dst, pathSet);
return dst;
}
//------------------------------------------------------------
void TSystem::readDirectoryTree(TFilePathSet &dst, const TFilePath &path) {
if (!TFileStatus(path).isDirectory()) {
throw TSystemException(path, " is not a directory");
}
#ifdef WIN32
WIN32_FIND_DATA findFileData;
string search = (path + "*").getFullPath();
HANDLE h = FindFirstFile(search.c_str(), &findFileData);
if (h == INVALID_HANDLE_VALUE) return;
do {
string filename(findFileData.cFileName);
if (filename == "." || filename == "..") continue;
TFilePath son = path + findFileData.cFileName;
if (findFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
readDirectoryTree(dst, son);
else
dst.push_back(son);
} while (FindNextFile(h, &findFileData));
FindClose(h);
#else
DIR *dirp;
struct direct *directp;
dirp = opendir(path.getFullPath().c_str());
if (dirp == 0) throw TSystemException(path, errno);
while (directp = readdir(dirp)) {
string filename(directp->d_name);
if (filename == "." || filename == "..") continue;
TFilePath son = path + filename;
if (TFileStatus(son).isDirectory())
readDirectoryTree(dst, son);
else
dst.push_back(son);
}
closedir(dirp);
#endif
}
//------------------------------------------------------------
void TSystem::readDirectoryTree(TFilePathSet &dst,
const TFilePathSet &pathSet) {
for (TFilePathSet::const_iterator it = pathSet.begin(); it != pathSet.end();
it++)
readDirectoryTree(dst, *it);
}
//------------------------------------------------------------
TFilePathSet TSystem::readDirectoryTree(const TFilePath &path) {
TFilePathSet dst;
readDirectoryTree(dst, path);
return dst;
}
//------------------------------------------------------------
TFilePathSet TSystem::readDirectoryTree(const TFilePathSet &pathSet) {
TFilePathSet dst;
readDirectoryTree(dst, pathSet);
return dst;
}
//------------------------------------------------------------
TFilePathSet TSystem::packLevelNames(const TFilePathSet &fps) {
std::set<TFilePath> tmpSet;
TFilePathSet::const_iterator cit;
for (cit = fps.begin(); cit != fps.end(); ++cit)
tmpSet.insert(cit->getParentDir() + cit->getLevelName());
TFilePathSet fps2;
for (std::set<TFilePath>::const_iterator c_sit = tmpSet.begin();
c_sit != tmpSet.end(); ++c_sit) {
fps2.push_back(*c_sit);
}
return fps2;
}
//------------------------------------------------------------
TFilePathSet TSystem::getDisks() {
TFilePathSet filePathSet;
#ifdef WIN32
DWORD size = GetLogicalDriveStrings(0, NULL);
char *buffer = new char[size + 1];
char *ptr = buffer;
DWORD rc = GetLogicalDriveStrings(size, buffer);
if (rc == 0) throw TSystemException("", getFormattedMessage(GetLastError()));
while (*ptr) {
filePathSet.push_back(ptr);
while (*ptr) ptr++;
ptr++;
}
delete[] buffer;
return filePathSet;
#else
FILE *f = setmntent("/etc/fstab", "r");
if (f) {
while (struct mntent *m = getmntent(f)) {
// cout << "machine "<< m->mnt_fsname << " dir " <<m->mnt_dir << " type "
// << m->mnt_type << endl;
filePathSet.push_back(m->mnt_dir);
}
endmntent(f);
}
return filePathSet;
#endif
}
//------------------------------------------------------------
ULONG TSystem::getDiskSize(const TFilePath &diskName) {
ULONG size = 0;
if (!diskName.isAbsolute()) {
assert(0);
return 0;
}
#ifndef WIN32
struct statfs buf;
#ifdef __sgi
statfs(diskName.getFullPath().c_str(), &buf, sizeof(struct statfs), 0);
#else
statfs(diskName.getFullPath().c_str(), &buf);
#endif
size = (ULONG)((buf.f_blocks * buf.f_bsize) >> 10);
#else
DWORD sectorsPerCluster; // sectors per cluster
DWORD bytesPerSector; // bytes per sector
DWORD numberOfFreeClusters; // free clusters
DWORD totalNumberOfClusters;
BOOL rc = GetDiskFreeSpace(diskName.getFullPath().c_str(), // root path
§orsPerCluster, // sectors per cluster
&bytesPerSector, // bytes per sector
&numberOfFreeClusters, // free clusters
&totalNumberOfClusters // total clusters
);
if (!rc)
throw TSystemException(diskName, getFormattedMessage(GetLastError()));
else
size = (totalNumberOfClusters * sectorsPerCluster * bytesPerSector) >> 10;
#endif
return size;
}
//------------------------------------------------------------
ULONG TSystem::getFreeDiskSize(const TFilePath &diskName) {
ULONG size = 0;
if (!diskName.isAbsolute()) {
assert(0);
return 0;
}
#ifndef WIN32
struct statfs buf;
#ifdef __sgi
statfs(diskName.getFullPath().c_str(), &buf, sizeof(struct statfs), 0);
#else
statfs(diskName.getFullPath().c_str(), &buf);
#endif
size = (ULONG)(buf.f_bfree * buf.f_bsize) >> 10;
#else
DWORD sectorsPerCluster; // sectors per cluster
DWORD bytesPerSector; // bytes per sector
DWORD numberOfFreeClusters; // free clusters
DWORD totalNumberOfClusters;
BOOL rc = GetDiskFreeSpace(diskName.getFullPath().c_str(), // root path
§orsPerCluster, // sectors per cluster
&bytesPerSector, // bytes per sector
&numberOfFreeClusters, // free clusters
&totalNumberOfClusters // total clusters
);
if (!rc) // eccezione... getLastError etc...
throw TSystemException(diskName, getFormattedMessage(GetLastError()));
else
size = (numberOfFreeClusters * sectorsPerCluster * bytesPerSector) >> 10;
#endif
return size;
}
//------------------------------------------------------------
ULONG TSystem::getFreeMemorySize() {
ULONG totalFree = 0;
#ifdef WIN32
ULONG virtualFree = 0;
ULONG physicalFree = 0;
MEMORYSTATUS buff;
GlobalMemoryStatus(&buff);
physicalFree = buff.dwAvailPhys;
virtualFree = buff.dwAvailVirtual;
totalFree = (physicalFree + virtualFree) >> 10;
#else
#ifdef __sgi
// check for virtual memory
int numberOfResources =
swapctl(SC_GETNSWP, 0); /* get number of swapping resources configued */
if (numberOfResources == 0) return 0;
// avrei voluto fare: struct swaptable *table = new struct swaptable[...]
struct swaptable *table = (struct swaptable *)calloc(
1, sizeof(struct swapent) * numberOfResources + sizeof(int));
table->swt_n = numberOfResources;
swapctl(SC_LIST, table); /* list all the swapping resources */
ULONG virtualFree = 0;
ULONG physicalFree = 0;
for (int i = 0; i < table->swt_n; i++) {
virtualFree += table->swt_ent[i].ste_free;
}
free(table);
totalFree = virtualFree << 4 + physicalFree;
#else
#ifdef LINUX
struct sysinfo *sysInfo = (struct sysinfo *)calloc(1, sizeof(struct sysinfo));
if (!sysinfo(sysInfo)) {
totalFree = sysInfo->freeram + sysInfo->freeswap;
} else {
assert(!"sysinfo function failed");
}
free(sysInfo);
#else
@ @ @ERROR : PLATFORM NOT SUPPORTED
#endif
#endif //__sgi
#endif // WIN32
#ifndef WIN32
#else
#endif
return totalFree;
}
//------------------------------------------------------------
ostream &operator<<(ostream &out, const TTime &t) {
return out << t.getDate() << " " << t.getTime();
}
//------------------------------------------------------------
#ifdef __sgi
extern "C" long sginap(long ticks);
#else
#ifdef LINUX
extern "C" int usleep(unsigned int);
#endif
#endif
void TSystem::sleep(const TDeltaTime &delay) {
int ms = delay.getSeconds() * 1000;
assert(ms >= delay.getSeconds());
ms += delay.getMilliSeconds();
#ifdef WIN32
Sleep(ms);
#else
#ifdef __sgi
sginap(ms * CLK_TCK / 1000);
#else
#ifdef LINUX
ms *= 1000;
usleep(ms);
#endif
#endif
#endif
}
//--------------------------------------------------------------
TSystemException::TSystemException(const TFilePath &fname, int err)
: m_fname(fname.getFullPath())
, m_err(err)
, m_msg("")
{}
//--------------------------------------------------------------
TSystemException::TSystemException(const TFilePath &fname, const string &msg)
: m_fname(fname.getFullPath()), m_err(-1), m_msg(msg) {}
//--------------------------------------------------------------
TSystemException::TSystemException(const string &msg)
: m_fname(""), m_err(-1), m_msg(msg) {}
//--------------------------------------------------------------
string TSystemException::getMessage() const {
string msg = m_fname;
switch (m_err) {
case -1:
// nothing
msg += ": ";
msg += m_msg;
CASE EEXIST : msg +=
": Directory was not created because filename is the name of "
"an existing file, directory, or device";
CASE ENOENT : msg +=
": Path was not found, or the named file does not exist or "
"is a null pathname.";
CASE ENOTEMPTY : msg +=
": Given path is not a directory; directory is not empty; "
"or directory is either current working directory or root "
"directory";
CASE EACCES : msg +=
": Search permission is denied by a component of the path "
"prefix, or write permission on the file named by path is "
"denied, or times is NULL, and write access is denied";
CASE EFAULT : msg +=
": Times is not NULL and, or points outside the process's "
"allocated address space.";
CASE EINTR : msg += ": A signal was caught during the utime system call.";
CASE ENAMETOOLONG : msg +=
": The length of the path argument exceeds {PATH_MAX}, "
"or the length of a path component exceeds {NAME_MAX} "
"while _POSIX_NO_TRUNC is in effect.";
CASE ENOTDIR : msg +=
": A component of the path prefix is not a directory.";
CASE EPERM : msg +=
": The calling process does not have the super-user "
"privilege, the effective user ID is not the owner of the "
"file, and times is not NULL, or the file system containing "
"the file is mounted read-only";
CASE EROFS : msg +=
": The current file system level range does not envelop the "
"level of the file named by path, and the calling process "
"does not have the super-user privilege.";
CASE ENOSYS : msg +=
": When the named file cannot have its time reset. The file "
"is on a file system that doesn't have this operation.";
CASE EMFILE
: msg += ": The maximum number of file descriptors are currently open.";
CASE ENFILE : msg += ": The system file table is full.";
CASE EBADF : msg +=
": The file descriptor determined by the DIR stream is no "
"longer valid. This result occurs if the DIR stream has been "
"closed.";
CASE EINVAL
: msg +=
": 64-bit and non-64-bit calls were mixed in a sequence of calls.";
DEFAULT:
msg += ": Unknown error";
#ifndef WIN32
CASE ELOOP
: msg +=
": Too many symbolic links were encountered in translating path.";
CASE EMULTIHOP : msg +=
": Components of path require hopping to multiple remote "
"machines and the file system does not allow it.";
CASE ENOLINK : msg +=
": Path points to a remote machine and the link to that "
"machine is no longer active.";
#ifndef LINUX
CASE EDIRCORRUPTED : msg += ": The directory is corrupted on disk.";
#endif
CASE EOVERFLOW : msg +=
": One of the inode number values or offset values did "
"not fit in 32 bits, and the 64-bit interfaces were not "
"used.";
#endif
}
return msg;
}
//--------------------------------------------------------------
static const char *TnzLibMainProcName = "TLibMain";
static std::map<string, const TPluginInfo *> PluginTable;
static std::set<TnzLibMainProcType *> PluginMainTable;
//--------------------------------------------------------------
namespace {
#ifdef WIN32
static std::vector<HINSTANCE> PluginInstanceTable;
#else
static std::vector<void *> PluginInstanceTable;
#endif
extern "C" void unloadPlugins() {
#ifdef WIN32
for (std::vector<HINSTANCE>::iterator it = PluginInstanceTable.begin();
it != PluginInstanceTable.end(); ++it)
FreeLibrary(*it);
#else
for (std::vector<void *>::iterator it = PluginInstanceTable.begin();
it != PluginInstanceTable.end(); ++it)
dlclose(*it);
#endif
PluginInstanceTable.clear();
}
}
//--------------------------------------------------------------
void TSystem::unLoadPlugins() { unloadPlugins(); }
//--------------------------------------------------------------
void TSystem::loadPlugins(const TFilePath &dir) {
static bool cbReg = false;
if (!cbReg) {
cbReg = true;
atexit(unloadPlugins);
}
#ifdef WIN32
string extension = "dll";
#else
string extension = "so";
#endif
TFilePathSet dirContent = TSystem::readDirectory(dir);
if (dirContent.empty()) return;
for (TFilePathSet::iterator it = dirContent.begin(); it != dirContent.end();
it++) {
TFilePath fp = *it;
if (fp.getType() != extension) continue;
// cout << "Loading..." << fp << endl;
#ifdef WIN32
HINSTANCE handle = LoadLibrary(fp.getFullPath().c_str());
#else
void *handle = dlopen(fp.getFullPath().c_str(), RTLD_LAZY);
#endif
if (!handle) {
// non riesce a caricare la libreria;
#ifdef WIN32
DWORD err = GetLastError();
string s;
s = "*Error* unable to load " + fp.getFullPath() + ": " +
getFormattedMessage(err) + '\0';
TSystem::outputDebug(s);
#else
cout << "*ERROR* couldn't load " << fp << ":";
cout << dlerror() << endl;
#endif
} else {
PluginInstanceTable.push_back(handle);
// cout << "loaded" << endl;
#ifdef WIN32
TnzLibMainProcType *tnzLibMain =
(TnzLibMainProcType *)GetProcAddress(handle, TnzLibMainProcName);
#else
TnzLibMainProcType *tnzLibMain =
(TnzLibMainProcType *)dlsym(handle, TnzLibMainProcName);
#endif
if (!tnzLibMain) {
// La libreria non esporta TLibMain;
// per ora niente messaggi di errore
// cout<< "Unable to load TLibMain" << endl;
/*
#ifdef WIN32
FreeLibrary(handle);
#else
dlclose(handle);
#endif
*/
} else {
std::set<TnzLibMainProcType *>::iterator it;
it = PluginMainTable.find(tnzLibMain);
if (it == PluginMainTable.end()) {
PluginMainTable.insert(tnzLibMain);
const TPluginInfo *info = tnzLibMain();
if (info) {
PluginTable[info->getName()] = info;
}
}
} // if(tnzLibMain)
} // if(handle)
} // for
}
//--------------------------------------------------------------
void TSystem::loadStandardPlugins() {
static bool alreadyDone = false;
if (alreadyDone) return;
alreadyDone = true;
TFilePath pluginsDir = TSystem::getBinDir() + "plugins";
// cout << "loading standard plugins ... " << pluginsDir << endl;
try {
TSystem::loadPlugins(pluginsDir + "io");
} catch (const TException &e) {
#ifdef WIN32
MessageBox(0, e.getMessage().c_str(), "Error loading plugin", MB_OK);
#else
cout << e.getMessage() << endl;
#endif
}
try {
TSystem::loadPlugins(pluginsDir + "fx");
} catch (const TException &e) {
#ifdef WIN32
MessageBox(0, e.getMessage().c_str(), "Error loading plugin", MB_OK);
#else
cout << e.getMessage() << endl;
#endif
}
// cout << "done ... " << endl;
}
//--------------------------------------------------------------
const TPluginInfo *TSystem::getLoadedPluginInfo(string name) {
std::map<string, const TPluginInfo *>::iterator it;
it = PluginTable.find(name);
if (it == PluginTable.end())
return 0;
else
return it->second;
}
//--------------------------------------------------------------
void TSystem::showDocument(const TFilePath &path) {
#ifdef WIN32
int ret = (int)ShellExecute(0, "open", path.getFullPath().c_str(), 0, 0,
SW_SHOWNORMAL);
if (ret <= 32) {
throw TException(path.getFullPath() + " : can't open");
}
#else
string cmd = "mediaplayer ";
cmd = cmd + path.getFullPath();
system(cmd.c_str());
#endif
}
//--------------------------------------------------------------
int TSystem::getProcessorCount() {
#ifdef WIN32
SYSTEM_INFO sysInfo;
GetSystemInfo(&sysInfo);
return sysInfo.dwNumberOfProcessors;
#else
#ifdef __sgi
return sysconf(_SC_NPROC_CONF);
#else
return sysconf(_SC_NPROCESSORS_CONF);
#endif
#endif
}
//--------------------------------------------------------------
void TSystem::outputDebug(string s) {
#ifdef WIN32
OutputDebugString(s.c_str());
#else
cerr << s << endl;
#endif
}