perldebguts - Online en la nube

PROGRAMA:

NOMBRE

perldebguts - Tripas de depuración de Perl

DESCRIPCIÓN

Esto no es perldebug, que le dice cómo usar el depurador. Esta página de manual describe
detalles de bajo nivel sobre los componentes internos del depurador, que van desde difíciles hasta
imposible de entender para cualquiera que no sea increíblemente íntimo con las entrañas de Perl.
Lector de advertencias.

Depurador Internos

Perl tiene ganchos de depuración especiales en tiempo de compilación y tiempo de ejecución utilizados para crear depuración
Ambientes. Estos ganchos no deben confundirse con los perl -Dxxx comando descrito en
perlrun, que solo se puede utilizar si se crea un Perl especial según las instrucciones del
INSTALAR podpage en el árbol de fuentes de Perl.

Por ejemplo, siempre que llame a la función "llamador" incorporada de Perl desde el paquete "DB",
los argumentos con los que se llamó al marco de pila correspondiente se copian en el
@DB :: matriz de argumentos. Estos mecanismos se habilitan llamando a Perl con el -d switch.
Específicamente, las siguientes características adicionales están habilitadas (cf. "$ ^ P" en perlvar):

· Perl inserta el contenido de $ ENV {PERL5DB} (o "BEGIN {require 'perl5db.pl'}" si no
presente) antes de la primera línea de su programa.

· Cada matriz "@ {" _ <$ filename "}" contiene las líneas de $ filename para un archivo compilado por
Perl. Lo mismo ocurre con las cadenas ed "eval" que contienen subrutinas, o que
se están ejecutando actualmente. El nombre de archivo $ para las cadenas ed "eval" se parece a "(eval
34) ".

Los valores en esta matriz son mágicos en contexto numérico: se comparan solo a cero
si la línea no se puede romper.

· Cada hash "% {" _ <$ filename "}" contiene puntos de interrupción y acciones codificadas por número de línea.
Las entradas individuales (a diferencia del hash completo) se pueden configurar. Perl solo se preocupa por
Booleano verdadero aquí, aunque los valores usados ​​por perl5db.pl tener la forma
"$ break_condition \ 0 $ action".

Lo mismo se aplica a las cadenas evaluadas que contienen subrutinas, o que están actualmente
ser ejecutado. El nombre de archivo $ para las cadenas ed "eval" se parece a "(eval 34)".

· Cada escalar "$ {" _ <$ nombre de archivo "}" contiene "_ <$ nombre de archivo". Este es también el caso de
cadenas evaluadas que contienen subrutinas, o que se están ejecutando actualmente.
El nombre de archivo $ para las cadenas ed "eval" se parece a "(eval 34)".

· Después de que se compile cada archivo "requerido" d, pero antes de que se ejecute,
Se llama a "DB :: pospuesto (* {" _ <$ nombre de archivo "})" si existe la subrutina "DB :: pospuesto".
Aquí, $ filename es el nombre expandido del archivo "require" d, como se encuentra en el
valores de% INC.

· Después de que se compila cada subrutina "subnombre", la existencia de $ DB :: pospuesto {subname}
está chequeado. Si esta clave existe, se llama a "DB :: pospuesto (subnombre)" si el
También existe la subrutina "DB :: pospuesta".

· Se mantiene un hash% DB :: sub, cuyas claves son nombres de subrutina y cuyos valores tienen
el formulario "nombre de archivo: línea de inicio-línea de fin". "nombre de archivo" tiene la forma "(eval 34)" para
subrutinas definidas dentro de "eval" s.

· Cuando la ejecución de su programa alcanza un punto que puede contener un punto de interrupción, el
Se llama a la subrutina "DB :: DB ()" si alguna de las variables $ DB :: trace, $ DB :: single o
$ DB :: la señal es verdadera. Estas variables no son "locales" izables. Esta característica está deshabilitada
cuando se ejecuta dentro de "DB :: DB ()", incluidas las funciones a las que se llama a menos que "$ ^ D &
(1 << 30) "es cierto.

· Cuando la ejecución del programa alcanza una llamada de subrutina, una llamada a & DB :: sub (args) es
en su lugar, con $ DB :: sub sosteniendo el nombre de la subrutina llamada. (Esto no
sucederá si la subrutina se compiló en el paquete "DB").

Si la llamada es a una subrutina lvalue, y & DB :: lsub está definido & DB :: lsub (args) es
llamado en su lugar, de lo contrario recurriendo a & DB :: sub (args).

· Cuando la ejecución del programa usa "goto" para ingresar una subrutina que no es XS y el 0x80
bit se establece en $ ^ P, se realiza una llamada a & DB :: goto, con $ DB :: sub sosteniendo el nombre del
subrutina entrando.

Tenga en cuenta que si & DB :: sub necesita datos externos para que funcione, no es posible realizar una llamada a subrutina
sin ello. Como ejemplo, el & DB :: sub del depurador estándar depende de $ DB :: deep
variable (define cuántos niveles de recursividad en profundidad en el depurador puede ir antes
una pausa obligatoria). Si $ DB :: deep no está definido, las llamadas a subrutinas no son posibles, incluso
aunque existe & DB :: sub.

Escritura Su Propia Depurador
Medio Ambiente Variables

La variable de entorno "PERL5DB" se puede utilizar para definir un depurador. Por ejemplo, el
El depurador mínimo "en funcionamiento" (en realidad no hace nada) consta de una línea:

sub DB :: DB {}

Se puede definir fácilmente así:

$ PERL5DB = "sub DB :: DB {}" perl -d su-script

Otro depurador breve, un poco más útil, se puede crear solo con la línea:

sub DB :: DB {imprimir ++ $ i; escalar }

Este depurador imprime un número que se incrementa para cada declaración encontrada y espera
para que acceda a una nueva línea antes de continuar con la siguiente declaración.

El siguiente depurador es realmente útil:

{
paquete DB;
base de datos secundaria {}
sub sub {imprimir ++ $ i, "$ sub \ n"; & $ sub}
}

Imprime el número de secuencia de cada llamada de subrutina y el nombre de la llamada.
subrutina. Tenga en cuenta que & DB :: sub se está compilando en el paquete "DB" mediante el uso de
la directiva "paquete".

Cuando se inicia, el depurador lee su archivo rc (./.perldb or ~ / .perldb bajo Unix), que
puede configurar opciones importantes. (Aquí también se puede definir una subrutina (& afterinit); es
ejecutado después de que el depurador complete su propia inicialización).

Después de leer el archivo rc, el depurador lee la variable de entorno PERLDB_OPTS y
lo usa para configurar las opciones del depurador. Los contenidos de esta variable se tratan como si fueran
el argumento de un comando de depuración "o ..." (qv en "Opciones configurables" en perldebug).

Depurador Interno Variables

Además de las variables relacionadas con el archivo y la subrutina mencionadas anteriormente, el depurador
también mantiene varias variables internas mágicas.

· @DB :: dbline es un alias para "@ {" :: _
archivo seleccionado actualmente (compilado por Perl), ya sea elegido explícitamente con el
comando "f" del depurador, o implícitamente por el flujo de ejecución.

Los valores en esta matriz son mágicos en contexto numérico: se comparan solo a cero
si la línea no se puede romper.

·% DB :: dbline es un alias para "% {" :: _
acciones tecleadas por número de línea en el archivo actualmente seleccionado, ya sea elegido explícitamente
con el comando "f" del depurador, o implícitamente mediante el flujo de ejecución.

Como se señaló anteriormente, las entradas individuales (a diferencia del hash completo) son configurables.
Perl solo se preocupa por Boolean true aquí, aunque los valores utilizados por perl5db.pl have
la forma "$ break_condition \ 0 $ action".

Depurador Personalización Funciones

Se proporcionan algunas funciones para simplificar la personalización.

· Consulte "Opciones configurables" en perldebug para obtener una descripción de las opciones analizadas por
"DB :: parse_options (cadena)".

· "DB :: dump_trace (skip [, count])" omite el número especificado de fotogramas y devuelve una lista
que contiene información sobre los marcos de llamada (todos ellos, si falta "recuento").
Cada entrada es una referencia a un hash con las claves "contexto" (ya sea ".", "$" O "@"), "sub"
(nombre de subrutina o información sobre "eval"), "args" ("undef" o una referencia a una matriz),
"archivo" y "línea".

· "DB :: print_trace (FH, skip [, count [, short]])" imprime información formateada sobre la persona que llama
marcos. Las dos últimas funciones pueden ser convenientes como argumentos para los comandos "<", "<<".

Tenga en cuenta que cualquier variable y función que no esté documentada en estas páginas de manual (o en
perldebug) se consideran solo para uso interno y, como tales, están sujetos a cambios sin
cuenta.

Cuadro Publicaciones Salida Ejemplos

La opción "marco" se puede utilizar para controlar la salida de la información del marco. Por ejemplo,
contrasta este rastro de expresión:

$ perl-de 42
Volcado de pila durante el dado habilitado fuera de evaluaciones.

Carga de rutinas de base de datos desde el nivel de parche perl5db.pl 0.94
Soporte de Emacs disponible.

Ingrese ho 'hh' para obtener ayuda.

principal :: (- e: 1): 0
DB <1> sub foo {14}

Barra secundaria DB <2> {3}

DB <3> t imprimir foo () * bar ()
principal :: ((eval 172): 3): imprimir foo () + barra ();
principal :: foo ((eval 168): 2):
principal :: barra ((eval 170): 2):
42

con este, una vez que se ha establecido el marco "o" ption "= 2":

DB <4> de = 2
marco = '2'
DB <5> t imprimir foo () * bar ()
3: foo () * barra ()
entrando en main :: foo
2: sub foo {14};
salió de main :: foo
entrando en main :: bar
2: barra secundaria {3};
salió de main :: bar
42

A modo de demostración, presentamos a continuación un laborioso listado resultante de configurar su
Variable de entorno "PERLDB_OPTS" al valor "f = n N", y en ejecución perl -d -V desde la
línea de comando. Se muestran ejemplos que utilizan varios valores de "n" para darle una idea de la
diferencia entre configuraciones. Por muy largo que sea, esta no es una lista completa, pero
sólo extractos.

1.
entrando en main :: BEGIN
ingresando Config :: BEGIN
Paquete lib / Exporter.pm.
Paquete lib / Carp.pm.
Paquete lib / Config.pm.
entrando en Config :: TIEHASH
entrando Exportador :: importación
entrando Exportador :: exportar
entrando en Config :: myconfig
ingresando Config :: FETCH
ingresando Config :: FETCH
ingresando Config :: FETCH
ingresando Config :: FETCH

2.
entrando en main :: BEGIN
ingresando Config :: BEGIN
Paquete lib / Exporter.pm.
Paquete lib / Carp.pm.
salió de Config :: BEGIN
Paquete lib / Config.pm.
entrando en Config :: TIEHASH
salió de Config :: TIEHASH
entrando Exportador :: importación
entrando Exportador :: exportar
exportador salido :: exportar
Exportador salido :: importación
salió de main :: BEGIN
entrando en Config :: myconfig
ingresando Config :: FETCH
salió de Config :: FETCH
ingresando Config :: FETCH
salió de Config :: FETCH
ingresando Config :: FETCH

3.
en $ = main :: BEGIN () desde / dev / null: 0
en $ = Config :: BEGIN () de lib / Config.pm: 2
Paquete lib / Exporter.pm.
Paquete lib / Carp.pm.
Paquete lib / Config.pm.
en $ = Config :: TIEHASH ('Config') de lib / Config.pm: 644
en $ = Exporter :: import ('Config', 'myconfig', 'config_vars') desde / dev / null: 0
en $ = Exporter :: export ('Config', 'main', 'myconfig', 'config_vars') de li
en @ = Config :: myconfig () desde / dev / null: 0
en $ = Config :: FETCH (ref (Config), 'paquete') de lib / Config.pm: 574
en $ = Config :: FETCH (ref (Config), 'baserev') de lib / Config.pm: 574
en $ = Config :: FETCH (ref (Config), 'PERL_VERSION') de lib / Config.pm: 574
en $ = Config :: FETCH (ref (Config), 'PERL_SUBVERSION') de lib / Config.pm: 574
en $ = Config :: FETCH (ref (Config), 'osname') de lib / Config.pm: 574
en $ = Config :: FETCH (ref (Config), 'osvers') de lib / Config.pm: 574

4.
en $ = main :: BEGIN () desde / dev / null: 0
en $ = Config :: BEGIN () de lib / Config.pm: 2
Paquete lib / Exporter.pm.
Paquete lib / Carp.pm.
out $ = Config :: BEGIN () de lib / Config.pm: 0
Paquete lib / Config.pm.
en $ = Config :: TIEHASH ('Config') de lib / Config.pm: 644
out $ = Config :: TIEHASH ('Config') de lib / Config.pm: 644
en $ = Exporter :: import ('Config', 'myconfig', 'config_vars') desde / dev / null: 0
en $ = Exporter :: export ('Config', 'main', 'myconfig', 'config_vars') de lib /
out $ = Exporter :: export ('Config', 'main', 'myconfig', 'config_vars') de lib /
out $ = Exporter :: import ('Config', 'myconfig', 'config_vars') desde / dev / null: 0
out $ = main :: BEGIN () desde / dev / null: 0
en @ = Config :: myconfig () desde / dev / null: 0
en $ = Config :: FETCH (ref (Config), 'paquete') de lib / Config.pm: 574
out $ = Config :: FETCH (ref (Config), 'paquete') de lib / Config.pm: 574
en $ = Config :: FETCH (ref (Config), 'baserev') de lib / Config.pm: 574
out $ = Config :: FETCH (ref (Config), 'baserev') de lib / Config.pm: 574
en $ = Config :: FETCH (ref (Config), 'PERL_VERSION') de lib / Config.pm: 574
out $ = Config :: FETCH (ref (Config), 'PERL_VERSION') de lib / Config.pm: 574
en $ = Config :: FETCH (ref (Config), 'PERL_SUBVERSION') de lib / Config.pm: 574

5.
en $ = main :: BEGIN () desde / dev / null: 0
en $ = Config :: BEGIN () de lib / Config.pm: 2
Paquete lib / Exporter.pm.
Paquete lib / Carp.pm.
out $ = Config :: BEGIN () de lib / Config.pm: 0
Paquete lib / Config.pm.
en $ = Config :: TIEHASH ('Config') de lib / Config.pm: 644
out $ = Config :: TIEHASH ('Config') de lib / Config.pm: 644
en $ = Exporter :: import ('Config', 'myconfig', 'config_vars') desde / dev / null: 0
en $ = Exporter :: export ('Config', 'main', 'myconfig', 'config_vars') de lib / E
out $ = Exporter :: export ('Config', 'main', 'myconfig', 'config_vars') de lib / E
out $ = Exporter :: import ('Config', 'myconfig', 'config_vars') desde / dev / null: 0
out $ = main :: BEGIN () desde / dev / null: 0
en @ = Config :: myconfig () desde / dev / null: 0
en $ = Config :: FETCH ('Config =Hachís(0x1aa444) ',' paquete ') de lib / Config.pm: 574
out $ = Config :: FETCH ('Config =Hachís(0x1aa444) ',' paquete ') de lib / Config.pm: 574
en $ = Config :: FETCH ('Config =Hachís(0x1aa444) ',' baserev ') de lib / Config.pm: 574
out $ = Config :: FETCH ('Config =Hachís(0x1aa444) ',' baserev ') de lib / Config.pm: 574

6.
en $ =CÓDIGO(0x15eca4) () de / dev / null: 0
en $ =CÓDIGO(0x182528) () de lib / Config.pm: 2
Paquete lib / Exporter.pm.
fuera $ =CÓDIGO(0x182528) () de lib / Config.pm: 0
retorno de contexto escalar de CÓDIGO(0x182528): indef
Paquete lib / Config.pm.
en $ = Config :: TIEHASH ('Config') de lib / Config.pm: 628
out $ = Config :: TIEHASH ('Config') de lib / Config.pm: 628
Retorno de contexto escalar de Config :: TIEHASH: hash vacío
en $ = Exporter :: import ('Config', 'myconfig', 'config_vars') desde / dev / null: 0
en $ = Exporter :: export ('Config', 'main', 'myconfig', 'config_vars') de lib / Exporter.pm: 171
out $ = Exporter :: export ('Config', 'main', 'myconfig', 'config_vars') de lib / Exporter.pm: 171
retorno de contexto escalar de Exporter :: export: ''
out $ = Exporter :: import ('Config', 'myconfig', 'config_vars') desde / dev / null: 0
retorno de contexto escalar de Exporter :: import: ''

En todos los casos que se muestran arriba, la sangría de línea muestra el árbol de llamadas. Si el bit 2 de "trama"
está configurado, también se imprime una línea al salir de una subrutina. Si se establece el bit 4, el
los argumentos se imprimen junto con la información de la persona que llama. Si se establece el bit 8, los argumentos son
impresos incluso si están atados o referencias. Si se establece el bit 16, el valor de retorno es
impreso también.

Cuando se compila un paquete, una línea como esta

Paquete lib / Carp.pm.

se imprime con la sangría adecuada.

Depuración Regular Expresiones

Hay dos formas de habilitar la salida de depuración para expresiones regulares.

Si su perl está compilado con "-DDEBUGGING", puede usar el -Dr bandera en la línea de comando.

De lo contrario, se puede "usar re 'debug'", lo que tiene efectos en el tiempo de compilación y ejecución.
Desde Perl 5.9.5, este pragma tiene un ámbito léxico.

Tiempo de compilación Salida
La salida de depuración en tiempo de compilación se ve así:

Compilando REx '[bc] d (ef * g) + h [ij] k $'
tamaño 45 Obtuve 364 bytes para anotaciones de desplazamiento.
primero en 1
carácter más raro a 0
carácter más raro d en 0
1: CUALQUIERA [bc] (12)
12: EXACTO (14)
14: CURLYX [0] {1,32767} (28)
16: ABIERTO1(18)
18: EXACTO (20)
20: STAR(23)
21: EXACTO (0)
23: EXACTO (25)
25: CERRAR1(27)
27: WHILEM [1/1] (0)
28: NADA(29)
29: EXACTO (31)
31: CUALQUIERA [ij] (42)
42: EXACTO (44)
44: EOL(45)
45: FIN(0)
anclado 'de' en 1 flotante 'gh' en 3..2147483647 (control flotante)
stclass 'ANYOF [bc]' minlen 7
Compensaciones: [45]
1[4] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 5[1]
0[0] 12[1] 0[0] 6[1] 0[0] 7[1] 0[0] 9[1] 8[1] 0[0] 10[1] 0[0]
11[1] 0[0] 12[0] 12[0] 13[1] 0[0] 14[4] 0[0] 0[0] 0[0] 0[0]
0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 18[1] 0[0] 19[1] 20[0]
Omitiendo el soporte de $ `$ & $ '.

La primera línea muestra la forma precompilada de la expresión regular. El segundo muestra el tamaño del
forma compilada (en unidades arbitrarias, generalmente palabras de 4 bytes) y el número total de bytes
asignado para la tabla de desplazamiento / longitud, generalmente 4+ "tamaño" * 8. La siguiente línea muestra la etiqueta
id del primer nodo que hace una coincidencia.

La

anclado 'de' en 1 flotante 'gh' en 3..2147483647 (control flotante)
stclass 'ANYOF [bc]' minlen 7

línea (dividida en dos líneas arriba) contiene información del optimizador. En el ejemplo mostrado,
el optimizador encontró que la coincidencia debe contener una subcadena "de" en el desplazamiento 1, más
subcadena "gh" en algún desplazamiento entre 3 e infinito. Además, al comprobar estos
subcadenas (para abandonar coincidencias imposibles rápidamente), Perl buscará la subcadena "gh"
antes de comprobar la subcadena "de". El optimizador también puede utilizar el conocimiento de que
comienza el partido (en el "primero" id) con una clase de carácter y ninguna cadena menor de 7
los personajes posiblemente pueden coincidir.

Los campos de interés que pueden aparecer en esta línea son

"anclado" CADENA "a" TPV
"flotante" CADENA "a" POS1..POS2
Véase más arriba.

"coincidente flotante / anclado"
Qué subcadena comprobar primero.

"minlen"
La duración mínima del partido.

"stclass" TIPO
Tipo de primer nodo coincidente.

"noscan"
No busque las subcadenas encontradas.

"es todo"
Significa que la información del optimizador es todo lo que contiene la expresión regular, y
por lo tanto, no es necesario ingresar al motor de expresiones regulares.

"GPOS"
Establezca si el patrón contiene "\ G".

"más"
Establezca si el patrón comienza con un carácter repetido (como en "x + y").

"implícito"
Establezca si el patrón comienza con ". *".

"con eval"
Establezca si el patrón contiene grupos de evaluación, como "(? {Código})" y "(?? {código})".

"anclado (TIPO)"
Si el patrón puede coincidir solo en algunos lugares, donde "TYPE" es "SBOL",
"MBOL" o "GPOS". Consulte la tabla siguiente.

Si se sabe que una subcadena coincide solo al final de la línea, puede ir seguida de "$", como en
"flotante 'k' $".

La información específica del optimizador se usa para evitar ingresar (un motor de expresiones regulares lento) en
cadenas que definitivamente no coincidirán. Si se establece el indicador "isall", una llamada a la expresión regular
El motor puede evitarse incluso cuando el optimizador encuentra un lugar apropiado para el partido.

Encima de la sección del optimizador está la lista de nodos de la forma compilada de la expresión regular. Cada
la línea tiene formato

""id: TIPO INFORMACIÓN OPCIONAL (siguiente ID)

Tipos of Nodes
Estos son los tipos posibles actuales, con descripciones breves:

# TYPE arg-description [num-args] [longjump-len] DESCRIPCIÓN

# Puntos de salida

END no Fin del programa.
ÉXITO sin Retorno de una subrutina, básicamente.

# Anclas de inicio de línea:
SBOL no Match "" al principio de la línea: / ^ /, / \ A /
MBOL no Igual, asumiendo multilínea: / ^ / m

# Anclajes de extremo de línea:
SEOL no Match "" al final de la línea: / $ /
MEOL no Igual, asumiendo multilínea: / $ / m
EOS no Match "" al final de la cadena: / \ z /

# Anclas de inicio de partido:
GPOS no Coincide donde quedó el último m // g.

# Códigos de operación de límite de palabra:
BOUND no Como BOUNDA para no utf8; de lo contrario, coincida con ""
entre cualquier Unicode \ w \ W o \ W \ w
BOUNDL no Como BOUND / BOUNDU, pero \ w y \ W están definidos
por localidad actual
BOUNDU no Match "" en cualquier límite de un tipo determinado
usando reglas Unicode
BOUNDA no Match "" en cualquier límite entre \ w \ W o
\ W \ w, donde \ w es [_a-zA-Z0-9]
NBOUND no Me gusta NBOUNDA para no utf8; de lo contrario, coincida
"" entre cualquier \ w \ w o \ W \ W Unicode
NBOUNDL no Como NBOUND / NBOUNDU, pero \ w y \ W son
definido por la configuración regional actual
NBOUNDU no Match "" en ningún límite de un tipo determinado
usando el uso de reglas Unicode
NBOUNDA no hay coincidencia "" entre cualquier \ w \ w o \ W \ W, donde \ w
es [_a-zA-Z0-9]

# Alternativas [especiales]:
REG_ANY no Coincide con ningún carácter (excepto nueva línea).
SANY no coincide con ningún personaje.
CANY no Coincide con ningún byte.
ANYOF sv 1 Coincidencia de carácter en (o no) esta clase,
solo coincidencia de un solo carácter
ANYOFL sv 1 Como ANYOF, pero / l está en vigor

# Clases de caracteres POSIX:
POSIXD ninguno Algunos [[: clase:]] bajo / d; el campo BANDERAS
da cual
POSIXL ninguno Algunos [[: clase:]] bajo / l; el campo BANDERAS
da cual
POSIXU ninguno Algunos [[: clase:]] bajo / u; el campo BANDERAS
da cual
POSIXA ninguno Algunos [[: clase:]] bajo / a; el campo BANDERAS
da cual
NPOSIXD ningún complemento de POSIXD, [[: ^ class:]]
NPOSIXL ningún complemento de POSIXL, [[: ^ class:]]
NPOSIXU ningún complemento de POSIXU, [[: ^ class:]]
NPOSIXA ningún complemento de POSIXA, [[: ^ class:]]

CLUMP no Coincide con ninguna secuencia de cúmulo de grafemas extendido

# Alternancia

# SUCURSAL El conjunto de ramas que constituyen una única opción son
# enlazados con sus "siguientes" punteros, ya que
# la precedencia evita que cualquier cosa se concatene a
# cualquier rama individual. El puntero "siguiente" del último
# RAMA en una elección apunta a lo que sigue al
# elección completa. Aquí también es donde el "siguiente" final
# puntero de cada punto de rama individual; cada rama
# comienza con el nodo operando de un nodo BRANCH.
#
Nodo SUCURSAL Haga coincidir esta alternativa o la siguiente ...

# Literales

EXACT str Coincide con esta cadena (precedida por la longitud).
EXACTL str Como EXACT, pero / l está vigente.
EXACTF str Coincide con esta cadena no UTF-8 (no garantizado
para plegar) usando las reglas / id (w / len).
EXACTFL str Coincide con esta cadena (no se garantiza que sea
plegado) usando las reglas / il (w / len).
EXACTFU str Coincide con esta cadena (doblada iff en UTF-8,
la longitud en el plegado no cambia si no está en
UTF-8) usando reglas / iu (w / len).
EXACTFA str Coincide con esta cadena (no se garantiza que sea
plegado) usando las reglas / iaa (w / len).

EXACTFU_SS str Coincide con esta cadena (doblada iff en UTF-8,
la longitud en el plegado puede cambiar incluso si no está en
UTF-8) usando reglas / iu (w / len).
EXACTFLU8 str Cirugías raras: como EXACTFU, pero es
debajo de / l, UTF-8, doblado y todo en
está por encima de 255.
EXACTFA_NO_TRIE str Coincide con esta cadena (que no se puede probar;
no se garantiza que se pliegue) usando / iaa
reglas (w / len).

# No hacer nada tipos

NADA no coincide con la cadena vacía.
# Una variante de above que delimita un grupo, por lo que detiene optimizaciones
COLA no Coincide con la cadena vacía. Puede saltar aquí desde
fuera de.

# Bucles

# STAR, PLUS '?', Y los complejos '*' y '+', se implementan como
# Estructuras circulares de RAMA. Casos sencillos
# (un carácter por partido) se implementan con STAR
# y PLUS para aumentar la velocidad y minimizar las inmersiones recursivas.
#
Nodo ESTRELLA Coincide con esta cosa (simple) 0 o más veces.
Nodo PLUS Coincide con esta cosa (simple) 1 o más veces.

CURLY sv 2 Coincide con esta simple cosa {n, m} veces.
CURLYN no 2 Capture lo siguiente después de esto simple
CURLYM no 2 Capture esta cosa de complejidad media {n, m}
veces.
CURLYX sv 2 Coincide con esta cosa compleja {n, m} veces.

# Este terminador crea una estructura de bucle para CURLYX
WHILEM no Realice un procesamiento rizado y vea si el resto coincide.

# Relacionado con búfer

# OPEN, CLOSE, GROUPP ... se numeran en el momento de la compilación.
OPEN num 1 Marque este punto en la entrada como inicio de #n.
CERRAR num 1 Análogo a ABRIR.

REF num 1 Coincide con alguna cadena ya coincidente
REFF num 1 Coincide con la cadena ya emparejada, doblada usando
reglas de juego de caracteres nativos para no utf8
REFFL núm 1 Coincide con la cuerda ya emparejada, doblada en loc.
REFFU num 1 Coincide con la cadena ya emparejada, doblada usando
reglas unicode para no utf8
REFFA num 1 Coincide con la cadena ya emparejada, doblada usando
reglas unicode para no utf8, sin mezcla ASCII,
no ASCII

# Referencias nombradas. El código en regcomp.c asume que todos estos son posteriores
# las referencias numeradas
NREF no-sv 1 Coincide con alguna cadena ya coincidente
NREFF no-sv 1 Coincide con la cadena ya emparejada, doblada usando
reglas de juego de caracteres nativos para no utf8
NREFFL no-sv 1 Coincide con la cadena ya emparejada, doblada en loc.
NREFFU num 1 Coincide con la cadena ya emparejada, doblada usando
reglas unicode para no utf8
NREFFA num 1 Coincide con la cadena ya emparejada, doblada usando
reglas unicode para no utf8, sin mezcla ASCII,
no ASCII

# Soporte para RE largo
LONGJMP off 1 1 Salta lejos.
BRANCHJ off 1 1 BRANCH con desplazamiento largo.

# Regops de casos especiales
IFMATCH off 1 2 Tiene éxito si lo siguiente coincide.
UNLESSM off 1 2 Falla si lo siguiente coincide.
SUSPEND off 1 1 Sub-RE "Independiente".
SI ENTONCES apagado 1 1 Interruptor, debe ir precedido de un interruptor.
GROUPP num 1 Si el grupo coincide.

# El trabajador pesado

EVAL evl / flags Ejecuta algún código Perl.
2L

# Modificadores

MINMOD no El siguiente operador no es codicioso.
LÓGICO no El siguiente código de operación debe establecer solo la bandera.

# Esto aún no se usa
RENUM desactivado 1 1 Grupo con paréntesis numerados independientemente.

Relacionado con # Trie

# Comportarse igual que A | LIST | OF | PALABRAS. Las variantes '..C'
# tienen datos de clase de caracteres en línea (solo ascii), la 'C' los almacena en el
# estructura.

TRIE trie 1 Coincide con muchos EXACT (F [ALU]?)? En seguida.
banderas == tipo
TRIEC trie Igual que TRIE, pero con charclass incrustado
datos charclass

AHOCORASICK trie 1 Aho Corasick stclass. banderas == tipo
AHOCORASICKC trie Igual que AHOCORASICK, pero con
charclass charclass datos

# Subrutinas Regex
GOSUB núm / ofs 2L recursivo a par arg1 en (firmado) ofs arg2
GOSTART no recurse al inicio del patrón

# Condicionales especiales
NGROUPP no-sv 1 Si el grupo coincide.
INSUBP núm. 1 Si estamos en un recurse concreto.
DEFINEP ninguno 1 Nunca ejecute directamente.

# Verbos de retroceso
ENDLIKE ninguno Se usa solo para el campo de tipo de verbos
OPFAIL ninguno Igual que (?!)
ACCEPT parno 1 Acepta la cadena coincidente actual.

# Verbos con argumentos
VERB no-sv 1 Usado solo para el campo de tipo de verbos
PRUNE no-sv 1 El patrón falla en este punto de inicio si no
retrocediendo a través de esto
MARKPOINT no-sv 1 Pulse la ubicación actual para retroceder por
un secado.
SKIP no-sv 1 En caso de falla, avance (hasta la marca) antes
reintentando
COMMIT no-sv 1 El patrón falla por completo si retrocede
a través de esto
CUTGROUP no-sv 1 En caso de avería pasar a la siguiente alternancia en el
grupo de XNUMX

# Controle qué guardar en $ &.
NO MANTIENE $ ​​y comienza aquí.

# Nuevos patrones tipo charclass
LNBREAK ningún patrón de nueva línea genérico

# REGOPS ESPECIALES

# Esto no es realmente un nodo, sino una parte optimizada de un "largo"
# nodo. Para simplificar la salida de depuración, la marcamos como si fuera un nodo.
OPTIMIZADO off Placeholder for dump.

# Código de operación especial con la propiedad de que no hay código de operación en un programa compilado
# alguna vez será de este tipo. Por lo tanto, se puede utilizar como un valor de bandera que
# no se ha visto ningún otro código de operación. END se usa de manera similar, ya que un END
# nodo no se puede optimizar. Entonces, END implica "no optimizable" y PSEUDO
# significa "no he visto nada para optimizar todavía".
PSEUDO off Pseudo código de operación para uso interno.

A continuación de la información del optimizador hay un volcado de la tabla de longitud / desplazamiento, aquí dividida
a través de varias líneas:

Compensaciones: [45]
1[4] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 5[1]
0[0] 12[1] 0[0] 6[1] 0[0] 7[1] 0[0] 9[1] 8[1] 0[0] 10[1] 0[0]
11[1] 0[0] 12[0] 12[0] 13[1] 0[0] 14[4] 0[0] 0[0] 0[0] 0[0]
0[0] 0[0] 0[0] 0[0] 0[0] 0[0] 18[1] 0[0] 19[1] 20[0]

La primera línea aquí indica que la tabla de desplazamiento / longitud contiene 45 entradas. Cada
la entrada es un par de números enteros, indicados por "desplazamiento [longitud]". Las entradas están numeradas comenzando
con 1, entonces la entrada # 1 aquí es "1 [4]" y la entrada # 12 es "5 [1]". "1 [4]" indica que el
nodo etiquetado "1:" (el "1: ANYOF [bc]") comienza en la posición de carácter 1 en el precompilado
forma de la expresión regular, y tiene una longitud de 4 caracteres. "5 [1]" en la posición 12 indica que
el nodo etiquetado "12:" (el "12: EXACT ") comienza en la posición de carácter 5 en la
forma compilada de la expresión regular y tiene una longitud de 1 carácter. "12 [1]" en la posición 14
indica que el nodo etiquetado "14:" (el "14: CURLYX [0] {1,32767}") comienza en el carácter
posición 12 en la forma precompilada de la expresión regular, y tiene una longitud de 1 carácter --- que
es decir, corresponde al símbolo "+" en la expresión regular precompilada.

Los elementos "0 [0]" indican que no hay un nodo correspondiente.

Tiempo de ejecución Salida
En primer lugar, al hacer una coincidencia, es posible que no se obtenga salida en tiempo de ejecución incluso si la depuración es
activado. Esto significa que el motor de expresiones regulares nunca se ingresó y que todo el trabajo fue
por lo tanto, realizado por el optimizador.

Si se ingresó el motor de expresiones regulares, la salida puede verse así:

Coincidencia de '[bc] d (ef * g) + h [ij] k $' con 'abcdefg__gh__'
Estableciendo un alcance EVAL, savestack = 3
2 | 1: CUALQUIERA
3 | 11: EXACTO
4 | 13: CURLYX {1,32767}
4 | 26: WHILEM
0 de 1..32767 cc = effff31c
4 | 15: ABIERTO1
4 | 17: EXACTO
5 | 19: ESTRELLA
EXACTO puede coincidir 1 de 32767 ...
Estableciendo un alcance EVAL, savestack = 3
6 | 22: EXACTO
7 <__gh__> | 24: CLOSE1
7 <__gh__> | 26: WHILEM
1 de 1..32767 cc = effff31c
Estableciendo un alcance EVAL, savestack = 12
7 <__gh__> | 15: ABIERTO1
7 <__gh__> | 17: EXACTO
restaurando \ 1 a 4(4) ... 7
falló, intente continuar ...
7 <__gh__> | 27: NADA
7 <__gh__> | 28: EXACTO
fallido...
fallido...

La información más significativa en la salida es sobre el particular nodo del
expresión regular compilada que se está probando actualmente con la cadena de destino. El formato de
estas lineas son

""DESPLAZAMIENTO DE CADENA <PRE-CUERDA>POST-CADENA> |ID: TIPO

La TIPO info tiene sangría con respecto al nivel de retroceso. Otros incidentales
la información aparece intercalada en su interior.

Depuración Perl Salud Cerebral Uso

Perl es un derrochador derrochador cuando se trata del uso de la memoria. Hay un dicho que
estimar el uso de memoria de Perl, asumir un algoritmo razonable para la asignación de memoria,
multiplique esa estimación por 10, y aunque todavía puede perder la marca, al menos no será
bastante asombrado. Esto no es absolutamente cierto, pero puede proporcionar una buena comprensión de lo que
sucede.

Suponga que un número entero no puede ocupar menos de 20 bytes de memoria, un flotante no puede ocupar menos
de 24 bytes, una cadena no puede ocupar menos de 32 bytes (todos estos ejemplos asumen
arquitecturas, el resultado es bastante peor en arquitecturas de 64 bits). Si una variable
se accede de dos de tres formas diferentes (que requieren un número entero, un flotante o un
string), la huella de memoria puede aumentar otros 20 bytes. Un descuidado malloc(3)
la implementación puede inflar estos números dramáticamente.

En el extremo opuesto de la escala, una declaración como

sub-foo;

puede ocupar hasta 500 bytes de memoria, dependiendo de la versión de Perl que esté ejecutando.

Las estimaciones anecdóticas del exceso de código fuente a compilado sugieren un aumento de ocho veces. Esta
significa que la forma compilada de razonable (normalmente comentada, con sangría adecuada, etc.)
el código ocupará unas ocho veces más espacio en la memoria que el que ocupaba en el disco.

La -DL El modificador de línea de comandos está obsoleto desde Perl 5.6.0 (estaba disponible solo si
Perl fue construido con "-DDEBUGGING"). El interruptor se usó para rastrear la memoria de Perl
asignaciones y posibles pérdidas de memoria. En estos días, el uso de herramientas de depuración malloc como
Purificar or Valgrind se sugiere en su lugar. Consulte también "PERL_MEM_LOG" en perlhacktips.

Una forma de averiguar cuánta memoria están utilizando las estructuras de datos de Perl es instalar
el módulo Devel :: Size de CPAN: le da el número mínimo de bytes necesarios para
almacenar una estructura de datos particular. Tenga en cuenta la diferencia entre Talla()
y tamaño total().

Si Perl se ha compilado con malloc de Perl, puede analizar el uso de la memoria de Perl configurando
$ ENV {PERL_DEBUG_MSTATS}.

Usando $ ENV {PERL_DEBUG_MSTATS}
Si su perl está usando Perl malloc () y fue compilado con los modificadores necesarios (este
es el predeterminado), luego imprimirá estadísticas de uso de memoria después de compilar su código cuando
"$ ENV {PERL_DEBUG_MSTATS}> 1", y antes de la finalización del programa cuando
"$ ENV {PERL_DEBUG_MSTATS}> = 1". El formato del informe es similar al siguiente ejemplo:

$ PERL_DEBUG_MSTATS = 2 perl -e "requiere carpa"
Estadísticas de asignación de memoria después de la compilación: (cubos 4(4) ..8188(8192)
14216 libre: 130 117 28 7 9 0 2 2 1 0
+437 61 36 0 5
60924 utilizado: 125 137 161 55 7 8 6 16 2
+74 109 304 84 20
Sbrk total (): 77824/21: 119. Extremos impares: almohadilla + cabezas + cadena + cola: 0 + 636 + 0 + 2048.
Estadísticas de asignación de memoria después de la ejecución: (cubos 4(4) ..8188(8192)
30888 libre: 245 78 85 13 6 2 1 3 2 0
+315 162 39 42 11
175816 utilizado: 265 176 1112 111 26 22 11 27 2
+196 178 1066 798 39
Sbrk total (): 215040/47: 145. Extremos impares: almohadilla + cabezas + cadena + cola: 0 + 2192 + 0 + 6144.

Es posible solicitar dicha estadística en puntos arbitrarios de su ejecución utilizando el
mstat () funciona fuera del módulo estándar Devel :: Peek.

Aquí hay una explicación de ese formato:

"cubos MÁS PEQUEÑO (APROX) ... MÁS GRANDE (APROX)"
Perl's malloc () utiliza asignaciones agrupadas. Cada solicitud se redondea al más cercano
tamaño de balde disponible, y se toma un balde del grupo de baldes de ese tamaño.

La línea anterior describe los límites de cubos actualmente en uso. Cada cubo tiene dos
Tamaños: huella de memoria y el tamaño máximo de datos de usuario que pueden caber en este
Cubeta. Suponga en el ejemplo anterior que el cubo más pequeño fuera de tamaño 4. El
el cubo más grande tendría un tamaño utilizable 8188 y la huella de memoria sería 8192.

En un Perl creado para depuración, algunos depósitos pueden tener un tamaño utilizable negativo. Esto significa
que estos cubos no se pueden (y no se utilizarán). Para cubetas más grandes, la memoria
la huella puede ser una página mayor que una potencia de 2. Si es así, la potencia correspondiente
de dos está impreso en el campo "APROX" arriba.

Gratis / Usado
Las 1 o 2 filas de números siguientes que corresponden al número de cubos de cada
tamaño entre "MÁS PEQUEÑO" y "MÁS GRANDE". En la primera fila, los tamaños (memoria
huellas) de cubos son potencias de dos, o posiblemente una página más. En el segundo
fila, si está presente, las huellas de memoria de los depósitos están entre la memoria
huellas de dos cubos "arriba".

Por ejemplo, suponga que en el ejemplo anterior, las huellas de memoria fueron

gratis: 8 16 32 64 128 256 512 1024
+4 12 24 48 80

Con un perl sin "DEPURACIÓN", los depósitos que comienzan desde 128 tienen una sobrecarga de 4 bytes y
por lo tanto, un depósito de 8192 de longitud puede ocupar hasta 8188 bytes de asignaciones.

"Total sbrk (): SBRKed / SBRKs: CONTINUOUS"
Los dos primeros campos dan la cantidad total de memoria perl sbrk(2) ed (¿ess-roto? :-)
y número de sbrk(2) s utilizados. El tercer número es lo que perl piensa sobre la continuidad de
trozos devueltos. Siempre que este número sea positivo, malloc () asumirá que es
probable que sbrk(2) proporcionará memoria continua.

La memoria asignada por bibliotecas externas no se cuenta.

"pad: 0"
La cantidad de sbrk(2) memoria ed necesaria para mantener los cubos alineados.

"cabezas: 2192"
Aunque la sobrecarga de memoria de los depósitos más grandes se mantiene dentro del depósito, para los
cubos, se mantiene en áreas separadas. Este campo da el tamaño total de estos
áreas.

"cadena: 0"
malloc () es posible que desee subdividir un grupo más grande en grupos más pequeños. Si solo una parte
del cubo fallecido se deja sin subdividir, el resto se mantiene como un elemento de un
lista enlazada. Este campo proporciona el tamaño total de estos fragmentos.

"cola: 6144"
Para minimizar el número de sbrk(2) s, malloc () pide más memoria. Este campo da
el tamaño de la parte aún no utilizada, que es sbrk(2) ed, pero nunca tocado.

Use perldebguts en línea usando los servicios de onworks.net