bool StepController::IsStepComplete(InterpreterHaltState* haltState, HaltCallback * haltCallback, OpCode originalOpcode)
{
int currentFrameCount = haltState->framePointers->Count();
AssertMsg(currentFrameCount > 0, "In IsStepComplete we must have at least one frame.");
FunctionBody* body = haltState->framePointers->Peek()->GetJavascriptFunction()->GetFunctionBody();
bool canPossiblyHalt = haltCallback->CanHalt(haltState);
OUTPUT_TRACE(Js::DebuggerPhase, _u("StepController::IsStepComplete(): stepType = %d "), stepType);
uint scriptId = GetScriptId(body);
AssertMsg(scriptId != InvalidScriptId, "scriptId cannot be 'invalid-reserved'");
int byteOffset = haltState->GetCurrentOffset();
bool fCanHalt = false;
if (this->frameCountWhenSet > currentFrameCount && STEP_DOCUMENT != stepType)
{
// all steps match once the frame they started on has popped.
fCanHalt = canPossiblyHalt;
}
else if (STEP_DOCUMENT == stepType)
{
OUTPUT_TRACE(Js::DebuggerPhase, _u("StepController::IsStepComplete(): docId when set=%d, currentDocId = %d, can Halt = %d, will halt = %d "), this->scriptIdWhenSet, scriptId, canPossiblyHalt, fCanHalt);
fCanHalt = (scriptId != this->scriptIdWhenSet) && canPossiblyHalt;
}
else if (STEP_IN != stepType && this->frameCountWhenSet < currentFrameCount)
{
// Only step into allows the stack to be deeper
OUTPUT_TRACE(Js::DebuggerPhase, _u("StepController::IsStepComplete(stepType = %d) returning false "), stepType);
return false;
}
else if (STEP_OUT == stepType)
{
fCanHalt = this->frameCountWhenSet > currentFrameCount && canPossiblyHalt;
}
else if (nullptr != this->statementMap && this->statementMap->isSubexpression && STEP_IN != stepType)
{
// Only step into started from subexpression is allowed to stop on another subexpression
Js::FunctionBody* pCurrentFuncBody = haltState->GetFunction();
Js::FunctionBody::StatementMap* map = pCurrentFuncBody->GetMatchingStatementMapFromByteCode(byteOffset, false);
if (nullptr != map && map->isSubexpression) // Execute remaining Subexpressions
{
fCanHalt = false;
}
else
{
Js::FunctionBody::StatementMap* outerMap = pCurrentFuncBody->GetMatchingStatementMapFromByteCode(this->statementMap->byteCodeSpan.begin, true);
if (nullptr != outerMap && map == outerMap) // Execute the rest of current regular statement
{
fCanHalt = false;
}
else
{
fCanHalt = canPossiblyHalt;
}
}
}
else
{
// Match if we are no longer on the original statement. Stepping means move off current statement.
if (body != this->body || NULL == this->statementMap ||
!this->statementMap->byteCodeSpan.Includes(byteOffset))
{
fCanHalt = canPossiblyHalt;
}
}
// At this point we are verifying of global return opcode.
// The global returns are alway added as a zero range begin with zero.
if (fCanHalt && originalOpcode == OpCode::Ret)
{
Js::FunctionBody* pCurrentFuncBody = haltState->GetFunction();
Js::FunctionBody::StatementMap* map = pCurrentFuncBody->GetMatchingStatementMapFromByteCode(byteOffset, true);
fCanHalt = !FunctionBody::IsDummyGlobalRetStatement(&map->sourceSpan);
if (fCanHalt)
{
// We are breaking at last line of function, imagine '}'
AddReturnToReturnedValueContainer();
}
}
OUTPUT_TRACE(Js::DebuggerPhase, _u("StepController::IsStepComplete(stepType = %d) returning %d "), stepType, fCanHalt);
return fCanHalt;
}
