nevrax.org : docs

00001 
+00007 /* Copyright, 2000 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 <process.h>
+00030 #include <windows.h>
+00031 #else
+00032 #include <unistd.h>
+00033 #endif
+00034 
+00035 #include <time.h>
+00036 #include <stdarg.h>
+00037 
+00038 #include "nel/misc/displayer.h"
+00039 #include "nel/misc/log.h"
+00040 #include "nel/misc/debug.h"
+00041 #include "nel/misc/path.h"
+00042 
+00043 using namespace std;
+00044 
+00045 
+00046 namespace NLMISC
+00047 {
+00048 
+00049 string *CLog::_ProcessName = NULL;
+00050 
+00051 CLog::CLog( TLogType logType) : _LogType (logType), _Line(-1), _FileName(NULL), _Mutex("LOG"+toString((uint)logType)), _PosSet(false)
+00052 {
+00053 }
+00054 
+00055 void CLog::setDefaultProcessName ()
+00056 {
+00057 #ifdef NL_OS_WINDOWS
+00058         if (_ProcessName == NULL)
+00059         {
+00060                 _ProcessName = new string;
+00061         }
+00062         
+00063         if ((*_ProcessName).empty())
+00064         {
+00065                 char name[1024];
+00066                 GetModuleFileName (NULL, name, 1023);
+00067                 (*_ProcessName) = CFile::getFilename(name);
+00068         }
+00069 #endif
+00070 }
+00071 
+00072 void CLog::setProcessName (const std::string &processName)
+00073 {
+00074         if (_ProcessName == NULL)
+00075         {
+00076                 _ProcessName = new string;
+00077         }
+00078 
+00079         *_ProcessName = processName;
+00080 }
+00081 
+00082 void CLog::setPosition (sint line, char *filename)
+00083 {
+00084         if ( !noDisplayer() )
+00085         {
+00086                 _Mutex.enter();
+00087                 _PosSet++;
+00088             _Line = line;
+00089                 _FileName = filename;
+00090         }
+00091 }
+00092 
+00094 void CLog::unsetPosition()
+00095 {
+00096         nlassert( !noDisplayer() );
+00097 
+00098         if ( _PosSet > 0 )
+00099         {
+00100                 _FileName = NULL;
+00101                 _Line = -1;
+00102                 _PosSet--;
+00103                 _Mutex.leave(); // needs setPosition() to have been called
+00104         }
+00105 }
+00106 
+00107 
+00108 void CLog::addDisplayer (IDisplayer *displayer, bool bypassFilter)
+00109 {
+00110         if (displayer == NULL)
+00111         {
+00112                 nlwarning ("Trying to add a NULL displayer");
+00113                 return;
+00114         }
+00115 
+00116         if (bypassFilter)
+00117         {
+00118                 CDisplayers::iterator idi = std::find (_BypassFilterDisplayers.begin (), _BypassFilterDisplayers.end (), displayer);
+00119                 if (idi == _BypassFilterDisplayers.end ())
+00120                 {
+00121                         _BypassFilterDisplayers.push_back (displayer);
+00122                 }
+00123                 else
+00124                 {
+00125                         nlwarning ("Couldn't add the displayer, it was already added");
+00126                 }
+00127         }
+00128         else
+00129         {
+00130                 CDisplayers::iterator idi = std::find (_Displayers.begin (), _Displayers.end (), displayer);
+00131                 if (idi == _Displayers.end ())
+00132                 {
+00133                         _Displayers.push_back (displayer);
+00134                 }
+00135                 else
+00136                 {
+00137                         nlwarning ("Couldn't add the displayer, it was already added");
+00138                 }
+00139         }
+00140 }
+00141 
+00142 void CLog::removeDisplayer (IDisplayer *displayer)
+00143 {
+00144         if (displayer == NULL)
+00145         {
+00146                 nlwarning ("Trying to remove a NULL displayer");
+00147                 return;
+00148         }
+00149 
+00150         CDisplayers::iterator idi = std::find (_Displayers.begin (), _Displayers.end (), displayer);
+00151         if (idi != _Displayers.end ())
+00152         {
+00153                 _Displayers.erase (idi);
+00154         }
+00155 
+00156         idi = std::find (_BypassFilterDisplayers.begin (), _BypassFilterDisplayers.end (), displayer);
+00157         if (idi != _BypassFilterDisplayers.end ())
+00158         {
+00159                 _BypassFilterDisplayers.erase (idi);
+00160         }
+00161 
+00162 }
+00163 
+00164 void CLog::removeDisplayer (const char *displayerName)
+00165 {
+00166         if (displayerName == NULL || displayerName[0] == '\0')
+00167         {
+00168                 nlwarning ("Trying to remove an empty displayer name");
+00169                 return;
+00170         }
+00171 
+00172         CDisplayers::iterator idi;
+00173         for (idi = _Displayers.begin (); idi != _Displayers.end ();)
+00174         {
+00175                 if ((*idi)->DisplayerName == displayerName)
+00176                 {
+00177                         idi = _Displayers.erase (idi);
+00178                 }
+00179                 else
+00180                 {
+00181                         idi++;
+00182                 }
+00183         }
+00184 
+00185         for (idi = _BypassFilterDisplayers.begin (); idi != _BypassFilterDisplayers.end ();)
+00186         {
+00187                 if ((*idi)->DisplayerName == displayerName)
+00188                 {
+00189                         idi = _BypassFilterDisplayers.erase (idi);
+00190                 }
+00191                 else
+00192                 {
+00193                         idi++;
+00194                 }
+00195         }
+00196 }
+00197 
+00198 IDisplayer *CLog::getDisplayer (const char *displayerName)
+00199 {
+00200         if (displayerName == NULL || displayerName[0] == '\0')
+00201         {
+00202                 nlwarning ("Trying to get an empty displayer name");
+00203                 return NULL;
+00204         }
+00205 
+00206         CDisplayers::iterator idi;
+00207         for (idi = _Displayers.begin (); idi != _Displayers.end (); idi++)
+00208         {
+00209                 if ((*idi)->DisplayerName == displayerName)
+00210                 {
+00211                         return *idi;
+00212                 }
+00213         }
+00214         for (idi = _BypassFilterDisplayers.begin (); idi != _BypassFilterDisplayers.end (); idi++)
+00215         {
+00216                 if ((*idi)->DisplayerName == displayerName)
+00217                 {
+00218                         return *idi;
+00219                 }
+00220         }
+00221         return NULL;
+00222 }
+00223 
+00224 /*
+00225  * Returns true if the specified displayer is attached to the log object
+00226  */
+00227 bool CLog::attached(IDisplayer *displayer) const 
+00228 {
+00229         return (find( _Displayers.begin(), _Displayers.end(), displayer ) != _Displayers.end()) ||
+00230                         (find( _BypassFilterDisplayers.begin(), _BypassFilterDisplayers.end(), displayer ) != _BypassFilterDisplayers.end());
+00231 }
+00232 
+00233 static string TempString;
+00234 static TDisplayInfo TempArgs;
+00235 
+00236 
+00237 void CLog::displayString (const char *str)
+00238 {
+00239         const char *disp = NULL;
+00240         TDisplayInfo localargs, *args = NULL;
+00241 
+00242         setDefaultProcessName ();
+00243 
+00244         if(strchr(str,'\n') == NULL)
+00245         {
+00246                 if (TempString.empty())
+00247                 {
+00248                         time (&TempArgs.Date);
+00249                         TempArgs.LogType = _LogType;
+00250                         TempArgs.ProcessName = *_ProcessName;
+00251                         TempArgs.ThreadId = getThreadId();
+00252                         TempArgs.Filename = _FileName;
+00253                         TempArgs.Line = _Line;
+00254                         TempArgs.CallstackAndLog = "";
+00255 
+00256                         TempString = str;
+00257                 }
+00258                 else
+00259                 {
+00260                         TempString += str;
+00261                 }
+00262                 return;
+00263         }
+00264         else
+00265         {
+00266                 if (TempString.empty())
+00267                 {
+00268                         time (&localargs.Date);
+00269                         localargs.LogType = _LogType;
+00270                         localargs.ProcessName = *_ProcessName;
+00271                         localargs.ThreadId = getThreadId();
+00272                         localargs.Filename = _FileName;
+00273                         localargs.Line = _Line;
+00274                         localargs.CallstackAndLog = "";
+00275 
+00276                         disp = str;
+00277                         args = &localargs;
+00278                 }
+00279                 else
+00280                 {
+00281                         TempString += str;
+00282                         disp = TempString.c_str();
+00283                         args = &TempArgs;
+00284                 }
+00285         }
+00286 
+00287         // send to all bypass filter displayers
+00288         for (CDisplayers::iterator idi=_BypassFilterDisplayers.begin(); idi!=_BypassFilterDisplayers.end(); idi++ )
+00289         {
+00290                 (*idi)->display( *args, disp );
+00291         }
+00292 
+00293         // get the log at the last minute to be sure to have everything
+00294         if(args->LogType == LOG_ERROR || args->LogType == LOG_ASSERT)
+00295         {
+00296                 getCallStackAndLog (args->CallstackAndLog, 4);
+00297         }
+00298 
+00299         if (passFilter (disp))
+00300         {
+00301                 // Send to the attached displayers
+00302                 for (CDisplayers::iterator idi=_Displayers.begin(); idi!=_Displayers.end(); idi++ )
+00303                 {
+00304                         (*idi)->display( *args, disp );
+00305                 }
+00306         }
+00307         TempString = "";
+00308         unsetPosition();
+00309 }
+00310 
+00311 
+00312 /*
+00313  * Display the string with decoration and final new line to all attached displayers
+00314  */
+00315 void CLog::displayNL (const char *format, ...)
+00316 {
+00317         if ( noDisplayer() )
+00318         {
+00319                 return;
+00320         }
+00321 
+00322         char *str;
+00323         NLMISC_CONVERT_VARGS (str, format, 256/*NLMISC::MaxCStringSize*/);
+00324 
+00325         if (strlen(str)<256/*NLMISC::MaxCStringSize*/-1)
+00326                 strcat (str, "\n");
+00327         else
+00328                 str[256/*NLMISC::MaxCStringSize*/-2] = '\n';
+00329 
+00330         displayString (str);
+00331 }
+00332  
+00333 /*
+00334  * Display the string with decoration to all attached displayers
+00335  */
+00336 void CLog::display (const char *format, ...)
+00337 {
+00338         if ( noDisplayer() )
+00339         {
+00340                 return;
+00341         }
+00342 
+00343         char *str;
+00344         NLMISC_CONVERT_VARGS (str, format, 256/*NLMISC::MaxCStringSize*/);
+00345 
+00346         displayString (str);
+00347 }
+00348 
+00349 
+00350 void CLog::displayRawString (const char *str)
+00351 {
+00352         const char *disp = NULL;
+00353         TDisplayInfo localargs, *args = NULL;
+00354 
+00355         setDefaultProcessName ();
+00356 
+00357         if(strchr(str,'\n') == NULL)
+00358         {
+00359                 if (TempString.empty())
+00360                 {
+00361                         localargs.Date = 0;
+00362                         localargs.LogType = CLog::LOG_NO;
+00363                         localargs.ProcessName = "";
+00364                         localargs.ThreadId = 0;
+00365                         localargs.Filename = NULL;
+00366                         localargs.Line = -1;
+00367                         localargs.CallstackAndLog = "";
+00368 
+00369                         TempString = str;
+00370                 }
+00371                 else
+00372                 {
+00373                         TempString += str;
+00374                 }
+00375                 return;
+00376         }
+00377         else
+00378         {
+00379                 if (TempString.empty())
+00380                 {
+00381                         localargs.Date = 0;
+00382                         localargs.LogType = CLog::LOG_NO;
+00383                         localargs.ProcessName = "";
+00384                         localargs.ThreadId = 0;
+00385                         localargs.Filename = NULL;
+00386                         localargs.Line = -1;
+00387                         localargs.CallstackAndLog = "";
+00388 
+00389                         disp = str;
+00390                         args = &localargs;
+00391                 }
+00392                 else
+00393                 {
+00394                         TempString += str;
+00395                         disp = TempString.c_str();
+00396                         args = &TempArgs;
+00397                 }
+00398         }
+00399 
+00400         // send to all bypass filter displayers
+00401         for (CDisplayers::iterator idi=_BypassFilterDisplayers.begin(); idi!=_BypassFilterDisplayers.end(); idi++ )
+00402         {
+00403                 (*idi)->display( *args, disp );
+00404         }
+00405 
+00406         // get the log at the last minute to be sure to have everything
+00407         if(args->LogType == LOG_ERROR || args->LogType == LOG_ASSERT)
+00408         {
+00409                 getCallStackAndLog (args->CallstackAndLog, 4);
+00410         }
+00411 
+00412         if ( passFilter( disp ) )
+00413         {
+00414                 // Send to the attached displayers
+00415                 for ( CDisplayers::iterator idi=_Displayers.begin(); idi!=_Displayers.end(); idi++ )
+00416                 {
+00417                         (*idi)->display( *args, disp );
+00418                 }
+00419         }
+00420         TempString = "";
+00421         unsetPosition();
+00422 }
+00423 
+00424 /*
+00425  * Display a string (and nothing more) to all attached displayers
+00426  */
+00427 void CLog::displayRawNL( const char *format, ... )
+00428 {
+00429         if ( noDisplayer() )
+00430         {
+00431                 return;
+00432         }
+00433 
+00434         char *str;
+00435         NLMISC_CONVERT_VARGS (str, format, 256/*NLMISC::MaxCStringSize*/);
+00436 
+00437         if (strlen(str)<256/*NLMISC::MaxCStringSize*/-1)
+00438                 strcat (str, "\n");
+00439         else
+00440                 str[256/*NLMISC::MaxCStringSize*/-2] = '\n';
+00441 
+00442         displayRawString(str);
+00443 }
+00444 
+00445 /*
+00446  * Display a string (and nothing more) to all attached displayers
+00447  */
+00448 void CLog::displayRaw( const char *format, ... )
+00449 {
+00450         if ( noDisplayer() )
+00451         {
+00452                 return;
+00453         }
+00454 
+00455         char *str;
+00456         NLMISC_CONVERT_VARGS (str, format, 256/*NLMISC::MaxCStringSize*/);
+00457 
+00458         displayRawString(str);
+00459 }
+00460 
+00461 
+00462 void CLog::forceDisplayRaw (const char *format, ...)
+00463 {
+00464         if ( noDisplayer() )
+00465         {
+00466                 return;
+00467         }
+00468 
+00469         char *str;
+00470         NLMISC_CONVERT_VARGS (str, format, 256/*NLMISC::MaxCStringSize*/);
+00471 
+00472         TDisplayInfo args;
+00473 
+00474         // Send to the attached displayers
+00475         for ( CDisplayers::iterator idi=_Displayers.begin(); idi!=_Displayers.end(); idi++ )
+00476         {
+00477                 (*idi)->display( args, str );
+00478         }
+00479 }
+00480 
+00481 
+00482 
+00483 /*
+00484  * Returns true if the string must be logged, according to the current filter
+00485  */
+00486 bool CLog::passFilter( const char *filter )
+00487 {
+00488         bool yes = _PositiveFilter.empty();
+00489 
+00490         bool found;
+00491         list<string>::iterator ilf;
+00492 
+00493         // 1. Positive filter
+00494         for ( ilf=_PositiveFilter.begin(); ilf!=_PositiveFilter.end(); ++ilf )
+00495         {
+00496                 found = ( strstr( filter, (*ilf).c_str() ) != NULL );
+00497                 if ( found )
+00498                 {
+00499                         yes = true; // positive filter passed (no need to check another one)
+00500                         break;
+00501                 }
+00502                 // else try the next one
+00503         }
+00504         if ( ! yes )
+00505         {
+00506                 return false; // positive filter not passed
+00507         }
+00508 
+00509         // 2. Negative filter
+00510         for ( ilf=_NegativeFilter.begin(); ilf!=_NegativeFilter.end(); ++ilf )
+00511         {
+00512                 found = ( strstr( filter, (*ilf).c_str() ) != NULL );
+00513                 if ( found )
+00514                 {
+00515                         return false; // negative filter not passed (no need to check another one)
+00516                 }
+00517         }
+00518         return true; // negative filter passed
+00519 }
+00520 
+00521 
+00522 /*
+00523  * Removes a filter by name. Returns true if it was found.
+00524  */
+00525 void CLog::removeFilter( const char *filterstr )
+00526 {
+00527         if (filterstr == NULL)
+00528         {
+00529                 _PositiveFilter.clear();
+00530                 _NegativeFilter.clear();
+00531                 //displayNL ("CLog::addNegativeFilter('%s')", filterstr);
+00532         }
+00533         else
+00534         {
+00535                 _PositiveFilter.remove( filterstr );
+00536                 _NegativeFilter.remove( filterstr );
+00537                 //displayNL ("CLog::removeFilter('%s')", filterstr);
+00538         }
+00539 }
+00540 
+00541 void CLog::displayFilter( CLog &log )
+00542 {
+00543         std::list<std::string>::iterator it;
+00544         log.displayNL ("Positive Filter(s):");
+00545         for (it = _PositiveFilter.begin (); it != _PositiveFilter.end (); it++)
+00546         {
+00547                 log.displayNL ("'%s'", (*it).c_str());
+00548         }
+00549         log.displayNL ("Negative Filter(s):");
+00550         for (it = _NegativeFilter.begin (); it != _NegativeFilter.end (); it++)
+00551         {
+00552                 log.displayNL ("'%s'", (*it).c_str());
+00553         }
+00554 }
+00555 
+00556 void CLog::addPositiveFilter( const char *filterstr )
+00557 {
+00558         //displayNL ("CLog::addPositiveFilter('%s')", filterstr);
+00559         _PositiveFilter.push_back( filterstr );
+00560 }
+00561 
+00562 void CLog::addNegativeFilter( const char *filterstr )
+00563 {
+00564         //displayNL ("CLog::addNegativeFilter('%s')", filterstr);
+00565         _NegativeFilter.push_back( filterstr );
+00566 }
+00567 
+00568 void CLog::resetFilters()
+00569 {
+00570         //displayNL ("CLog::resetFilter()");
+00571         _PositiveFilter.clear();
+00572         _NegativeFilter.clear();
+00573 }
+00574 
+00575 } // NLMISC
+00576 
+
log.cpp
