e71aac64f322a8fbd814f02815a856d63026bf9c
[WebKit-https.git] / Source / JavaScriptCore / debugger / DebuggerParseData.cpp
1 /*
2  * Copyright (C) 2016 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
14  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
15  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
17  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
18  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
19  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
20  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
21  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
23  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
24  */
25
26 #include "config.h"
27 #include "DebuggerParseData.h"
28
29 #include "Parser.h"
30
31 namespace JSC {
32
33 Optional<JSTextPosition> DebuggerPausePositions::breakpointLocationForLineColumn(int line, int column)
34 {
35     unsigned start = 0;
36     unsigned end = m_positions.size();
37     while (start != end) {
38         unsigned middle = start + ((end - start) / 2);
39         DebuggerPausePosition& pausePosition = m_positions[middle];
40         int pauseLine = pausePosition.position.line;
41         int pauseColumn = pausePosition.position.offset - pausePosition.position.lineStartOffset;
42
43         if (line < pauseLine) {
44             end = middle;
45             continue;
46         }
47         if (line > pauseLine) {
48             start = middle + 1;
49             continue;
50         }
51
52         if (column == pauseColumn) {
53             // Found an exact position match. Roll forward if this was a function Entry.
54             // We are guarenteed to have a Leave for an Entry so we don't need to bounds check.
55             while (true) {
56                 if (pausePosition.type != DebuggerPausePositionType::Enter)
57                     return Optional<JSTextPosition>(pausePosition.position);
58                 pausePosition = m_positions[middle++];
59             }
60         }
61
62         if (column < pauseColumn)
63             end = middle;
64         else
65             start = middle + 1;
66     }
67
68     // Past the end, no possible pause locations.
69     if (start >= m_positions.size())
70         return Nullopt;
71
72     // If the next location is a function Entry we will need to decide if we should go into
73     // the function or go past the function. We decide to go into the function if the
74     // input is on the same line as the function entry. For example:
75     //
76     //     1. x;
77     //     2.
78     //     3. function foo() {
79     //     4.     x;
80     //     5. }
81     //     6.
82     //     7. x;
83     //
84     // If the input was line 2, skip past functions to pause on line 7.
85     // If the input was line 3, go into the function to pause on line 4.
86
87     // Valid pause location. Use it.
88     DebuggerPausePosition& firstSlidePosition = m_positions[start];
89     if (firstSlidePosition.type != DebuggerPausePositionType::Enter)
90         return Optional<JSTextPosition>(firstSlidePosition.position);
91
92     // Determine if we should enter this function or skip past it.
93     // If entryStackSize is > 0 we are skipping functions.
94     bool shouldEnterFunction = firstSlidePosition.position.line == line;
95     int entryStackSize = shouldEnterFunction ? 0 : 1;
96     for (unsigned i = start + 1; i < m_positions.size(); ++i) {
97         DebuggerPausePosition& slidePosition = m_positions[i];
98         ASSERT(entryStackSize >= 0);
99
100         // Already skipping functions.
101         if (entryStackSize) {
102             if (slidePosition.type == DebuggerPausePositionType::Enter)
103                 entryStackSize++;
104             else if (slidePosition.type == DebuggerPausePositionType::Leave)
105                 entryStackSize--;
106             continue;
107         }
108
109         // Start skipping functions.
110         if (slidePosition.type == DebuggerPausePositionType::Enter) {
111             entryStackSize++;
112             continue;
113         }
114
115         // Found pause position.
116         return Optional<JSTextPosition>(slidePosition.position);
117     }
118
119     // No pause positions found.
120     return Nullopt;
121 }
122
123 void DebuggerPausePositions::sort()
124 {
125     std::sort(m_positions.begin(), m_positions.end(), [] (const DebuggerPausePosition& a, const DebuggerPausePosition& b) {
126         return a.position.offset < b.position.offset;
127     });
128 }
129
130 typedef enum { Program, Module } DebuggerParseInfoTag;
131 template <DebuggerParseInfoTag T> struct DebuggerParseInfo { };
132
133 template <> struct DebuggerParseInfo<Program> {
134     typedef JSC::ProgramNode RootNode;
135     static const SourceParseMode parseMode = SourceParseMode::ProgramMode;
136     static const JSParserStrictMode strictMode = JSParserStrictMode::NotStrict;
137     static const JSParserScriptMode scriptMode = JSParserScriptMode::Classic;
138 };
139
140 template <> struct DebuggerParseInfo<Module> {
141     typedef JSC::ModuleProgramNode RootNode;
142     static const SourceParseMode parseMode = SourceParseMode::ModuleEvaluateMode;
143     static const JSParserStrictMode strictMode = JSParserStrictMode::Strict;
144     static const JSParserScriptMode scriptMode = JSParserScriptMode::Module;
145 };
146
147 template <DebuggerParseInfoTag T>
148 bool gatherDebuggerParseData(VM& vm, const SourceCode& source, DebuggerParseData& debuggerParseData)
149 {
150     typedef typename DebuggerParseInfo<T>::RootNode RootNode;
151     SourceParseMode parseMode = DebuggerParseInfo<T>::parseMode;
152     JSParserStrictMode strictMode = DebuggerParseInfo<T>::strictMode;
153     JSParserScriptMode scriptMode = DebuggerParseInfo<T>::scriptMode;
154
155     ParserError error;
156     std::unique_ptr<RootNode> rootNode = parse<RootNode>(&vm, source, Identifier(),
157         JSParserBuiltinMode::NotBuiltin, strictMode, scriptMode, parseMode, SuperBinding::NotNeeded,
158         error, nullptr, ConstructorKind::None, DerivedContextType::None, EvalContextType::None,
159         &debuggerParseData);
160     if (!rootNode)
161         return false;
162
163     debuggerParseData.pausePositions.sort();
164
165     return true;
166 }
167
168 bool gatherDebuggerParseDataForSource(VM& vm, SourceProvider* provider, DebuggerParseData& debuggerParseData)
169 {
170     int startLine = provider->startPosition().m_line.oneBasedInt();
171     int startColumn = provider->startPosition().m_column.oneBasedInt();
172     SourceCode completeSource(provider, startLine, startColumn);
173
174     switch (provider->sourceType()) {
175     case SourceProviderSourceType::Program:
176         return gatherDebuggerParseData<Program>(vm, completeSource, debuggerParseData);        
177     case SourceProviderSourceType::Module:
178         return gatherDebuggerParseData<Module>(vm, completeSource, debuggerParseData);
179     default:
180         return false;
181     }
182 }
183
184 } // namespace JSC