/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions are met:

*

* - Redistributions of source code must retain the above copyright notice,

*   this list of conditions and the following disclaimer.

* - Redistributions in binary form must reproduce the above copyright notice,

*   this list of conditions and the following disclaimer in the documentation

*   and/or other materials provided with the distribution.

* - Neither the name of Nokia Corporation nor the names of its contributors

*   may be used to endorse or promote products derived from this software

*   without specific prior written permission.

*

* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"

* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE

* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR

* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF

* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS

* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN

* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)

* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE

* POSSIBILITY OF SUCH DAMAGE.

* 

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: 

*

*/

#define SUPPORT_OLD_MEMSPY_KERNEL_HEAP_DUMPS

using System;

using System.Collections.Generic;

using System.Text;

using System.Text.RegularExpressions;

using HeapLib.Reconstructor.Misc;

using HeapLib.Reconstructor.DataSources.Analyser.Interpreter;

using SymbianUtils;

namespace HeapLib.Reconstructor.DataSources.Analyser.Extractor.Implementations

{

    internal sealed class ExtractorText : Extractor

    {

        #region Constructors & destructor

        public ExtractorText()

        {

        }

        #endregion

        #region API

        public override bool CanExtractFrom( string aLine )

        {

            // CASE 1: Original file format, logging via trace

            // 

            //      HeapData - EComServer::!ecomserver - HEAP INFO FOR THREAD 'EComServer::!ecomserver'

            //      HeapData - EComServer::!ecomserver - ==============================================

            //      HeapData - EComServer::!ecomserver - HeapInfo - heapBaseAddress:     0x00700074

            //      HeapData - EComServer::!ecomserver - HeapInfo - heapSize:                745352

            //      HeapData - EComServer::!ecomserver - HeapInfo - heapChunkSize:           745472

            //      ...

            //      HeapData - EComServer::!ecomserver - 00700084: 00 00 00 00 03 03 03 03 03 03 03 03 03 03 03 03 ................

            //      HeapData - EComServer::!ecomserver - 00700094: 03 03 03 03 03 03 03 03 28 00 00 00 ec 47 28 80 ........(....G(.

            //      HeapData - EComServer::!ecomserver - 007000a4: d8 0c 70 00 58 0d 70 00 f8 0c 70 00 03 03 03 03 ..p.X.p...p.....

            //      HeapData - EComServer::!ecomserver - 007000b4: 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 03 ................

            //      HeapData - EComServer::!ecomserver - 007000c4: 48 00 00 00 e8 2b 30 80 00 2c 30 80 ec 02 70 00 H....+0..,0...p.

            //

            // CASE 2: Original file format, logging to file

            //

            //      HEAP INFO FOR THREAD 'ecomserver::!ecomserver'

            //      ==============================================

            //      HeapInfo - heapBaseAddress:     0x0f8c0074

            //      HeapInfo - heapSize:                262028

            //

            // CASE 3: Original file format, logging to file - kernel - the thread name is omitted!

            //

            //      HeapInfo - heapBaseAddress:     0xc809b074

            //      HeapInfo - heapSize:               3374984

            //      HeapInfo - heapMinSize:             720892

            //      HeapInfo - heapMaxSize:           17408000

            //      HeapInfo - heapFreeCellAddress: 0xc809b04c

            //      HeapInfo - heapFreeCellLength:           0

            //      HeapInfo - heapMinCellSize:              40

            //      HeapInfo - heapUsingDebugAlloc:           0

            //      HeapInfo - chunkName:              ekern.exe[100041af]0001::SvHeap

            //      HeapInfo - heapCellAllocCount:       15216

            //      HeapInfo - heapAllocSpace:         3171512

            //

            // CASE 4: New file format, still text, logging via trace

            //

            //      HeapData - ApsExe::AppArcServerThread - HEAP INFO FOR THREAD 'APSEXE::APPARCSERVERTHREAD'  

            //      HeapData - ApsExe::AppArcServerThread - =================================================  

            //      HeapData - ApsExe::AppArcServerThread -                                                     

            //      HeapData - ApsExe::AppArcServerThread - Meta Data                                          

            //      HeapData - ApsExe::AppArcServerThread - =========                                          

            //      HeapData - ApsExe::AppArcServerThread - Type:                                               Symbian OS RHeap

            //      HeapData - ApsExe::AppArcServerThread - Chunk Name:                                         ApsExe.exe[10003a3f]0001::AppArcServerThread::$HEAP

            //      HeapData - ApsExe::AppArcServerThread - Chunk Size:                                         319488

            //      HeapData - ApsExe::AppArcServerThread - Chunk Base Address:                                 0x00600000

            //      HeapData - ApsExe::AppArcServerThread - Debug Allocator:                                    0

            //      

            // First step is to identify the prefix. We do this by looking for the common line which remains

            // unchanged in all text file formats, and that is the "HEAP INFO FOR THREAD" item.

            //

            // If the data included tracing prefixes (e.g. Musti), these will already have been removed.

            bool ret = false;

            string line = aLine;

#if SUPPORT_OLD_MEMSPY_KERNEL_HEAP_DUMPS

            if ( line.Contains( "HeapInfo - heapBaseAddress:     0xc" ) )

            {

                // This is a work around for a problem with an old version of MemSpy in which

                // the kernel thread name was not included in the heap data listing. This

                // results in Heap Analyser discarding the thread entirely.

                //

                // Spoof the line

                int startPos = line.IndexOf( "HeapInfo - heapBaseAddress:     0xc" );

                line = line.Substring( 0, startPos ) + "HEAP INFO FOR THREAD \'ekern.exe[100041af]0001::Supervisor\'  ";

            }

#endif

            Match heapInfoForThreadMatch = KHeapInfoInitialRegEx.Match( line );

            if ( heapInfoForThreadMatch.Success )

            {

                // Work out if there is a prefix prior to the HEAP INFO element...

                int pos = heapInfoForThreadMatch.Index;

                if ( pos == 0 )

                {

                    // There's no prefix

                }

                else

                {

                    // There is some kind of standard prefix

                    iPrefix = line.Substring( 0, pos );

                    // Check if there is the "HeapData -" prefix also. If there is we may need to strip off a musti timestamp:

                    //

                    // E.g.:

                    // 10:54:29.672 HeapData - !MsvServer::!MsvServer - 00600a74: 00 00 00 00 20 00 00 00 04 00 00 00 57 4c 29 80 ............WL).

                    // 10:54:29.672 HeapData - !MsvServer::!MsvServer - 00600a84: 00 00 00 00 d8 11 00 00 03 03 03 03 03 03 03 03 ................

                    // 10:54:29.672 HeapData - !MsvServer::!MsvServer - 00600a94: 28 00 00 00 64 f9 52 80 00 24 60 00 50 00 00 10 (...d.R..$`.P...

                    // 10:54:29.672 HeapData - !MsvServer::!MsvServer - 00600aa4: 69 3c 00 10 d6 72 20 10 00 00 00 00 01 00 00 00 i<...r..........

                    // 10:54:29.672 HeapData - !MsvServer::!MsvServer - 00600ab4: 38 21 60 00 00 00 00 00 40 00 00 00 c4 4c 2c 80 8!`.....@....L,.

                    // 10:54:29.672 HeapData - !MsvServer::!MsvServer - 00600ac4: 38 00 00 00 20 00 00 00 40 00 00 00 28 43 60 00 8.......@...(C`.

                    // 10:54:29.672 HeapData - !MsvServer::!MsvServer - 00600ad4: 28 00 00 00 a4 1f 60 00 14 00 bf 00 c1 00 cb 00 (.....`.........

                    // 10:54:29.672 HeapData - !MsvServer::!MsvServer - 00600ae4: 10 4e 40 00 ad 2f 37 80 a8 1f 60 00 03 03 03 03 .N@../7...`.....

                    // 10:54:29.672 HeapData - !MsvServer::!MsvServer - 00600af4: 03 03 03 03 03 03 03 03 98 04 00 00 94 f6 52 80 ..............R.

                    if ( iPrefix.Contains( KHeapDataPrefix ) )

                    {

                        int pos2 = iPrefix.IndexOf( KHeapDataPrefix );

                        iPrefix = iPrefix.Substring( pos2 );

                    }

                }

                // Either way, we need the thread name as we use this

                // as the identifier for the data source, i.e. the hash

                iThreadName = heapInfoForThreadMatch.Groups[ "ThreadName" ].Value;

                // Save data after the prefix

                base.PrimaryLine = line.Substring( heapInfoForThreadMatch.Index );

                ret = true;

            }

            return ret;

        }

        public override bool ExtractFrom( string aLine, bool aForceExtractionOfThreadIdentifier )

        {

            // First pass identification stage

            string line = aLine;

            bool handled = ( iPrefix.Length == 0 );

            if ( !handled )

            {

                // Check for prefix match

                handled = aLine.Contains( iPrefix );

                if ( handled )

                {

                    // Check that it's not the start of a new data set

                    if ( !aForceExtractionOfThreadIdentifier && aLine.Contains( KHeapDataDataSetStartMarker ) ) // "HEAP INFO FOR THREAD"

                    {

                        handled = false;

                    }

                    else

                    {

                        int pos = aLine.IndexOf( iPrefix );

                        line = aLine.Substring( pos + iPrefix.Length );

                    }

                }

            }

            // Data processing stage

            if ( handled )

            {

                ExtractedData data = PrepareExtractedData( line, aLine );

                base.Interpreter.Interpret( data );

            }

            // Done

            return handled;

        }

        #endregion

        #region Properties

        public override string Hash

        {

            get { return iThreadName; }

        }

        #endregion

        #region Internal methods

        private ExtractedData PrepareExtractedData( string aLine, string aOriginalLine )

        {

            ExtractedData ret = null;

            // We need the heap base address before we are able to start

            // extracting binary data.

            DataSource ds = Interpreter.DataSource;

            Elements.MetaData metaData = ds.MetaData;

            Elements.Groups.GpHeap heapInfo = metaData.Heap;

            uint baseAddress = heapInfo.HeapBaseAddress;

            if ( baseAddress != 0 )

            {

                // We can now work out the next expected address

                uint nextExpectedAddress = baseAddress + (uint) metaData.HeapData.Count;

                // Build our regex string that will match the binary heap data.

                string prefix = string.Format( "{0:x8}: ", nextExpectedAddress );

                int pos = aLine.IndexOf( prefix );

                if ( pos >= 0 )

                {

                    Match m = KHeapDataRegEx.Match( aLine );

                    if ( m.Success )

                    {

                        List<byte> bytes = new List<byte>();

                        //

                        CaptureCollection data = m.Groups[ "Data" ].Captures;

                        foreach ( Capture dataItem in data )

                        {

                            string hexValue = dataItem.Value.Trim();

                            uint byteVal = System.Convert.ToUInt32( hexValue, KBaseHex );

                            bytes.Add( (byte) byteVal );

                        }

                        //

                        ret = ExtractedData.NewBinaryData( bytes.ToArray(), aOriginalLine );

                    }

                }

                //

                if ( ret == null )

                {

                    ret = ExtractedData.NewText( aLine, aOriginalLine );

                }

            }

            else

            {

                ret = ExtractedData.NewText( aLine, aOriginalLine );

            }

            //

            return ret;

        }

        #endregion

        #region Internal constants

        private const int KBaseHex = 16;

        private const string KHeapDataPrefix = "HeapData -";

        private const string KHeapDataDataSetStartMarker = "HEAP INFO FOR THREAD";

        #endregion

        #region Internal regular expressions

        private static readonly Regex KHeapInfoInitialRegEx = new Regex( 

            @"HEAP INFO FOR THREAD \'(?<ThreadName>.+)\'", 

            RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase );

        private static readonly Regex KHeapDataRegEx = new Regex(

                                                        @"\x3A" +

                                                        @"\s{1}" +

                                                        @"(?<Data>[a-fA-F0-9]{2}\s{1}){1,16}" +

                                                        @"(?<Padding>\s{1}){0,44}",

            RegexOptions.Singleline | RegexOptions.Compiled | RegexOptions.IgnoreCase );

        #endregion

        #region Data members

        private string iPrefix = string.Empty;

        private string iThreadName = string.Empty;

        #endregion

    }

}