--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/memana/analyzetoolclient/commandlineengine/internal/src/CATDataSaver.cpp Thu Feb 11 15:51:35 2010 +0200
@@ -0,0 +1,860 @@
+/*
+* Copyright (c) 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: Definitions for the class CATDataSaver.
+*
+*/
+
+
+#include "../inc/catdatasaver.h"
+
+#include <xercesc/util/OutOfMemoryException.hpp>
+
+#if defined(XERCES_NEW_IOSTREAMS)
+#include <iostream>
+#else
+#include <iostream.h>
+#endif
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::CATDataSaver
+// Constructor.
+// -----------------------------------------------------------------------------
+CATDataSaver::CATDataSaver( void )
+{
+ LOG_FUNC_ENTRY("CATDataSaver::CATDataSaver");
+ m_iLoggingLevel = DEFAULT_LOGGING_LEVEL;
+ m_bPrintImmediately = true;
+ m_bXMLInitOk = false;
+ m_bUdebBuild = true;
+
+ m_iRunNumber = 1;
+
+ m_pDomDoc = NULL;
+ m_pRootElem = NULL;
+ m_Serializer = NULL;
+ m_pCurrentLeakElem = NULL;
+ m_pRunElement = NULL;
+ m_pMemoryLeaks = NULL;
+ m_pHandleLeaks = NULL;
+ m_pCurrentSubTestElem = NULL;
+ m_pSubtestMemoryLeaks = NULL;
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::~CATDataSaver
+// Destructor.
+// -----------------------------------------------------------------------------
+CATDataSaver::~CATDataSaver(void)
+{
+ LOG_FUNC_ENTRY("CATDataSaver::~CATDataSaver");
+ if( m_bXMLInitOk )
+ {
+ if( m_Serializer )
+ delete m_Serializer;
+
+ m_pDomDoc->release();
+ xercesc::XMLPlatformUtils::Terminate();
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::SaveLinesToFile
+// Gets logging level.
+// -----------------------------------------------------------------------------
+void CATDataSaver::SaveLinesToFile( const char* pFileName, int iDataToSave )
+{
+ LOG_FUNC_ENTRY("CATDataSaver::SaveLinesToFile");
+
+ // Nothing to print?
+ if( m_vLines.empty() )
+ {
+ printf( "No output data." );
+ return;
+ }
+ if( iDataToSave != XML_DATA )
+ {
+ ofstream out( pFileName );
+
+ if( !out.good() )
+ {
+ printf( "Can not open file: %s\n", pFileName );
+ return;
+ }
+ switch( iDataToSave )
+ {
+ case TEXT_DATA:
+ for( int i = 0 ; i < (int)m_vLines.size() ; i++ )
+ {
+ out << m_vLines[i].c_str();
+ }
+ break;
+ }
+ out.close();
+ }
+ else
+ {
+ if( m_bXMLInitOk )
+ {
+ xercesc::XMLFormatTarget* myFormTarget = NULL;
+ try
+ {
+ myFormTarget = new xercesc::LocalFileFormatTarget( pFileName );
+ m_Serializer->writeNode(myFormTarget, *m_pDomDoc);
+ }
+ catch(...)
+ {
+ printf( "Can not save output file: %s.", pFileName );
+ }
+ if( myFormTarget )
+ delete myFormTarget; //lint !e118
+ }
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::PrintLinesToScreen
+// Prints all saved lines to screen.
+// -----------------------------------------------------------------------------
+void CATDataSaver::PrintLinesToScreen( void )
+{
+ LOG_FUNC_ENTRY("CATDataSaver::PrintLinesToScreen");
+ // Nothing to print?
+ if( m_vLines.empty() )
+ {
+ printf( "No output data." );
+ return;
+ }
+ for( int i = 0 ; i < (int)m_vLines.size() ; i++ )
+ {
+ printf( m_vLines[i].c_str() );
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::AddLineToFirst
+// Adds saved line to first in database.
+// -----------------------------------------------------------------------------
+void CATDataSaver::AddLineToFirst( void )
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::AddLineToFirst");
+ m_sLine.append( "\n" );
+ m_vLines.insert( m_vLines.begin(), m_sLine );
+ m_sLine.clear();
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::AddLineToLast
+// Adds saved line to last in database.
+// -----------------------------------------------------------------------------
+void CATDataSaver::AddLineToLast()
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::AddLineToLast");
+ m_sLine.append( "\n" );
+
+ string sTempDataLine;
+
+ m_vLines.push_back( m_sLine );
+
+ SaveXML( m_sCarbideDataLine, ITEM );
+
+ if( m_bPrintImmediately )
+ {
+ printf( m_sLine.c_str() );
+ }
+
+ m_sCarbideDataLine.clear();
+ m_sLine.clear();
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::AddString
+// Adds string to current line.
+// -----------------------------------------------------------------------------
+void CATDataSaver::AddString( const char* pData, bool bSaveCarbideData )
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::AddString");
+ m_sLine.append( pData );
+
+ if( bSaveCarbideData )
+ {
+ m_sCarbideDataLine.append( pData );
+ m_sCarbideDataLine.append(";");
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::AddInteger
+// Converts integer to string and adds it to current line.
+// -----------------------------------------------------------------------------
+void CATDataSaver::AddInteger( int iValue, bool bSaveCarbideData )
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::AddInteger");
+ char cTemp[128];
+ string sValue( itoa( iValue, cTemp, 10 ) );
+ m_sLine.append( sValue );
+
+ if( bSaveCarbideData )
+ {
+ m_sCarbideDataLine.append( sValue );
+ m_sCarbideDataLine.append(";");
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::SetLoggingLevel
+// Sets logging level.
+// -----------------------------------------------------------------------------
+void CATDataSaver::SetLoggingLevel( int iLoggingLevel )
+{
+ LOG_FUNC_ENTRY("CATDataSaver::SetLoggingLevel");
+ // Check that new logging level is valid
+ // Acceptable values are between MIN_LOGGING_LEVEL and
+ // MAX_LOGGING_LEVEL including them
+ if( iLoggingLevel >= MIN_LOGGING_LEVEL && iLoggingLevel <= MAX_LOGGING_LEVEL )
+ {
+ m_iLoggingLevel = iLoggingLevel;
+ }
+ else
+ {
+ // New logging level value is invalid => set default logging level
+ m_iLoggingLevel = DEFAULT_LOGGING_LEVEL;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::GetLoggingLevel
+// Gets logging level.
+// -----------------------------------------------------------------------------
+int CATDataSaver::GetLoggingLevel( void )
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::GetLoggingLevel");
+ return m_iLoggingLevel;
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::SetPrintFlag
+// Sets print immediately flag.
+// -----------------------------------------------------------------------------
+void CATDataSaver::SetPrintFlag( bool bPrintImmediately )
+{
+ LOG_FUNC_ENTRY("CATDataSaver::SetPrintFlag");
+ m_bPrintImmediately = bPrintImmediately;
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::SaveCarbideDataHeader
+// Sets data header for Carbide data.
+// -----------------------------------------------------------------------------
+void CATDataSaver::SaveCarbideDataHeader( void )
+{
+ LOG_FUNC_ENTRY("CATDataSaver::SaveCarbideDataHeader");
+ SaveXML( m_sCarbideDataLine, LEAK );
+ m_sCarbideDataLine.clear();
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::InitXML
+// Initializes xerces xml parser.
+// -----------------------------------------------------------------------------
+bool CATDataSaver::InitXML( void )
+{
+ LOG_FUNC_ENTRY("CATDataSaver::InitXML");
+ try
+ {
+ xercesc::XMLPlatformUtils::Initialize();
+ }
+ catch ( ... )//(const XMLException& toCatch)
+ {
+ // Do your failure processing here
+ printf("XML initialization failed.\n");
+ return false;
+ }
+ // Error code.
+ int errorCode = 0;
+ // getDomIMplementation returns null if source has none.
+ xercesc::DOMImplementation* impl = xercesc::DOMImplementationRegistry::getDOMImplementation(L"Core");
+ if (impl != NULL)
+ {
+ // Create new DOMWriter.
+ m_Serializer = ((xercesc::DOMImplementationLS*)impl)->createDOMWriter();
+ // New document.
+ try
+ {
+ m_pDomDoc = impl->createDocument(
+ 0, // Root element namespace URI.
+ L"results", // Root element name
+ 0); // Document type object (DTD).
+
+ m_pRootElem = m_pDomDoc->getDocumentElement();
+ }
+ catch (const xercesc::OutOfMemoryException&)
+ {
+ XERCES_STD_QUALIFIER cerr << "OutOfMemoryException" << XERCES_STD_QUALIFIER endl;
+ errorCode = 5;
+ }
+ catch (const xercesc::DOMException& e)
+ {
+ XERCES_STD_QUALIFIER cerr << "DOMException code is: " << e.code << XERCES_STD_QUALIFIER endl;
+ errorCode = 2;
+ }
+ catch (...)
+ {
+ XERCES_STD_QUALIFIER cerr << "An error occurred creating the document" << XERCES_STD_QUALIFIER endl;
+ errorCode = 3;
+ }
+ } // (inpl != NULL)
+ else
+ {
+ XERCES_STD_QUALIFIER cerr << "Requested implementation is not supported" << XERCES_STD_QUALIFIER endl;
+ errorCode = 4;
+ }
+ if( !errorCode )
+ {
+ m_bXMLInitOk = true;
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::WCharToChar
+// Converts wchar_t* -> char*.
+// -----------------------------------------------------------------------------
+void CATDataSaver::WCharToChar( string& sInput, const WCHAR* Source )
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::WCharToChar");
+ if( !Source )
+ return;
+ int i = 0;
+
+ while( Source[i] != '\0' )
+ {
+ char c = (CHAR)Source[i];
+ sInput.append( &c, 1 );
+ ++i;
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::CharToWChar
+// Converts char* -> wchar_t*.
+// -----------------------------------------------------------------------------
+LPWSTR CATDataSaver::CharToWChar( const char* str )
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::CharToWChar");
+ LPWSTR out = NULL;
+ if( str != NULL )
+ {
+ int in_len = (int)strlen( str );
+ int out_len = MultiByteToWideChar(CP_ACP, 0, str, in_len, NULL, 0) + 2;
+ out = new WCHAR[out_len];
+
+ if (out)
+ {
+ memset(out, 0x00, sizeof(WCHAR)*out_len);
+ MultiByteToWideChar(CP_ACP, 0, str, in_len, out, in_len);
+ }
+ }
+ return out;
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::SaveXML
+// Writes data to xml tree.
+// -----------------------------------------------------------------------------
+void CATDataSaver::SaveXML( string sInput, int iElementType )
+{
+ LOG_FUNC_ENTRY("CATDataSaver::SaveXML");
+ // Variables ok?
+ if( sInput.empty() || m_pDomDoc == NULL )
+ {
+ return;
+ }
+ try
+ {
+ switch( iElementType )
+ {
+ case RESULT:
+ {
+ // Print number of runs
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ m_pRootElem->setAttribute( L"runs", (const LPWSTR)wTemp );
+
+ // Print failed runs
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+ m_pRootElem->setAttribute( L"failed", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ break;
+ case RUN:
+ {
+ if( m_pRootElem == NULL )
+ return;
+ xercesc::DOMElement* runElem = m_pDomDoc->createElement( L"run" );
+ m_pRootElem->appendChild( runElem );
+
+ // Reset handle leaks.
+ m_pHandleLeaks = NULL;
+
+ // Print start time
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ runElem->setAttribute( L"start_time", (const LPWSTR)wTemp );
+ runElem->setAttribute( L"end_time", NULL );
+ if( wTemp )
+ delete[] wTemp;
+
+ // Print build target
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ wTemp = CharToWChar( sTemp.c_str() );
+ runElem->setAttribute( L"build_target", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+
+ // Print process name
+ wTemp = CharToWChar( sInput.c_str() );
+ runElem->setAttribute( L"process_name", (const LPWSTR)wTemp );
+
+ m_pRunElement = runElem;
+
+ char cTemp[128];
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( itoa( m_iRunNumber, cTemp, 10 ) );
+ runElem->setAttribute( L"id", (const LPWSTR)wTemp );
+ m_iRunNumber++;
+ if( wTemp )
+ delete[] wTemp;
+ }
+ break;
+ case LEAK:
+ {
+ m_pCurrentLeakElem = m_pDomDoc->createElement( L"leak" );
+
+
+ if( m_pCurrentLeakElem == NULL || m_pRunElement == NULL )
+ return;
+
+ // Sub test?
+ if( m_pCurrentSubTestElem )
+ m_pCurrentSubTestElem->appendChild( m_pCurrentLeakElem );
+ else
+ m_pRunElement->appendChild( m_pCurrentLeakElem );
+
+ // Print leak ID
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ m_pCurrentLeakElem->setAttribute( L"id", (const LPWSTR)wTemp );
+
+ // Print leak size
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+ m_pCurrentLeakElem->setAttribute( L"size", (const LPWSTR)wTemp );
+
+ // Print leak address
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+ m_pCurrentLeakElem->setAttribute( L"memaddress", (const LPWSTR)wTemp );
+
+ // Print leak time
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+ m_pCurrentLeakElem->setAttribute( L"time", (const LPWSTR)wTemp );
+
+ // Print leak module
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+ m_pCurrentLeakElem->setAttribute( L"module", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ break;
+ case ITEM:
+ {
+ xercesc::DOMNode* callstackNode = NULL;
+
+ xercesc::DOMElement* callstackElem = NULL;
+
+ if( m_pCurrentLeakElem == NULL )
+ return;
+
+ // Print module name
+ if( !m_pCurrentLeakElem->hasChildNodes() )
+ {
+ callstackElem = m_pDomDoc->createElement( L"callstack" );
+ m_pCurrentLeakElem->appendChild( callstackElem );
+ callstackNode = callstackElem;
+ }
+ else
+ {
+ callstackNode = m_pCurrentLeakElem->getFirstChild();
+ }
+
+ // Add callstack item
+ xercesc::DOMElement* itemElem = m_pDomDoc->createElement( L"item" );
+ callstackNode->appendChild( itemElem );
+
+ // Print memory address name
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+
+ itemElem->setAttribute( L"memaddress", (const LPWSTR)wTemp );
+
+ // Print calculated memory address
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+
+ itemElem->setAttribute( L"calc_addr", (const LPWSTR)wTemp );
+
+ // Print module name
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+
+ itemElem->setAttribute( L"module", (const LPWSTR)wTemp );
+
+ // Print function name
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+
+ itemElem->setAttribute( L"function", (const LPWSTR)wTemp );
+
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+
+ // Print function line from urel build
+ if( !m_bUdebBuild )
+ {
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+ itemElem->setAttribute( L"function_line", (const LPWSTR)wTemp );
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ }
+
+ // Print file name
+ if( wTemp )
+ delete[] wTemp;
+ // Erase if path found from sTemp.
+ if ( sTemp.rfind( "/" ) != string::npos )
+ {
+ sTemp.erase(0, sTemp.rfind( "/" )+1 );
+ }
+ if ( sTemp.rfind( "\\" ) != string::npos )
+ {
+ sTemp.erase(0, sTemp.rfind( "\\" )+1 );
+ }
+ wTemp = CharToWChar( sTemp.c_str() );
+
+ itemElem->setAttribute( L"file", (const LPWSTR)wTemp );
+
+ // Print line of file
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+
+ if( m_bUdebBuild )
+ itemElem->setAttribute( L"line", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ break;
+ case RUN_END:
+ {
+ if( m_pRunElement == NULL )
+ return;
+ const LPWSTR wTemp = CharToWChar( sInput.c_str() );
+ m_pRunElement->setAttribute( L"end_time", wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ break;
+ case ERROR_IN_RUN:
+ {
+ if( m_pRunElement == NULL )
+ return;
+ // Add error item
+ xercesc::DOMElement* errorElem = m_pDomDoc->createElement( L"error" );
+ m_pRunElement->appendChild( errorElem );
+
+ // Print error code
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ errorElem->setAttribute( L"code", (const LPWSTR)wTemp );
+
+ // Print error time
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ if( wTemp )
+ delete[] wTemp;
+ wTemp = CharToWChar( sTemp.c_str() );
+ errorElem->setAttribute( L"time", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ break;
+ case MEM_LEAKS:
+ {
+ if( m_pRunElement == NULL )
+ return;
+ xercesc::DOMElement* memoryLeaksElement = m_pDomDoc->createElement( L"mem_leaks" );
+ m_pRunElement->appendChild( memoryLeaksElement );
+ m_pMemoryLeaks = memoryLeaksElement;
+
+ // Print number of leaks
+ LPWSTR wTemp = CharToWChar( sInput.c_str() );
+ memoryLeaksElement->setAttribute( L"count", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ break;
+ case MEM_LEAK_MODULE:
+ {
+ if( m_pMemoryLeaks == NULL )
+ return;
+ xercesc::DOMElement* moduleElement = m_pDomDoc->createElement( L"module" );
+ m_pMemoryLeaks->appendChild( moduleElement );
+
+ // Print module name
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ moduleElement->setAttribute( L"name", (const LPWSTR)wTemp );
+
+ if( wTemp )
+ delete[] wTemp;
+ // Print number of memory leaks
+ wTemp = CharToWChar( sInput.c_str() );
+ moduleElement->setAttribute( L"leaks", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ break;
+ case HANDLE_LEAKS:
+ {
+ if( m_pRunElement == NULL )
+ return;
+ if( m_pHandleLeaks )
+ {
+ // Update number of leaks
+ LPWSTR wTemp = CharToWChar( sInput.c_str() );
+ m_pHandleLeaks->setAttribute( L"count", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ else
+ {
+ xercesc::DOMElement* handleLeaksElement = m_pDomDoc->createElement( L"handle_leaks" );
+ m_pRunElement->appendChild( handleLeaksElement );
+ m_pHandleLeaks = handleLeaksElement;
+
+ // Print number of leaks
+ LPWSTR wTemp = CharToWChar( sInput.c_str() );
+ handleLeaksElement->setAttribute( L"count", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ }
+ break;
+ case HANDLE_LEAK_MODULE:
+ {
+ if( m_pHandleLeaks == NULL )
+ return;
+ xercesc::DOMElement* moduleElement = m_pDomDoc->createElement( L"module" );
+ m_pHandleLeaks->appendChild( moduleElement );
+
+ // Print module name
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ moduleElement->setAttribute( L"name", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+
+ // Print number of memory leaks
+ wTemp = CharToWChar( sInput.c_str() );
+ moduleElement->setAttribute( L"leaks", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ }
+ break;
+ case TEST_START:
+ {
+ m_pCurrentSubTestElem = m_pDomDoc->createElement( L"subtest" );
+
+ if( m_pCurrentSubTestElem == NULL || m_pRunElement == NULL )
+ return;
+
+ m_pRunElement->appendChild( m_pCurrentSubTestElem );
+
+ // Print sub test name
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ m_pCurrentSubTestElem->setAttribute( L"name", (const LPWSTR)wTemp );
+ if( wTemp )
+ {
+ delete[] wTemp;
+ wTemp = NULL;
+ }
+
+ // Print sub test time
+ sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ wTemp = CharToWChar( sTemp.c_str() );
+ m_pCurrentSubTestElem->setAttribute( L"start_time", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ break;
+ }
+ case TEST_END:
+ {
+ if( m_pCurrentSubTestElem == NULL )
+ return;
+ // Print end time
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ m_pCurrentSubTestElem->setAttribute( L"end_time", (const LPWSTR)wTemp );
+ m_pCurrentSubTestElem = NULL;
+ if( wTemp )
+ delete[] wTemp;
+ break;
+ }
+ case SUBTEST_MEM_LEAKS:
+ {
+ if( m_pCurrentSubTestElem == NULL )
+ return;
+ xercesc::DOMElement* memoryLeaksElement = m_pDomDoc->createElement( L"mem_leaks" );
+ m_pCurrentSubTestElem->appendChild( memoryLeaksElement );
+ m_pSubtestMemoryLeaks = memoryLeaksElement;
+
+ // Print number of leaks
+ LPWSTR wTemp = CharToWChar( sInput.c_str() );
+ memoryLeaksElement->setAttribute( L"count", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ break;
+ }
+ case SUBTEST_MEM_LEAK_MODULE:
+ {
+ if( m_pSubtestMemoryLeaks == NULL )
+ return;
+ xercesc::DOMElement* moduleElement = m_pDomDoc->createElement( L"module" );
+ m_pSubtestMemoryLeaks->appendChild( moduleElement );
+
+ // Print module name
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ moduleElement->setAttribute( L"name", (const LPWSTR)wTemp );
+
+ if( wTemp )
+ delete[] wTemp;
+ // Print number of memory leaks
+ wTemp = CharToWChar( sInput.c_str() );
+ moduleElement->setAttribute( L"leaks", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ break;
+ }
+ case SUBTEST_HANDLE_LEAKS:
+ {
+ if( m_pCurrentSubTestElem == NULL )
+ return;
+ xercesc::DOMElement* handleLeaksElement = m_pDomDoc->createElement( L"handle_leaks" );
+ m_pCurrentSubTestElem->appendChild( handleLeaksElement );
+
+ //Print number of handle leaks
+ string sTemp = GetStringUntilNextGivenChar( sInput, ';' );
+ LPWSTR wTemp = CharToWChar( sTemp.c_str() );
+ handleLeaksElement->setAttribute( L"count", (const LPWSTR)wTemp );
+ if( wTemp )
+ delete[] wTemp;
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ catch( ... )
+ {
+ printf( "Error when writing data to XML file." );
+ }
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::GetStringUntilNextGivenChar
+// Function returns string from begin of given string until next given char,
+// characters until given char are removed from sInput string.
+// -----------------------------------------------------------------------------
+string CATDataSaver::GetStringUntilNextGivenChar( string& sInput, char cCharacter )
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::GetStringUntilNextGivenChar");
+ string sRet;
+ size_t iPos = sInput.find( cCharacter );
+ if( sInput.size() > 1 && iPos != string::npos )
+ {
+ sRet = sInput.substr( 0, iPos );
+ sInput.erase( 0, (iPos + 1) );
+ }
+ return sRet;
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::SetBuild
+// Function sets build target info.
+// -----------------------------------------------------------------------------
+void CATDataSaver::SetBuild( bool bUdebBuild )
+{
+ LOG_FUNC_ENTRY("CATDataSaver::SetBuild");
+ m_bUdebBuild = bUdebBuild;
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::AddCarbideData
+// Function adds string to Carbide data.
+// -----------------------------------------------------------------------------
+void CATDataSaver::AddCarbideData( const string& sInput )
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::AddCarbideData");
+ m_sCarbideDataLine.append( sInput );
+ m_sCarbideDataLine.append(";");
+}
+
+// -----------------------------------------------------------------------------
+// CATDataSaver::IntegerToString
+// Converts integer to string.
+// -----------------------------------------------------------------------------
+string CATDataSaver::IntegerToString( int iValueToConvert )
+{
+ LOG_LOW_FUNC_ENTRY("CATDataSaver::IntegerToString");
+ char cTemp[128];
+ string sValue( itoa( iValueToConvert, cTemp, 10 ) );
+ return sValue;
+}