perl: cómo obtener la expresión original de la versión precompilada?

Question

código simple:

use 5.014; 
use warnings; 

my $re = <DATA>; 
chomp $re; 
my $re2 = qr/$re/; 
say $re2; 
__END__ 
^\w$ 

resultado:

(?^u:^\w$)  #added the (?^u: 

Es cualquier forma correcta de descompilar $ RE2 volver a la expresión regular original?

motivación: la expresión regular es un valor de configuración, por lo que necesitan:

• leyó
• compila
• guardarla en el archivo para el uso posterior.

Pero no puede salvar la expresión regular compilada para el uso posterior, porque en cada compilar la expresión regular consiguió ampliado con la (^ u :, así que después de varios ciclos i terminó con como:?

(?^u:(?^u:(?^u:(?^u:(?^u:^\w$))))) 

por lo tanto, la cuestión son:

• es aquí en cualquier forma correcta, cómo guardar la versión compilada
• si hay manera - como descompilar, para obtener la versión original
01??
• alguna idea?

Answer 1

Mientras que me limitaría a guardar la copia de cadena para el uso de datos, y luego compilar una copia cuando necesité usarla, también puede usar la función regexp_pattern del módulo re para devolver el patrón utilizado para crear un compilado expresiones regulares:

use re 'regexp_pattern'; 

print regexp_pattern qr/^\w$/; 

impresiones

^\w$ 

Answer 2

re::regexp_pattern

Créditos a vpit por señalar esto en MagNET #perl.

Answer 3

Tal vez tan simple como:

... 
($reoriginal = $re2) =~ s{^\(\?.+:(.+)\)}{$1}; 
say $reoriginal 

Answer 4

El original es un operador , no es un patrón de expresiones regulares. Solo mirando el primer valor devuelto por regexp_pattern (el patrón) resulta en pérdida de información. También necesita mirar el segundo (los indicadores).

qr/foo/     # pat: foo flags: u 
qr/foo/u     # pat: foo flags: u 
use re '/u'; qr/foo/ # pat: foo flags: u 

qr/foo/a     # pat: foo flags: a 
use re '/a'; qr/foo/ # pat: foo flags: a 

qr/foo/i     # pat: foo flags: ui 
use re '/i'; qr/foo/ # pat: foo flags: ui 
use re '/a'; qr/foo/i # pat: foo flags: ai 
use re '/ai'; qr/foo/ # pat: foo flags: ai 

Para obtener el posible más cercano que puede llegar al operador original, desea

use re qw(regexp_pattern); 
my ($pat, $flags) = regexp_pattern($re); 
$pat =~ s{/}{\\/}g; 
say qq{qr/$pat/$flags};