Esempio n. 1
0
 internal TryBlock MakeTryBlock(List<CILLabel> labels)
 {
     Contract.Requires(labels != null);
     Contract.Ensures(Contract.Result<TryBlock>() != null);
     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;
 }
Esempio n. 2
0
        internal TryBlock MakeTryBlock(List <CILLabel> labels)
        {
            Contract.Requires(labels != null);
            Contract.Ensures(Contract.Result <TryBlock>() != null);
            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);
        }
Esempio n. 3
0
 /// <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;
 }
Esempio n. 4
0
 /// <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);
 }
Esempio n. 5
0
 /// <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);
 }
Esempio n. 6
0
 /// <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);
 }
Esempio n. 7
0
 /// <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);
 }
Esempio n. 8
0
 public void AddTryBlock(TryBlock tryBlock)
 {
     if (exceptions == null)
     exceptions = new ArrayList();
       else if (exceptions.Contains(tryBlock)) return;
       exceptions.Add(tryBlock);
 }