public override int Run(InterpretedFrame frame) { frame.PopPendingContinuation(); Debug.Assert(!frame.IsJumpHappened()); // Just return 1, and the real instruction index will be calculated by GotoHandler later return(1); }
public override int Run(InterpretedFrame frame) { frame.PopPendingContinuation(); // If _pendingContinuation == -1 then we were getting into the finally block because an exception was thrown // In this case we just return 1, and the real instruction index will be calculated by GotoHandler later return(!frame.IsJumpHappened() ? 1 : frame.YieldToPendingContinuation()); // jump to goto target or to the next finally: }
public override int Run(InterpretedFrame frame) { Debug.Assert(!frame.IsJumpHappened()); frame.SetStackDepth(GetLabel(frame).StackDepth); frame.PushPendingContinuation(); frame.RemoveContinuation(); return(1); }
public override int Run(InterpretedFrame frame) { // If _pendingContinuation == -1 then we were getting into the finally block because an exception was thrown // in this case we need to set the stack depth // Else we were getting into this finally block from a 'Goto' jump, and the stack depth is already set properly if (!frame.IsJumpHappened()) { frame.SetStackDepth(GetLabel(frame).StackDepth); } frame.PushPendingContinuation(); frame.RemoveContinuation(); return(1); }
public override int Run(InterpretedFrame frame) { if (_hasFinally) { // Push finally. frame.PushContinuation(LabelIndex); } var prevInstrIndex = frame.InstructionIndex; frame.InstructionIndex++; // Start to run the try/catch/finally blocks var instructions = frame.Interpreter.Instructions.Instructions; try { // run the try block var index = frame.InstructionIndex; while (index >= Handler !.TryStartIndex && index < Handler.TryEndIndex) { index += instructions[index].Run(frame); frame.InstructionIndex = index; } // we finish the try block and is about to jump out of the try/catch blocks if (index == Handler.GotoEndTargetIndex) { // run the 'Goto' that jumps out of the try/catch/finally blocks Debug.Assert(instructions[index] is GotoInstruction, "should be the 'Goto' instruction that jumps out the try/catch/finally"); frame.InstructionIndex += instructions[index].Run(frame); } } catch (Exception exception) when(Handler !.HasHandler(frame, exception, out var exHandler, out var unwrappedException)) { Debug.Assert(!(unwrappedException is RethrowException)); frame.InstructionIndex += frame.Goto(exHandler.LabelIndex, unwrappedException, true); var rethrow = false; try { // run the catch block var index = frame.InstructionIndex; while (index >= exHandler.HandlerStartIndex && index < exHandler.HandlerEndIndex) { index += instructions[index].Run(frame); frame.InstructionIndex = index; } // we finish the catch block and is about to jump out of the try/catch blocks if (index == Handler.GotoEndTargetIndex) { // run the 'Goto' that jumps out of the try/catch/finally blocks Debug.Assert(instructions[index] is GotoInstruction, "should be the 'Goto' instruction that jumps out the try/catch/finally"); frame.InstructionIndex += instructions[index].Run(frame); } } catch (RethrowException) { // a rethrow instruction in a catch block gets to run rethrow = true; } if (rethrow) { throw; } } finally { if (Handler !.IsFinallyBlockExist) { // We get to the finally block in two paths: // 1. Jump from the try/catch blocks. This includes two sub-routes: // a. 'Goto' instruction in the middle of try/catch block // b. try/catch block runs to its end. Then the 'Goto(end)' will be trigger to jump out of the try/catch block // 2. Exception thrown from the try/catch blocks // In the first path, the continuation mechanism works and frame.InstructionIndex will be updated to point to the first instruction of the finally block // In the second path, the continuation mechanism is not involved and frame.InstructionIndex is not updated #if DEBUG var isFromJump = frame.IsJumpHappened(); Debug.Assert(!isFromJump || (isFromJump && Handler.FinallyStartIndex == frame.InstructionIndex), "we should already jump to the first instruction of the finally"); #endif // run the finally block // we cannot jump out of the finally block, and we cannot have an immediate rethrow in it var index = frame.InstructionIndex = Handler.FinallyStartIndex; while (index >= Handler.FinallyStartIndex && index < Handler.FinallyEndIndex) { index += instructions[index].Run(frame); frame.InstructionIndex = index; } } } return(frame.InstructionIndex - prevInstrIndex); }