perlreapi - Интернет в облаке

ПРОГРАММА:

ИМЯ

perlreapi - интерфейс плагина регулярных выражений Perl

ОПИСАНИЕ

Начиная с Perl 5.9.5 появился новый интерфейс для подключения и использования регулярных выражений.
двигатели, отличные от установленного по умолчанию.

Предполагается, что каждый движок предоставляет доступ к постоянной структуре следующего формата:

typedef struct regexp_engine {
REGEXP * (* comp) (pTHX_
const SV * шаблон const, флаги const U32);
I32 (* exec) (pTHX_
REGEXP * константа rx,
char * stringarg,
символ * поток, символ * strbeg,
SSize_t minend, SV * sv,
void * data, флаги U32);
символ * (* интуитивно) (pTHX_
REGEXP * const rx, SV * sv,
константный символ * константный стрбег,
char * strpos, char * strend, флаги U32,
struct re_scream_pos_data_s * данные);
SV * (* checkstr) (pTHX_ REGEXP * const rx);
void (* бесплатно) (pTHX_ REGEXP * const rx);
void (* numbered_buff_FETCH) (pTHX_
REGEXP * константа rx,
константа I32 парен,
СВ * const СВ);
void (* numbered_buff_STORE) (pTHX_
REGEXP * константа rx,
константа I32 парен,
SV const * значение const);
I32 (* numbered_buff_LENGTH) (pTHX_
REGEXP * константа rx,
константа СВ * константа СВ,
константа I32 парен);
SV * (* named_buff) (pTHX_
REGEXP * константа rx,
Клавиша SV * const,
SV * значение const,
Флаги U32);
SV * (* named_buff_iter) (pTHX_
REGEXP * константа rx,
const SV * const последний ключ,
флаги const U32);
SV * (* qr_package) (pTHX_ REGEXP * const rx);
#ifdef USE_ITHREADS
void * (* dupe) (pTHX_ REGEXP * const rx, CLONE_PARAMS * param);
#endif
REGEXP * (* op_comp) (...);

Когда регулярное выражение компилируется, его поле "engine" устанавливается так, чтобы указывать на соответствующий
структура, так что, когда ее нужно использовать, Perl может найти для этого подходящие процедуры.

Чтобы установить новый обработчик регулярных выражений, $ ^ H {regcomp} устанавливается в целое число, которое (когда
приведен соответствующим образом) разрешается в одну из этих структур. При компиляции "комп"
выполняется, и ожидается, что поле движка результирующей структуры "regexp"
укажите на ту же структуру.

Символ pTHX_ в определении - это макрос, используемый Perl при потоковой передаче, чтобы обеспечить
дополнительный аргумент подпрограммы, удерживающий указатель обратно на интерпретатор, который выполняет
регулярное выражение. Таким образом, при распараллеливании все подпрограммы получают дополнительный аргумент.

Обратные вызовы

комп
REGEXP * comp (pTHX_ const SV * const pattern, const U32 flags);

Скомпилируйте шаблон, хранящийся в "шаблоне", используя данные "флаги" и верните указатель на
подготовлена ​​структура "REGEXP", которая может провести матч. См. «Структура REGEXP» ниже.
для объяснения отдельных полей в структуре REGEXP.

Параметр "шаблон" - это скаляр, который использовался в качестве шаблона. Предыдущие версии
Perl передаст два символа «char *», указывающие начало и конец строкового шаблона; в
следующий фрагмент можно использовать для получения старых параметров:

СТРЛЕН пленка;
char * exp = SvPV (узор, пленка);
char * xend = exp + plen;

Поскольку в качестве шаблона можно передать любой скаляр, можно реализовать движок, который
что-то делает с массивом ("" ook "= ~ [qw / eek hlagh /]") или с нестроковым
форма скомпилированного регулярного выражения ("" ook "= ~ qr / eek /"). Собственный движок Perl всегда
структурировать все, используя приведенный выше фрагмент, но это не означает, что другие движки должны это делать.

Параметр «flags» - это битовое поле, которое указывает, какой из «msixpn» помечает регулярное выражение.
был скомпилирован с помощью. Он также содержит дополнительную информацию, например, если "использовать языковой стандарт" находится в
Эффект.

Флаги "eogc" удаляются перед передачей в процедуру comp. Регулярное выражение
движку не нужно знать, установлены ли какие-либо из них, поскольку эти флаги должны влиять только на
что Perl делает с шаблоном и его переменными соответствия, а не как он компилируется и
казнены.

К моменту вызова обратного вызова comp некоторые из этих флагов уже действуют.
(указано ниже, если применимо). Однако большая часть их эффекта происходит после приема композиции.
обратный вызов выполнен в подпрограммах, которые читают поле "rx-> extflags", которое он заполняет.

Как правило, после компиляции флаги должны быть сохранены в "rx-> extflags", хотя
механизм регулярных выражений может захотеть добавить или удалить некоторые из них, чтобы вызвать или отключить некоторые специальные
поведение в Perl. Флаги и любое вызываемое ими особое поведение задокументированы.
ниже:

Модификаторы узора:

"/ м" - RXf_PMf_MULTILINE
Если это находится в «rx-> extflags», он будет передан в «Perl_fbm_instr» с помощью «pp_split», который
будет рассматривать строку темы как многострочную строку.

"/ с" - RXf_PMf_SINGLELINE
"/ i" - RXf_PMf_FOLD
"/ x" - RXf_PMf_EXTENDED
Комментарии "#", если они присутствуют в регулярном выражении, будут обрабатываться токенизатором по-разному в
некоторые случаи.

TODO: Задокументируйте эти случаи.

"/ p" - RXf_PMf_KEEPCOPY
ЗАДАЧА: Задокументируйте это

Набор символов
Правила набора символов определяются перечислением, содержащимся в этом поле.
Это все еще экспериментально и может быть изменено, но текущий интерфейс возвращается
правила с помощью встроенной функции "get_regex_charset (const U32 flags)". В
только в настоящее время из него возвращается задокументированное значение REGEX_LOCALE_CHARSET, которое установлено
если действует "использовать локаль". Если присутствует в «rx-> extflags», «split» будет использовать
определение пробела, зависящее от локали, когда RXf_SKIPWHITE или RXf_WHITE находится в
эффект. Пробелы ASCII определяются в соответствии с isSPACE и внутренними макросами
«is_utf8_space» в UTF-8 и «isSPACE_LC» в «использовать локаль».

Дополнительные флаги:

RXf_SPLIT
Этот флаг был удален в perl 5.18.0. "split" "теперь применяется только в специальном корпусе
парсер. RXf_SPLIT по-прежнему #defined, поэтому вы можете проверить его. Вот как это было раньше
Работа:

Если «split» вызывается как «split ''» или без аргументов (что на самом деле означает «split ('
', $ _) ", см. разделение), Perl установит этот флаг. Механизм регулярных выражений может проверить его.
и установите внешние флаги SKIPWHITE и WHITE. Для этого движок Perl:

если (флаги & RXf_SPLIT && r-> prelen == 1 && r-> precomp [0] == '')
r-> extflags | = (RXf_SKIPWHITE | RXf_WHITE);

Эти флаги можно установить во время компиляции, чтобы включить оптимизацию в операторе «split».

RXf_SKIPWHITE
Этот флаг был удален в perl 5.18.0. Он по-прежнему # определен, поэтому вы можете его установить, но
это ни на что не повлияет. Вот как это работало раньше:

Если флаг присутствует в "rx-> extflags", "split" удалит пробелы с самого начала
строки темы до того, как она будет обработана. Что считается пробелом, зависит
включен, если тема является строкой UTF-8 и установлен флаг "RXf_PMf_LOCALE".

Если RXf_WHITE установлен в дополнение к этому флагу, "split" будет вести себя как "split" ""
под движком Perl.

RXf_START_ONLY
Сообщает оператору разделения разделить целевую строку на новые строки ("\ n") без
вызов механизма регулярных выражений.

Механизм Perl устанавливает это, если шаблон - "/ ^ /" ("plen == 1 && * exp == '^'"), даже
под "/ ^ / s"; см. разделение. Конечно, другой движок регулярных выражений может захотеть использовать
те же оптимизации с другим синтаксисом.

RXf_WHITE
Сообщает оператору разделения разделить целевую строку на пробелы без вызова
движок регулярных выражений. Определение пробелов зависит от того, если целевая строка
является строкой UTF-8 и включен, если установлен RXf_PMf_LOCALE.

Движок Perl устанавливает этот флаг, если используется шаблон «\ s +».

RXf_NULL
Сообщает оператору разделения разделить целевую строку на символы. Определение
зависит от того, является ли целевая строка строкой UTF-8.

Движок Perl устанавливает этот флаг для пустых шаблонов, эта оптимизация делает "split //"
намного быстрее, чем могло бы быть иначе. Это даже быстрее, чем «распаковать».

RXf_NO_INPLACE_SUBST
Этот флаг, добавленный в perl 5.18.0, указывает, что регулярное выражение может выполнять
операция, которая может помешать замене на месте. Например, это могло бы
содержать просмотр назад или присваивать немагические переменные (например, $ REGMARK и
$ REGERROR) во время сопоставления. "s ///" пропустит некоторые оптимизации, когда это установлено.

Exec
I32 exec (pTHX_ REGEXP * const rx,
char * stringarg, char * strend, char * strbeg,
SSize_t minend, SV * sv,
void * data, флаги U32);

Выполнить регулярное выражение. Аргументы

rx Регулярное выражение для выполнения.

sv Это SV, с которым нужно сравнивать. Обратите внимание, что фактический массив символов, который должен быть сопоставлен
против обеспечивается аргументами, описанными ниже; SV используется только для определения
UTF8ness, pos () и т. Д.

стрбег
Указатель на физическое начало строки.

прядь
Указатель на символ, следующий за физическим концом строки (т. Е. "\ 0", если
любой).

Stringarg
Указатель на позицию в строке, с которой должно начинаться сопоставление; это может не быть
равно "strbeg" (например, в более поздней итерации "/.../g").

минд
Минимальная длина строки (измеряется в байтах от "stringarg"), которая должна совпадать; если
Движок достигает конца совпадения, но не достиг этой позиции в строке, он
должен потерпеть неудачу.

данным
Данные оптимизации; могут быть изменены.

Флаги
Флаги оптимизации; могут быть изменены.

постигать интуитивно
char * intuit (pTHX_
REGEXP * константа rx,
СВ * св,
константный символ * константный стрбег,
char * strpos,
char * strend,
const флаги U32,
struct re_scream_pos_data_s * данные);

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

Аргументы:

rx: регулярное выражение для сопоставления
sv: соответствующий SV: используется только для флага utf8; Струна
доступ к самому себе осуществляется через указатели ниже. Обратите внимание, что на
что-то вроде перегруженного SV, SvPOK (sv) может быть ложным
и строковые указатели могут указывать на что-то, не имеющее отношения к
сам SV.
strbeg: реальное начало строки
strpos: точка в строке, с которой начинается сопоставление
strend: указатель на байт, следующий за последним символом строки
флаги в настоящее время не используются; установить на 0
данные: в настоящее время не используются; установить в NULL

контрольная улица
SV * checkstr (pTHX_ REGEXP * const rx);

Вернуть SV, содержащий строку, которая должна появиться в шаблоне. Используется "split" для
оптимизация матчей.

бесплатно
без пустот (pTHX_ REGEXP * const rx);

Вызывается Perl, когда он освобождает шаблон регулярного выражения, чтобы движок мог освободить любой
ресурсы, на которые указывает член "pprivate" структуры "regexp". Это только
отвечает за освобождение личных данных; Perl справится с выпуском всего, что содержится
в структуре "регулярное выражение".

нумерованный захватить обратные вызовы
Вызывается для получения / установки значений "$` "," $ '", $ & и их именованных эквивалентов, $ {^ PREMATCH},
$ {^ POSTMATCH} и $ {^ MATCH}, а также пронумерованные группы захвата ($ 1, $ 2, ...).

Параметр "paren" будет иметь значение 1 для $ 1, 2 для $ 2 и т. Д. И будет иметь эти символические
значения для специальных переменных:

$ {^ PREMATCH} RX_BUFF_IDX_CARET_PREMATCH
$ {^ POSTMATCH} RX_BUFF_IDX_CARET_POSTMATCH
$ {^ MATCH} RX_BUFF_IDX_CARET_FULLMATCH
$ `RX_BUFF_IDX_PREMATCH
$ 'RX_BUFF_IDX_POSTMATCH
$ & RX_BUFF_IDX_FULLMATCH

Обратите внимание, что в Perl 5.17.3 и ранее последние три константы также использовались для
каретки варианты переменных.

Имена выбраны по аналогии с именами методов Tie :: Scalar с дополнительным
ДЛИНА обратный звонок для эффективности. Однако именованные переменные захвата в настоящее время не привязаны
внутренне, но реализовано с помощью магии.

Numbered_buff_FETCH

void numbered_buff_FETCH (pTHX_ REGEXP * const rx, const I32 paren,
СВ * const СВ);

Получите заданный пронумерованный захват. "sv" должен быть установлен на скаляр для возврата,
скаляр передается как аргумент, а не возвращается из функции, потому что когда
он называется Perl уже имеет скаляр для хранения значения, создание другого будет
избыточный. Скаляр может быть установлен с помощью sv_setsv, sv_setpvn и других, см. Perlapi.

В этом обратном вызове Perl удаляет свои собственные переменные захвата в режиме taint (см.
перлсек). См. Функцию "Perl_reg_numbered_buff_fetch" в regcomp.c для того, как освободить
захватывать переменные, если вы хотите, чтобы ваш движок тоже делал это.

Numbered_buff_STORE

void (* numbered_buff_STORE) (pTHX_
REGEXP * константа rx,
константа I32 парен,
SV const * значение const);

Установите значение пронумерованной переменной захвата. "значение" - это скаляр, который должен использоваться как
новое значение. Двигатель должен убедиться, что это используется как новое значение (или
отклонить его).

Пример:

if ("ook" = ~ / (o *) /) {
# 'paren' будет '1', а 'value' будет 'ee'
$ 1 = ~ tr / o / e /;
}

Собственный движок Perl будет квакать при любой попытке изменить переменные захвата, чтобы сделать это в
другой движок использует следующий обратный вызов (скопирован из Perl_reg_numbered_buff_store):

аннулировать
Example_reg_numbered_buff_store (pTHX_
REGEXP * константа rx,
константа I32 парен,
SV const * значение const)
{
PERL_UNUSED_ARG (rx);
PERL_UNUSED_ARG (скобка);
PERL_UNUSED_ARG (значение);

если (! PL_localizing)
Perl_croak (aTHX_ PL_no_modify);
}

На самом деле Perl не будет всегда каркать в заявлении, которое выглядит так, будто оно изменяет
нумерованная переменная захвата. Это потому, что обратный вызов STORE не будет вызываться, если Perl
может определить, что изменять значение не нужно. Это именно то, как завязано
переменные ведут себя в такой же ситуации:

пакет CaptureVar;
используйте родительский 'Tie :: Scalar';

sub TIESCALAR {благослови []}
sub FETCH {undef}
sub STORE {die "Это не называется"}

основной пакет;

привяжите мой $ sv => "CaptureVar";
$ sv = ~ y / a / b /;

Поскольку $ sv имеет значение undef, когда к нему применяется оператор y ///, транслитерация
на самом деле не будет выполняться, и программа не «умрет». Это отличается от того, как 5.8 и
более ранние версии вели себя, поскольку тогда переменные захвата были переменными ТОЛЬКО ДЛЯ ЧТЕНИЯ; в настоящее время
они просто умрут, если назначены в движке по умолчанию.

Numbered_buff_LENGTH

I32 Numbered_buff_LENGTH (pTHX_
REGEXP * константа rx,
константа СВ * константа СВ,
константа I32 парен);

Получите «длину» переменной захвата. Для этого есть специальный обратный вызов, чтобы Perl
не нужно выполнять FETCH и запускать "length" для результата, так как длина (в Perl
case), известное из смещения, хранящегося в "rx-> offs", это намного эффективнее:

I32 s1 = rx-> offs [парен] .start;
I32 s2 = rx-> offs [парен] .end;
I32 лен = t1 - s1;

В случае с UTF-8 это немного сложнее, посмотрите, что
Perl_reg_numbered_buff_length работает с is_utf8_string_loclen.

Названный захватить обратные вызовы
Вызывается для получения / установки значений «% +» и «% -», а также некоторыми служебными функциями в re.

Есть два обратных вызова: named_buff вызывается во всех случаях: FETCH, STORE, DELETE,
Обратные вызовы CLEAR, EXISTS и SCALAR Tie :: Hash будут при изменении «% +» и «% -» и
"named_buff_iter" в тех же случаях, что и FIRSTKEY и NEXTKEY.

Параметр «flags» может использоваться, чтобы определить, какие из этих операций выполняются обратными вызовами.
должен ответить на. В настоящее время определены следующие флаги:

Какая операция Tie :: Hash выполняется с уровня Perl на «% +» или «% +», если есть:

RXapif_FETCH
RXapif_STORE
RXapif_DELETE
RXapif_CLEAR
RXapif_EXISTS
RXapif_SCALAR
RXapif_FIRSTKEY
RXapif_NEXTKEY

Если работает "% +" или "% -", если есть.

RXapif_ONE / *% + * /
RXapif_ALL / *% - * /

Если это вызывается как «re :: regname», «re :: regnames» или «re :: regnames_count», если есть.
Первые два будут объединены с «RXapif_ONE» или «RXapif_ALL».

RXapif_REGNAME
RXapif_REGNAMES
RXapif_REGNAMES_COUNT

Внутри "% +" и "% -" реализованы с помощью реального связанного интерфейса через
Связь :: Хеш :: NamedCapture. Методы в этом пакете будут вызывать эти функции.
Однако использование Tie :: Hash :: NamedCapture для этой цели может измениться в будущем.
выпускает. Например, вместо этого это может быть реализовано с помощью магии (потребуется
расширение до mgvtbl).

именованный_бафф

SV * (* named_buff) (pTHX_ REGEXP * const rx, SV * const ключ,
SV * const значение, флаги U32);

именованный_buff_iter

SV * (* named_buff_iter) (pTHX_
REGEXP * константа rx,
const SV * const последний ключ,
флаги const U32);

qr_package
SV * qr_package (pTHX_ REGEXP * const rx);

Пакет, в который благословлен магический объект qr // (как видно из "ref qr //"). это
рекомендуется, чтобы движки изменили это имя на свое имя пакета для идентификации независимо от того,
если они реализуют методы для объекта.

Пакет, возвращаемый этим методом, также должен содержать внутренний пакет «Regexp».
@ЭТО. "qr // -> isa (" Regexp ")" всегда должно быть истинным, независимо от того, какой движок
используемый.

Пример реализации может быть:

SV *
Example_qr_package (pTHX_ REGEXP * const rx)
{
PERL_UNUSED_ARG (rx);
return newSVpvs ("re :: engine :: Example");
}

Любые вызовы методов для объекта, созданного с помощью qr //, будут отправлены в пакет как
нормальный объект.

используйте re :: engine :: Example;
мой $ re = qr //;
$ ре-> мет; # отправляется в re :: engine :: Example :: meth ()

Чтобы получить объект «REGEXP» из скаляра в функции XS, используйте макрос «SvRX»,
см. «Функции REGEXP» в perlapi.

пустой метамфетамин (SV * rv)
ППКОД:
REGEXP * re = SvRX (св);

простофиля
void * dupe (pTHX_ REGEXP * const rx, CLONE_PARAMS * param);

В многопоточных сборках может потребоваться дублирование регулярного выражения, чтобы шаблон мог использоваться
несколько потоков. Ожидается, что эта процедура будет обрабатывать дублирование любых личных данных.
на который указывает член "pprivate" структуры "regexp". Он будет вызываться с
предварительно сконструированная новая структура "regexp" в качестве аргумента, член "pprivate" будет указывать на
старый частная структура, и эта процедура отвечает за создание копии и
вернуть на него указатель (который Perl затем будет использовать для перезаписи поля, переданного этому
рутина.)

Это позволяет движку обмануть свои личные данные, но также, если необходимо, изменить окончательные
структура, если это действительно необходимо.

В сборках без ниток это поле отсутствует.

op_comp
Это является частным для ядра Perl и может быть изменено. Следует оставить нулевым.

" REGEXP Структура

Структура REGEXP определена в регулярное выражение.h. Все механизмы регулярных выражений должны уметь правильно
строят такую ​​структуру в их "комп" рутине.

Структура REGEXP содержит все данные, которые Perl должен знать для правильной работы.
с регулярным выражением. Он включает данные об оптимизации, которые Perl может использовать для
определить, действительно ли следует использовать механизм регулярных выражений, и другую другую управляющую информацию, которая
необходим для правильного выполнения шаблонов в различных контекстах, например, если шаблон
закреплены каким-либо образом, или какие флаги использовались во время компиляции, или если программа
содержит специальные конструкции, о которых Perl должен знать.

Кроме того, он содержит два поля, которые предназначены для частного использования регулярного выражения.
двигатель, составивший шаблон. Это члены "intflags" и "pprivate".
"pprivate" - это недействительный указатель на произвольную структуру, использование и управление которой являются
ответственность компилирующего движка. Perl никогда не будет изменять ни одно из этих значений.

typedef структура регулярное выражение {
/ * какой движок создал это регулярное выражение? * /
const struct regexp_engine * двигатель;

/ * что это за облегченная копия? * /
struct regexp * mother_re;

/ * Информация о совпадении, которое ядро ​​Perl использует для управления
* вещи */
U32 extflags; / * Флаги, используемые как для внешнего, так и для внутреннего использования * /
I32 minlen; / * минимальное возможное количество символов в * /
строка для соответствия * /
I32 minlenret; / * минимальное возможное количество символов в $ & * /
U32 гофс; / * символы слева от позиции, которую мы ищем * /

/ * подстрока данных о строках, которые должны появиться
в финальном матче, используется для оптимизации * /
struct reg_substr_data * substrs;

U32 nparens; / * количество групп захвата * /

/ * данные, специфичные для частного движка * /
U32 intflags; / * Внутренние флаги, специфичные для движка * /
void * pprivate; / * Данные, принадлежащие механизму регулярных выражений, который
создал этот объект. * /

/ * Данные о последнем / текущем совпадении. Они изменяются во время
* соответствие * /
U32 lastparen; / * совпадение наивысшего близкого парена ($ +) * /
U32 lastcloseparen; / * последний совпавший закрывающий парен ($ ^ N) * /
regexp_paren_pair * своп; / * Поменять местами копию * офф * /
regexp_paren_pair * offs; / * Массив смещений для (@ -) и
(@ +) * /

char * subbeg; / * сохраненная или исходная строка, поэтому работает \ digit
навсегда. * /
SV_SAVED_COPY / * Если не NULL, SV, который является COW из оригинала * /
I32 субаренда; / * Длина строки, на которую указывает subbeg * /
Подсмещение I32; / * байтовое смещение subbeg от логического начала
str * /
Субсмещение I32; / * эквивалент субсмещения, но в символах (для @ - / @ +) * /

/ * Информация о совпадении, которая используется не часто * /
I32 prelen; / * длина прекомпенсации * /
const char * precomp; / * регулярное выражение перед компиляцией * /

char * завернутый; / * версия паттерна в оболочке * /
I32 wraplen; / * длина обертки * /

I32 seen_evals; / * количество eval-групп в шаблоне - для
проверки безопасности * /
HV * paren_names; / * Необязательный хэш имен паренов * /

/ * Refcount этого регулярного выражения * /
I32 refcnt; / * Refcount этого регулярного выражения * /
} регулярное выражение;

Поля обсуждаются более подробно ниже:

"двигатель"
Это поле указывает на структуру regexp_engine, которая содержит указатели на
подпрограммы, которые должны использоваться для выполнения сопоставления. Это процедура компиляции
ответственность за заполнение этого поля перед возвратом объекта регулярного выражения.

Внутренне установлено значение "NULL", если пользовательский движок не указан в $ ^ H {regcomp},
Собственный набор обратных вызовов Perl доступен в структуре, на которую указывает "RE_ENGINE_PTR".

"мать_ре"
TODO, см.http://www.mail-archive.com/perl5-changes@ perl.org / msg17328.html>

"extflags"
Это будет использоваться Perl, чтобы увидеть, с какими флагами было скомпилировано регулярное выражение, это будет
обычно устанавливается равным значению параметра flags обратным вызовом comp. Посмотреть комп
документация по действующим флагам.

"минлен" "минленрет"
Минимальная длина строки (в символах), необходимая для соответствия шаблону. Это используется
чтобы сократить пространство поиска, не беспокоясь о поиске ближе к концу строки, чем
позволил бы матч. Например, нет смысла даже запускать движок регулярных выражений, если
minlen - 10, но строка всего 5 символов. Нет никакого способа, чтобы
шаблон может совпадать.

"minlenret" - это минимальная длина (в символах) строки, которая может быть найдена в $ &
после матча.

Разницу между «минленом» и «минленретом» можно увидеть в следующем шаблоне:

/ нс (? = \ d) /

где minlen будет 3, а minlenret только 2, поскольку \ d требуется для
совпадают, но фактически не включаются в совпадающий контент. Это различие
особенно важно, поскольку логика подстановки использует "минленрет", чтобы определить, может ли он
замены на месте (это может привести к значительному ускорению).

"гофс"
Смещение влево от pos () чтобы начать матч в.

"подстроки"
Данные подстроки о строках, которые должны появиться в окончательном совпадении. В настоящее время это только
используется внутри движка Perl, но может быть использован в будущем для всех движков для
оптимизации.

"nparens", "lastparen", и "lastcloseparen"
Эти поля используются для отслеживания того, сколько родительских групп можно сопоставить в
шаблон, который был последним открытым пареном, который нужно ввести, и который был последним закрытым паром
быть введенным.

"intflags"
Личная копия флагов движка, с которыми был скомпилирован паттерн. Обычно это
то же, что и "extflags", если только движок не изменил один из них.

"частный"
Пустота *, указывающая на структуру данных, определяемую механизмом. Движок Perl использует
структура "regexp_internal" (см. "Базовые структуры" в perlreguts), но настраиваемый движок
следует использовать что-нибудь еще.

"поменять местами"
Не используется. Оставлено для совместимости с Perl 5.10.0.

"офф"
Структура "regexp_paren_pair", которая определяет смещения в сопоставляемой строке, которая
соответствуют захватам $ & и $ 1, $ 2 и т. д., определяется структура "regexp_paren_pair"
следующим образом:

typedef структура regexp_paren_pair {
И32 пуск;
I32 конец;
} regexp_paren_pair;

Если "-> offs [num] .start" или "-> offs [num] .end" равно "-1", то эта группа захвата не соответствует.
"-> offs [0] .start / end" представляет $ & (или "$ {^ MATCH}" под "// p") и "-> offs [paren] .end"
соответствует $$ paren, где $ paren = 1>.

"precomp" "прелен"
Используется для оптимизации. "precomp" содержит копию скомпилированного паттерна и
"прелен" его длина. Когда должен быть скомпилирован новый паттерн (например, внутри цикла),
внутренний оператор "regcomp" проверяет, скомпилированы ли "precomp" и "prelen" последнего скомпилированного "REGEXP"
эквивалентны новому, и если да, то использует старый шаблон вместо компиляции нового
вариант.

Соответствующий фрагмент из Perl_pp_regcomp:

if (! re ||! re-> precomp || re-> prelen! = (I32) len ||
memNE (re-> precomp, t, len))
/ * Компилируем новый паттерн * /

"paren_names"
Это хэш, используемый внутри для отслеживания именованных групп захвата и их смещений. Ключи
- это имена буферов, значения - двойные переменные, причем слот IV содержит номер
буферов с заданным именем, а pv - это встроенный массив I32. Ценности могут
также независимо содержаться в массиве данных в случаях, когда именованные обратные ссылки
используемый.

"подстроки"
Содержит информацию о самой длинной строке, которая должна встречаться с фиксированным смещением от начала.
шаблона и самая длинная строка, которая должна встречаться при плавающем смещении от начала
выкройки. Используется для поиска по строке Fast-Boyer-Moore, чтобы выяснить,
Стоит вообще использовать механизм регулярных выражений, и если да, то где в строке искать.

"суббег" "субаренда" "сохраненная_копия" "субсмещение" "субсмещение"
Используется на этапе выполнения для управления шаблонами поиска и замены, а также для
предоставление текста для $ &, $ 1 и т. д. "subbeg" указывает на буфер (либо исходный
строка или копия в случае «RX_MATCH_COPIED (rx)»), а «subblen» - длина
буфер. Начальный и конечный индексы RX_OFFS помещаются в этот буфер.

При наличии флага «REXEC_COPY_STR», но с добавлением
Флаги "REXEC_COPY_SKIP_PRE" или "REXEC_COPY_SKIP_POST", механизм может выбрать не копировать
полный буфер (хотя он все равно должен делать это при наличии "RXf_PMf_KEEPCOPY" или
соответствующие биты устанавливаются в "PL_sawampersand"). В этом случае он может установить "suboffset" на
указать количество байтов от логического начала буфера до физического начала
(т.е. «суббег»). Также следует установить «subcoffset», количество символов в смещении.
Последний необходим для поддержки «@ -» и «@ +», которые работают в символах, а не в байтах.

"завернутый" "обертка"
Сохраняет строку "qr //", преобразующуюся в. Например, движок Perl сохраняет "(? ^: Eek)" в
случай «qr / eek /».

При использовании специального механизма, который не поддерживает конструкцию "(? :)" для встроенных модификаторов,
вероятно, лучше всего, чтобы "qr //" преобразовывала в строку для предоставленного шаблона, обратите внимание, что это будет
создавать нежелательные шаблоны в таких случаях, как:

мой $ x = qr / a | b /; # "a | b"
мой $ y = qr / c / i; # "с"
мой $ z = qr / $ x $ y /; # "a | bc"

У этой проблемы нет другого решения, кроме как заставить настраиваемый движок понимать
построить как "(? :)".

"seen_evals"
Это сохраняет количество групп eval в шаблоне. Это используется в целях безопасности
при встраивании скомпилированных регулярных выражений в более крупные шаблоны с помощью «qr //».

"refcnt"
Количество ссылок на структуру. Когда он упадет до 0, регулярное выражение будет
автоматически освобождается при вызове pregfree. Это должно быть установлено на 1 в каждом двигателе.
"комп" рутина.

ИСТОРИЯ

Первоначально входил в состав перлрегутс.

АВТОРЫ

Первоначально написано Ивом Ортоном, дополнено Эваром Арнфьор` Бьярмасоном.

Используйте perlreapi онлайн с помощью сервисов onworks.net