1 /*

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

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 * 

    14 * Description:

    15 *

    16 */

    17 using System;

    18 using System.Text;

    19 using System.Collections.Generic;

    20 using SymbianUtils;

    21 using SymbianDebugLib.Engine;

    22 using SymbianStackLib.Engine;

    23 using SymbianStackLib.Exceptions;

    24 using CrashItemLib.Engine.Operations;

    25 using CrashItemLib.Crash;

    26 using CrashItemLib.Crash.Base;

    27 using CrashItemLib.Crash.Symbols;

    28 using CrashItemLib.Crash.Registers;

    29 using CrashItemLib.Crash.Processes;

    30 using CrashItemLib.Crash.CodeSegs;

    31 using CrashItemLib.Crash.Messages;

    32 using CrashItemLib.Engine;

    33 

    34 namespace CrashItemLib.Crash.Stacks

    35 {

    36 	internal class CIStackBuilder

    37     {

    38         #region Constructors

    39         public CIStackBuilder( CIStack aStack, DbgEngine aDebugEngine )

    40         {

    41             iStack = aStack;

    42             iStackEngine = new StackEngine( aDebugEngine );

    43             iStackEngine.AddressInfo.Pointer = aStack.PointerValue;

    44             iStackEngine.AddressInfo.Range = aStack.Range;

    45             iStackEngine.Registers = aStack.Registers;

    46             iStackEngine.DataSource = aStack.RawSourceData;

    47 

    48             // Get the code segments for the process

    49             bool isThreadStack = aStack.IsThreadAvailable;

    50             if ( isThreadStack )

    51             {

    52                 CIProcess process = OwningProcess;

    53                 System.Diagnostics.Debug.Assert( process != null );

    54 

    55                 // Seed stack engine with relevant code segments

    56                 iStackEngine.CodeSegments = process.CodeSegments;

    57             }

    58         }

    59         #endregion

    60 

    61         #region API

    62         public void Build( TSynchronicity aSynchronicity )

    63         {

    64             StackEventsSubscribe();

    65             iStackEngine.Reconstruct( aSynchronicity );

    66         }

    67         #endregion

    68 

    69         #region Properties

    70         public bool IsReady

    71         {

    72             get { return iIsReady; }

    73             private set

    74             {

    75                 lock ( this )

    76                 {

    77                     iIsReady = value;

    78                 }

    79             }

    80         }

    81 

    82         public CIProcess OwningProcess

    83         {

    84             get

    85             {

    86                 CIProcess ret = iStack.OwningProcess;

    87                 return ret;

    88             }

    89         }

    90 

    91         public StackEngine StackEngine

    92         {

    93             get { return iStackEngine; }

    94         }

    95         #endregion

    96 

    97         #region Event handlers

    98         private void StackEngine_EventHandler( StackEngine.TEvent aEvent, StackEngine aEngine )

    99         {

   100             if ( aEvent == StackEngine.TEvent.EStackBuildingComplete )

   101             {

   102                 StackEventsUnsubscribe();

   103                 IsReady = true;

   104             }

   105         }

   106 

   107         private void StackEngine_ExceptionHandler( Exception aException, StackEngine aEngine )

   108         {

   109             // Operation failed, but we must mark ourselves as ready or else UI clients will block forever...

   110             IsReady = true;

   111 

   112             // We'll deal with the public exceptions ourselves. Any kind of exception we cannot handle

   113             // will just get treated as a generic error.

   114             string msg = string.Empty;

   115             bool recognized = false;

   116             //

   117             if ( aException is StackAddressException )

   118             {

   119                 recognized = true;

   120                 StackAddressException exception = (StackAddressException) aException;

   121                 switch ( exception.Type )

   122                 {

   123                 case StackAddressException.TType.ETypePointerIsNull:

   124                     msg = LibResources.CIStackBuilder_AddressInfoException_PointerMissing;

   125                     break;

   126                 case StackAddressException.TType.ETypePointerOutOfBounds:

   127                     msg = LibResources.CIStackBuilder_AddressInfoException_PointerOutOfBounds;

   128                     break;

   129                 case StackAddressException.TType.ETypeBaseAddressBeforeTopAddress:

   130                     msg = LibResources.CIStackBuilder_AddressInfoException_BaseAddressBeforeTopAddress;

   131                     break;

   132                 case StackAddressException.TType.ETypeTopAddressAfterBaseAddress:

   133                     msg = LibResources.CIStackBuilder_AddressInfoException_TopAddressAfterBaseAddress;

   134                     break;

   135                 default:

   136                     recognized = false;

   137                     break;

   138                 }

   139             }

   140 

   141             // Not recognized? Unfortunately have to leak the original underlying .NET exception details

   142             if ( recognized == false )

   143             {

   144                 msg = aException.Message;

   145             }

   146 

   147             if ( string.IsNullOrEmpty( msg ) == false )

   148             {

   149                 // Treat exceptions as fatal errors

   150                 CIMessageError error = new CIMessageError( iStack.Container, LibResources.CIStackBuilder_Error_Title );

   151                 error.AddLine( msg );

   152                 iStack.AddChild( error );

   153             }

   154         }

   155 

   156         private void StackEngine_MessageHandler( StackEngine.TMessageType aType, string aMessage, StackEngine aEngine )

   157         {

   158             switch ( aType )

   159             {

   160             default:

   161                 break;

   162             case StackEngine.TMessageType.ETypeError:

   163                 {

   164                 CIMessageError error = new CIMessageError( iStack.Container, LibResources.CIStackBuilder_Error_Title );

   165                 error.AddLine( aMessage );

   166                 iStack.AddChild( error );

   167                 break;

   168                 }

   169             case StackEngine.TMessageType.ETypeWarning:

   170                 {

   171                 CIMessageWarning warning = new CIMessageWarning( iStack.Container, LibResources.CIStackBuilder_Warning_Title );

   172                 warning.AddLine( aMessage );

   173                 iStack.AddChild( warning );

   174                 break;

   175                 }

   176             }

   177         }

   178         #endregion

   179 

   180         #region Internal methods

   181         private void StackEventsSubscribe()

   182         {

   183             StackEngine.MessageHandler += new StackEngine.StackEngineMessageHandler( StackEngine_MessageHandler );

   184             StackEngine.EventHandler += new StackEngine.StackEngineEventHandler( StackEngine_EventHandler );

   185             StackEngine.ExceptionHandler += new StackEngine.StackEngineExceptionHandler( StackEngine_ExceptionHandler );

   186         }

   187 

   188         private void StackEventsUnsubscribe()

   189         {

   190             StackEngine.MessageHandler -= new StackEngine.StackEngineMessageHandler( StackEngine_MessageHandler );

   191             StackEngine.EventHandler -= new StackEngine.StackEngineEventHandler( StackEngine_EventHandler );

   192             StackEngine.ExceptionHandler -= new StackEngine.StackEngineExceptionHandler( StackEngine_ExceptionHandler );

   193         }

   194         #endregion

   195 

   196         #region From System.Object

   197         public override string ToString()

   198         {

   199             StringBuilder ret = new StringBuilder();

   200             ret.AppendFormat( "CIStackBuilder_{0}_{1}", iStack.Id, iStack.Name );

   201             return ret.ToString();

   202         }

   203         #endregion

   204 

   205         #region Data members

   206         private readonly CIStack iStack;

   207         private readonly StackEngine iStackEngine;

   208         private bool iIsReady = false;

   209         #endregion

   210     }

   211 }