selectors.cc (46379B)
1 #include "selectors.hh" 2 3 #include "buffer_utils.hh" 4 #include "context.hh" 5 #include "event_manager.hh" 6 #include "flags.hh" 7 #include "option_manager.hh" 8 #include "option_types.hh" 9 #include "regex.hh" 10 #include "selection.hh" 11 #include "string.hh" 12 #include "unit_tests.hh" 13 #include "utf8_iterator.hh" 14 15 #include <algorithm> 16 17 namespace Kakoune 18 { 19 20 using Utf8Iterator = utf8::iterator<BufferIterator>; 21 22 namespace 23 { 24 25 Selection utf8_range(const BufferIterator& first, const BufferIterator& last) 26 { 27 return {first.coord(), last.coord()}; 28 } 29 30 Selection utf8_range(const Utf8Iterator& first, const Utf8Iterator& last) 31 { 32 return {first.base().coord(), last.base().coord()}; 33 } 34 35 ConstArrayView<Codepoint> get_extra_word_chars(const Context& context) 36 { 37 return context.options()["extra_word_chars"].get<Vector<Codepoint, MemoryDomain::Options>>(); 38 } 39 40 } 41 42 Selection keep_direction(Selection res, const Selection& ref) 43 { 44 if ((res.cursor() < res.anchor()) != (ref.cursor() < ref.anchor())) 45 std::swap<BufferCoord>(res.cursor(), res.anchor()); 46 return res; 47 } 48 49 template<WordType word_type> 50 Optional<Selection> 51 select_to_next_word(const Context& context, const Selection& selection) 52 { 53 auto extra_word_chars = get_extra_word_chars(context); 54 auto& buffer = context.buffer(); 55 Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer}; 56 if (begin+1 == buffer.end()) 57 return {}; 58 if (categorize<word_type>(*begin, extra_word_chars) != 59 categorize<word_type>(*(begin+1), extra_word_chars)) 60 ++begin; 61 62 if (not skip_while(begin, buffer.end(), 63 [](Codepoint c) { return is_eol(c); })) 64 return {}; 65 Utf8Iterator end = begin+1; 66 67 auto is_word = [&](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); }; 68 auto is_punctuation = [&](Codepoint c) { return Kakoune::is_punctuation(c, extra_word_chars); }; 69 70 if (is_word(*begin)) 71 skip_while(end, buffer.end(), is_word); 72 else if (is_punctuation(*begin)) 73 skip_while(end, buffer.end(), is_punctuation); 74 75 skip_while(end, buffer.end(), is_horizontal_blank); 76 77 return utf8_range(begin, end-1); 78 } 79 template Optional<Selection> select_to_next_word<WordType::Word>(const Context&, const Selection&); 80 template Optional<Selection> select_to_next_word<WordType::WORD>(const Context&, const Selection&); 81 82 template<WordType word_type> 83 Optional<Selection> 84 select_to_next_word_end(const Context& context, const Selection& selection) 85 { 86 auto extra_word_chars = get_extra_word_chars(context); 87 auto& buffer = context.buffer(); 88 Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer}; 89 if (begin+1 == buffer.end()) 90 return {}; 91 if (categorize<word_type>(*begin, extra_word_chars) != 92 categorize<word_type>(*(begin+1), extra_word_chars)) 93 ++begin; 94 95 if (not skip_while(begin, buffer.end(), 96 [](Codepoint c) { return is_eol(c); })) 97 return {}; 98 Utf8Iterator end = begin; 99 skip_while(end, buffer.end(), is_horizontal_blank); 100 101 auto is_word = [&](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); }; 102 auto is_punctuation = [&](Codepoint c) { return Kakoune::is_punctuation(c, extra_word_chars); }; 103 104 if (is_word(*end)) 105 skip_while(end, buffer.end(), is_word); 106 else if (is_punctuation(*end)) 107 skip_while(end, buffer.end(), is_punctuation); 108 109 return utf8_range(begin, end-1); 110 } 111 template Optional<Selection> select_to_next_word_end<WordType::Word>(const Context&, const Selection&); 112 template Optional<Selection> select_to_next_word_end<WordType::WORD>(const Context&, const Selection&); 113 114 template<WordType word_type> 115 Optional<Selection> 116 select_to_previous_word(const Context& context, const Selection& selection) 117 { 118 auto extra_word_chars = get_extra_word_chars(context); 119 auto& buffer = context.buffer(); 120 Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer}; 121 if (begin == buffer.begin()) 122 return {}; 123 if (categorize<word_type>(*begin, extra_word_chars) != 124 categorize<word_type>(*(begin-1), extra_word_chars)) 125 --begin; 126 127 skip_while_reverse(begin, buffer.begin(), [](Codepoint c){ return is_eol(c); }); 128 Utf8Iterator end = begin; 129 130 auto is_word = [&](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); }; 131 auto is_punctuation = [&](Codepoint c) { return Kakoune::is_punctuation(c, extra_word_chars); }; 132 133 bool with_end = skip_while_reverse(end, buffer.begin(), is_horizontal_blank); 134 if (is_word(*end)) 135 with_end = skip_while_reverse(end, buffer.begin(), is_word); 136 else if (is_punctuation(*end)) 137 with_end = skip_while_reverse(end, buffer.begin(), is_punctuation); 138 139 return utf8_range(begin, with_end ? end : end+1); 140 } 141 template Optional<Selection> select_to_previous_word<WordType::Word>(const Context&, const Selection&); 142 template Optional<Selection> select_to_previous_word<WordType::WORD>(const Context&, const Selection&); 143 144 template<WordType word_type> 145 Optional<Selection> select_word(const Context& context, const Selection& selection, int count, ObjectFlags flags) 146 { 147 auto extra_word_chars = get_extra_word_chars(context); 148 auto& buffer = context.buffer(); 149 150 auto is_word = [&](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); }; 151 152 Utf8Iterator first{buffer.iterator_at(selection.cursor()), buffer}; 153 if (not is_word(*first)) 154 return {}; 155 156 Utf8Iterator last = first; 157 if (flags & ObjectFlags::ToBegin) 158 { 159 skip_while_reverse(first, buffer.begin(), is_word); 160 if (not is_word(*first)) 161 ++first; 162 } 163 if (flags & ObjectFlags::ToEnd) 164 { 165 skip_while(last, buffer.end(), is_word); 166 if (not (flags & ObjectFlags::Inner)) 167 skip_while(last, buffer.end(), is_horizontal_blank); 168 --last; 169 } 170 return (flags & ObjectFlags::ToEnd) ? utf8_range(first, last) 171 : utf8_range(last, first); 172 } 173 template Optional<Selection> select_word<WordType::Word>(const Context&, const Selection&, int, ObjectFlags); 174 template Optional<Selection> select_word<WordType::WORD>(const Context&, const Selection&, int, ObjectFlags); 175 176 template<bool only_move> 177 Optional<Selection> select_to_line_end(const Context& context, const Selection& selection) 178 { 179 auto& buffer = context.buffer(); 180 BufferCoord begin = selection.cursor(); 181 LineCount line = begin.line; 182 BufferCoord end = utf8::previous(buffer.iterator_at({line, buffer[line].length() - 1}), 183 buffer.iterator_at(line)).coord(); 184 if (end < begin) // Do not go backward when cursor is on eol 185 end = begin; 186 return Selection{only_move ? end : begin, {end, max_non_eol_column}}; 187 } 188 template Optional<Selection> select_to_line_end<false>(const Context&, const Selection&); 189 template Optional<Selection> select_to_line_end<true>(const Context&, const Selection&); 190 191 template<bool only_move> 192 Optional<Selection> select_to_line_begin(const Context&, const Selection& selection) 193 { 194 BufferCoord begin = selection.cursor(); 195 BufferCoord end = begin.line; 196 return Selection{only_move ? end : begin, end}; 197 } 198 template Optional<Selection> select_to_line_begin<false>(const Context&, const Selection&); 199 template Optional<Selection> select_to_line_begin<true>(const Context&, const Selection&); 200 201 Optional<Selection> select_to_first_non_blank(const Context& context, const Selection& selection) 202 { 203 auto& buffer = context.buffer(); 204 auto it = buffer.iterator_at(selection.cursor().line); 205 skip_while(it, buffer.iterator_at(selection.cursor().line+1), 206 is_horizontal_blank); 207 return {it.coord()}; 208 } 209 210 template<bool forward> 211 Optional<Selection> select_matching(const Context& context, const Selection& selection) 212 { 213 auto& buffer = context.buffer(); 214 auto& matching_pairs = context.options()["matching_pairs"].get<Vector<Codepoint, MemoryDomain::Options>>(); 215 Utf8Iterator it{buffer.iterator_at(selection.cursor()), buffer}; 216 auto match = matching_pairs.end(); 217 218 if (forward) while (it != buffer.end()) 219 { 220 match = find(matching_pairs, *it); 221 if (match != matching_pairs.end()) 222 break; 223 ++it; 224 } 225 else while (true) 226 { 227 match = find(matching_pairs, *it); 228 if (match != matching_pairs.end() 229 or it == buffer.begin()) 230 break; 231 --it; 232 } 233 234 if (match == matching_pairs.end()) 235 return {}; 236 237 Utf8Iterator begin = it; 238 239 if (((match - matching_pairs.begin()) % 2) == 0) 240 { 241 int level = 0; 242 const Codepoint opening = *match; 243 const Codepoint closing = *(match+1); 244 while (it != buffer.end()) 245 { 246 if (*it == opening) 247 ++level; 248 else if (*it == closing and --level == 0) 249 return utf8_range(begin, it); 250 ++it; 251 } 252 } 253 else 254 { 255 int level = 0; 256 const Codepoint opening = *(match-1); 257 const Codepoint closing = *match; 258 while (true) 259 { 260 if (*it == closing) 261 ++level; 262 else if (*it == opening and --level == 0) 263 return utf8_range(begin, it); 264 if (it == buffer.begin()) 265 break; 266 --it; 267 } 268 } 269 return {}; 270 } 271 template Optional<Selection> 272 select_matching<true>(const Context& context, const Selection& selection); 273 template Optional<Selection> 274 select_matching<false>(const Context& context, const Selection& selection); 275 276 template<typename Iterator, typename Container> 277 Optional<std::pair<Iterator, Iterator>> 278 find_opening(Iterator pos, const Container& container, 279 const Regex& opening, const Regex& closing, 280 int level, bool nestable) 281 { 282 MatchResults<Iterator> res; 283 // When on the token of a non-nestable block, we want to consider it opening 284 if (nestable and 285 backward_regex_search(container.begin(), pos, 286 container.begin(), container.end(), res, closing, 287 RegexExecFlags::None, EventManager::handle_urgent_events) and 288 res[0].second == pos) 289 pos = res[0].first; 290 291 using RegexIt = RegexIterator<Iterator, RegexMode::Backward, const Regex, void (*)()>; 292 for (auto&& match : RegexIt{container.begin(), pos, container.begin(), container.end(), opening, 293 RegexExecFlags::None, EventManager::handle_urgent_events}) 294 { 295 if (nestable) 296 { 297 for (auto m [[maybe_unused]] : RegexIt{match[0].second, pos, container.begin(), container.end(), closing, 298 RegexExecFlags::None, EventManager::handle_urgent_events}) 299 ++level; 300 } 301 302 if (not nestable or level == 0) 303 return match[0]; 304 pos = match[0].first; 305 --level; 306 } 307 return {}; 308 } 309 310 template<typename Iterator, typename Container> 311 Optional<std::pair<Iterator, Iterator>> 312 find_closing(Iterator pos, const Container& container, 313 const Regex& opening, const Regex& closing, 314 int level, bool nestable) 315 { 316 for (auto match : RegexIterator{pos, container.end(), container.begin(), container.end(), closing, 317 RegexExecFlags::None, EventManager::handle_urgent_events}) 318 { 319 if (nestable) 320 { 321 for (auto m [[maybe_unused]] : RegexIterator{pos, match[0].first, container.begin(), container.end(), opening, 322 RegexExecFlags::None, EventManager::handle_urgent_events}) 323 ++level; 324 } 325 326 if (not nestable or level == 0) 327 return match[0]; 328 pos = match[0].second; 329 --level; 330 } 331 return {}; 332 } 333 334 template<typename Container, typename Iterator> 335 Optional<std::pair<Iterator, Iterator>> 336 find_surrounding(const Container& container, Iterator pos, 337 const Regex& opening, const Regex& closing, 338 ObjectFlags flags, int level) 339 { 340 auto empty = [](const std::pair<Iterator, Iterator>& m) { return m.first == m.second; }; 341 const bool nestable = opening != closing; 342 auto first = pos; 343 auto last = pos; 344 if (flags & ObjectFlags::ToBegin) 345 { 346 if (auto res = find_opening(first+1, container, opening, closing, level, nestable)) 347 { 348 first = (flags & ObjectFlags::Inner) ? res->second : res->first; 349 if (flags & ObjectFlags::ToEnd) // ensure we find the matching end 350 { 351 last = empty(*res) ? std::next(res->second) : res->second; 352 level = 0; 353 } 354 } 355 else 356 return {}; 357 } 358 else if (MatchResults<Iterator> res; 359 regex_search(pos, container.end(), container.begin(), container.end(), res, opening, 360 RegexExecFlags::None, EventManager::handle_urgent_events) and 361 res[0].first == pos) // Skip opening match if pos lies on it 362 last = empty(res[0]) ? std::next(res[0].second) : res[0].second; 363 364 if (flags & ObjectFlags::ToEnd) 365 { 366 if (auto res = find_closing(last, container, opening, closing, level, nestable)) 367 last = utf8::previous((flags & ObjectFlags::Inner) ? res->first : res->second, 368 container.begin()); 369 else 370 return {}; 371 } 372 if (first > last) 373 return {}; 374 375 return std::pair<Iterator, Iterator>{first, last}; 376 } 377 378 Optional<Selection> 379 select_surrounding(const Context& context, const Selection& selection, 380 const Regex& opening, const Regex& closing, int level, 381 ObjectFlags flags) 382 { 383 auto& buffer = context.buffer(); 384 auto pos = buffer.iterator_at(selection.cursor()); 385 386 auto res = find_surrounding(buffer, pos, opening, closing, flags, level); 387 388 // If the ends we're changing didn't move, find the parent 389 if (res and not (flags & ObjectFlags::Inner) and 390 (res->first.coord() == selection.min() or not (flags & ObjectFlags::ToBegin)) and 391 (res->second.coord() == selection.max() or not (flags & ObjectFlags::ToEnd))) 392 res = find_surrounding(buffer, pos, opening, closing, flags, level+1); 393 394 if (res) 395 return (flags & ObjectFlags::ToEnd) ? utf8_range(res->first, res->second) 396 : utf8_range(res->second, res->first); 397 return {}; 398 } 399 400 Optional<Selection> 401 select_to(const Context& context, const Selection& selection, 402 Codepoint c, int count, bool inclusive) 403 { 404 auto& buffer = context.buffer(); 405 Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer}; 406 Utf8Iterator end = begin; 407 do 408 { 409 ++end; 410 skip_while(end, buffer.end(), [c](Codepoint cur) { return cur != c; }); 411 if (end == buffer.end()) 412 return {}; 413 } 414 while (--count > 0); 415 416 return utf8_range(begin, inclusive ? end : end-1); 417 } 418 419 Optional<Selection> 420 select_to_reverse(const Context& context, const Selection& selection, 421 Codepoint c, int count, bool inclusive) 422 { 423 auto& buffer = context.buffer(); 424 425 // if we are selecting backwards from the beginning of the buffer, 426 // there is nothing more that can be selected. 427 if (selection.cursor() == buffer.begin()) 428 return {}; 429 430 Utf8Iterator begin{buffer.iterator_at(selection.cursor()), buffer}; 431 Utf8Iterator end = begin; 432 do 433 { 434 --end; 435 if (skip_while_reverse(end, buffer.begin(), 436 [c](Codepoint cur) { return cur != c; })) 437 return {}; 438 } 439 while (--count > 0); 440 441 return utf8_range(begin, inclusive ? end : end+1); 442 } 443 444 Optional<Selection> 445 select_number(const Context& context, const Selection& selection, 446 int count, ObjectFlags flags) 447 { 448 auto is_number = [&](char c) { 449 return (c >= '0' and c <= '9') or 450 (not (flags & ObjectFlags::Inner) and c == '.'); 451 }; 452 453 auto& buffer = context.buffer(); 454 BufferIterator first = buffer.iterator_at(selection.cursor()); 455 BufferIterator last = first; 456 457 if (not is_number(*first) and *first != '-') 458 return {}; 459 460 if (flags & ObjectFlags::ToBegin) 461 { 462 skip_while_reverse(first, buffer.begin(), is_number); 463 if (not is_number(*first) and *first != '-' and 464 first+1 != buffer.end()) 465 ++first; 466 } 467 468 if (flags & ObjectFlags::ToEnd) 469 { 470 if (*last == '-') 471 ++last; 472 skip_while(last, buffer.end(), is_number); 473 if (last != buffer.begin()) 474 --last; 475 } 476 477 return (flags & ObjectFlags::ToEnd) ? Selection{first.coord(), last.coord()} 478 : Selection{last.coord(), first.coord()}; 479 } 480 481 Optional<Selection> 482 select_sentence(const Context& context, const Selection& selection, 483 int count, ObjectFlags flags) 484 { 485 auto is_end_of_sentence = [](char c) { 486 return c == '.' or c == ';' or c == '!' or c == '?'; 487 }; 488 489 auto& buffer = context.buffer(); 490 BufferIterator first = buffer.iterator_at(selection.cursor()); 491 BufferIterator last; 492 493 for (int i = 0; i <= count; ++i) 494 { 495 if (not (flags & ObjectFlags::ToEnd) and first != buffer.begin()) 496 { 497 BufferIterator prev_non_blank = first-1; 498 skip_while_reverse(prev_non_blank, buffer.begin(), 499 [](char c) { return is_horizontal_blank(c) or is_eol(c); }); 500 if (is_end_of_sentence(*prev_non_blank)) 501 first = prev_non_blank; 502 } 503 504 if (i == 0) 505 last = first; 506 507 if (flags & ObjectFlags::ToBegin) 508 { 509 bool saw_non_blank = false; 510 while (first != buffer.begin()) 511 { 512 char cur = *first; 513 char prev = *(first-1); 514 if (not is_horizontal_blank(cur)) 515 saw_non_blank = true; 516 if (is_eol(prev) and is_eol(cur) and first + 1 != buffer.end()) 517 { 518 ++first; 519 break; 520 } 521 else if (is_end_of_sentence(prev)) 522 { 523 if (saw_non_blank) 524 break; 525 else if (flags & ObjectFlags::ToEnd) 526 last = first-1; 527 } 528 --first; 529 } 530 skip_while(first, buffer.end(), is_horizontal_blank); 531 } 532 if (flags & ObjectFlags::ToEnd) 533 { 534 while (last != buffer.end()) 535 { 536 char cur = *last; 537 if (is_end_of_sentence(cur) or 538 (is_eol(cur) and (last+1 == buffer.end() or is_eol(*(last+1))))) 539 break; 540 ++last; 541 } 542 if (not (flags & ObjectFlags::Inner) and last != buffer.end()) 543 { 544 ++last; 545 skip_while(last, buffer.end(), is_horizontal_blank); 546 --last; 547 } 548 } 549 } 550 return (flags & ObjectFlags::ToEnd) ? Selection{first.coord(), last.coord()} 551 : Selection{last.coord(), first.coord()}; 552 } 553 554 Optional<Selection> 555 select_paragraph(const Context& context, const Selection& selection, 556 int count, ObjectFlags flags) 557 { 558 auto& buffer = context.buffer(); 559 BufferIterator first = buffer.iterator_at(selection.cursor()); 560 BufferIterator last; 561 562 for (int i = 0; i <= count; ++i) 563 { 564 if (not (flags & ObjectFlags::ToEnd) and first.coord() > BufferCoord{0,1} and 565 is_eol(*(first-1)) and first-1 != buffer.begin() and is_eol(*(first-2))) 566 --first; 567 else if ((flags & ObjectFlags::ToEnd) and 568 first != buffer.begin() and (first+1) != buffer.end() and 569 is_eol(*(first-1)) and is_eol(*first)) 570 ++first; 571 if (i == 0) 572 last = first; 573 574 if ((flags & ObjectFlags::ToBegin) and first != buffer.begin()) 575 { 576 skip_while_reverse(first, buffer.begin(), 577 [](Codepoint c){ return is_eol(c); }); 578 if (flags & ObjectFlags::ToEnd) 579 last = first; 580 while (first != buffer.begin()) 581 { 582 char cur = *first; 583 char prev = *(first-1); 584 if (is_eol(prev) and is_eol(cur)) 585 { 586 ++first; 587 break; 588 } 589 --first; 590 } 591 } 592 if (flags & ObjectFlags::ToEnd) 593 { 594 if (last != buffer.end() and is_eol(*last)) 595 ++last; 596 while (last != buffer.end()) 597 { 598 if (last != buffer.begin() and is_eol(*last) and is_eol(*(last-1))) 599 { 600 if (not (flags & ObjectFlags::Inner)) 601 skip_while(last, buffer.end(), 602 [](Codepoint c){ return is_eol(c); }); 603 break; 604 } 605 ++last; 606 } 607 --last; 608 } 609 } 610 return (flags & ObjectFlags::ToEnd) ? Selection{first.coord(), last.coord()} 611 : Selection{last.coord(), first.coord()}; 612 } 613 614 Optional<Selection> 615 select_whitespaces(const Context& context, const Selection& selection, 616 int count, ObjectFlags flags) 617 { 618 auto is_whitespace = [&](char c) { 619 return c == ' ' or c == '\t' or 620 (not (flags & ObjectFlags::Inner) and c == '\n'); 621 }; 622 auto& buffer = context.buffer(); 623 BufferIterator first = buffer.iterator_at(selection.cursor()); 624 BufferIterator last = first; 625 626 if (not is_whitespace(*first)) 627 return {}; 628 629 if (flags & ObjectFlags::ToBegin) 630 { 631 if (is_whitespace(*first)) 632 { 633 skip_while_reverse(first, buffer.begin(), is_whitespace); 634 if (not is_whitespace(*first)) 635 ++first; 636 } 637 } 638 if (flags & ObjectFlags::ToEnd) 639 { 640 if (is_whitespace(*last)) 641 { 642 skip_while(last, buffer.end(), is_whitespace); 643 --last; 644 } 645 } 646 return (flags & ObjectFlags::ToEnd) ? Selection{first.coord(), last.coord()} 647 : Selection{last.coord(), first.coord()}; 648 } 649 650 Optional<Selection> 651 select_indent(const Context& context, const Selection& selection, 652 int count, ObjectFlags flags) 653 { 654 auto get_indent = [](StringView str, int tabstop) { 655 CharCount indent = 0; 656 for (auto& c : str) 657 { 658 if (c == ' ') 659 ++indent; 660 else if (c =='\t') 661 indent = (indent / tabstop + 1) * tabstop; 662 else 663 break; 664 } 665 return indent; 666 }; 667 668 auto get_current_indent = [&](const Buffer& buffer, LineCount line, int tabstop) 669 { 670 for (auto l = line; l >= 0; --l) 671 if (buffer[l] != "\n"_sv) 672 return get_indent(buffer[l], tabstop); 673 for (auto l = line+1; l < buffer.line_count(); ++l) 674 if (buffer[l] != "\n"_sv) 675 return get_indent(buffer[l], tabstop); 676 return 0_char; 677 }; 678 679 auto is_only_whitespaces = [](StringView str) { 680 auto it = str.begin(); 681 skip_while(it, str.end(), 682 [](char c){ return c == ' ' or c == '\t' or c == '\n'; }); 683 return it == str.end(); 684 }; 685 686 const bool to_begin = flags & ObjectFlags::ToBegin; 687 const bool to_end = flags & ObjectFlags::ToEnd; 688 689 auto& buffer = context.buffer(); 690 int tabstop = context.options()["tabstop"].get<int>(); 691 auto pos = selection.cursor(); 692 const LineCount line = pos.line; 693 const auto indent = get_current_indent(buffer, line, tabstop); 694 695 LineCount begin_line = line - 1; 696 if (to_begin) 697 { 698 while (begin_line >= 0 and (buffer[begin_line] == "\n"_sv or 699 get_indent(buffer[begin_line], tabstop) >= indent)) 700 --begin_line; 701 } 702 ++begin_line; 703 LineCount end_line = line + 1; 704 if (to_end) 705 { 706 const LineCount end = buffer.line_count(); 707 while (end_line < end and (buffer[end_line] == "\n"_sv or 708 get_indent(buffer[end_line], tabstop) >= indent)) 709 ++end_line; 710 } 711 --end_line; 712 // remove only whitespaces lines in inner mode 713 if (flags & ObjectFlags::Inner) 714 { 715 while (begin_line < end_line and 716 is_only_whitespaces(buffer[begin_line])) 717 ++begin_line; 718 while (begin_line < end_line and 719 is_only_whitespaces(buffer[end_line])) 720 --end_line; 721 } 722 723 auto first = to_begin ? begin_line : pos; 724 auto last = to_end ? BufferCoord{end_line, buffer[end_line].length() - 1} : pos; 725 return to_end ? Selection{first, last} : Selection{last, first}; 726 } 727 728 Optional<Selection> 729 select_argument(const Context& context, const Selection& selection, 730 int level, ObjectFlags flags) 731 { 732 enum Class { None, Opening, Closing, Delimiter }; 733 auto classify = [](Codepoint c) { 734 switch (c) 735 { 736 case '(': case '[': case '{': return Opening; 737 case ')': case ']': case '}': return Closing; 738 case ',': case ';': return Delimiter; 739 default: return None; 740 } 741 }; 742 743 auto& buffer = context.buffer(); 744 BufferIterator pos = buffer.iterator_at(selection.cursor()); 745 switch (classify(*pos)) 746 { 747 //case Closing: if (pos+1 != buffer.end()) ++pos; break; 748 case Opening: 749 case Delimiter: if (pos != buffer.begin()) --pos; break; 750 default: break; 751 }; 752 753 bool first_arg = false; 754 BufferIterator begin = pos; 755 for (int lev = level; begin != buffer.begin(); --begin) 756 { 757 Class c = classify(*begin); 758 if (c == Closing) 759 ++lev; 760 else if (c == Opening and (lev-- == 0)) 761 { 762 first_arg = true; 763 ++begin; 764 break; 765 } 766 else if (c == Delimiter and lev == 0) 767 { 768 ++begin; 769 break; 770 } 771 } 772 773 bool last_arg = false; 774 BufferIterator end = pos; 775 for (int lev = level; end != buffer.end(); ++end) 776 { 777 Class c = classify(*end); 778 if (c == Opening) 779 ++lev; 780 else if (end != pos and c == Closing and (lev-- == 0)) 781 { 782 last_arg = true; 783 --end; 784 break; 785 } 786 else if (c == Delimiter and lev == 0) 787 { 788 // include whitespaces *after* the delimiter only for first argument 789 if (first_arg and not (flags & ObjectFlags::Inner)) 790 { 791 while (end + 1 != buffer.end() and is_blank(*(end+1))) 792 ++end; 793 } 794 break; 795 } 796 } 797 798 if (flags & ObjectFlags::Inner) 799 { 800 if (not last_arg) 801 --end; 802 skip_while(begin, end, is_blank); 803 skip_while_reverse(end, begin, is_blank); 804 } 805 // get starting delimiter for non inner last arg 806 else if (not first_arg and last_arg and begin != buffer.begin()) 807 --begin; 808 809 if (end == buffer.end()) 810 --end; 811 812 if (flags & ObjectFlags::ToBegin and not (flags & ObjectFlags::ToEnd)) 813 return Selection{pos.coord(), begin.coord()}; 814 return Selection{(flags & ObjectFlags::ToBegin ? begin : pos).coord(), 815 end.coord()}; 816 } 817 818 Vector<Selection> for_each_sel(const Context& context, auto&& callback) 819 { 820 auto& buffer = context.buffer(); 821 Vector<Selection> res; 822 for (auto& sel : context.selections()) 823 callback(res, buffer.iterator_at(sel.min()), buffer.iterator_at(buffer.char_next(sel.max()))); 824 if (res.empty()) 825 throw runtime_error("nothing selected"); 826 return res; 827 } 828 829 template<WordType word_type> 830 Vector<Selection> select_nested_words(const Context& context, int count, ObjectFlags flags) 831 { 832 auto is_word = [extra_word_chars=get_extra_word_chars(context)](Codepoint c) { return Kakoune::is_word<word_type>(c, extra_word_chars); }; 833 auto is_not_word = [&](Codepoint c) { return not is_word(c); }; 834 835 return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator beg, BufferIterator end) { 836 for (auto it = Utf8Iterator{beg, context.buffer()}; it != end; ) 837 { 838 if (not skip_while(it, end, is_not_word)) 839 break; 840 auto start = it; 841 skip_while(it, end, is_word); 842 if (not (flags & ObjectFlags::Inner)) 843 skip_while(it, end, is_horizontal_blank); 844 res.push_back({start.base().coord(), context.buffer().char_prev(it.base().coord())}); 845 } 846 }); 847 } 848 template Vector<Selection> select_nested_words<Word>(const Context& context, int count, ObjectFlags flags); 849 template Vector<Selection> select_nested_words<WORD>(const Context& context, int count, ObjectFlags flags); 850 851 Vector<Selection> select_nested_numbers(const Context& context, int count, ObjectFlags flags) 852 { 853 auto is_digit = [](char c) { return c >= '0' and c <= '9'; }; 854 auto is_number = [&](char c) { return is_digit(c) or (not (flags & ObjectFlags::Inner) and c == '.'); }; 855 856 return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) { 857 while (it != end) 858 { 859 if (not skip_while(it, end, [&](char c) { return not (c == '-' or is_number(c)); })) 860 break; 861 862 auto start = it; 863 if (*it == '-') 864 ++it; 865 skip_while(it, end, is_number); 866 if (it == start) 867 ++it; 868 else if (std::find_if(start, it, is_digit) != it) 869 res.push_back({start.coord(), context.buffer().char_prev(it.coord())}); 870 } 871 }); 872 } 873 874 Vector<Selection> select_nested_sentences(const Context& context, int count, ObjectFlags flags) 875 { 876 auto is_end_of_sentence = [](char c) { return c == '.' or c == ';' or c == '!' or c == '?'; }; 877 878 return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) { 879 while (it != end) 880 { 881 if (not skip_while(it, end, [](char c) { return c == ' ' or c == '\n' or c == '\t'; })) 882 break; 883 auto start = it; 884 it = std::find_if(it, end, is_end_of_sentence); 885 if (it != end) 886 { 887 ++it; 888 if (not (flags & ObjectFlags::Inner)) 889 skip_while(it, end, [](char c) { return c == ' '; }); 890 } 891 res.push_back({start.coord(), context.buffer().char_prev(it.coord())}); 892 } 893 }); 894 } 895 896 Vector<Selection> select_nested_paragraphs(const Context& context, int count, ObjectFlags flags) 897 { 898 auto is_eol = [](char c) { return c == '\n'; }; 899 900 return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) { 901 while (it != end) 902 { 903 auto start = std::find_if(it, end, [&](char c) {return not is_eol(c); }); 904 int consecutive_eols = 0; 905 for (it = start; it != end; ++it) 906 { 907 if (is_eol(*it)) 908 { 909 ++consecutive_eols; 910 if (consecutive_eols == 2 and (flags & ObjectFlags::Inner)) 911 break; 912 } 913 else if (consecutive_eols >= 2) 914 break; 915 else 916 consecutive_eols = 0; 917 } 918 res.push_back({start.coord(), context.buffer().char_prev(it.coord())}); 919 } 920 }); 921 } 922 923 Vector<Selection> select_nested_whitespaces(const Context& context, int count, ObjectFlags flags) 924 { 925 auto is_whitespace = [&](char c) { return c == ' ' or c == '\t' or (not (flags & ObjectFlags::Inner) and c == '\n'); }; 926 927 return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) { 928 while (it != end) 929 { 930 if (not skip_while(it, end, [&](char c) { return not is_whitespace(c); })) 931 break; 932 auto start = it; 933 skip_while(it, end, is_whitespace); 934 res.push_back({start.coord(), context.buffer().char_prev(it.coord())}); 935 } 936 }); 937 } 938 939 Vector<Selection> select_nested_indents(const Context& context, int count, ObjectFlags flags) 940 { 941 throw runtime_error("nested indents are not implemented"); 942 } 943 944 Vector<Selection> select_nested_arguments(const Context& context, int count, ObjectFlags flags) 945 { 946 auto is_whitespace = [&](char c) { return c == ' ' or c == '\t' or c == '\n'; }; 947 const bool inner = (flags & ObjectFlags::Inner); 948 auto& buffer = context.buffer(); 949 950 return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator it, BufferIterator end) { 951 auto start = it; 952 int level = 0; 953 while (it != end) 954 { 955 switch(*it) 956 { 957 case '(': case '[': case '{': ++level; ++it; break; 958 case ')': case ']': case '}': --level; ++it; break; 959 case ',': case ';': 960 if (level == 0) 961 { 962 res.push_back({start.coord(), inner ? buffer.char_prev(it.coord()) : it.coord()}); 963 ++it; 964 while (inner and it != end and is_whitespace(*it)) 965 ++it; 966 start = it; 967 break; 968 } 969 [[fallthrough]]; 970 default: ++it; break; 971 } 972 } 973 if (start != it) 974 res.push_back({start.coord(), context.buffer().char_prev(it.coord())}); 975 }); 976 } 977 978 Vector<Selection> regex_select_nested(const Context& context, const Regex& opening, const Regex& closing, int count, ObjectFlags flags) 979 { 980 kak_assert(opening != closing); 981 auto& buffer = context.buffer(); 982 const bool inner = (flags & ObjectFlags::Inner); 983 984 return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator beg, BufferIterator end) { 985 RegexIterator opening_matches{beg, end, buffer.begin(), buffer.end(), opening, RegexExecFlags::None, EventManager::handle_urgent_events}; 986 RegexIterator closing_matches{beg, end, buffer.begin(), buffer.end(), closing, RegexExecFlags::None, EventManager::handle_urgent_events}; 987 auto opening_it = opening_matches.begin(), closing_it = closing_matches.begin(); 988 auto opening_end = opening_matches.end(), closing_end = closing_matches.end(); 989 990 Optional<BufferIterator> start; 991 int level = -count - 1; 992 while (opening_it != opening_end and closing_it != closing_end) 993 { 994 while (opening_it != opening_end and (closing_it == closing_end or (*opening_it)[0].first < (*closing_it)[0].first)) 995 { 996 if (++level == 0) 997 start = inner ? (*opening_it)[0].second : (*opening_it)[0].first; 998 ++opening_it; 999 } 1000 while (closing_it != closing_end and (opening_it == opening_end or (*closing_it)[0].first < (*opening_it)[0].first)) 1001 { 1002 if (level-- == 0 and start) 1003 { 1004 auto end_coord = buffer.char_prev((inner ? (*closing_it)[0].first : (*closing_it)[0].second).coord()); 1005 if (start->coord() <= end_coord) 1006 res.push_back({start->coord(), end_coord}); 1007 start.reset(); 1008 } 1009 ++closing_it; 1010 } 1011 } 1012 if (start) 1013 res.push_back({start->coord(), buffer.char_prev(end.coord())}); 1014 }); 1015 } 1016 1017 Vector<Selection> regex_select_nested(const Context& context, const Regex& delimiter, ObjectFlags flags) 1018 { 1019 auto& buffer = context.buffer(); 1020 const bool inner = (flags & ObjectFlags::Inner); 1021 1022 return for_each_sel(context, [&](Vector<Selection>& res, BufferIterator beg, BufferIterator end) { 1023 Optional<BufferIterator> start; 1024 for (auto m : RegexIterator{beg, end, buffer.begin(), buffer.end(), 1025 delimiter, RegexExecFlags::None, EventManager::handle_urgent_events}) 1026 { 1027 if (not start) 1028 start = inner ? m[0].second : m[0].first; 1029 else 1030 { 1031 auto end_coord = buffer.char_prev((inner ? m[0].first : m[0].second).coord()); 1032 if (start->coord() <= end_coord) 1033 res.push_back({start->coord(), end_coord}); 1034 start.reset(); 1035 } 1036 } 1037 if (start) 1038 res.push_back({start->coord(), buffer.char_prev(end.coord())}); 1039 }); 1040 } 1041 1042 Optional<Selection> 1043 select_lines(const Context& context, const Selection& selection) 1044 { 1045 auto& buffer = context.buffer(); 1046 BufferCoord anchor = selection.anchor(); 1047 BufferCoord cursor = selection.cursor(); 1048 BufferCoord& to_line_start = anchor <= cursor ? anchor : cursor; 1049 BufferCoord& to_line_end = anchor <= cursor ? cursor : anchor; 1050 1051 to_line_start.column = 0; 1052 to_line_end.column = buffer[to_line_end.line].length()-1; 1053 1054 return Selection{anchor, {cursor, max_column}}; 1055 } 1056 1057 Optional<Selection> 1058 trim_partial_lines(const Context& context, const Selection& selection) 1059 { 1060 auto& buffer = context.buffer(); 1061 BufferCoord anchor = selection.anchor(); 1062 BufferCoord cursor = selection.cursor(); 1063 BufferCoord& to_line_start = anchor <= cursor ? anchor : cursor; 1064 BufferCoord& to_line_end = anchor <= cursor ? cursor : anchor; 1065 1066 if (to_line_start.column != 0) 1067 to_line_start = to_line_start.line+1; 1068 if (to_line_end.column != buffer[to_line_end.line].length()-1) 1069 { 1070 if (to_line_end.line == 0) 1071 return {}; 1072 1073 auto prev_line = to_line_end.line-1; 1074 to_line_end = BufferCoord{ prev_line, buffer[prev_line].length()-1 }; 1075 } 1076 1077 if (to_line_start > to_line_end) 1078 return {}; 1079 1080 return Selection{anchor, {cursor, max_column}}; 1081 } 1082 1083 static RegexExecFlags 1084 match_flags(const Buffer& buf, const BufferIterator& begin, const BufferIterator& end) 1085 { 1086 return match_flags(is_bol(begin.coord()), is_eol(buf, end.coord()), 1087 is_bow(buf, begin.coord()), is_eow(buf, end.coord())); 1088 } 1089 1090 static bool find_next(const Buffer& buffer, const BufferIterator& pos, 1091 MatchResults<BufferIterator>& matches, 1092 const Regex& ex, bool& wrapped) 1093 { 1094 if (pos != buffer.end() and 1095 regex_search(pos, buffer.end(), buffer.begin(), buffer.end(), 1096 matches, ex, match_flags(buffer, pos, buffer.end()), 1097 EventManager::handle_urgent_events)) 1098 return true; 1099 wrapped = true; 1100 return regex_search(buffer.begin(), buffer.end(), buffer.begin(), buffer.end(), 1101 matches, ex, match_flags(buffer, buffer.begin(), buffer.end()), 1102 EventManager::handle_urgent_events); 1103 } 1104 1105 static bool find_prev(const Buffer& buffer, const BufferIterator& pos, 1106 MatchResults<BufferIterator>& matches, 1107 const Regex& ex, bool& wrapped) 1108 { 1109 if (pos != buffer.begin() and 1110 backward_regex_search(buffer.begin(), pos, buffer.begin(), buffer.end(), 1111 matches, ex, 1112 match_flags(buffer, buffer.begin(), pos) | 1113 RegexExecFlags::NotInitialNull, 1114 EventManager::handle_urgent_events)) 1115 return true; 1116 wrapped = true; 1117 return backward_regex_search(buffer.begin(), buffer.end(), buffer.begin(), buffer.end(), 1118 matches, ex, 1119 match_flags(buffer, buffer.begin(), buffer.end()) | 1120 RegexExecFlags::NotInitialNull, 1121 EventManager::handle_urgent_events); 1122 } 1123 1124 Selection find_next_match(const Context& context, const Selection& sel, const Regex& regex, RegexMode mode, bool& wrapped) 1125 { 1126 kak_assert(is_direction(mode)); 1127 const bool forward = mode & RegexMode::Forward; 1128 auto& buffer = context.buffer(); 1129 MatchResults<BufferIterator> matches; 1130 auto pos = buffer.iterator_at(forward ? sel.max() : sel.min()); 1131 wrapped = false; 1132 const bool found = forward ? 1133 find_next(buffer, utf8::next(pos, buffer.end()), matches, regex, wrapped) 1134 : find_prev(buffer, pos, matches, regex, wrapped); 1135 1136 if (not found or matches[0].first == buffer.end()) 1137 throw runtime_error(format("no matches found: '{}'", regex.str())); 1138 1139 CaptureList captures; 1140 for (const auto& match : matches) 1141 captures.push_back(buffer.string(match.first.coord(), match.second.coord())); 1142 1143 auto begin = matches[0].first, end = matches[0].second; 1144 end = (begin == end) ? end : utf8::previous(end, begin); 1145 if (not forward) 1146 std::swap(begin, end); 1147 1148 return {begin.coord(), end.coord(), std::move(captures)}; 1149 } 1150 1151 Vector<Selection> select_matches(const Buffer& buffer, ConstArrayView<Selection> selections, const Regex& regex, int capture_idx) 1152 { 1153 const int mark_count = (int)regex.mark_count(); 1154 if (capture_idx < 0 or capture_idx > mark_count) 1155 throw runtime_error("invalid capture number"); 1156 1157 Vector<Selection> result; 1158 ThreadedRegexVM<BufferIterator, RegexMode::Forward | RegexMode::Search> vm{*regex.impl()}; 1159 for (auto& sel : selections) 1160 { 1161 auto sel_beg = buffer.iterator_at(sel.min()); 1162 auto sel_end = utf8::next(buffer.iterator_at(sel.max()), buffer.end()); 1163 1164 for (auto&& match : RegexIterator{sel_beg, sel_end, vm, match_flags(buffer, sel_beg, sel_end), 1165 EventManager::handle_urgent_events}) 1166 { 1167 auto capture = match[capture_idx]; 1168 if (not capture.matched or capture.first == sel_end) 1169 continue; 1170 1171 CaptureList captures; 1172 captures.reserve(mark_count); 1173 for (const auto& submatch : match) 1174 captures.push_back(buffer.string(submatch.first.coord(), 1175 submatch.second.coord())); 1176 1177 auto begin = capture.first, end = capture.second; 1178 result.push_back( 1179 keep_direction({ begin.coord(), 1180 (begin == end ? end : utf8::previous(end, begin)).coord(), 1181 std::move(captures) }, sel)); 1182 } 1183 } 1184 if (result.empty()) 1185 throw runtime_error("nothing selected"); 1186 1187 std::sort(result.begin(), result.end(), compare_selections); 1188 return result; 1189 } 1190 1191 Vector<Selection> split_on_matches(const Buffer& buffer, ConstArrayView<Selection> selections, const Regex& regex, int capture_idx) 1192 { 1193 if (capture_idx < 0 or capture_idx > (int)regex.mark_count()) 1194 throw runtime_error("invalid capture number"); 1195 1196 Vector<Selection> result; 1197 auto buf_end = buffer.end(); 1198 ThreadedRegexVM<BufferIterator, RegexMode::Forward | RegexMode::Search> vm{*regex.impl()}; 1199 for (auto& sel : selections) 1200 { 1201 auto sel_begin = buffer.iterator_at(sel.min()); 1202 auto begin = sel_begin; 1203 auto sel_end = utf8::next(buffer.iterator_at(sel.max()), buf_end); 1204 1205 for (auto&& match : RegexIterator{begin, sel_end, vm, match_flags(buffer, begin, sel_end)}) 1206 { 1207 auto capture = match[capture_idx]; 1208 BufferIterator end = capture.first; 1209 if (end == buf_end) 1210 continue; 1211 1212 if (end != sel_begin) 1213 { 1214 auto sel_end = (begin == end) ? end : utf8::previous(end, begin); 1215 result.push_back(keep_direction({ begin.coord(), sel_end.coord() }, sel)); 1216 } 1217 begin = capture.second; 1218 } 1219 if (begin.coord() <= sel.max()) 1220 result.push_back(keep_direction({ begin.coord(), sel.max() }, sel)); 1221 } 1222 if (result.empty()) 1223 throw runtime_error("nothing selected"); 1224 return result; 1225 } 1226 1227 UnitTest test_find_surrounding{[]() 1228 { 1229 StringView s = "{foo [bar { baz[] }]}"; 1230 auto check_equal = [&](const char* pos, StringView opening, StringView closing, 1231 ObjectFlags flags, int level, StringView expected) { 1232 auto res = find_surrounding(s, pos, 1233 Regex{"\\Q" + opening, RegexCompileFlags::Backward}, 1234 Regex{"\\Q" + closing, RegexCompileFlags::Backward}, 1235 flags, level); 1236 kak_assert((not res) == expected.empty()); 1237 if (not res) 1238 return; 1239 auto min = std::min(res->first, res->second), 1240 max = std::max(res->first, res->second); 1241 kak_assert(StringView{min, max+1} == expected); 1242 }; 1243 1244 check_equal(s.begin() + 13, '{', '}', ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "{ baz[] }"); 1245 check_equal(s.begin() + 13, '[', ']', ObjectFlags::ToBegin | ObjectFlags::ToEnd | ObjectFlags::Inner, 0, "bar { baz[] }"); 1246 check_equal(s.begin() + 5, '[', ']', ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "[bar { baz[] }]"); 1247 check_equal(s.begin() + 10, '{', '}', ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "{ baz[] }"); 1248 check_equal(s.begin() + 16, '[', ']', ObjectFlags::ToBegin | ObjectFlags::ToEnd | ObjectFlags::Inner, 0, ""); 1249 check_equal(s.begin() + 18, '[', ']', ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "[bar { baz[] }]"); 1250 check_equal(s.begin() + 6, '[', ']', ObjectFlags::ToBegin, 0, "[b"); 1251 1252 s = "[*][] foo"; 1253 kak_assert(not find_surrounding(s, s.begin() + 6, 1254 Regex{"\\Q[", RegexCompileFlags::Backward}, 1255 Regex{"\\Q]", RegexCompileFlags::Backward}, 1256 ObjectFlags::ToBegin, 0)); 1257 1258 s = "begin foo begin bar end end"; 1259 check_equal(s.begin() + 6, "begin", "end", ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, s); 1260 check_equal(s.begin() + 22, "begin", "end", ObjectFlags::ToBegin | ObjectFlags::ToEnd, 0, "begin bar end"); 1261 }}; 1262 1263 }