public override void Visit(IOperationExceptionInformation operationExceptionInformation) { if (Process(operationExceptionInformation)) { visitor.Visit(operationExceptionInformation); } base.Visit(operationExceptionInformation); }
public override void Visit(IOperationExceptionInformation operationExceptionInformation) { ITypeReference excepType = operationExceptionInformation.ExceptionType; if (excepType == Dummy.TypeReference) { return; } base.Visit(operationExceptionInformation); }
private static int CompareHandlers(IOperationExceptionInformation handler1, IOperationExceptionInformation handler2) { Contract.Requires(handler1 != null); Contract.Requires(handler2 != null); if (handler1.TryStartOffset < handler2.TryStartOffset) { return(-1); } if (handler1.TryStartOffset > handler2.TryStartOffset) { return(1); } if (handler1.TryEndOffset > handler2.TryEndOffset) { return(-1); } if (handler1.TryEndOffset < handler2.TryEndOffset) { return(1); } if (handler1.HandlerStartOffset < handler2.HandlerStartOffset) { return(-1); } if (handler2.HandlerStartOffset > handler2.HandlerStartOffset) { return(1); } if (handler1.HandlerEndOffset > handler2.HandlerEndOffset) { return(-1); } if (handler1.HandlerEndOffset < handler2.HandlerEndOffset) { return(1); } return(0); }
/// <summary> /// Visits the specified operation exception information. /// </summary> /// <param name="operationExceptionInformation">The operation exception information.</param> public virtual void Visit(IOperationExceptionInformation operationExceptionInformation) { if (this.stopTraversal) return; //^ int oldCount = this.path.Count; this.path.Push(operationExceptionInformation); this.Visit(operationExceptionInformation.ExceptionType); //^ assume this.path.Count == oldCount+1; //True because all of the virtual methods of this class promise not decrease this.path.Count. this.path.Pop(); }
/// <summary> /// Traverses the specified operation exception information. /// </summary> public void Traverse(IOperationExceptionInformation operationExceptionInformation) { Contract.Requires(operationExceptionInformation != null); if (this.preorderVisitor != null) this.preorderVisitor.Visit(operationExceptionInformation); if (this.stopTraversal) return; this.TraverseChildren(operationExceptionInformation); if (this.stopTraversal) return; if (this.postorderVisitor != null) this.postorderVisitor.Visit(operationExceptionInformation); }
public void Visit(IOperationExceptionInformation operationExceptionInformation) { throw new NotImplementedException(); }
private void EmitCatchFilter(uint offset, IOperationExceptionInformation expInfo) { Contract.Requires(expInfo != null); this.sourceEmitter.EmitString("expSwitchVal" + expInfo.TryStartOffset + " = " + this.exceptionSwitchTables.NumberOfEntries(expInfo.TryStartOffset) + ";"); this.sourceEmitter.EmitNewLine(); this.sourceEmitter.EmitString("goto lcatch_filter_" + expInfo.HandlerStartOffset + ";"); this.sourceEmitter.EmitNewLine(); string label = "l" + offset.ToString("x4") + "_" + expInfo.HandlerStartOffset.ToString("x4") + "_" + labelCounter++; this.exceptionSwitchTables.Add(expInfo.TryStartOffset, label); this.sourceEmitter.EmitLabel(label + ":"); this.sourceEmitter.EmitNewLine(); this.sourceEmitter.EmitString("if (canHandleExp > 0) "); this.sourceEmitter.EmitBlockOpeningDelimiter("{"); this.sourceEmitter.EmitNewLine(); this.sourceEmitter.EmitString("canHandleExp = 0;"); this.sourceEmitter.EmitNewLine(); this.sourceEmitter.EmitString("goto lrun_finallies_for_catch_" + expInfo.HandlerStartOffset + ";"); this.sourceEmitter.EmitNewLine(); this.sourceEmitter.EmitBlockClosingDelimiter("}"); this.sourceEmitter.EmitNewLine(); }
bool PopulateExceptionInformation() { SEHTableEntry[]/*?*/ sehTable = this.MethodIL.SEHTable; if (sehTable != null) { int n = sehTable.Length; var exceptions = new IOperationExceptionInformation[n]; for (int i = 0; i < n; i++) { SEHTableEntry sehTableEntry = sehTable[i]; int sehFlag = (int)sehTableEntry.SEHFlags; int handlerKindIndex = sehFlag >= ILReader.HandlerKindMap.Length ? ILReader.HandlerKindMap.Length - 1 : sehFlag; ITypeReference exceptionType = Dummy.TypeReference; uint filterDecisionStart = 0; HandlerKind handlerKind = ILReader.HandlerKindMap[handlerKindIndex]; uint tryStart = sehTableEntry.TryOffset; uint tryEnd = sehTableEntry.TryOffset + sehTableEntry.TryLength; uint handlerStart = sehTableEntry.HandlerOffset; uint handlerEnd = sehTableEntry.HandlerOffset + sehTableEntry.HandlerLength; if (sehTableEntry.SEHFlags == SEHFlags.Catch) { ITypeReference/*?*/ typeRef = this.PEFileToObjectModel.GetTypeReferenceForToken(this.MethodDefinition, sehTableEntry.ClassTokenOrFilterOffset); if (typeRef == null) { // Error return false; } else { exceptionType = typeRef; } } else if (sehTableEntry.SEHFlags == SEHFlags.Filter) { exceptionType = this.PEFileToObjectModel.PlatformType.SystemObject; filterDecisionStart = sehTableEntry.ClassTokenOrFilterOffset; } exceptions[i] = new CilExceptionInformation(handlerKind, exceptionType, tryStart, tryEnd, filterDecisionStart, handlerStart, handlerEnd); } this.MethodBody.SetExceptionInformation(exceptions); } return true; }
public override void Visit(IOperationExceptionInformation operationExceptionInformation) { if(Process(operationExceptionInformation)){visitor.Visit(operationExceptionInformation);} base.Visit(operationExceptionInformation); }
/// <summary> /// Performs some computation with the given IL operation exception information instance. /// </summary> public void Visit(IOperationExceptionInformation operationExceptionInformation) { }
public override void Visit(IOperationExceptionInformation operationExceptionInformation) { ITypeReference excepType = operationExceptionInformation.ExceptionType; if (excepType == Dummy.TypeReference) return; base.Visit(operationExceptionInformation); }
public override void TraverseChildren(IBlockStatement block) { Contract.Assume(block is BlockStatement); var decompiledBlock = (BlockStatement)block; var statements = decompiledBlock.Statements; List <IStatement> newStatements = null; for (int i = 0, n = statements.Count; i < n; i++) { LabeledStatement outerLabel = null; Contract.Assume(i < statements.Count); var statement = statements[i]; Contract.Assume(statement != null); var nestedBlock = statement as DecompiledBlock; if (nestedBlock != null) { var trycf = this.tryCatchFinallyMap.Find(nestedBlock.StartOffset, nestedBlock.EndOffset); if (trycf != null) { statements[i] = trycf; if (newStatements == null) { newStatements = CopyStatements(statements, i); } IOperationExceptionInformation handlerInfo = this.handlerMap.Find(nestedBlock.StartOffset, nestedBlock.EndOffset); if (handlerInfo == null) { outerLabel = nestedBlock.ReturnInitialLabel(); if (outerLabel != null) { newStatements.Add(outerLabel); var innerLabel = new LabeledStatement(outerLabel); innerLabel.Label = this.host.NameTable.GetNameFor(outerLabel.Label.Value + "#inner"); nestedBlock.ReplaceInitialLabel(innerLabel); this.trystartOutsideLabels.Add(outerLabel); this.insideLabelFor[(uint)outerLabel.Label.UniqueKey] = innerLabel; } trycf.TryBody = nestedBlock; statement = trycf; } else { switch (handlerInfo.HandlerKind) { case HandlerKind.Catch: ILocalDefinition exceptionContainer = this.ExtractExceptionContainer(nestedBlock, handlerInfo.ExceptionType); if (!(exceptionContainer is Dummy)) { this.RemoveLocalDeclarationOf(exceptionContainer, nestedBlock); } trycf.CatchClauses.Add(new CatchClause() { Body = nestedBlock, ExceptionType = handlerInfo.ExceptionType, ExceptionContainer = exceptionContainer }); break; case HandlerKind.Fault: trycf.FaultBody = nestedBlock; break; case HandlerKind.Filter: var filterCondition = this.GetFilterCondition(nestedBlock); if (filterCondition != null) { this.RemovedFilterCondition(nestedBlock); } trycf.CatchClauses.Add(new CatchClause() { Body = nestedBlock, ExceptionType = this.host.PlatformType.SystemObject, FilterCondition = filterCondition }); break; case HandlerKind.Finally: this.RemoveEndFinallyFrom(nestedBlock); trycf.FinallyBody = nestedBlock; break; } this.Traverse(nestedBlock); if (outerLabel != null) { this.trystartOutsideLabels.Remove(outerLabel); } continue; } } } if (newStatements != null) { newStatements.Add(statement); } this.Traverse(statement); } if (newStatements != null) { decompiledBlock.Statements = newStatements; for (int i = 0, n = newStatements.Count - 1; i < n; i++) { var trycf = newStatements[i] as TryCatchFinallyStatement; if (trycf == null) { continue; } var followingBlock = newStatements[i + 1] as DecompiledBlock; if (followingBlock != null) { this.RemoveUnconditionalBranchesToLabelImmediatelyFollowing(trycf, followingBlock); } this.ConsolidateScopes(trycf); } } }
/// <summary> /// Performs some computation with the given IL operation exception information instance. /// </summary> public virtual void Visit(IOperationExceptionInformation operationExceptionInformation) { }
/// <summary> /// Rewrites the specified operation exception information. /// </summary> public virtual IOperationExceptionInformation Rewrite( IOperationExceptionInformation operationExceptionInformation) { return operationExceptionInformation; }
public override void Visit(IOperationExceptionInformation operationExceptionInformation) { allElements.Add(new InvokInfo(Traverser, "IOperationExceptionInformation", operationExceptionInformation)); }
private static int CompareHandlers(IOperationExceptionInformation handler1, IOperationExceptionInformation handler2) { Contract.Requires(handler1 != null); Contract.Requires(handler2 != null); if (handler1.TryStartOffset < handler2.TryStartOffset) return -1; if (handler1.TryStartOffset > handler2.TryStartOffset) return 1; if (handler1.TryEndOffset > handler2.TryEndOffset) return -1; if (handler1.TryEndOffset < handler2.TryEndOffset) return 1; if (handler1.HandlerStartOffset < handler2.HandlerStartOffset) return -1; if (handler2.HandlerStartOffset > handler2.HandlerStartOffset) return 1; if (handler1.HandlerEndOffset > handler2.HandlerEndOffset) return -1; if (handler1.HandlerEndOffset < handler2.HandlerEndOffset) return 1; return 0; }
/// <summary> /// Traverses the specified operation exception information. /// </summary> public virtual void TraverseChildren(IOperationExceptionInformation operationExceptionInformation) { Contract.Requires(operationExceptionInformation != null); if (operationExceptionInformation.HandlerKind == HandlerKind.Catch || operationExceptionInformation.HandlerKind == HandlerKind.Filter) this.Traverse(operationExceptionInformation.ExceptionType); }
public virtual void onMetadataElement(IOperationExceptionInformation operationExceptionInformation) { }
public void Visit(IOperationExceptionInformation operationExceptionInformation) { Contract.Assume(false); }
/// <summary> /// Is the target operation in the try block of the test? /// </summary> /// <param name="operation"> /// The operation to test. /// </param> /// <param name="handlerBounds"> /// The handler bounds to test against. Presumably a set of bounds that exist in the same method from /// whence the operation came. /// </param> /// <returns> /// True if the operation is in the test try block, false otherwise. /// </returns> public static bool IsOperationInTryBlock(this IOperation operation, IOperationExceptionInformation handlerBounds) { return operation.Offset >= handlerBounds.TryStartOffset && operation.Offset <= handlerBounds.TryEndOffset; }
public override void TraverseChildren(IOperationExceptionInformation operationExceptionInformation) { base.TraverseChildren(operationExceptionInformation); }
public override void TraverseChildren(IOperationExceptionInformation operationExceptionInformation) { MethodEnter(operationExceptionInformation); base.TraverseChildren(operationExceptionInformation); MethodExit(); }
internal void SetExceptionInformation(IOperationExceptionInformation[] cilExceptionInformation) { this.cilExceptionInformation = IteratorHelper.GetReadonly(cilExceptionInformation); }
/// <summary> /// Traverses the specified operation exception information. /// </summary> public virtual void TraverseChildren(IOperationExceptionInformation operationExceptionInformation) { if (operationExceptionInformation.HandlerKind == HandlerKind.Catch || operationExceptionInformation.HandlerKind == HandlerKind.Filter) this.Traverse(operationExceptionInformation.ExceptionType); }