gba/common/GBALogger.cpp
branchRCL_3
changeset 8 ece4bbb094df
parent 5 3b17fc5c9564
equal deleted inserted replaced
7:6e226572c5f0 8:ece4bbb094df
    19 #ifdef _DEBUG
    19 #ifdef _DEBUG
    20 
    20 
    21 #include    "GBALogger.h"
    21 #include    "GBALogger.h"
    22 #include    <flogger.h>
    22 #include    <flogger.h>
    23 
    23 
    24 const TInt KDebugBufferSize1024 = 1024;
    24 const TInt KDebugBufferSize1024         = 1024;
    25 const TInt KDebugBufferSize512  = 512;
    25 const TInt KDebugBufferSize512          = 512;
    26 const TInt KDebugBufferSize240  = 240;
    26 const TInt KDebugBufferSize256          = 256;
    27 const TInt KDebugBufferSize120  = 120;
    27 const TInt KDebugBufferFragmentSize     = 120;
       
    28 const TInt KDebugBufferSize128          = 128;
    28 
    29 
    29 _LIT(KTimeFormat, "%F%D/%M/%Y %J:%T:%S");
    30 _LIT(KTimeFormat, "%F%D/%M/%Y %J:%T:%S");
    30 
    31 
    31 void debugline(const char *a, void *arg1, void* arg1b, void *arg2, void *arg3, const char *arg4) 
    32 void debugline(const char *aFormatString, void *aArg1, void* aArg2, void *aArg3, void *aArg4, const char *aArg5)
    32     {
    33     {
    33     TBuf8<KDebugBufferSize1024> logbuffer;
    34     TBuf8<KDebugBufferSize1024> logbuffer;
    34     TPtrC8 p((const TUint8 *)a);
    35     TPtrC8 p((const TUint8 *)aFormatString);
    35     TPtrC8 temp_arg4((const TUint8 *)arg4);
    36     TPtrC8 tempArg5((const TUint8 *)aArg5);
       
    37     logbuffer.Format(p, aArg1,aArg2, aArg3, aArg4);
    36     
    38     
    37     if( temp_arg4.Length() > KDebugBufferSize1024 - KDebugBufferSize120  )
    39     if( KDebugBufferSize1024 < logbuffer.Size() + tempArg5.Size() )
    38         return;
    40         return;
    39     
    41     
    40     logbuffer.Format(p, arg1,arg1b, arg2, arg3);
    42     logbuffer.Append(tempArg5);
    41     logbuffer.Append(temp_arg4);
       
    42     
    43     
    43     if ( logbuffer.Length() <= KDebugBufferSize120 )
    44     TInt iterator = 0;
       
    45     
       
    46     TBuf8<KDebugBufferSize256> tempbuffer;
       
    47     TInt bufferSize = logbuffer.Size();
       
    48     while( iterator < bufferSize )
    44         {
    49         {
    45         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    50         if( (bufferSize - iterator) > KDebugBufferFragmentSize )
    46                                   EFileLoggingModeAppend, 
    51             {
    47                                   logbuffer );
    52             tempbuffer.Copy(logbuffer.Mid(iterator, KDebugBufferFragmentSize));
    48         }
       
    49     else
       
    50         {
       
    51         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
       
    52                                   EFileLoggingModeAppend, 
       
    53                                   logbuffer.Left( KDebugBufferSize120 ) );
       
    54         //max length is 150, print another line 
       
    55         if (logbuffer.Mid(KDebugBufferSize120).Length()<= KDebugBufferSize120 )
       
    56             { 
       
    57             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    53             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    58                                       EFileLoggingModeAppend, 
    54                                         EFileLoggingModeAppend,
    59                                       logbuffer.Mid(KDebugBufferSize120) );
    55                                         _L8("%S"), &tempbuffer);
    60             }
    56             }
    61         else
    57         else
    62             {
    58             {
       
    59             tempbuffer.Copy(logbuffer.Mid(iterator, bufferSize - iterator));
    63             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    60             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    64                                       EFileLoggingModeAppend, 
    61                                       EFileLoggingModeAppend,
    65                                       logbuffer.Mid(KDebugBufferSize120, KDebugBufferSize120) );
    62                                       _L8("%S"), &tempbuffer);
    66             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    63             }
    67                                       EFileLoggingModeAppend, 
    64         iterator += KDebugBufferFragmentSize;
    68                                       logbuffer.Mid(KDebugBufferSize240) );                           
    65         }
    69             }                
       
    70           }
       
    71     }
    66     }
    72 
    67 
    73 
    68 void debugline(const char *aFormatString, void *aArg1, void* aArg2, void *aArg3, void *aArg4, const TDesC &aArg5)
    74 void debugline(const char *a, void *arg1, void* arg1b, void *arg2, void *arg3, const TDesC &arg4) 
       
    75     {
    69     {
    76     TBuf8<KDebugBufferSize1024> logbuffer;
    70     TBuf8<KDebugBufferSize1024> logbuffer;
       
    71     TPtrC8 p((const TUint8 *)aFormatString);
       
    72     logbuffer.Format(p, aArg1,aArg2, aArg3, aArg4);
    77     
    73     
    78     if( arg4.Length() > KDebugBufferSize1024 - KDebugBufferSize120  )
    74     if( KDebugBufferSize1024 < logbuffer.Size() + aArg5.Length() )
    79         return;
    75         return;
    80     
    76     
    81     TPtrC8 p((const TUint8 *)a);
    77     logbuffer.Append(aArg5);
    82     logbuffer.Format(p, arg1,arg1b, arg2, arg3);
       
    83     logbuffer.Append(arg4);
       
    84     
    78     
    85     if ( logbuffer.Length() <= KDebugBufferSize120 )
    79     TInt iterator = 0;
       
    80     
       
    81     TBuf8<KDebugBufferSize256> tempbuffer;
       
    82     TInt bufferSize = logbuffer.Size();
       
    83     while( iterator < bufferSize )
    86         {
    84         {
    87         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    85         if( (bufferSize - iterator) > KDebugBufferFragmentSize )
    88                                   EFileLoggingModeAppend, 
    86             {
    89                                   logbuffer );
    87             tempbuffer.Copy(logbuffer.Mid(iterator, KDebugBufferFragmentSize));
    90         }
       
    91     else
       
    92         {
       
    93         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
       
    94                                   EFileLoggingModeAppend, 
       
    95                                   logbuffer.Left( KDebugBufferSize120 ) );
       
    96         //max length is 150, print another line 
       
    97         if (logbuffer.Mid(KDebugBufferSize120).Length()<= KDebugBufferSize120 )
       
    98             { 
       
    99             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    88             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   100                                       EFileLoggingModeAppend, 
    89                                         EFileLoggingModeAppend,
   101                                       logbuffer.Mid(KDebugBufferSize120) );
    90                                         _L8("%S"), &tempbuffer);
   102             }
    91             }
   103         else
    92         else
   104             {
    93             {
       
    94             tempbuffer.Copy(logbuffer.Mid(iterator, bufferSize - iterator));
   105             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    95             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   106                                       EFileLoggingModeAppend, 
    96                                         EFileLoggingModeAppend,
   107                                       logbuffer.Mid(KDebugBufferSize120, KDebugBufferSize120) );
    97                                         _L8("%S"), &tempbuffer);
   108             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
    98             }
   109                                       EFileLoggingModeAppend, 
    99         iterator += KDebugBufferFragmentSize;
   110                                       logbuffer.Mid(KDebugBufferSize240) );                          	
   100         }
   111             }        
       
   112     	  }
       
   113     }
   101     }
   114 
   102 
   115 void debugline(const char *a, void *arg1, void *arg1b, void *arg2, void *arg3, const TDesC8 &arg4) 
   103 void debugline(const char *aFormatString, void *aArg1, void *aArg2, void *aArg3, void *aArg4, const TDesC8 &aArg5)
   116     {  
   104     {
   117     TBuf8<KDebugBufferSize1024> logbuffer;
   105     TBuf8<KDebugBufferSize1024> logbuffer;
       
   106     TPtrC8 p((const TUint8 *)aFormatString);
       
   107     logbuffer.Format(p, aArg1,aArg2, aArg3, aArg4);
   118     
   108     
   119     if( arg4.Length() > KDebugBufferSize1024 - KDebugBufferSize120)
   109     if( KDebugBufferSize1024 < logbuffer.Size() + aArg5.Size() )
   120         return;
   110         return;
   121     
   111     
   122     TPtrC8 p((const TUint8 *)a);
   112     logbuffer.Append(aArg5);
   123     logbuffer.Format(p, arg1,arg1b, arg2, arg3);
       
   124     logbuffer.Append(arg4); 
       
   125     
   113     
   126     if ( logbuffer.Length() <= KDebugBufferSize120 )
   114     TInt iterator = 0;
       
   115     
       
   116     TBuf8<KDebugBufferSize256> tempbuffer;
       
   117     TInt bufferSize = logbuffer.Size();
       
   118     while( iterator < bufferSize )
   127         {
   119         {
   128         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   120         if( (bufferSize - iterator) > KDebugBufferFragmentSize )
   129                                   EFileLoggingModeAppend, 
   121             {
   130                                   logbuffer );
   122             tempbuffer.Copy(logbuffer.Mid(iterator, KDebugBufferFragmentSize));
   131         }
       
   132     else
       
   133         {
       
   134         RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
       
   135                                   EFileLoggingModeAppend, 
       
   136                                   logbuffer.Left(KDebugBufferSize120) );
       
   137         //max length is 150, print another line 
       
   138         
       
   139         if (logbuffer.Mid(KDebugBufferSize120).Length()<= KDebugBufferSize120 )
       
   140             { 
       
   141             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   123             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   142                                       EFileLoggingModeAppend, 
   124                                         EFileLoggingModeAppend,
   143                                       logbuffer.Mid(KDebugBufferSize120) );
   125                                         _L8("%S"), &tempbuffer);
   144             }
   126             }
   145         else
   127         else
   146             {
   128             {
       
   129             tempbuffer.Copy(logbuffer.Mid(iterator, bufferSize - iterator));
   147             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   130             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   148                                       EFileLoggingModeAppend, 
   131                                         EFileLoggingModeAppend,
   149                                       logbuffer.Mid(KDebugBufferSize120, KDebugBufferSize120) );
   132                                         _L8("%S"), &tempbuffer);
   150             RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   133             }
   151                                       EFileLoggingModeAppend, 
   134         iterator += KDebugBufferFragmentSize;
   152                                       logbuffer.Mid(KDebugBufferSize240) );                          	
   135         }
   153             }                               
       
   154     	  }     
       
   155     }
   136     }
   156 
   137 
   157 void debugline(const char *a, void *arg1, void *arg1b, void *arg2, void *arg3, const char *arg4, const TInt& aNum ) 
   138 void debugline(const char *aFormatString, void *aArg1, void *aArg2, void *aArg3, void *aArg4, const char *aArg5, const TInt& aNum )
   158     {
   139     {
   159     TBuf8<KDebugBufferSize512> logbuf;
   140     TBuf8<KDebugBufferSize512> logbuffer;
   160     TPtrC8 temp_arg4((TUint8 *)arg4);
   141     TPtrC8 tempArg5((const TUint8 *)aArg5);
   161     
   142     if( tempArg5.Size() > KDebugBufferSize512 - KDebugBufferSize128 )
   162     if( temp_arg4.Length() > KDebugBufferSize512 - KDebugBufferSize120)
       
   163         return;
   143         return;
   164     
   144     
   165     logbuf.Format( temp_arg4, aNum );
   145     TPtrC8 p((const TUint8 *)aFormatString);
   166     debugline(a, arg1, arg1b, arg2, arg3, logbuf);
   146     logbuffer.Format(p, aArg1,aArg2, aArg3, aArg4);
   167     }
   147     //Print in two seperate lines
       
   148     RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
       
   149                                                 EFileLoggingModeAppend,
       
   150                                                 _L8("%S"), &logbuffer);
       
   151     RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
       
   152                                             EFileLoggingModeAppend,
       
   153                                             _L8(aArg5), aNum);
       
   154     }  
   168 
   155 
   169 void debugline(const char *a, void *arg1, void *arg1b, void *arg2, void *arg3, const TDesC &arg4, const TInt& aNum ) 
   156 void debugBinary( const TDesC8 &aBuffer )
   170     {
       
   171     TBuf<KDebugBufferSize512> logbuf;
       
   172     
       
   173     if( arg4.Length() > KDebugBufferSize512 - KDebugBufferSize120 )
       
   174         return;
       
   175     
       
   176     logbuf.Format( arg4, aNum );
       
   177     debugline(a, arg1, arg1b, arg2, arg3, logbuf);
       
   178     }    
       
   179 
       
   180 void DebugBinary( const TDesC8 &buf ) 
       
   181     {
   157     {
   182     RFileLogger::HexDump( KGBALogDir, KGBALogFileName,
   158     RFileLogger::HexDump( KGBALogDir, KGBALogFileName,
   183         EFileLoggingModeAppend, 
   159                                 EFileLoggingModeAppend,
   184        NULL, NULL , buf.Ptr(), buf.Length() );
   160                                 NULL, NULL , aBuffer.Ptr(), aBuffer.Length() );
   185     } 
   161     }
   186 
   162 
   187 void debugTTime( TTime& aTime )
   163 void debugTTime( TTime& aTime )
   188     {
   164     {
   189     TBuf<KDebugBufferSize120> buf;
   165     TBuf<KDebugBufferSize256> buf;
   190     TRAPD(error , aTime.FormatL( buf, KTimeFormat));
   166     TRAPD(error , aTime.FormatL( buf, KTimeFormat));
   191     if(error != KErrNone)
   167     if(error != KErrNone)
   192         return;
   168         return;
   193     RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   169     RFileLogger::WriteFormat( KGBALogDir, KGBALogFileName,
   194                              EFileLoggingModeAppend, 
   170                                 EFileLoggingModeAppend,
   195                              buf );
   171                                 buf );
   196     }
   172     }
   197 
   173 
   198 #endif
   174 #endif
   199 
   175 
   200 //EOF
   176 //EOF