public override IArmInstruction ConvertToInstruction(uint aAddress, TArmInstructionSet aInstructionSet, uint aRawValue)
{
CodePlugin plugin = this.Plugin;
IArmInstruction[] ret = plugin.ProvisioningManager.InstructionLibrary.ConvertToInstructions(aInstructionSet, new uint[1] {
aRawValue
}, aAddress);
System.Diagnostics.Debug.Assert(ret != null && ret.Length == 1);
return(ret[0]);
}
internal CodeView(string aToken, CodePlugin aPlugin)
: base(aToken, aPlugin)
{
iRelocator = new CodeRelocator(aPlugin);
iQueryAPI = new CodeQueryAPI(iRelocator);
}
public override void Prime(TSynchronicity aSynchronicity)
{
CodePlugin plugin = this.Plugin;
// Wipe any state ready for new priming attempt
base.OnPrepareToPrime();
if (base.ResetEngineBeforePriming)
{
plugin.Clear();
}
// Report the "priming started event" prior to adding the sources
base.ReportEvent(TPrimeEvent.EEventPrimingStarted, null);
// Any sources already registered with the source manager at the start of a new
// priming request are assumed to already be complete.
RecordAlreadyCompletedSources();
// Initially, whilst adding the sources to the source manager, we'll
// operate synchronously. This prevents us from triggering the read
// operation in the SourceAdded callback below.
iSynchronicity = TSynchronicity.ESynchronous;
// Listen to source manager events in case any new sources are
// created whilst reading those we already know about.
CodeSourceManager sourceManager = this.SourceManager;
sourceManager.SourceAdded += new CodeSourceManager.SourceEventHandler(SourceManager_SourceAdded);
sourceManager.SourceRemoved += new CodeSourceManager.SourceEventHandler(SourceManager_SourceRemoved);
// Tell the source manager which sources we are reading. This also will
// call our event handler (added above) so that we can observe source events.
CodeSourceCollection sources = iSources;
iSources = new CodeSourceCollection();
sourceManager.AddRange(sources);
// If we're operating asynchronously, then the loop below will potentially
// complete quite quickly. This means that any (new/additional) sources which
// are created (asynchronously) whilst reading is underway will not themselves
// be read.
//
// Therefore, we store the synchronisation mode as a data member, and when
// 'SourceAdded' is called, if operating asynchronously, we'll also initiate
// a read operation for the source (as soon as it is added).
//
// If we're operating synchronously, then this isn't important. Because we're
// behaving synchronously, the loop below will only process one source at a
// time (before waiting) and therefore even if that source adds new/additional
// sources to the source manager, we'll catch them as soon as we move the
// next iteration around the loop.
iSynchronicity = aSynchronicity;
// TODO: possibly re-write this so that it uses two separate code paths
// for synchronous and asynchronous priming? By trying to use one path
// this code looks rather complex and isn't terribly robust.
try
{
// Now we can start the sources running.
int count = iSourcesYetToBePrimed.Count;
while (count > 0)
{
// Get the head source and remove it from the pending list
CodeSource source = iSourcesYetToBePrimed[0];
iSourcesYetToBePrimed.Remove(source);
// If the source wants to read it's data immediately, then activated
// it right now...
if (source.TimeToRead == CodeSource.TTimeToRead.EReadWhenPriming)
{
source.Read(aSynchronicity);
}
else
{
// This source will read it's data on it's own terms so skip
// it to ensure that we can track when all the other sources
// (that do actually read their files now..) are ready.
Skip(source);
}
count = iSourcesYetToBePrimed.Count;
}
}
catch (Exception e)
{
// If priming failed, report completion before rethrowing...
OnPrimeComplete();
throw e;
}
}
public CodePrimer(CodePlugin aPlugin)
: base(aPlugin)
{
}
