private void catchEnd()
{
PERWAPI.TryBlock lastTry = (PERWAPI.TryBlock)errBlocks.Pop();
if (dotnetErr != null)
{
// use a filter if we need to "dual-check" for native exception
code.EndFilterBlock(filterStart, lastTry);
dotnetErr = null;
filterStart = null;
}
else
{
// this is the normal catch block
code.EndCatchBlock(emitter.findType(exType) as PERWAPI.Class, lastTry);
}
}
private PERWAPI.TryBlock getLastTryBlock()
{
for (int i = 0; i < tryJump.Length; i++)
{
if (startPos == tryJump[i])
{
int start = tryStart[i];
int end = tryEnd[i];
string key = start + "/" + end;
PERWAPI.TryBlock block = (PERWAPI.TryBlock)tryBlocks[key];
if (block == null)
{
block = code.EndTryBlock();
tryBlocks[key] = block;
}
return(block);
}
}
throw new System.Exception("This is not good");
}
/// <summary>
/// Mark this position as the end of the last started block and
/// make it a try block. This try block is added to the current
/// instructions (ie do not need to call AddTryBlock)
/// </summary>
/// <returns>The try block just ended</returns>
public TryBlock EndTryBlock()
{
TryBlock tBlock = new TryBlock((CILLabel)blockStack.Pop(),NewCodedLabel());
AddTryBlock(tBlock);
return tBlock;
}
/// <summary>
/// Mark this position as the end of the last started block and
/// make it a finally block. This finally block is associated with the
/// specified try block.
/// </summary>
/// <param name="tryBlock">the try block associated with this finally block</param>
public void EndFinallyBlock(TryBlock tryBlock)
{
Finally finBlock= new Finally((CILLabel)blockStack.Pop(),NewCodedLabel());
tryBlock.AddHandler(finBlock);
}
/// <summary>
/// Mark this position as the end of the last started block and
/// make it a filter block. This filter block is associated with the
/// specified try block. The format is:
/// filterLab: ...
/// ...
/// filterHandler : ...
/// ...
/// </summary>
/// <param name="filterLab">the label where the filter code is</param>
/// <param name="tryBlock">the try block associated with this filter block</param>
public void EndFilterBlock(CILLabel filterLab, TryBlock tryBlock)
{
Filter filBlock = new Filter(filterLab,(CILLabel)blockStack.Pop(),NewCodedLabel());
tryBlock.AddHandler(filBlock);
}
/// <summary>
/// Mark this position as the end of the last started block and
/// make it a fault block. This fault block is associated with the
/// specified try block.
/// </summary>
/// <param name="tryBlock">the try block associated with this fault block</param>
public void EndFaultBlock(TryBlock tryBlock)
{
Fault fBlock= new Fault((CILLabel)blockStack.Pop(),NewCodedLabel());
tryBlock.AddHandler(fBlock);
}
/// <summary>
/// Mark this position as the end of the last started block and
/// make it a catch block. This catch block is associated with the
/// specified try block.
/// </summary>
/// <param name="exceptType">the exception type to be caught</param>
/// <param name="tryBlock">the try block associated with this catch block</param>
public void EndCatchBlock(Class exceptType, TryBlock tryBlock)
{
Catch catchBlock = new Catch(exceptType,(CILLabel)blockStack.Pop(), NewCodedLabel());
tryBlock.AddHandler(catchBlock);
}
public void AddTryBlock(TryBlock tryBlock)
{
if (exceptions == null)
exceptions = new ArrayList();
else if (exceptions.Contains(tryBlock)) return;
exceptions.Add(tryBlock);
}
internal TryBlock MakeTryBlock(ArrayList labels)
{
TryBlock tBlock = new TryBlock(CILInstructions.GetLabel(labels,tryOffset),
CILInstructions.GetLabel(labels,tryOffset + tryLength));
CILLabel hStart = CILInstructions.GetLabel(labels,handlerOffset);
CILLabel hEnd = CILInstructions.GetLabel(labels,handlerOffset+handlerLength);
HandlerBlock handler = null;
switch (clauseType) {
case (EHClauseType.Exception) :
handler = new Catch((Class)classToken,hStart,hEnd);
break;
case (EHClauseType.Filter) :
handler = new Filter(CILInstructions.GetLabel(labels,filterOffset),hStart,hEnd);
break;
case (EHClauseType.Finally) :
handler = new Finally(hStart,hEnd);
break;
case (EHClauseType.Fault) :
handler = new Fault(hStart,hEnd);
break;
}
tBlock.AddHandler(handler);
return tBlock;
}
internal void EndFinallyBlock(TryBlock tryBlock) {
System.Diagnostics.Debug.Assert(blocks.Peek() == Clause.Finally);
blocks.Pop();
buffer.EndFinallyBlock(tryBlock);
}
internal void EndCatchBlock(PERWAPI.Class type, TryBlock tryBlock) {
System.Diagnostics.Debug.Assert(blocks.Peek() == Clause.Catch);
blocks.Pop();
buffer.EndCatchBlock(type, tryBlock);
}
