DebuggerParseData.cpp [plain text]
#include "config.h"
#include "DebuggerParseData.h"
#include "Parser.h"
#include <wtf/Optional.h>
namespace JSC {
Optional<JSTextPosition> DebuggerPausePositions::breakpointLocationForLineColumn(int line, int column)
{
DebuggerPausePosition position = { DebuggerPausePositionType::Invalid, JSTextPosition(line, column, 0) };
auto it = std::lower_bound(m_positions.begin(), m_positions.end(), position, [] (const DebuggerPausePosition& a, const DebuggerPausePosition& b) {
if (a.position.line == b.position.line)
return a.position.column() < b.position.column();
return a.position.line < b.position.line;
});
if (it == m_positions.end())
return WTF::nullopt;
if (line == it->position.line && column == it->position.column()) {
while (it->type == DebuggerPausePositionType::Enter)
++it;
return it->position;
}
auto& firstSlidePosition = *it;
if (firstSlidePosition.type != DebuggerPausePositionType::Enter)
return Optional<JSTextPosition>(firstSlidePosition.position);
bool shouldEnterFunction = firstSlidePosition.position.line == line;
int entryStackSize = shouldEnterFunction ? 0 : 1;
++it;
for (; it != m_positions.end(); ++it) {
auto& slidePosition = *it;
ASSERT(entryStackSize >= 0);
if (entryStackSize) {
if (slidePosition.type == DebuggerPausePositionType::Enter)
entryStackSize++;
else if (slidePosition.type == DebuggerPausePositionType::Leave)
entryStackSize--;
continue;
}
if (slidePosition.type == DebuggerPausePositionType::Enter) {
entryStackSize++;
continue;
}
return Optional<JSTextPosition>(slidePosition.position);
}
return WTF::nullopt;
}
void DebuggerPausePositions::sort()
{
std::sort(m_positions.begin(), m_positions.end(), [] (const DebuggerPausePosition& a, const DebuggerPausePosition& b) {
if (a.position.offset == b.position.offset)
return a.type < b.type;
return a.position.offset < b.position.offset;
});
}
typedef enum { Program, Module } DebuggerParseInfoTag;
template <DebuggerParseInfoTag T> struct DebuggerParseInfo { };
template <> struct DebuggerParseInfo<Program> {
typedef JSC::ProgramNode RootNode;
static constexpr SourceParseMode parseMode = SourceParseMode::ProgramMode;
static constexpr JSParserStrictMode strictMode = JSParserStrictMode::NotStrict;
static constexpr JSParserScriptMode scriptMode = JSParserScriptMode::Classic;
};
template <> struct DebuggerParseInfo<Module> {
typedef JSC::ModuleProgramNode RootNode;
static constexpr SourceParseMode parseMode = SourceParseMode::ModuleEvaluateMode;
static constexpr JSParserStrictMode strictMode = JSParserStrictMode::Strict;
static constexpr JSParserScriptMode scriptMode = JSParserScriptMode::Module;
};
template <DebuggerParseInfoTag T>
bool gatherDebuggerParseData(VM& vm, const SourceCode& source, DebuggerParseData& debuggerParseData)
{
typedef typename DebuggerParseInfo<T>::RootNode RootNode;
SourceParseMode parseMode = DebuggerParseInfo<T>::parseMode;
JSParserStrictMode strictMode = DebuggerParseInfo<T>::strictMode;
JSParserScriptMode scriptMode = DebuggerParseInfo<T>::scriptMode;
ParserError error;
std::unique_ptr<RootNode> rootNode = parse<RootNode>(vm, source, Identifier(),
JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, parseMode, SuperBinding::NotNeeded,
error, nullptr, ConstructorKind::None, DerivedContextType::None, EvalContextType::None,
&debuggerParseData);
if (!rootNode)
return false;
debuggerParseData.pausePositions.sort();
return true;
}
bool gatherDebuggerParseDataForSource(VM& vm, SourceProvider* provider, DebuggerParseData& debuggerParseData)
{
ASSERT(provider);
int startLine = provider->startPosition().m_line.oneBasedInt();
int startColumn = provider->startPosition().m_column.oneBasedInt();
SourceCode completeSource(*provider, startLine, startColumn);
switch (provider->sourceType()) {
case SourceProviderSourceType::Program:
return gatherDebuggerParseData<Program>(vm, completeSource, debuggerParseData);
case SourceProviderSourceType::Module:
return gatherDebuggerParseData<Module>(vm, completeSource, debuggerParseData);
default:
return false;
}
}
}