nevrax.org : docs

00001 
+00007 /* Copyright, 2001 Nevrax Ltd.
+00008  *
+00009  * This file is part of NEVRAX NEL.
+00010  * NEVRAX NEL is free software; you can redistribute it and/or modify
+00011  * it under the terms of the GNU General Public License as published by
+00012  * the Free Software Foundation; either version 2, or (at your option)
+00013  * any later version.
+00014 
+00015  * NEVRAX NEL is distributed in the hope that it will be useful, but
+00016  * WITHOUT ANY WARRANTY; without even the implied warranty of
+00017  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+00018  * General Public License for more details.
+00019 
+00020  * You should have received a copy of the GNU General Public License
+00021  * along with NEVRAX NEL; see the file COPYING. If not, write to the
+00022  * Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+00023  * MA 02111-1307, USA.
+00024  */
+00025 
+00026 #include "stdmisc.h"
+00027 
+00028 #ifdef NL_OS_WINDOWS
+00029 #include <windows.h>
+00030 #elif defined NL_OS_UNIX
+00031 #include <unistd.h>
+00032 #include <string.h>
+00033 #include <errno.h>
+00034 #endif
+00035 
+00036 #include "nel/misc/command.h"
+00037 
+00038 using namespace std;
+00039 
+00040 #ifdef NL_OS_WINDOWS
+00041 #  ifdef __STL_DEBUG
+00042 #    define STL_MODE "debug"
+00043 #  else
+00044 #    define STL_MODE "normal"
+00045 #  endif // __STL_DEBUG
+00046 #  if(__SGI_STL_PORT < 0x400)
+00047 #    define STL_STR_VER "< 4.0"
+00048 #  elif(__SGI_STL_PORT == 0x400)
+00049 #    define STL_STR_VER "4.0"
+00050 #  elif(__SGI_STL_PORT == 0x450)
+00051 #    define STL_STR_VER "4.5"
+00052 #  elif(__SGI_STL_PORT > 0x450)
+00053 #    define STL_STR_VER "> 4.5"
+00054 #  endif // __SGI_STL_PORT
+00055 #  pragma message("Using STLport version "STL_STR_VER" in "STL_MODE" mode")
+00056 #endif // NL_OS_WINDOWS
+00057 
+00058 namespace       NLMISC
+00059 {
+00060 
+00061 /*
+00062  * Portable Sleep() function that suspends the execution of the calling thread for a number of milliseconds.
+00063  * Note: the resolution of the timer is system-dependant and may be more than 1 millisecond.
+00064  */
+00065 void nlSleep( uint32 ms )
+00066 {
+00067 #ifdef NL_OS_WINDOWS
+00068 
+00070 #ifdef NL_DEBUG
+00071         ms = max(ms, (uint32)1);
+00072 #endif
+00073 
+00074         Sleep( ms );
+00075 
+00076 #elif defined NL_OS_UNIX
+00077         usleep( ms*1000 );
+00078 #endif
+00079 }
+00080 
+00081 
+00082 /*
+00083  * Returns Thread Id (note: on Linux, Process Id is the same as the Thread Id)
+00084  */
+00085 uint getThreadId()
+00086 {
+00087 #ifdef NL_OS_WINDOWS
+00088         return GetCurrentThreadId();
+00089 #elif defined NL_OS_UNIX
+00090         return getpid();
+00091 #endif
+00092 
+00093 }
+00094 
+00095 
+00096 /*
+00097  * Returns a readable string from a vector of bytes. '\0' are replaced by ' '
+00098  */
+00099 string stringFromVector( const vector<uint8>& v, bool limited )
+00100 {
+00101         string s;
+00102 
+00103         if (!v.empty())
+00104         {
+00105                 int size = v.size ();
+00106                 if (limited && size > 1000)
+00107                 {
+00108                         string middle = "...<buf too big,skip middle part>...";
+00109                         s.resize (1000 + middle.size());
+00110                         memcpy (&*s.begin(), &*v.begin(), 500);
+00111                         memcpy (&*s.begin()+500, &*middle.begin(), middle.size());
+00112                         memcpy (&*s.begin()+500+middle.size(), &*v.begin()+size-500, 500);
+00113                 }
+00114                 else
+00115                 {
+00116                         s.resize (size);
+00117                         memcpy( &*s.begin(), &*v.begin(), v.size() );
+00118                 }
+00119 
+00120                 // Replace '\0' characters
+00121                 string::iterator is;
+00122                 for ( is=s.begin(); is!=s.end(); ++is )
+00123                 {
+00124                         // remplace non printable char and % with '?' chat
+00125                         if ( ! isprint((uint8)(*is)) || (*is) == '%')
+00126                         {
+00127                                 (*is) = '?';
+00128                         }
+00129                 }
+00130         }
+00131 /*
+00132         if ( ! v.empty() )
+00133         {
+00134                 // Copy contents
+00135                 s.resize( v.size() );
+00136                 memcpy( &*s.begin(), &*v.begin(), v.size() );
+00137 
+00138                 // Replace '\0' characters
+00139                 string::iterator is;
+00140                 for ( is=s.begin(); is!=s.end(); ++is )
+00141                 {
+00142                         // remplace non printable char and % with '?' chat
+00143                         if ( ! isprint((*is)) || (*is) == '%')
+00144                         {
+00145                                 (*is) = '?';
+00146                         }
+00147                 }
+00148         }
+00149 */      return s;
+00150 }
+00151 
+00152 
+00153 sint smprintf( char *buffer, size_t count, const char *format, ... )
+00154 {
+00155         sint ret;
+00156 
+00157         va_list args;
+00158         va_start( args, format );
+00159         ret = vsnprintf( buffer, count, format, args );
+00160         if ( ret == -1 )
+00161         {
+00162                 buffer[count-1] = '\0';
+00163         }
+00164         va_end( args );
+00165 
+00166         return( ret );
+00167 }
+00168 
+00169 
+00170 sint64 atoiInt64 (const char *ident, sint64 base)
+00171 {
+00172         sint64 number = 0;
+00173         bool neg = false;
+00174 
+00175         // NULL string
+00176         nlassert (ident != NULL);
+00177 
+00178         // empty string
+00179         if (*ident == '\0') goto end;
+00180         
+00181         // + sign
+00182         if (*ident == '+') ident++;
+00183 
+00184         // - sign
+00185         if (*ident == '-') { neg = true; ident++; }
+00186 
+00187         while (*ident != '\0')
+00188         {
+00189                 if (isdigit(*ident))
+00190                 {
+00191                         number *= base;
+00192                         number += (*ident)-'0';
+00193                 }
+00194                 else if (base > 10 && islower(*ident))
+00195                 {
+00196                         number *= base;
+00197                         number += (*ident)-'a'+10;
+00198                 }
+00199                 else if (base > 10 && isupper(*ident))
+00200                 {
+00201                         number *= base;
+00202                         number += (*ident)-'A'+10;
+00203                 }
+00204                 else
+00205                 {
+00206                         goto end;
+00207                 }
+00208                 ident++;
+00209         }
+00210 end:
+00211         if (neg) number = -number;
+00212         return number;
+00213 
+00215 /*      uint64 k = 0;
+00216 
+00217         while (*ident != '\0')
+00218         {
+00219                 switch(*(ident++))
+00220                 {
+00221                 case '0':
+00222                         k +=0;
+00223                         break;
+00224                 case '1':
+00225                         k +=1;
+00226                         break;
+00227                 case '2':
+00228                         k +=2;
+00229                         break;
+00230                 case '3':
+00231                         k +=3;
+00232                         break;
+00233                 case '4':
+00234                         k +=4;
+00235                         break;
+00236                 case '5':
+00237                         k +=5;
+00238                         break;
+00239                 case '6':
+00240                         k +=6;
+00241                         break;
+00242                 case '7':
+00243                         k +=7;
+00244                         break;
+00245                 case '8':
+00246                         k +=8;
+00247                         break;
+00248                 case '9':
+00249                         k +=9;
+00250                         break;
+00251                 case 'a':
+00252                         k +=10;
+00253                         break;
+00254                 case 'b':
+00255                         k +=11;
+00256                         break;
+00257                 case 'c':
+00258                         k +=12;
+00259                         break;
+00260                 case 'd':
+00261                         k +=13;
+00262                         break;
+00263                 case 'e':
+00264                         k +=14;
+00265                         break;
+00266                 case 'f':
+00267                         k +=15;
+00268                         break;
+00269 
+00270                 case 'A':
+00271                         k +=10;
+00272                         break;
+00273                 case 'B':
+00274                         k +=11;
+00275                         break;
+00276                 case 'C':
+00277                         k +=12;
+00278                         break;
+00279                 case 'D':
+00280                         k +=13;
+00281                         break;
+00282                 case 'E':
+00283                         k +=14;
+00284                         break;
+00285                 case 'F':
+00286                         k +=15;
+00287                         break;
+00288 
+00289                 case 0:
+00290                         return k;
+00291                         break;
+00292                 }
+00293                 if(*ident != 0) k *= base;
+00294         }
+00295 
+00296         return k;
+00297 */
+00298 }
+00299 
+00300 void itoaInt64 (sint64 number, char *str, sint64 base)
+00301 {
+00302         str[0] = '\0';
+00303         char b[256];
+00304         if(!number)
+00305         {
+00306                 str[0] = '0';
+00307                 str[1] = '\0';
+00308                 return;
+00309         }
+00310         memset(b,'\0',255);
+00311         memset(b,'0',64);
+00312         sint n;
+00313         sint64 x = number;
+00314         if (x < 0) x = -x;
+00315         char baseTable[] = "0123456789abcdefghijklmnopqrstuvwyz";
+00316         for(n = 0; n < 64; n ++)
+00317         {
+00318                 sint num = (sint)(x % base);
+00319                 b[64 - n] = baseTable[num];
+00320                 if(!x) 
+00321                 {
+00322                         int k;
+00323                         int j = 0;
+00324         
+00325                         if (number < 0)
+00326                         {
+00327                                 str[j++] = '-';
+00328                         }
+00329 
+00330                         for(k = 64 - n + 1; k <= 64; k++)       
+00331                         {
+00332                                 str[j ++] = b[k];
+00333                         }
+00334                         str[j] = '\0';
+00335                         break;
+00336                 }
+00337                 x /= base;
+00338         }
+00339 }
+00340 
+00341 uint raiseToNextPowerOf2(uint v)
+00342 {
+00343         uint    res=1;
+00344         while(res<v)
+00345                 res<<=1;
+00346         
+00347         return res;
+00348 }
+00349 
+00350 uint    getPowerOf2(uint v)
+00351 {
+00352         uint    res=1;
+00353         uint    ret=0;
+00354         while(res<v)
+00355         {
+00356                 ret++;
+00357                 res<<=1;
+00358         }
+00359         
+00360         return ret;
+00361 }
+00362 
+00363 bool isPowerOf2(sint32 v)
+00364 {
+00365         while(v)
+00366         {
+00367                 if(v&1)
+00368                 {
+00369                         v>>=1;
+00370                         if(v)
+00371                                 return false;
+00372                 }
+00373                 else
+00374                         v>>=1;
+00375         }
+00376 
+00377         return true;
+00378 }
+00379 
+00380 string bytesToHumanReadable (uint32 bytes)
+00381 {
+00382         static char *divTable[]= { "b", "kb", "mb", "gb", "tb" };
+00383         uint div = 0;
+00384         float res = (float)bytes;
+00385         float newres = res;
+00386         while (true)
+00387         {
+00388                 newres /= 1024;
+00389                 if(newres < 1.0f || div > 4)
+00390                         break;
+00391                 div++;
+00392                 res = newres;
+00393         }
+00394         int ires = (int) res;
+00395         if (res-(float)ires < .01f)
+00396                 return toString ("%.0f%s", res, divTable[div]);
+00397         else
+00398                 return toString ("%.2f%s", res, divTable[div]);
+00399 }
+00400 
+00401 NLMISC_COMMAND(bthr, "Convert a bytes number into an human readable", "<int>")
+00402 {
+00403         if (args.size() != 1)
+00404                 return false;
+00405         
+00406         log.displayNL("%d -> %s", atoi(args[0].c_str()), bytesToHumanReadable(atoi(args[0].c_str())).c_str());
+00407 
+00408         return true;
+00409 }
+00410 
+00411 std::string strlwr ( const std::string &str )
+00412 {
+00413         string res;
+00414         res.reserve (str.size());
+00415         for (uint i=0; i<str.size(); i++)
+00416         {
+00417                 if ( (str[i] >= 'A') && (str[i] <= 'Z') )
+00418                         res += str[i] - 'A' + 'a';
+00419                 else
+00420                         res += str[i];
+00421         }
+00422 
+00423         return res;
+00424 }
+00425 
+00426 std::string &strlwr ( std::string &str )
+00427 {
+00428         for (int i=str.size()-1; i>=0; i--)
+00429         {
+00430                 if ( (str[i] >= 'A') && (str[i] <= 'Z') )
+00431                 {
+00432                         str[i] = str[i] - 'A' + 'a';
+00433                 }
+00434         }
+00435 
+00436         return (str);
+00437 }
+00438 
+00439 char *strlwr ( char *str )
+00440 {
+00441         if (str == NULL)
+00442                 return (NULL);
+00443 
+00444         while (*str != '\0')
+00445         {
+00446                 if ( (*str >= 'A') && (*str <= 'Z') )
+00447                 {
+00448                         *str = *str - 'A' + 'a';
+00449                 }
+00450                 str++;
+00451         }
+00452 
+00453         return (str);
+00454 }
+00455 
+00456 std::string &strupr ( std::string &str )
+00457 {
+00458         for (int i=str.size()-1; i>=0; i--)
+00459         {
+00460                 if ( (str[i] >= 'a') && (str[i] <= 'z') )
+00461                 {
+00462                         str[i] = str[i] - 'a' + 'A';
+00463                 }
+00464         }
+00465 
+00466         return (str);
+00467 }
+00468 
+00469 char *strupr ( char *str )
+00470 {
+00471         if (str == NULL)
+00472                 return (NULL);
+00473 
+00474         while (*str != '\0')
+00475         {
+00476                 if ( (*str >= 'a') && (*str <= 'z') )
+00477                 {
+00478                         *str = *str - 'a' + 'A';
+00479                 }
+00480                 str++;
+00481         }
+00482 
+00483         return (str);
+00484 }
+00485 
+00486 sint nlstricmp(const char *lhs,const char *rhs)
+00487 {
+00488         nlassert(lhs);
+00489         nlassert(rhs);
+00490         uint lchar, rchar;
+00491         while (*lhs != '\0' && *rhs != '\0')
+00492         {
+00493                 lchar = ::toupper(*lhs);
+00494                 rchar = ::toupper(*rhs);
+00495                 if (lchar != rchar) return lchar - rchar;
+00496                 ++lhs;
+00497                 ++rhs;
+00498         }
+00499         if (*lhs != 0) return 1;
+00500         if (*rhs != 0) return -1;
+00501         return 0;
+00502 }
+00503 
+00504 sint nlstricmp(const std::string &lhs,const std::string &rhs)
+00505 {
+00506         return nlstricmp(lhs.c_str(), rhs.c_str());
+00507 }
+00508 
+00509 
+00510 
+00511 //
+00512 // Exceptions
+00513 //
+00514 
+00515 Exception::Exception() : _Reason("Unknown Exception")
+00516 {
+00517 //      nlinfo("Exception will be launched: %s", _Reason.c_str());
+00518 }
+00519 
+00520 Exception::Exception(const std::string &reason) : _Reason(reason)
+00521 {
+00522         nlinfo("Exception will be launched: %s", _Reason.c_str());
+00523 }
+00524 
+00525 Exception::Exception(const char *format, ...)
+00526 {
+00527         NLMISC_CONVERT_VARGS (_Reason, format, NLMISC::MaxCStringSize);
+00528         nlinfo("Exception will be launched: %s", _Reason.c_str());
+00529 }
+00530 
+00531 const char      *Exception::what() const throw()
+00532 {
+00533         return _Reason.c_str();
+00534 }
+00535 
+00536 bool launchProgram (const std::string &programName, const std::string &arguments)
+00537 {
+00538 
+00539 #ifdef NL_OS_WINDOWS
+00540 
+00541         SECURITY_ATTRIBUTES sa;
+00542         sa.nLength = sizeof (sa);
+00543         sa.lpSecurityDescriptor = NULL;
+00544         sa.bInheritHandle = FALSE;
+00545 
+00546         STARTUPINFO si;
+00547         si.cb = sizeof (si);
+00548         si.lpReserved = NULL;
+00549         si.lpDesktop = NULL;
+00550         si.lpTitle = NULL;
+00551         si.dwFlags = STARTF_USESHOWWINDOW;
+00552         si.cbReserved2 = 0;
+00553         si.wShowWindow = SW_MINIMIZE;
+00554         si.lpReserved2 = NULL;
+00555 
+00556         PROCESS_INFORMATION pi;
+00557 
+00558         BOOL res = CreateProcess(programName.c_str(), (char*)arguments.c_str(), &sa, &sa, FALSE, 0, NULL, NULL, &si, &pi);
+00559 
+00560         if (res)
+00561         {
+00562                 nldebug("Successful launch '%s' with arg '%s'", programName.c_str(), arguments.c_str());
+00563                 return true;
+00564         }
+00565         else
+00566         {
+00567                 LPVOID lpMsgBuf;
+00568                 FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, GetLastError(), MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL);
+00569                 nlwarning("Failed launched '%s' with arg '%s' err %d: '%s'", programName.c_str(), arguments.c_str(), GetLastError (), lpMsgBuf);
+00570                 LocalFree(lpMsgBuf);
+00571         }
+00572 
+00573 #elif defined(NL_OS_UNIX)
+00574 
+00575         int status = vfork ();
+00576         if (status == -1)
+00577         {
+00578                 char *err = strerror (errno);
+00579                 nlwarning("Failed launched '%s' with arg '%s' err %d: '%s'", programName.c_str(), arguments.c_str(), errno, err);
+00580         }
+00581         else if (status == 0)
+00582     {
+00583                 status = execlp(programName.c_str(), programName.c_str(), arguments.c_str(), 0);
+00584                 if (status == -1)
+00585                 {
+00586                         perror("Failed launched");
+00587                         _exit(EXIT_FAILURE);
+00588                 }
+00589         }
+00590         else
+00591         {
+00592                 nldebug("Successful launch '%s' with arg '%s'", programName.c_str(), arguments.c_str());
+00593                 return true;
+00594         }
+00595 #else
+00596         nlwarning ("launchProgram() not implemented");
+00597 #endif
+00598 
+00599         return false;
+00600 
+00601 }
+00602 
+00603 } // NLMISC
+
common.cpp
