public CIMessageDictionary GetMessages()
{
CIElementList <CIMessage> list = base.ChildrenByType <CIMessage>(TChildSearchType.EEntireHierarchy);
CIMessageDictionary ret = new CIMessageDictionary(list);
return(ret);
}
private void XmlSerializeRegisters(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
// Must obtain the registers in advance to avoid creating an empty list.
List <CIRegisterList> regs = new List <CIRegisterList>();
// Find register lists
CIElementList <CIRegisterListCollection> allRegs = iThread.ChildrenByType <CIRegisterListCollection>();
foreach (CIRegisterListCollection registerListCol in allRegs)
{
foreach (CIRegisterList registerList in registerListCol)
{
if (registerList.Count > 0)
{
regs.Add(registerList);
}
}
}
// Only write something if we have some entries
if (regs.Count > 0)
{
CXmlNode.WriteLinkListStart(aParameters.Writer, SegConstants.Registers);
foreach (CIRegisterList registerList in regs)
{
CXmlNode.WriteLink(registerList.Id, SegConstants.Registers, aParameters.Writer);
}
CXmlNode.WriteLinkListEnd(aParameters.Writer);
}
}
protected override void XmlSerializeChildren(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
CIElementList <CIRegisterVisualization> visList = iRegister.ChildrenByType <CIRegisterVisualization>();
foreach (CIRegisterVisualization vis in visList)
{
CXmlNode.WriteLink(vis.Id, SegConstants.ValueInterpretation, aParameters.Writer);
}
}
public static void XmlSerializeMessages(CXmlDocumentSerializationParameters aParameters, CIElement aElement)
{
CIElementList <CIMessage> messages = aElement.ChildrenByType <CIMessage>();
foreach (CIMessage msg in messages)
{
CXmlNode.WriteLink(msg.Id, SegConstants.Messages, aParameters.Writer);
}
}
protected override void XmlSerializeChildren(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
CIElementList <CIStack> stacks = aParameters.Container.ChildrenByType <CIStack>(CIElement.TChildSearchType.EEntireHierarchy);
foreach (CIStack stack in stacks)
{
CXmlStack xmlStack = new CXmlStack(stack);
xmlStack.XmlSerialize(aParameters);
}
}
protected override void XmlSerializeChildren(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
CIElementList <CIProcess> processes = aParameters.Container.ChildrenByType <CIProcess>(CIElement.TChildSearchType.EEntireHierarchy);
foreach (CIProcess process in processes)
{
CXmlProcess xmlProcess = new CXmlProcess(process);
xmlProcess.XmlSerialize(aParameters);
}
}
protected override void XmlSerializeChildren(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
CIElementList <CIThread> threads = aParameters.Container.ChildrenByType <CIThread>(CIElement.TChildSearchType.EEntireHierarchy);
foreach (CIThread thread in threads)
{
CXmlThread xmlThread = new CXmlThread(thread);
xmlThread.XmlSerialize(aParameters);
}
}
protected override void XmlSerializeChildren(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
CIElementList <CIRegisterVisualization> visList = aParameters.Container.ChildrenByType <CIRegisterVisualization>(CIElement.TChildSearchType.EEntireHierarchy);
foreach (CIRegisterVisualization visualisation in visList)
{
CXmlValueInterpretation xmlVis = new CXmlValueInterpretation(visualisation);
xmlVis.XmlSerialize(aParameters);
}
}
private void CreateImplicitCodeSegments(CIElementFinalizationParameters aParams)
{
CIElementList <CISymbol> children = base.ChildrenByType <CISymbol>(TChildSearchType.EEntireHierarchy);
base.Trace(string.Format("[CIProcess] CreateImplicitCodeSegments() - children count: {1}, {0}", this, children.Count));
//
foreach (CISymbol symbol in children)
{
EnsureCodeSegmentExistsForSymbol(aParams, symbol);
}
}
internal void AddStacks(CIContainer aContainer)
{
CIElementList <CIStack> stacks = aContainer.ChildrenByType <CIStack>(CIElement.TChildSearchType.EEntireHierarchy);
foreach (CIStack stack in stacks)
{
CXmlCallStack callStack = new CXmlCallStack();
callStack.Read(stack);
callStack.CleanStack();
iCallStacks.Add(callStack);
}
}
private void BuildIndex()
{
CIElementList <CIMessage> messages = Container.ChildrenByType <CIMessage>(TChildSearchType.EEntireHierarchy);
foreach (CIMessage message in messages)
{
if (!base.Contains(message.Id))
{
base.Add(message);
}
}
}
internal void AddRegisterLists(CIContainer aContainer)
{
CIElementList <CIRegisterListCollection> regListCols = aContainer.ChildrenByType <CIRegisterListCollection>(CIElement.TChildSearchType.EEntireHierarchy);
foreach (CIRegisterListCollection regListCol in regListCols)
{
foreach (CIRegisterList regList in regListCol)
{
iRegStorage.ReadRegisterData(regList);
}
}
}
internal void AddPanicedProcess(CIContainer aContainer)
{
CIElementList <CIProcess> processes = aContainer.ChildrenByType <CIProcess>(CIElement.TChildSearchType.EEntireHierarchy);
if (processes.Count > 1)
{
System.Console.WriteLine("Warning: CrashInfoFilePlugin found multiple processes. CI file output can handle only one process!");
}
foreach (CIProcess process in processes)
{
iProcess = process.Name;
iUID = process.Uids.MostSignificant;
}
}
protected override void XmlSerializeChildren(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
CIElementList <CIRegisterListCollection> regListCols = aParameters.Container.ChildrenByType <CIRegisterListCollection>(CIElement.TChildSearchType.EEntireHierarchy);
foreach (CIRegisterListCollection regListCol in regListCols)
{
foreach (CIRegisterList regList in regListCol)
{
if (regList.Count > 0)
{
CXmlRegisterSet xmlRegList = new CXmlRegisterSet(regList);
xmlRegList.XmlSerialize(aParameters);
}
}
}
}
private void XmlSerializeStacks(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
// Find stacks
CIElementList <CIStack> stacks = iThread.ChildrenByType <CIStack>();
// Only write something if we have some entries
if (stacks.Count > 0)
{
CXmlNode.WriteLinkListStart(aParameters.Writer, SegConstants.Stacks);
foreach (CIStack item in stacks)
{
CXmlNode.WriteLink(item.Id, SegConstants.Stacks, aParameters.Writer);
}
CXmlNode.WriteLinkListEnd(aParameters.Writer);
}
}
internal void AddThreadAndExitInfo(CIContainer aContainer)
{
CIElementList <CIThread> threads = aContainer.ChildrenByType <CIThread>(CIElement.TChildSearchType.EEntireHierarchy);
if (threads.Count > 1)
{
System.Console.WriteLine("Warning: XmlFilePlugin found multiple threads. XML file output can handle only one thread!");
}
foreach (CIThread thread in threads)
{
iPanicCategory = thread.ExitInfo.Category;
iPanicID = thread.ExitInfo.Reason;
iPanicDescription = XmlErrorLibrary.GetPanicDescription(iPanicCategory, iPanicID.ToString());
iCrashedModuleName = thread.FullName;
}
}
internal void AddMemoryInfo(CIContainer aContainer)
{
CIElementList <CIMemoryInfo> list = aContainer.ChildrenByType <CIMemoryInfo>(CIElement.TChildSearchType.EEntireHierarchy);
foreach (CIMemoryInfo info in list)
{
if (info.Type == CIMemoryInfo.TType.ETypeRAM)
{
iFreeMomery = info.Free;
}
if (info.Type == CIMemoryInfo.TType.ETypeDrive)
{
iDiskInfo = info.Free;
}
}
}
public override void Check(CIContainer aContainer)
{
CIElementList <CICodeSeg> allCodeSegs = aContainer.ChildrenByType <CICodeSeg>(CIElement.TChildSearchType.EEntireHierarchy);
foreach (CICodeSeg codeSeg in allCodeSegs)
{
bool isResolved = codeSeg.IsResolved;
if (!isResolved)
{
CreateMissingWarning(codeSeg);
}
if (codeSeg.IsMismatched)
{
CreateMismatchWarning(codeSeg);
}
}
}
internal override void DoFinalize(CIElementFinalizationParameters aParams, Queue <CIElement> aCallBackLast, bool aForceFinalize)
{
CIContainer container = base.Container;
// Find all the stacks and add them as children before we call the base class
// method, since the base class will then take care of finalizing the new dynamically created
// summarisable objects.
CIElementList <CIStack> stacks = container.ChildrenByType <CIStack>(TChildSearchType.EEntireHierarchy);
if (stacks != null && stacks.Count > 0)
{
foreach (CIStack stack in stacks)
{
CISummarisableEntity entity = this[stack];
if (entity == null)
{
entity = new CISummarisableEntity(stack);
AddChild(entity);
}
}
}
// Now, make sure there are summarisable wrappers created for any threads which do not have associated
// stacks. Call stacks will be unavailable, but there's still plenty of useful information at the thread
// process and register levels.
CIElementList <CIThread> threads = container.ChildrenByType <CIThread>(TChildSearchType.EEntireHierarchy);
if (threads != null && threads.Count > 0)
{
foreach (CIThread thread in threads)
{
CISummarisableEntity entity = this[thread];
if (entity == null)
{
entity = new CISummarisableEntity(thread);
AddChild(entity);
}
}
}
// Now run finalizers on children et al.
base.DoFinalize(aParams, aCallBackLast, aForceFinalize);
}
protected override void XmlSerializeChildren(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
// Get the code segments
CIElementList <CICodeSeg> codeSegs = aParameters.Container.ChildrenByType <CICodeSeg>(CIElement.TChildSearchType.EEntireHierarchy);
// Sort them
Comparison <CICodeSeg> comparer = delegate(CICodeSeg aLeft, CICodeSeg aRight)
{
return(string.Compare(aLeft.Name, aRight.Name, true));
};
codeSegs.Sort(comparer);
// List them
foreach (CICodeSeg codeSeg in codeSegs)
{
CXmlCodeSeg xmlCodeSeg = new CXmlCodeSeg(codeSeg);
xmlCodeSeg.XmlSerialize(aParameters);
}
}
protected override void XmlSerializeChildren(CrashXmlPlugin.FileFormat.Document.CXmlDocumentSerializationParameters aParameters)
{
// First partition the symbols into sets
CISymbolDictionary globalSymbols = aParameters.Container.Symbols;
Partition(globalSymbols);
// Also get the dictionaries from the individual processes
CIElementList <CIProcess> processes = aParameters.Container.ChildrenByType <CIProcess>();
foreach (CIProcess process in processes)
{
CISymbolDictionary processSymbols = process.Symbols;
Partition(processSymbols);
}
// Then serialize the sets
foreach (KeyValuePair <string, CXmlSymbolSet> kvp in iSets)
{
CXmlSymbolSet set = kvp.Value;
set.XmlSerialize(aParameters);
}
}
internal void AddCodeSegments(CIContainer aContainer)
{
// Get the code segments
CIElementList <CICodeSeg> codeSegs = aContainer.ChildrenByType <CICodeSeg>(CIElement.TChildSearchType.EEntireHierarchy);
// Sort them
Comparison <CICodeSeg> comparer = delegate(CICodeSeg aLeft, CICodeSeg aRight)
{
return(string.Compare(aLeft.Name, aRight.Name, true));
};
codeSegs.Sort(comparer);
// List them
foreach (CICodeSeg codeSeg in codeSegs)
{
uint start = codeSeg.Range.Min;
uint end = codeSeg.Range.Max;
string name = codeSeg.Name;
CXmlCodeSegItem ciCodeSeg = new CXmlCodeSegItem(start, end, name);
iCodeSegs.Add(ciCodeSeg);
}
}
System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
{
CIElementList <CIStackEntry> entries = base.ChildrenByType <CIStackEntry>();
return(entries.GetEnumerator());
}
public new IEnumerator <CIStackEntry> GetEnumerator()
{
CIElementList <CIStackEntry> entries = base.ChildrenByType <CIStackEntry>();
return(entries.GetEnumerator());
}
public IEnumerable <CISummarisableEntity> GetSummarisableEnumerator()
{
CIElementList <CISummarisableEntity> list = base.ChildrenByType <CISummarisableEntity>();
return(list);
}
internal CIMessageDictionary(CIElementList <CIMessage> aList)
: this(aList.Container)
{
base.AddRange(aList.ToArray());
}
