Поиск с помощью регулярных выражений

В GNU Emacs можно искать следующее совпадение с регулярным выражением (см. Синтаксис регулярных выражений) как в инкрементальном режиме, так и без него. Сведения об инкрементальных командах поиска см. в разделе Поиск с помощью регулярных выражений в Руководстве GNU Emacs. Здесь мы описываем только функции поиска, полезные в программах. Основная из них — re-search-forward.

Эти функции поиска преобразуют регулярное выражение в многобайтовое, если буфер многобайтовый, и в однобайтовое, если буфер однобайтовый. См. Представления текста.

Команда: re-search-forward regexp &optional limit noerror count

Эта функция выполняет поиск вперёд в текущем буфере строки текста, соответствующей регулярному выражению regexp. Функция пропускает любое количество текста, не соответствующего regexp, и оставляет точку в конце первого найденного совпадения. Она возвращает новое значение точки.

Если limit не равен nil, он должен быть позицией в текущем буфере. Он задаёт верхнюю границу поиска. Совпадение, выходящее за эту позицию, не принимается. Если limit опущен или равен nil, по умолчанию используется конец доступной части буфера.

Действие re-search-forward при неудачном поиске зависит от значения noerror:

nil

Выдать ошибку search-failed.

t

Ничего не делать и вернуть nil.

любое другое значение

Переместить точку в limit (или в конец доступной части буфера) и вернуть nil.

Аргумент noerror влияет только на корректные поиски, в которых не удалось найти совпадение. Некорректные аргументы вызывают ошибки независимо от значения noerror.

Если count — положительное число n, поиск выполняется n раз; каждый следующий поиск начинается в конце предыдущего совпадения. Если все эти последовательные поиски успешны, вызов функции завершается успешно, перемещая точку и возвращая её новое значение. В противном случае вызов функции завершается неудачно; результат зависит от значения noerror, как описано выше. Если count — отрицательное число −n, поиск выполняется n раз в противоположном (обратном) направлении.

В следующем примере точка изначально находится перед «T». Выполнение вызова поиска перемещает точку в конец этой строки (между «t» в «hat» и символом новой строки).

---------- Buffer: foo ----------
I read "∗The cat in the hat
comes back" twice.
---------- Buffer: foo ----------

(re-search-forward "[a-z]+" nil t 5)
     ⇒ 27

---------- Buffer: foo ----------
I read "The cat in the hat∗
comes back" twice.
---------- Buffer: foo ----------

Команда: re-search-backward regexp &optional limit noerror count

Эта функция выполняет поиск назад в текущем буфере строки текста, соответствующей регулярному выражению regexp, оставляя точку в начале первого найденного фрагмента текста.

Эта функция аналогична re-search-forward, но они не являются точными зеркальными отражениями друг друга. re-search-forward находит совпадение, начало которого находится как можно ближе к начальной точке. Если бы re-search-backward была точным зеркальным отражением, она находила бы совпадение, конец которого находится как можно ближе. Однако на самом деле она находит совпадение, начало которого находится как можно ближе (и конец которого при этом расположен перед начальной точкой). Причина в том, что поиск соответствия регулярному выражению в заданной позиции всегда выполняется от начала к концу и начинается с указанной начальной позиции.

Точное зеркальное отражение re-search-forward потребовало бы специальной возможности сопоставления регулярных выражений от конца к началу. Реализовывать её нецелесообразно.

Функция: string-match regexp string &optional start inhibit-modify

Эта функция возвращает индекс начала первого совпадения регулярного выражения regexp в string или nil, если совпадений нет. Если start не равен nil, поиск начинается с этого индекса в string.

Например,

(string-match
 "quick" "The quick brown fox jumped quickly.")
     ⇒ 4

(string-match
 "quick" "The quick brown fox jumped quickly." 8)
     ⇒ 27

Индекс первого символа строки равен 0, индекс второго символа — 1 и так далее.

По умолчанию, если эта функция находит совпадение, индекс первого символа после него доступен как (match-end 0). См. Данные о совпадении. Если inhibit-modify не равен nil, данные о совпадении не изменяются.

(string-match
 "quick" "The quick brown fox jumped quickly." 8)
     ⇒ 27

(match-end 0)
     ⇒ 32

Функция: string-match-p regexp string &optional start

Эта функция-предикат выполняет то же, что и string-match, но не изменяет данные о совпадении.

Функция: looking-at regexp &optional inhibit-modify

Эта функция определяет, соответствует ли регулярному выражению regexp текст в текущем буфере непосредственно после точки. «Непосредственно после» означает именно это: поиск «привязан» и может быть успешным, только если начинается с первого символа после точки. Если это так, результат — t, в противном случае — nil.

Эта функция не перемещает точку, но обновляет данные о совпадении (если inhibit-modify равен nil или не указан, что является значением по умолчанию). См. Данные о совпадении. Для удобства вместо аргумента inhibit-modify можно использовать looking-at-p, описанную ниже.

В этом примере точка находится непосредственно перед «T». Если бы она находилась где-либо ещё, результатом было бы nil.

---------- Buffer: foo ----------
I read "∗The cat in the hat
comes back" twice.
---------- Buffer: foo ----------

(looking-at "The cat in the hat$")
     ⇒ t

Функция: looking-back regexp limit &optional greedy

Эта функция возвращает t, если regexp соответствует тексту непосредственно перед точкой (то есть заканчивается в точке), и nil в противном случае.

Поскольку сопоставление регулярных выражений работает только в направлении вперёд, эта функция реализована как поиск назад от точки совпадения, заканчивающегося в точке. Если приходится искать на большом расстоянии, это может быть довольно медленно. Можно ограничить время поиска, указав значение limit, не равное nil; это запрещает поиск перед limit. В этом случае найденное совпадение должно начинаться в позиции limit или после неё. Например:

---------- Buffer: foo ----------
I read "∗The cat in the hat
comes back" twice.
---------- Buffer: foo ----------

(looking-back "read \"" 3)
     ⇒ t
(looking-back "read \"" 4)
     ⇒ nil

Если greedy не равен nil, эта функция расширяет совпадение назад настолько, насколько возможно, останавливаясь, когда ещё один предыдущий символ уже не может входить в совпадение с regexp. Если совпадение расширяется, его начало может находиться перед limit.

В целом старайтесь по возможности не использовать looking-back, поскольку эта функция работает медленно. По этой причине планов добавлять функцию looking-back-p нет.

Функция: looking-at-p regexp

Эта функция-предикат работает как looking-at, но не обновляет данные о совпадении.

Переменная: search-spaces-regexp

Если эта переменная не равна nil, её значением должно быть регулярное выражение, задающее способ поиска пробельных символов. В этом случае любая группа пробелов в регулярном выражении, используемом для поиска, означает применение этого регулярного выражения. Однако пробелы внутри таких конструкций, как «[…]» и «*», «+», «?», не затрагиваются search-spaces-regexp.

Поскольку эта переменная влияет на все конструкции поиска и сопоставления с регулярными выражениями, временно привязывайте её на как можно меньшем участке кода и только там, где затронутый привязкой код Lisp выполняет поиск с регулярным выражением, сформированным из интерактивного пользовательского ввода. Иными словами, эту переменную следует использовать только для того, чтобы сообщить примитивам поиска по регулярным выражениям, как интерпретировать пробельные символы, введённые пользователем.