diff -r 000000000000 -r 08ec8eefde2f loggingservices/filelogger/SCLI/FLOGCLI.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/loggingservices/filelogger/SCLI/FLOGCLI.CPP Fri Jan 22 11:06:30 2010 +0200 @@ -0,0 +1,809 @@ +// Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// + +/** + @file +*/ + +#include +#include +#include "FLOGSTD.H" + +/** +Macro for Single blank space. + +*/ +#define BLANK _S("") + +const TInt KHexDumpWidth=16; + +/** +Literal constant that hold a string and unicode hex. + +*/ +_LIT(KFirstFormatString,"%s%04x : "); + +/** +Literal constant that hold a string and unicode hex. + +*/ +_LIT(KSecondFormatString,"%02x "); + +/** +Character Constant. + +*/ +_LIT(KThirdFormatString,"%c"); + +/** +Literal Constant for 3 blank spaces. + +*/ +_LIT(KThreeSpaces," "); + +/** +Literal Constant for 2 blank spaces. + +*/ +_LIT(KTwoSpaces," "); + + +IMPORT_C extern const TBool KFloggerSTI; + +/* +RFileLogger class definition +*/ + +EXPORT_C RFileLogger::RFileLogger() + : RSessionBase(), iFormatter(), iLastError(KErrNone), iLogSTI(KFloggerSTI) +/** Creates a default RFileLogger object. */ + {} + +EXPORT_C RFileLogger::~RFileLogger() +/** Empty destructor. +Clients with open sessions must end the session by calling Close() beforehand. +Note that it does not delete the log file.*/ + {} + +EXPORT_C TVersion RFileLogger::Version() const +/** Returns the version number. + +@return The version number. */ + { + + return(TVersion(KFLogSrvMajorVersionNumber,KFLogSrvMinorVersionNumber,KFLogSrvBuildVersionNumber)); + } + +EXPORT_C TInt RFileLogger::Connect() +/** Connects to the file logger server with the default number of message slots, which is 8. + +This function does not need to be called if you are using the static versions +of Write(), WriteFormat() or HexDump(). + +@return KErrNone if successful, otherwise one of the system-wide error codes. */ + { + + TInt ret=DoConnect(); + if (ret==KErrNotFound) + { + ret=FLogger::Start(); + if (ret==KErrNone || ret==KErrAlreadyExists) + ret=DoConnect(); + } + return ret; + } + +EXPORT_C void RFileLogger::SetDateAndTime(TBool aUseDate,TBool aUseTime) +/** Specifies whether time and/or date should be appended to log data. + +Appending of the time and date to log entries can be switched on and off +at anytime between creation and destruction of RFileLogger. + +This function does not need to be called if you are using the static versions +of Write(), WriteFormat() or HexDump(). + +@param aUseDate Use ETrue to log the date, otherwise EFalse. +@param aUseTime Use ETrue to log the time, otherwise EFalse. */ + { + + iFormatter.SetDateAndTime(aUseDate,aUseTime); + } + +EXPORT_C void RFileLogger::CreateLog(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode) +/** Creates or opens a file for logging. + +When specifying a directory for logging only specify the relative path to +'C:\\Logs\\' and do not append a '\\' to the end of the path either. CreateLog() +only creates the specified log file if the directory exists. This means that +switching logging on and off can be achieved without having to re-compile, +by just removing or renaming the log directory. + +aLogFile.iValid is set according to whether logging will actually occur or not. + +@param aDir The directory relative to 'C:\\Logs\\' where the log file resides +or is to be created. +@param aName The name of the log file. +@param aMode The mode in which the log file should be opened, either EAppend +or EOverwrite. */ + { + + iLogFile.Set(aDir,aName,aMode); + TPckg logFilePckg(iLogFile); + iLastError=SendReceive(ECreateLog, TIpcArgs( &logFilePckg)); + + if (iLastError!=KErrNone && !LogSTI()) + iLogFile.SetValid(EFalse); + } + +EXPORT_C void RFileLogger::CloseLog() +/** Closes the log file, iLogFile. + +This function closes the log file previously created or opened by CreateLog(). */ + { + TPckg logFilePckg(iLogFile); + iLastError=SendReceive(ECloseLog,TIpcArgs( &logFilePckg)); + } + +EXPORT_C TBool RFileLogger::LogValid() const +/** Returns the status of the log. + +@return ETrue if the log file is valid; otherwise EFalse. */ + { + + return iLogFile.Valid(); + } + +EXPORT_C TInt RFileLogger::LastError() const +/** Returns the last error status that has been set. + +@return This value can be set to any of the valid error codes from any of +the functions in this class. */ + { + + return iLastError; + } + +EXPORT_C TBool RFileLogger::LogSTI() const +/** Returns patchable constant value. + +@return This value specify the logging output. The default value EFalse +cause that the logs are stored to filesystem. ETrue intorduced as in CR 1688 +is used for logging using RDebug::Print */ + { + + return iLogSTI; + } + +// +// 16-bit non-static writes +// + +EXPORT_C void RFileLogger::Write(const TDesC16& aText) +/** Writes a string of Unicode characters to an open log, iLogFile, if it is a valid file. + +Note that the text will be converted to an 8 bit format for the log file. + +@param aText The Unicode string to write to the open log. */ + { + + if (iLogFile.Valid() || LogSTI()) + { + TBuf8 buf; + iLastError=iFormatter.FormatTextToWritableBuffer(buf,aText); + if (iLastError==KErrNone) + DoWrite(buf); + } + } + +EXPORT_C void RFileLogger::WriteFormat(TRefByValue aFmt,...) +/** Formats the remaining arguments of the function according to aFmt, and writes the +result to the log, iLogFile, if it is a valid file. + +The format string aFmt contains literal text, embedded with directives, for converting +the trailing list of arguments into text. The number and type of arguments is dictated +by the structure of the directives in aFmt. + +Note that the text will be converted to an 8 bit format for the log file. + +@param aFmt The 16-bit non modifiable descriptor containing the format string. +The TRefByValue class provides a constructor which takes a TDesC16 type. */ + { + + VA_LIST list; + VA_START(list,aFmt); + DoWriteFormat(aFmt,list); + } + +EXPORT_C void RFileLogger::WriteFormat(TRefByValue aFmt, VA_LIST& aList) +/** Formats the arguments pointed to by aList according to aFmt, and writes the +result to the log, iLogFile, if it is a valid file. + +The format string aFmt contains literal text, embedded with directives, +for converting the trailing list of arguments into text. The number and type +of arguments pointed to by aList is dictated by the structure of the directives +in aFmt. + +Note that the text will be converted to an 8 bit format for the log file. + +@param aFmt The 16-bit non modifiable descriptor containing the format string. +The TRefByValue class provides a constructor which takes a TDesC16 type. +@param aList A pointer to an argument list. */ + { + + DoWriteFormat(aFmt,aList); + } + +// +// 8-bit non-static writes +// + +EXPORT_C void RFileLogger::Write(const TDesC8& aText) +/** Writes a string of 8-bit characters to an open log, iLogFile, if it is a valid file. + +@param aText The 8-bit character string to write to the open log. */ + { + + if (iLogFile.Valid() || LogSTI()) + { + TBuf8 buf; + iLastError=iFormatter.FormatTextToWritableBuffer(buf,aText); + if (iLastError==KErrNone) + DoWrite(buf); + } + } + +EXPORT_C void RFileLogger::WriteFormat(TRefByValue aFmt,...) +/** Formats the remaining arguments of the function according to aFmt, and writes the +result to the log, iLogFile, if it is a valid file. + +The format string aFmt contains literal text, embedded with directives, +for converting the trailing list of arguments into text. The number and type +of arguments is dictated by the structure of the directives in aFmt. + +@param aFmt The 8 bit non modifiable descriptor containing the format string. +The TRefByValue class provides a constructor which takes a TDesC8 type.*/ + { + + VA_LIST list; + VA_START(list,aFmt); + DoWriteFormat(aFmt,list); + } + +EXPORT_C void RFileLogger::WriteFormat(TRefByValue aFmt, VA_LIST& aList) +/** Formats the arguments pointed to by aList according to aFmt, and writes the result +to the log, iLogFile, if it is a valid file. + +The format string aFmt contains literal text, embedded with directives, +for converting the trailing list of arguments into text. The number and type +of arguments pointed to by aList is dictated by the structure of the directives +in aFmt. + +@param aFmt The 8 bit non modifiable descriptor containing the format string. +The TRefByValue class provides a constructor which takes a TDesC8 type. +@param aList A pointer to an argument list. */ + { + + DoWriteFormat(aFmt,aList); + } + +// +// 16-bit static writes +// + +EXPORT_C void RFileLogger::Write(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, const TDesC16& aText) +/** Writes a string of 16-bit characters to an open log. + +Connects to the logging server, creates/opens the log file and write aText to it. + +This is a "static write". + +Note that the text will be converted to an 8 bit format for the log file. + +@param aDir The directory relative to 'C:\\Logs\\' where the log file resides. +@param aName The name of the log file. +@param aMode The mode in which the log file should be opened: either EAppend or EOverwrite. +@param aText The Unicode string to write to the log. */ + { + + RFileLogger logger; + TInt ret=logger.Connect(); + if (ret==KErrNone) + { + logger.SetDateAndTime(ETrue,ETrue); + logger.iLogFile.Set(aDir,aName,aMode); + TBuf8 buf; + ret=logger.iFormatter.FormatTextToWritableBuffer(buf,aText); + if (ret==KErrNone) + { + if (logger.LogSTI()) + { + logger.DoStaticWrite(buf); + } else + { + TPckg logFilePckg(logger.iLogFile); + logger.SendReceive(ECreateWriteAndCloseLog, TIpcArgs ( &logFilePckg, &buf)); // ignore error + } + } + } + logger.Close(); + } + +EXPORT_C void RFileLogger::WriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue aFmt,...) +/** Formats the remaining arguments of the function according to aFmt and writes the +result to the log. + +The format string aFmt contains literal text, embedded with directives, +for converting the trailing list of arguments into text. The number and type +of arguments is dictated by the structure of the directives in aFmt. + +Connects to the logging server, creates/opens the log file and writes the text arguments to it. + +This is a "static write". + +Note that the text will be converted to an 8 bit format for the log file. + +@param aDir The directory relative to 'C:\\Logs\\' where the log file resides. +@param aName The name of the log file. +@param aMode The mode in which the log file should be opened: either EAppend +or EOverwrite. +@param aFmt The 16 bit non modifiable descriptor containing the format string. +The TRefByValue class provides a constructor which takes a TDesC16 type. */ + { + + VA_LIST list; + VA_START(list,aFmt); + DoStaticWriteFormat(aDir,aName,aMode,aFmt,list); + } + +EXPORT_C void RFileLogger::WriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue aFmt, VA_LIST& aList) +/** Formats the arguments pointed to by aList according to aFmt, and writes the result +to the log. + +The format string aFmt contains literal text, embedded with directives, +for converting the trailing list of arguments into text. The number and type +of arguments pointed to by aList is dictated by the structure of the directives +in aFmt. + +Connects to the logging server, creates/opens the log file and writes the text arguments to it. + +This is a "static write". + +Note that the text will be converted to an 8 bit format for the log file. + +@param aDir The directory relative to 'C:\\Logs\\' where the log file resides. +@param aName The name of the log file. +@param aMode The mode in which the log file should be opened: either EAppend +or EOverwrite. +@param aFmt The 16 bit non modifiable descriptor containing the format string. +The TRefByValue class provides a constructor which takes a TDesC16 type. +@param aList A pointer to an argument list. */ + { + + DoStaticWriteFormat(aDir,aName,aMode,aFmt,aList); + } + +// +// 8-bit static writes +// + +EXPORT_C void RFileLogger::Write(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, const TDesC8& aText) +/** Writes a string of 8-bit characters to an open log. + +Connects to the logging server, creates/opens the log file and writes aText to it. + +This is a "static write". + +@param aDir The directory relative to 'C:\\Logs\\' where the log file resides. +@param aName The name of the log file. +@param aMode The mode in which the log file should be opened: either EAppend +or EOverwrite. +@param aText The 8-bit string to write to the log. */ + + { + + RFileLogger logger; + TInt ret=logger.Connect(); + if (ret==KErrNone) + { + logger.SetDateAndTime(ETrue,ETrue); + logger.iLogFile.Set(aDir,aName,aMode); +// TBuf8 buf; + TBuf8<1600> buf; //Want at least an mtu sized buffer + //PG 14/08/2002 - If mode is set to *Raw, Don't change format of client buffer + if(aMode == EFileLoggingModeAppendRaw || aMode == EFileLoggingModeOverwriteRaw) + buf.Copy(aText); + else + ret=logger.iFormatter.FormatTextToWritableBuffer(buf,aText); + if (ret==KErrNone) + logger.DoStaticWrite(buf); + } + logger.Close(); + } + +EXPORT_C void RFileLogger::WriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue aFmt,...) +/** Formats the remaining arguments of the function according to aFmt and writes the +result to the log. + +The format string aFmt contains literal text, embedded with directives, +for converting the trailing list of arguments into text. The number and type +of arguments is dictated by the structure of the directives in aFmt. + +Connects to the logging server, creates/opens the log file and writes the text arguments to it. + +This is a "static write". + +@param aDir The directory relative to 'C:\\Logs\\' where the log file resides. +@param aName The name of the log file. +@param aMode The mode in which the log file should be opened: either EAppend +or EOverwrite. +@param aFmt The 8 bit non modifiable descriptor containing the format string. +The TRefByValue class provides a constructor which takes a TDesC8 type. */ + { + + VA_LIST list; + VA_START(list,aFmt); + DoStaticWriteFormat(aDir,aName,aMode,aFmt,list); + } + +EXPORT_C void RFileLogger::WriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue aFmt, VA_LIST& aList) +/** Formats the arguments pointed to by aList according to aFmt, and writes the +result to the log. + +The format string aFmt contains literal text, embedded with directives, +for converting the trailing list of arguments into text. The number and type +of arguments pointed to by aList is dictated by the structure of the directives +in aFmt. + +Connects to the logging server, creates/opens the log file and writes the text arguments to it. + +This is a "static write". + +@param aDir The directory relative to 'C:\\Logs\\' where the log file resides. +@param aName The name of the log file. +@param aMode The mode in which the log file should be opened: either EAppend +or EOverwrite. +@param aFmt The 8 bit non modifiable descriptor containing the format string. +The TRefByValue class provides a constructor which takes a TDesC8 type. +@param aList A pointer to an argument list. */ + { + + DoStaticWriteFormat(aDir,aName,aMode,aFmt,aList); + } + +// +// Hex Dumps +// + +EXPORT_C void RFileLogger::HexDump(const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen) +/** Writes a hex dump of the specified data to the log. + +The format of the hex dump entry is a header followed by the hex string of +the data followed by any printable characters (non printable characters are +substituted with '.'). For example, + +@code +RLog_Ex0000 : 41 42 6C 6B 0A 0A 45 46 20 20 78 7A ABlk..EF + xz +RL_cont0001 : 43 44 6C 6B 0A 0A 45 46 20 20 78 7A CDlk..EF + xz +RL_cont0002 : 45 46 6C 6B 0A 0A 47 48 20 20 78 7A EFlk..GH + xz +. +. +. +@endcode +@param aHeader A label for the hex dump entry. The label has a sequence number +appended to it automatically. +@param aMargin A continuation label if the hex dump exceeds one line. This +label is displayed on all subsequent lines after line one and also has a sequence +number appended to it. +@param aPtr The data that is to be converted to a hex string. +@param aLen How many of the characters in aPtr are to be converted. Conversion +always starts from position 0 within aPtr. */ + { + + if (iLogFile.Valid() || LogSTI()) + DoHexDump(aHeader,aMargin,aPtr,aLen); + } + +EXPORT_C void RFileLogger::HexDump(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen) +/** Writes a hex dump of the specified data to the log. + +The format of the hex dump entry is a header followed by the hex string of +the data followed by any printable characters (non printable characters are +substituted with '.'). For example, + +@code +RLog_Ex0000 : 41 42 6C 6B 0A 0A 45 46 20 20 78 7A ABlk..EF + xz +RL_cont0001 : 43 44 6C 6B 0A 0A 45 46 20 20 78 7A CDlk..EF + xz +RL_cont0002 : 45 46 6C 6B 0A 0A 47 48 20 20 78 7A EFlk..GH + xz +. +. +. +@endcode + + +@param aDir The directory relative to 'C:\\Logs\\' where the log file resides. +@param aName The name of the log file. +@param aMode The mode in which the log file should be opened: either EAppend +or EOverwrite. +@param aHeader A label for the hex dump entry. The label has a sequence number +appended to it automatically. +@param aMargin A continuation label if the hex dump exceeds one line. This +label is displayed on all subsequent lines after line one and also has a sequence +number appended to it. +@param aPtr The data that is to be converted to a hex string. +@param aLen How many of the characters in aPtr are to be converted. Conversion +always starts from position 0 within aPtr. */ + { + + RFileLogger logger; + TInt ret=logger.Connect(); + if (ret==KErrNone) + { + logger.CreateLog(aDir,aName,aMode); + if (logger.iLogFile.Valid()) + { + logger.SetDateAndTime(ETrue,ETrue); + logger.DoHexDump(aHeader,aMargin,aPtr,aLen); + } + logger.CloseLog(); + } + logger.Close(); + } + +// +// Private functions +// + +TInt RFileLogger::DoConnect() +/** +Connects to the flogger server - default number of message slots = 8 + +@return TInt indicating success code (KErrNone) or an error code. +*/ + { + + return CreateSession(KFLoggerServerName,Version(),0); // no async IPC + } + +void RFileLogger::DoWrite(const TDesC8& aBuf) +/** +Sends the pre-formatted write string to the flogger server. + +@pre +session is already open. +@param aBuf 8-bit text to be written. +*/ + { + if (LogSTI()) + { + TBuf n; + n.Copy(aBuf); + if (iLogFile.Valid()) + { + TFileName logFileName = iLogFile.Name(); + RDebug::Print(_L("FLG %S %S"),&logFileName,&n); + } else + { + RDebug::Print(_L("FLG %S "),&n); + } + } else + { + TPckg logFilePckg(iLogFile); + iLastError=SendReceive(EWriteLog,TIpcArgs (&logFilePckg, &aBuf)); + } + } + +void RFileLogger::DoStaticWrite(const TDesC8& aBuf) +/** +Sends the pre-formatted write string to the flogger server. + +@pre +session is already open. aText is not longer than KLogBufferSize +@param aBuf text to write +@post +The text is only written if the original connection was successful. +No text is ever written if the directory specified in the original connection request does not exist. +Each line is preceded in the date and time. +*/ + { + TPckg logFilePckg(iLogFile); + if (LogSTI()) + { + TBuf n; + n.Copy(aBuf); + if (iLogFile.Valid()) + { + TFileName logFileName = iLogFile.Name(); + RDebug::Print(_L("FLG %S %S"),&logFileName,&n); + } else + { + RDebug::Print(_L("FLG %S "),&n); + } + + } else + { + SendReceive(ECreateWriteAndCloseLog, TIpcArgs( &logFilePckg, &aBuf)); // ignore error + } + } + +void RFileLogger::DoWriteFormat(TRefByValue aFmt, VA_LIST& aList) +/** +Trim format string before sending to the flogger server. + +@pre +session is already open. +@param aFmt c-style formatted text to be written. +@param aList any variables required by the format. +@post +The final string is truncated to KLogBufferSize. +@see void RFileLogger::DoWriteFormat(TRefByValue aFmt, VA_LIST& aList) +*/ + { + + if (iLogFile.Valid() || LogSTI()) + { + TBuf8 buf; + iLastError=iFormatter.ConvertToWritableBuffer(buf,aFmt,aList); + if (iLastError==KErrNone) + DoWrite(buf); + } + } + +void RFileLogger::DoWriteFormat(TRefByValue aFmt, VA_LIST& aList) +/** +Trim format string before sending to the flogger server. + +@pre +session is already open. +@param aFmt c-style formatted text to be written. +@param aList any variables required by the format. +@post +The final string is truncated to KLogBufferSize. +*/ + { + + if (iLogFile.Valid() || LogSTI()) + { + TBuf8 buf; + iLastError=iFormatter.ConvertToWritableBuffer(buf,aFmt,aList); + if (iLastError==KErrNone) + DoWrite(buf); + } + } + +void RFileLogger::DoStaticWriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue aFmt, VA_LIST& aList) +/** +Sends a format write string to the flogger server to write to the specified file. + +@param aDir Path of the log file. +@param aName Name of the log file. +@param aFmt c-style formatted text to be written. +@param aList any variables required by the format. +@post +The text is only written if the original connection was successful. +No text is ever written if the directory specified in the original connection request does not exist. +Each line is preceded in the date and time. +@see void RFileLogger::DoStaticWriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue aFmt, VA_LIST& aList) +*/ + { + + RFileLogger logger; + TInt ret=logger.Connect(); + if (ret==KErrNone) + { + logger.SetDateAndTime(ETrue,ETrue); + logger.iLogFile.Set(aDir,aName,aMode); + TBuf8 buf; + ret=logger.iFormatter.ConvertToWritableBuffer(buf,aFmt,aList); + if (ret==KErrNone) + logger.DoStaticWrite(buf); + } + logger.Close(); + } + +void RFileLogger::DoStaticWriteFormat(const TDesC& aDir, const TDesC& aName, TFileLoggingMode aMode, TRefByValue aFmt, VA_LIST& aList) +/** +Sends a format write string to the flogger server to write to the specified file. +There is no pre-condition. + +@param aDir Path of the log file. +@param aName Name of the log file. +@param aFmt c-style formatted text to be written. +@param aList any variables required by the format. +@post +The text is only written if the original connection was successful. +No text is ever written if the directory specified in the original +connection request does not exist. Each line is preceded in the date and time. +*/ + { + + RFileLogger logger; + TInt ret=logger.Connect(); + if (ret==KErrNone) + { + logger.SetDateAndTime(ETrue,ETrue); + logger.iLogFile.Set(aDir,aName,aMode); + TBuf8 buf; + ret=logger.iFormatter.ConvertToWritableBuffer(buf,aFmt,aList); + if (ret==KErrNone) + logger.DoStaticWrite(buf); + } + logger.Close(); + } + +void RFileLogger::DoHexDump(const TText* aHeader, const TText* aMargin, const TUint8* aPtr, TInt aLen) +/** +Static Write. Dumps arbitrary data to the log file as a standard hex dump. + +@pre +session is already open. +@param aHeader Specify a string to be printed before the first hex line. +Leave as null or an empty string for no header. +@param aMargin Specify a string to be printed before each subsequent line. +Leave as null or an empty string for no Margin. +@param aPtr pointer to the data being dumped. +@param aLen the number of bytes to dump +@post +The text is only written if the original connection was successful. +No text is ever written if the directory specified in the original connection +request does not exist. Each line is preceded in the date and time. +@note This function has poor performance since it performs a full connection and +disconnection to the flogger server. Example of aHeader/aMargin. +If "aHeader" is set to "Fn Output:" and "aMargin" is set to " ", then output +would look like (for a print of the alphabet): +14/11/2002 12:32:24 Fn Output:0000 : 61 62 63 64 65 66 67 68 69 6a 6b 6c 6d 6e 6f 70 abcdefghijklmnop +14/11/2002 12:32:24 0010 : 71 72 73 74 75 76 77 78 79 7a qrstuvwxyz +*/ + { + + if (aPtr==NULL) // nothing to do + return; + + TBuf buf; + TBuf8 temp; + TInt i=0; + const TText* p=aHeader; + while (aLen>0) + { + if (p==NULL) + p=BLANK; // if NULL set p to a blank string + TInt n=(aLen>KHexDumpWidth ? KHexDumpWidth : aLen); + buf.AppendFormat(KFirstFormatString,p,i); + TInt j; + for (j=0; j126) ? KFullStopChar : aPtr[i+j]); + + iLastError=iFormatter.FormatTextToWritableBuffer(temp,buf); + if (iLastError==KErrNone) + DoWrite(temp); + + buf.SetLength(0); + temp.SetLength(0); + aLen-=n; + i+=n; + p=aMargin; + } + } +