|
0
|
1 // CodeMirror, copyright (c) by Marijn Haverbeke and others
|
|
|
2 // Distributed under an MIT license: https://codemirror.net/5/LICENSE
|
|
|
3
|
|
|
4 (function(mod) {
|
|
|
5 if (typeof exports == "object" && typeof module == "object") // CommonJS
|
|
|
6 mod(require("../../lib/codemirror"))
|
|
|
7 else if (typeof define == "function" && define.amd) // AMD
|
|
|
8 define(["../../lib/codemirror"], mod)
|
|
|
9 else // Plain browser env
|
|
|
10 mod(CodeMirror)
|
|
|
11 })(function(CodeMirror) {
|
|
|
12 "use strict"
|
|
|
13 var Pos = CodeMirror.Pos
|
|
|
14
|
|
|
15 function regexpFlags(regexp) {
|
|
|
16 var flags = regexp.flags
|
|
|
17 return flags != null ? flags : (regexp.ignoreCase ? "i" : "")
|
|
|
18 + (regexp.global ? "g" : "")
|
|
|
19 + (regexp.multiline ? "m" : "")
|
|
|
20 }
|
|
|
21
|
|
|
22 function ensureFlags(regexp, flags) {
|
|
|
23 var current = regexpFlags(regexp), target = current
|
|
|
24 for (var i = 0; i < flags.length; i++) if (target.indexOf(flags.charAt(i)) == -1)
|
|
|
25 target += flags.charAt(i)
|
|
|
26 return current == target ? regexp : new RegExp(regexp.source, target)
|
|
|
27 }
|
|
|
28
|
|
|
29 function maybeMultiline(regexp) {
|
|
|
30 return /\\s|\\n|\n|\\W|\\D|\[\^/.test(regexp.source)
|
|
|
31 }
|
|
|
32
|
|
|
33 function searchRegexpForward(doc, regexp, start) {
|
|
|
34 regexp = ensureFlags(regexp, "g")
|
|
|
35 for (var line = start.line, ch = start.ch, last = doc.lastLine(); line <= last; line++, ch = 0) {
|
|
|
36 regexp.lastIndex = ch
|
|
|
37 var string = doc.getLine(line), match = regexp.exec(string)
|
|
|
38 if (match)
|
|
|
39 return {from: Pos(line, match.index),
|
|
|
40 to: Pos(line, match.index + match[0].length),
|
|
|
41 match: match}
|
|
|
42 }
|
|
|
43 }
|
|
|
44
|
|
|
45 function searchRegexpForwardMultiline(doc, regexp, start) {
|
|
|
46 if (!maybeMultiline(regexp)) return searchRegexpForward(doc, regexp, start)
|
|
|
47
|
|
|
48 regexp = ensureFlags(regexp, "gm")
|
|
|
49 var string, chunk = 1
|
|
|
50 for (var line = start.line, last = doc.lastLine(); line <= last;) {
|
|
|
51 // This grows the search buffer in exponentially-sized chunks
|
|
|
52 // between matches, so that nearby matches are fast and don't
|
|
|
53 // require concatenating the whole document (in case we're
|
|
|
54 // searching for something that has tons of matches), but at the
|
|
|
55 // same time, the amount of retries is limited.
|
|
|
56 for (var i = 0; i < chunk; i++) {
|
|
|
57 if (line > last) break
|
|
|
58 var curLine = doc.getLine(line++)
|
|
|
59 string = string == null ? curLine : string + "\n" + curLine
|
|
|
60 }
|
|
|
61 chunk = chunk * 2
|
|
|
62 regexp.lastIndex = start.ch
|
|
|
63 var match = regexp.exec(string)
|
|
|
64 if (match) {
|
|
|
65 var before = string.slice(0, match.index).split("\n"), inside = match[0].split("\n")
|
|
|
66 var startLine = start.line + before.length - 1, startCh = before[before.length - 1].length
|
|
|
67 return {from: Pos(startLine, startCh),
|
|
|
68 to: Pos(startLine + inside.length - 1,
|
|
|
69 inside.length == 1 ? startCh + inside[0].length : inside[inside.length - 1].length),
|
|
|
70 match: match}
|
|
|
71 }
|
|
|
72 }
|
|
|
73 }
|
|
|
74
|
|
|
75 function lastMatchIn(string, regexp, endMargin) {
|
|
|
76 var match, from = 0
|
|
|
77 while (from <= string.length) {
|
|
|
78 regexp.lastIndex = from
|
|
|
79 var newMatch = regexp.exec(string)
|
|
|
80 if (!newMatch) break
|
|
|
81 var end = newMatch.index + newMatch[0].length
|
|
|
82 if (end > string.length - endMargin) break
|
|
|
83 if (!match || end > match.index + match[0].length)
|
|
|
84 match = newMatch
|
|
|
85 from = newMatch.index + 1
|
|
|
86 }
|
|
|
87 return match
|
|
|
88 }
|
|
|
89
|
|
|
90 function searchRegexpBackward(doc, regexp, start) {
|
|
|
91 regexp = ensureFlags(regexp, "g")
|
|
|
92 for (var line = start.line, ch = start.ch, first = doc.firstLine(); line >= first; line--, ch = -1) {
|
|
|
93 var string = doc.getLine(line)
|
|
|
94 var match = lastMatchIn(string, regexp, ch < 0 ? 0 : string.length - ch)
|
|
|
95 if (match)
|
|
|
96 return {from: Pos(line, match.index),
|
|
|
97 to: Pos(line, match.index + match[0].length),
|
|
|
98 match: match}
|
|
|
99 }
|
|
|
100 }
|
|
|
101
|
|
|
102 function searchRegexpBackwardMultiline(doc, regexp, start) {
|
|
|
103 if (!maybeMultiline(regexp)) return searchRegexpBackward(doc, regexp, start)
|
|
|
104 regexp = ensureFlags(regexp, "gm")
|
|
|
105 var string, chunkSize = 1, endMargin = doc.getLine(start.line).length - start.ch
|
|
|
106 for (var line = start.line, first = doc.firstLine(); line >= first;) {
|
|
|
107 for (var i = 0; i < chunkSize && line >= first; i++) {
|
|
|
108 var curLine = doc.getLine(line--)
|
|
|
109 string = string == null ? curLine : curLine + "\n" + string
|
|
|
110 }
|
|
|
111 chunkSize *= 2
|
|
|
112
|
|
|
113 var match = lastMatchIn(string, regexp, endMargin)
|
|
|
114 if (match) {
|
|
|
115 var before = string.slice(0, match.index).split("\n"), inside = match[0].split("\n")
|
|
|
116 var startLine = line + before.length, startCh = before[before.length - 1].length
|
|
|
117 return {from: Pos(startLine, startCh),
|
|
|
118 to: Pos(startLine + inside.length - 1,
|
|
|
119 inside.length == 1 ? startCh + inside[0].length : inside[inside.length - 1].length),
|
|
|
120 match: match}
|
|
|
121 }
|
|
|
122 }
|
|
|
123 }
|
|
|
124
|
|
|
125 var doFold, noFold
|
|
|
126 if (String.prototype.normalize) {
|
|
|
127 doFold = function(str) { return str.normalize("NFD").toLowerCase() }
|
|
|
128 noFold = function(str) { return str.normalize("NFD") }
|
|
|
129 } else {
|
|
|
130 doFold = function(str) { return str.toLowerCase() }
|
|
|
131 noFold = function(str) { return str }
|
|
|
132 }
|
|
|
133
|
|
|
134 // Maps a position in a case-folded line back to a position in the original line
|
|
|
135 // (compensating for codepoints increasing in number during folding)
|
|
|
136 function adjustPos(orig, folded, pos, foldFunc) {
|
|
|
137 if (orig.length == folded.length) return pos
|
|
|
138 for (var min = 0, max = pos + Math.max(0, orig.length - folded.length);;) {
|
|
|
139 if (min == max) return min
|
|
|
140 var mid = (min + max) >> 1
|
|
|
141 var len = foldFunc(orig.slice(0, mid)).length
|
|
|
142 if (len == pos) return mid
|
|
|
143 else if (len > pos) max = mid
|
|
|
144 else min = mid + 1
|
|
|
145 }
|
|
|
146 }
|
|
|
147
|
|
|
148 function searchStringForward(doc, query, start, caseFold) {
|
|
|
149 // Empty string would match anything and never progress, so we
|
|
|
150 // define it to match nothing instead.
|
|
|
151 if (!query.length) return null
|
|
|
152 var fold = caseFold ? doFold : noFold
|
|
|
153 var lines = fold(query).split(/\r|\n\r?/)
|
|
|
154
|
|
|
155 search: for (var line = start.line, ch = start.ch, last = doc.lastLine() + 1 - lines.length; line <= last; line++, ch = 0) {
|
|
|
156 var orig = doc.getLine(line).slice(ch), string = fold(orig)
|
|
|
157 if (lines.length == 1) {
|
|
|
158 var found = string.indexOf(lines[0])
|
|
|
159 if (found == -1) continue search
|
|
|
160 var start = adjustPos(orig, string, found, fold) + ch
|
|
|
161 return {from: Pos(line, adjustPos(orig, string, found, fold) + ch),
|
|
|
162 to: Pos(line, adjustPos(orig, string, found + lines[0].length, fold) + ch)}
|
|
|
163 } else {
|
|
|
164 var cutFrom = string.length - lines[0].length
|
|
|
165 if (string.slice(cutFrom) != lines[0]) continue search
|
|
|
166 for (var i = 1; i < lines.length - 1; i++)
|
|
|
167 if (fold(doc.getLine(line + i)) != lines[i]) continue search
|
|
|
168 var end = doc.getLine(line + lines.length - 1), endString = fold(end), lastLine = lines[lines.length - 1]
|
|
|
169 if (endString.slice(0, lastLine.length) != lastLine) continue search
|
|
|
170 return {from: Pos(line, adjustPos(orig, string, cutFrom, fold) + ch),
|
|
|
171 to: Pos(line + lines.length - 1, adjustPos(end, endString, lastLine.length, fold))}
|
|
|
172 }
|
|
|
173 }
|
|
|
174 }
|
|
|
175
|
|
|
176 function searchStringBackward(doc, query, start, caseFold) {
|
|
|
177 if (!query.length) return null
|
|
|
178 var fold = caseFold ? doFold : noFold
|
|
|
179 var lines = fold(query).split(/\r|\n\r?/)
|
|
|
180
|
|
|
181 search: for (var line = start.line, ch = start.ch, first = doc.firstLine() - 1 + lines.length; line >= first; line--, ch = -1) {
|
|
|
182 var orig = doc.getLine(line)
|
|
|
183 if (ch > -1) orig = orig.slice(0, ch)
|
|
|
184 var string = fold(orig)
|
|
|
185 if (lines.length == 1) {
|
|
|
186 var found = string.lastIndexOf(lines[0])
|
|
|
187 if (found == -1) continue search
|
|
|
188 return {from: Pos(line, adjustPos(orig, string, found, fold)),
|
|
|
189 to: Pos(line, adjustPos(orig, string, found + lines[0].length, fold))}
|
|
|
190 } else {
|
|
|
191 var lastLine = lines[lines.length - 1]
|
|
|
192 if (string.slice(0, lastLine.length) != lastLine) continue search
|
|
|
193 for (var i = 1, start = line - lines.length + 1; i < lines.length - 1; i++)
|
|
|
194 if (fold(doc.getLine(start + i)) != lines[i]) continue search
|
|
|
195 var top = doc.getLine(line + 1 - lines.length), topString = fold(top)
|
|
|
196 if (topString.slice(topString.length - lines[0].length) != lines[0]) continue search
|
|
|
197 return {from: Pos(line + 1 - lines.length, adjustPos(top, topString, top.length - lines[0].length, fold)),
|
|
|
198 to: Pos(line, adjustPos(orig, string, lastLine.length, fold))}
|
|
|
199 }
|
|
|
200 }
|
|
|
201 }
|
|
|
202
|
|
|
203 function SearchCursor(doc, query, pos, options) {
|
|
|
204 this.atOccurrence = false
|
|
|
205 this.afterEmptyMatch = false
|
|
|
206 this.doc = doc
|
|
|
207 pos = pos ? doc.clipPos(pos) : Pos(0, 0)
|
|
|
208 this.pos = {from: pos, to: pos}
|
|
|
209
|
|
|
210 var caseFold
|
|
|
211 if (typeof options == "object") {
|
|
|
212 caseFold = options.caseFold
|
|
|
213 } else { // Backwards compat for when caseFold was the 4th argument
|
|
|
214 caseFold = options
|
|
|
215 options = null
|
|
|
216 }
|
|
|
217
|
|
|
218 if (typeof query == "string") {
|
|
|
219 if (caseFold == null) caseFold = false
|
|
|
220 this.matches = function(reverse, pos) {
|
|
|
221 return (reverse ? searchStringBackward : searchStringForward)(doc, query, pos, caseFold)
|
|
|
222 }
|
|
|
223 } else {
|
|
|
224 query = ensureFlags(query, "gm")
|
|
|
225 if (!options || options.multiline !== false)
|
|
|
226 this.matches = function(reverse, pos) {
|
|
|
227 return (reverse ? searchRegexpBackwardMultiline : searchRegexpForwardMultiline)(doc, query, pos)
|
|
|
228 }
|
|
|
229 else
|
|
|
230 this.matches = function(reverse, pos) {
|
|
|
231 return (reverse ? searchRegexpBackward : searchRegexpForward)(doc, query, pos)
|
|
|
232 }
|
|
|
233 }
|
|
|
234 }
|
|
|
235
|
|
|
236 SearchCursor.prototype = {
|
|
|
237 findNext: function() {return this.find(false)},
|
|
|
238 findPrevious: function() {return this.find(true)},
|
|
|
239
|
|
|
240 find: function(reverse) {
|
|
|
241 var head = this.doc.clipPos(reverse ? this.pos.from : this.pos.to);
|
|
|
242 if (this.afterEmptyMatch && this.atOccurrence) {
|
|
|
243 // do not return the same 0 width match twice
|
|
|
244 head = Pos(head.line, head.ch)
|
|
|
245 if (reverse) {
|
|
|
246 head.ch--;
|
|
|
247 if (head.ch < 0) {
|
|
|
248 head.line--;
|
|
|
249 head.ch = (this.doc.getLine(head.line) || "").length;
|
|
|
250 }
|
|
|
251 } else {
|
|
|
252 head.ch++;
|
|
|
253 if (head.ch > (this.doc.getLine(head.line) || "").length) {
|
|
|
254 head.ch = 0;
|
|
|
255 head.line++;
|
|
|
256 }
|
|
|
257 }
|
|
|
258 if (CodeMirror.cmpPos(head, this.doc.clipPos(head)) != 0) {
|
|
|
259 return this.atOccurrence = false
|
|
|
260 }
|
|
|
261 }
|
|
|
262 var result = this.matches(reverse, head)
|
|
|
263 this.afterEmptyMatch = result && CodeMirror.cmpPos(result.from, result.to) == 0
|
|
|
264
|
|
|
265 if (result) {
|
|
|
266 this.pos = result
|
|
|
267 this.atOccurrence = true
|
|
|
268 return this.pos.match || true
|
|
|
269 } else {
|
|
|
270 var end = Pos(reverse ? this.doc.firstLine() : this.doc.lastLine() + 1, 0)
|
|
|
271 this.pos = {from: end, to: end}
|
|
|
272 return this.atOccurrence = false
|
|
|
273 }
|
|
|
274 },
|
|
|
275
|
|
|
276 from: function() {if (this.atOccurrence) return this.pos.from},
|
|
|
277 to: function() {if (this.atOccurrence) return this.pos.to},
|
|
|
278
|
|
|
279 replace: function(newText, origin) {
|
|
|
280 if (!this.atOccurrence) return
|
|
|
281 var lines = CodeMirror.splitLines(newText)
|
|
|
282 this.doc.replaceRange(lines, this.pos.from, this.pos.to, origin)
|
|
|
283 this.pos.to = Pos(this.pos.from.line + lines.length - 1,
|
|
|
284 lines[lines.length - 1].length + (lines.length == 1 ? this.pos.from.ch : 0))
|
|
|
285 }
|
|
|
286 }
|
|
|
287
|
|
|
288 CodeMirror.defineExtension("getSearchCursor", function(query, pos, caseFold) {
|
|
|
289 return new SearchCursor(this.doc, query, pos, caseFold)
|
|
|
290 })
|
|
|
291 CodeMirror.defineDocExtension("getSearchCursor", function(query, pos, caseFold) {
|
|
|
292 return new SearchCursor(this, query, pos, caseFold)
|
|
|
293 })
|
|
|
294
|
|
|
295 CodeMirror.defineExtension("selectMatches", function(query, caseFold) {
|
|
|
296 var ranges = []
|
|
|
297 var cur = this.getSearchCursor(query, this.getCursor("from"), caseFold)
|
|
|
298 while (cur.findNext()) {
|
|
|
299 if (CodeMirror.cmpPos(cur.to(), this.getCursor("to")) > 0) break
|
|
|
300 ranges.push({anchor: cur.from(), head: cur.to()})
|
|
|
301 }
|
|
|
302 if (ranges.length)
|
|
|
303 this.setSelections(ranges, 0)
|
|
|
304 })
|
|
|
305 });
|
