Foro - Perl en Español

por **pablgonz** » 2016-04-17 16:11 @716

Hola a todos de nuevo, estoy añadiendo código a un script (el mismo que he mostrado en ocasiones anteriores) y estoy tratando de aprender a manejar hash y array.

El asunto es así: paso una expresión regular a varios array y luego efectúo varias modificaciones en esto, eliminar duplicados y quitar líneas en blanco.

El tema es que debo hacerlo por cada array que se presenta, es decir, escribo varias veces un mismo código (entre las líneas 80 y 115) y me gustaría poder dejarlo dentro de una función (que ya tengo definida). El código es el siguiente:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
use v5.20;
use autodie;                                            # muere si ocurre un error
use File::Basename;                                     # separa el archivo de entrada
use Data::Dumper;
### Argumentos ---------------------------------------------------------
@ARGV == 1  or die "Uso: $0 <archivo TeX a procesar>\n";
my $nombre_archivo = shift;
-f $nombre_archivo or die "ERROR: No encuentro [$nombre_archivo]\n";
 
### Arreglo de la extensión --------------------------------------------
my @SuffixList = ('.tex', '', '.ltx');                  # posible extensión
my ($name, $path, $ext) = fileparse($nombre_archivo, @SuffixList);
$ext = '.tex' if not $ext;                              # fijamos la extensión
 
### Directorio para las imágenes y otros
my $imageDir  = "images";       
my $myverb    = "myverb";       
my $ignore    = "ignore";       
 
### Abrimos el archivo de entrada a modificar --------------------------
open my $ENTRADA, '<', $nombre_archivo;
my $archivo;
{
    local $/;
    $archivo = <$ENTRADA>;
}
close   $ENTRADA;
 
## Cambios a realizar
my %cambios = (
        '\pspicture'                => '\TRICKS',
        '\endpspicture'             => '\ENDTRICKS',
 
        '\begin{pspicture'          => '\begin{TRICKS',
        '\end{pspicture'            => '\end{TRICKS',
        
        '\begin{postscript}'        => '\begin{POSTRICKS}',
        '\end{postscript}'          => '\end{POSTRICKS}',
);
 
## Variables y constantes
my $no_del = "\0";
my $del    = $no_del;
 
## Reglas 
my $braces      = qr/ (?:\{)(.+?)(?:\})         /msx;
my $braquet     = qr/ (?:\[)(.+?)(?:\])         /msx;
my $llaves      = qr/\{ .+? \}                  /x;
my $no_corchete = qr/(?:\[ .+? \])?             /msx;
my $delimitador = qr/\{ (?<del>.+?) \}          /x;
my $anidado     = qr/(\{(?:[^\{\}]++|(?1))*\})  /x;
 
# TCOLORBOX ... \begin{...} ... \end{...} del paquete tcolorbox
my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /msx;
my $tcbxpack = qr/\\ (?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) $braces /msx;
 
# MINTED ... \begin{...} ... \end{...}, inline del paquete minted
my $mintdenv   = qr/\\ newminted $braces (?:\{.+?\})            /x;
my $mintcenv   = qr/\\ newminted $braquet (?:\{.+?\})           /x;
my $mintdshrt  = qr/\\ newmint $braces (?:\{.+?\})              /x; 
my $mintcshrt  = qr/\\ newmint $braquet (?:\{.+?\})             /x; 
my $mintdline  = qr/\\ newmintinline $braces (?:\{.+?\})        /x;
my $mintcline  = qr/\\ newmintinline $braquet (?:\{.+?\})       /x;   
 
### Expresión regular pasada a un array
my @mint_denv  = $archivo =~ m/$mintdenv/xg;  # \newminted{$mintdenv}{options} (for)
my @mint_cenv  = $archivo =~ m/$mintcenv/xg;  # \newminted[$mintcenv]{lang} (for)
my @mint_dshrt = $archivo =~ m/$mintdshrt/xg; # \newmint{$mintdshrt}{options} (while)
my @mint_cshrt = $archivo =~ m/$mintcshrt/xg; # \newmint[$mintcshrt]{lang}{options} (while)
my @mint_dline = $archivo =~ m/$mintdline/xg; # \newmintinline{$mintdline}{options} (while)
my @mint_cline = $archivo =~ m/$mintcline/xg; # \newmintinline[$mintcline]{lang}{options} (while)
my @tcolorbox  = $archivo =~ m/$tcbxpack/gmsx; # \newenvironment[...]{$tcbxpack} (for)
 
### Quitamos los elementos duplicados del array
sub uniq {
    my %seen;
    grep !$seen{$_}++, @_;
}
@mint_denv  = uniq(@mint_denv) ; 
@mint_cenv  = uniq(@mint_cenv) ; 
@mint_dline = uniq(@mint_dline); 
@mint_cline = uniq(@mint_cline); 
@mint_dshrt = uniq(@mint_dshrt); 
@mint_cshrt = uniq(@mint_cshrt); 
@tcolorbox  = uniq(@tcolorbox) ; 
 
### Quitamos los espacios, % y líneas en blanco 
@mint_denv  = grep(!/\%/, @mint_denv);
@mint_cenv  = grep(!/\%/, @mint_cenv);
@mint_dline = grep(!/\%/, @mint_dline);
@mint_cline = grep(!/\%/, @mint_cline);
@mint_dshrt = grep(!/\%/, @mint_dshrt);
@mint_cshrt = grep(!/\%/, @mint_cshrt);
@tcolorbox  = grep(!/\%/, @tcolorbox);
 
@mint_denv  = grep /\S/, @mint_denv;
@mint_cenv  = grep /\S/, @mint_cenv;
@mint_dline = grep /\S/, @mint_dline;
@mint_cline = grep /\S/, @mint_cline;
@mint_dshrt = grep /\S/, @mint_dshrt;
@mint_cshrt = grep /\S/, @mint_cshrt;
@tcolorbox  = grep /\S/, @tcolorbox;
 
s{^\s+|\s+$}{}g foreach @mint_denv;
s{^\s+|\s+$}{}g foreach @mint_cenv;
s{^\s+|\s+$}{}g foreach @mint_dline;
s{^\s+|\s+$}{}g foreach @mint_cline;
s{^\s+|\s+$}{}g foreach @mint_dshrt;
s{^\s+|\s+$}{}g foreach @mint_cshrt;
s{^\s+|\s+$}{}g foreach @tcolorbox;
 
# Agregamos "code" e "inline" para usar en qr/
if (!@mint_denv == 0){
$mintdenv   = join "\n", map { qq/$_\Qcode\E/ } @mint_denv;
@mint_denv  = split /\n/, $mintdenv; # (for)
}
if (!@mint_dline == 0){
$mintdline  = join "\n", map { qq/$_\Qinline\E/ } @mint_dline;
@mint_dline = split /\n/, $mintdline; # (while)
}
# Agregamos la palabra "TMP" para crear el hash
my $mintdenv_hash   = join "\n", map { qq/TMP$_/ } @mint_denv; # default
my @mint_denv_hash  = split /\n/, $mintdenv_hash; # default
my $mintcenv_hash   = join "\n", map { qq/TMP$_/ } @mint_cenv; # custom
my @mint_cenv_hash  = split /\n/, $mintcenv_hash; # custom
my $mintdline_hash  = join "\n", map { qq/TMP$_/ } @mint_dline; # default
my @mint_dline_hash = split /\n/, $mintdline_hash; # default
my $mintcline_hash  = join "\n", map { qq/TMP$_/ } @mint_cline; # default 
my @mint_cline_hash = split /\n/, $mintcline_hash; # default 
my $mintdshrt_hash  = join "\n", map { qq/TMP$_/ } @mint_dshrt; # default
my @mint_dshrt_hash = split /\n/, $mintdshrt_hash; # default
my $mintcshrt_hash  = join "\n", map { qq/TMP$_/ } @mint_cshrt; # default
my @mint_cshrt_hash = split /\n/, $mintcshrt_hash; # default
my $tcolorbox_hash  = join "\n", map { qq/TMP$_/ } @tcolorbox; # default
my @tcolorbox_hash  = split /\n/, $tcolorbox_hash; # default
 
# Array para el hash de entrada con las palabras sin TMP
my @infile_verb;  
push(@infile_verb,@mint_denv, @mint_cenv, @tcolorbox);
 
# Array para el hash de salida con las palabras con TMP
my @outfile_verb;
push(@outfile_verb,@mint_denv_hash, @mint_cenv_hash, @tcolorbox_hash);
 
# Ahora creamos hash para la entrada y salida del archivo
my %hash_entrada;
@hash_entrada{@infile_verb} = @outfile_verb;
 
my %hash_salida;
@hash_salida{@outfile_verb} = @infile_verb;
 
# Creamos %nuevo = (%cambios,%hash_entrada) y lo pasamos por (for) y (while)
my %nuevo = (%cambios,%hash_entrada);
 
# Pasamos @infile_verb y minted a  \qr 
my $fileverb = join "|", map quotemeta, @infile_verb; # \begin{...} ... \end{...}
$mintdline   = join "|", map quotemeta, @mint_dline; # inline verbatim default
$mintcline   = join "|", map quotemeta, @mint_cline; # inline verbatim custom
$mintdshrt   = join "|", map quotemeta, @mint_dshrt; # inline verbatim default
$mintcshrt   = join "|", map quotemeta, @mint_cshrt; # inline verbatim custom
my $mintedpack  = qr/\b(?:$mintdline|$mintcline|$mintdshrt|$mintcshrt)/x;
$fileverb       = qr/\b(?:$fileverb)/x;
 
### Reglas de captura
my $verb        = qr/(?:(spv|v|V)erb | $myverb) [*]?                                            /ix;
my $lst         = qr/(?:lstinline|$mintedpack|$myverb) (?!\*) $no_corchete                      /ix;
my $mint        = qr/ mint(?:inline)?(?!\*) $no_corchete $llaves                                /ix;
my $marca       = qr/\\ (?:$verb | $lst| $mint ) (\S) .+? \g{-1}                                /x;
### Comentarios y delimitadores
my $comentario  = qr/^ \s* \%+ .+? $                                                            /mx;
my $definedel   = qr/\\ (?:   DefineShortVerb | lstMakeShortInline  ) $no_corchete $delimitador /ix;
my $indefinedel = qr/\\ (?: UndefineShortVerb | lstDeleteShortInline) $llaves                   /ix;
### tcbverb,minted,mintline anidados
my $mintverb    = qr/\\ (?:mint(?:inline)?(?!\*)) $no_corchete $llaves                          /ix;
my $tcbxverb    = qr/\\ (?: tcboxverb | $myverb |$mintedpack(?!\*)) $no_corchete                /ix;
my $tcbxmint    = qr/(?:$tcbxverb|$mintverb) $anidado                                           /x; 
 
### Cambiar cuando aparece en una sola línea
while ($archivo =~
        /   $tcbxmint
        |   $marca
        |   $comentario
        |   $definedel
        |   $indefinedel
        |   $del .+? $del                                                       # delimitado
        /pgmx) {
 
        my($pos_inicial, $pos_final) = ($-[0], $+[0]);                          # posiciones
        my $encontrado = ${^MATCH};                                             # lo encontrado
 
    if ($encontrado =~ /$definedel/){                                           # definimos delimitador
                        $del = $+{del};
                        $del = "\Q$+{del}" if substr($del,0,1) ne '\\';         # es necesario "escapar" el delimitador
                }
    elsif($encontrado =~ /$indefinedel/) {                                      # indefinimos delimitador
                 $del = $no_del;                                        
        }
    else {                                                                      # aquí se hacen los cambios
        while (my($busco, $cambio) = each %nuevo) {
                       $encontrado =~ s/\Q$busco\E/$cambio/g;                   # es necesario escapar $busco
                        }
        substr $archivo, $pos_inicial, $pos_final-$pos_inicial, $encontrado;    # insertamos los nuevos cambios
 
        pos($archivo)= $pos_inicial + length $encontrado;                       # re posicionamos la siguiente búsqueda
        }
}
 
### Definimos los entornos en los cuales haremos los cambios
my $Verbatim  = qr/(?:(v|V)erbatim\*?     | # verbatim and fancyvrb 
(?:(?:P)?Center|(?:P)?SideBySide)?Example | # fancyvrb
                           PSTexample     | # pst-exa 
                           PSTcode        | # pst-exa
                           LTXexample     | # showexpl 
                           $ignore\*?     | # $ignore 
                           tcblisting\*?  | # tcolorbox 
                        tcboutputlisting  | # tcolorbox 
                           tcbexternal    | # tcolorbox 
                           extcolorbox    | # tcolorbox 
                           extikzpicture  | # tcolorbox 
                           spverbatim     | # spverbatim
                           minted         | # minted
                           listing        | # minted
                           lstlisting     | # listing
                           alltt          | # alltt 
                           comment\*?     | # comment 
                           xcomment         # xcomment
                           )/x;
 
### Dividimos por líneas el archivo de entrada
my @lineas = split /\n/, $archivo;
 
### Del    
my $DEL;
 
### Hacemos los cambios dentro de los entornos \begin{...} ... \end{...}
for (@lineas) {
    if (/\\begin\{($fileverb\*?|$Verbatim)(?{ $DEL = "\Q$^N" })\}/ .. /\\end\{$DEL\}/) {
        while (my($busco, $cambio) = each %cambios) {
            s/\Q$busco\E/$cambio/g;
        }
    }
} # close 
 
### Volvemos 
$archivo = join("\n", @lineas); 
 
### Ahora dividimos el archivo de entrada
my($cabeza,$cuerpo,$final) = $archivo =~ m/\A (.+?) (\\begin\{document\} .+?)(\\end\{document\}.*)\z/msx;
 
### postscript environment
my $BPL        = '\begin{postscript}';
my $EPL        = '\end{postscript}';
my $POSTSCRIPT = qr/(?: postscript)/xi;
 
### tikzpicture environment
my $ENVIRONMENT    = qr/(?: tikzpicture | pspicture\*?)/xi;
 
### \pspicture a \begin{pspicture}
$cuerpo =~ s/\\pspicture(\*)?(.+?)\\endpspicture/\\begin{pspicture$1}$2\\end{pspicture$1}/gmsx;
 
### tikz/pst a Postscript
$cuerpo =~ s/\\begin\{($POSTSCRIPT)\}.+?\\end\{\g{-1}\}(*SKIP)(*F)|
        (
        (?:\\(psset|tikzset)(\{(?:\{.*?\}|[^\{])*\}).*?)?  # si está lo guardo
        (\\begin\{($ENVIRONMENT)\} (.*?)  \\end\{\g{-2}\})
    )
    /$BPL\n$1\n$EPL/gmsx;
 
### Convertir
my $grap="\\includegraphics[scale=1]{EXTRAIDO-fig-";
my $close = '}';
my $imgNo = 1; # 
my $BP        = '\\\\begin\{postscript\}';
my $EP        = '\\\\end\{postscript\}';
$cuerpo =~ s/$BP.+?$EP/$grap@{[$imgNo++]}$close/msg; # 
 
my %cambios = (
# pst/tikz set    
    '\PSSET'                    =>      '\psset',
    '\TIKZSET'                  =>      '\tikzset',                     
# pspicture    
    '\TRICKS'                   =>      '\pspicture',
    '\ENDTRICKS'                =>      '\endpspicture',             
# pspicture
    '\begin{TRICKS'             =>      '\begin{pspicture',
    '\end{TRICKS'               =>      '\end{pspicture',
# postscript
    '\begin{POSTRICKS}'         =>      '\begin{postscript}',
    '\end{POSTRICKS}'           =>      '\end{postscript}',
);
 
%nuevo = (%cambios,%hash_salida);
 
### Reemplazamos y unimos
while (my($busco, $cambio) = each %nuevo) {
    $cabeza =~ s/\Q$busco\E/$cambio/g;
    $cuerpo =~ s/\Q$busco\E/$cambio/g;
    $final  =~ s/\Q$busco\E/$cambio/g;
            }
            
### Escritura del resultado
open my $SALIDA, '>', "$name-out$ext";
print   $SALIDA "$cabeza$cuerpo$final";
close   $SALIDA;
 
__END__
#delete @cambios{'\begin{postscript}','\end{postscript}'}; 
#print Dumper(\%cambios);
Coloreado en 0.011 segundos,  usando GeSHi 1.0.8.4

Si el archivo de entrada es de esta forma :

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

\documentclass{article}
\usepackage{minted}
\usepackage{pstricks-add}
\newtcblisting[opcional]{mytcbliting}
%\renewtcblisting[opcional]{nombre_2}
%\newtcblisting{nombre_1a}
%\renewtcblisting{nombre_2a}
%\DeclareTCBListing[opcional]{nombre_3}
%\NewTCBListing[opcional]{nombre_4}
%\ProvideTCBListing[opcional]{nombre_6}
%\newtcbexternalizeenvironment{nombre_7}
%\renewtcbexternalizeenvironment{nombre_8}
%\newtcbexternalizetcolorbox{nombre_9}
%\renewtcbexternalizetcolorbox{nombre_10}
\RenewTCBListing[
                        opcion                  
                        ]{
                        opcionaluno
                        }
\DefineVerbatimEnvironment{MyVerbatim}
{Verbatim}
{gobble=2,frame=lines,framerule=0.8mm}
\begin{document}
%Se convierte
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se convierte
\end{pspicture}
\end{postscript}
 
\begin{mytcbliting}
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{postscript}
\end{mytcbliting}
%Se convierte
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se convierte 
\end{pspicture}
\end{postscript}
 
\begin{opcionaluno}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{opcionaluno}
 
\begin{MyVerbatim*}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{MyVerbatim*}
 
\newminted{algun}{options}
\begin{alguncode*}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{alguncode*}
 
\newminted[langA]{lang1}{options}
 
\begin{langA}[opciones]
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{langA}
 
\begin{langArm}[opciones]
%Se convierte
\begin{pspicture}[showgrid](0,3)(10,10)
Se convierte
\end{pspicture}
\end{langArm}
 
\section{minted inline}
\subsection{delimitado}
Original delimitado \mintinline{latex}|\begin{langA} ... \end{langA}| text
Original delimitado \mintinline{latex}|\begin{MyVerbatim*}| text
Original delimitado con opciones \mintinline[opciones]{latex}/\begin{pspicture}/ text
 
Definiendo nuevo mintinline delimitado \newmintinline{mylatex}{showspaces}
Definiendo nuevo mintinline delimitado \newmintinline{myotrolatex}{showspaces}
con opciones \mylatexinline[opciones]|\begin{pspicture}| y sin opciones \mylatexinline|\begin{pspicture}|
con opciones \myotrolatexinline[opciones]|\begin{pspicture}| y sin opciones \myotrolatexinline|\begin{pspicture}|
 
Definiendo nuevo mintinline con nombre propio delimitado \newmintinline[personal]{latex}{showspaces}
con opciones \personal[opciones]|\begin{pspicture}| y sin opciones \personal[opciones]|\begin{pspicture}|
 
\subsection{anidado}
Original anidado \mintinline{latexdos}{\begin{pspicture} y \end{pspicture}} text
Original anidado con opciones \mintinline[opciones]{latexdos}{\begin{pspicture} y \end{pspicture}} text
 
Definiendo nuevo mintinline anidado \newmintinline{mylatexdos}{showspaces}
con opciones \mylatexdosinline[opciones]{\begin{pspicture} y \end{pspicture}} y sin opciones \mylatexdosinline{\begin{pspicture} y \end{pspicture}}
 
Definiendo nuevo mintinline con nombre propio anidado \newmintinline[personal]{latex}{showspaces}
con opciones \personal[opciones]{\begin{pspicture} y \end{pspicture}} y sin opciones \personal[opciones]{\begin{pspicture} y \end{pspicture}}
 
\subsection{new short minted}
\subsection{delimitado}
Original short \mint{python}|\begin{pspicture}|
 
Definiendo nuevo mint short default \newmint{mylenguaje}{showspaces}
\mylenguaje/\begin{pspicture}/ y \mylenguaje[opciones]/\begin{pspicture}/
 
Definiendo nuevo mint short custom \newmint[mymint]{mylenguaje}{showspaces}
\mymint/\begin{pspicture}/ \mymint[opciones]/\begin{pspicture}/ 
 
\subsection{anidado}
Original short \mint{lenguaje}{\begin{pspicture}}
 
\mylenguaje{\begin{pspicture} y \end{pspicture}} 
 
\mymint{\begin{pspicture} y \end{pspicture}} \mymint[opciones]{\begin{pspicture} y \end{pspicture}}
 
\section{tcolorbox}
\tcboxverb{\begin{pspicture} o \begin{pspicture*}} y \tcboxverb[algo]{\begin{pspicture} o {algo} o \begin{pspicture*}} 
 
Usamos \verb|\begin{pspicture} o \begin{pspicture*}| o \verb*|\begin{pspicture} o \begin{pspicture*}| (cambia)
 
\end{document}
IGNORAR
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{postscript}
 
Coloreado en 0.004 segundos,  usando GeSHi 1.0.8.4

Obtengo:

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

\documentclass{article}
\usepackage{minted}
\usepackage{pstricks-add}
\newtcblisting[opcional]{mytcbliting}
%\renewtcblisting[opcional]{nombre_2}
%\newtcblisting{nombre_1a}
%\renewtcblisting{nombre_2a}
%\DeclareTCBListing[opcional]{nombre_3}
%\NewTCBListing[opcional]{nombre_4}
%\ProvideTCBListing[opcional]{nombre_6}
%\newtcbexternalizeenvironment{nombre_7}
%\renewtcbexternalizeenvironment{nombre_8}
%\newtcbexternalizetcolorbox{nombre_9}
%\renewtcbexternalizetcolorbox{nombre_10}
\RenewTCBListing[
                        opcion                  
                        ]{
                        opcionaluno
                        }
\DefineVerbatimEnvironment{MyVerbatim}
{Verbatim}
{gobble=2,frame=lines,framerule=0.8mm}
\begin{document}
%Se convierte
\includegraphics[scale=1]{EXTRAIDO-fig-1}
 
\begin{mytcbliting}
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{postscript}
\end{mytcbliting}
%Se convierte
\includegraphics[scale=1]{EXTRAIDO-fig-2}
 
\begin{opcionaluno}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{opcionaluno}
 
\begin{MyVerbatim*}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{MyVerbatim*}
 
\newminted{algun}{options}
\begin{alguncode*}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{alguncode*}
 
\newminted[langA]{lang1}{options}
 
\begin{langA}[opciones]
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{langA}
 
\begin{langArm}[opciones]
%Se convierte
\includegraphics[scale=1]{EXTRAIDO-fig-3}
\end{langArm}
 
\section{minted inline}
\subsection{delimitado}
Original delimitado \mintinline{latex}|\begin{langA} ... \end{langA}| text
Original delimitado \mintinline{latex}|\begin{MyVerbatim*}| text
Original delimitado con opciones \mintinline[opciones]{latex}/\begin{pspicture}/ text
 
Definiendo nuevo mintinline delimitado \newmintinline{mylatex}{showspaces}
Definiendo nuevo mintinline delimitado \newmintinline{myotrolatex}{showspaces}
con opciones \mylatexinline[opciones]|\begin{pspicture}| y sin opciones \mylatexinline|\begin{pspicture}|
con opciones \myotrolatexinline[opciones]|\begin{pspicture}| y sin opciones \myotrolatexinline|\begin{pspicture}|
 
Definiendo nuevo mintinline con nombre propio delimitado \newmintinline[personal]{latex}{showspaces}
con opciones \personal[opciones]|\begin{pspicture}| y sin opciones \personal[opciones]|\begin{pspicture}|
 
\subsection{anidado}
Original anidado \mintinline{latexdos}{\begin{pspicture} y \end{pspicture}} text
Original anidado con opciones \mintinline[opciones]{latexdos}{\includegraphics[scale=1]{EXTRAIDO-fig-4}} text
 
Definiendo nuevo mintinline anidado \newmintinline{mylatexdos}{showspaces}
con opciones \mylatexdosinline[opciones]{\begin{pspicture} y \end{pspicture}} y sin opciones \mylatexdosinline{\begin{pspicture} y \end{pspicture}}
 
Definiendo nuevo mintinline con nombre propio anidado \newmintinline[personal]{latex}{showspaces}
con opciones \personal[opciones]{\begin{pspicture} y \end{pspicture}} y sin opciones \personal[opciones]{\begin{pspicture} y \end{pspicture}}
 
\subsection{new short minted}
\subsection{delimitado}
Original short \mint{python}|\begin{pspicture}|
 
Definiendo nuevo mint short default \newmint{mylenguaje}{showspaces}
\mylenguaje/\begin{pspicture}/ y \mylenguaje[opciones]/\begin{pspicture}/
 
Definiendo nuevo mint short custom \newmint[mymint]{mylenguaje}{showspaces}
\mymint/\begin{pspicture}/ \mymint[opciones]/\begin{pspicture}/ 
 
\subsection{anidado}
Original short \mint{lenguaje}{\begin{pspicture}}
 
\mylenguaje{\begin{pspicture} y \end{pspicture}} 
 
\mymint{\begin{pspicture} y \end{pspicture}} \mymint[opciones]{\begin{pspicture} y \end{pspicture}}
 
\section{tcolorbox}
\tcboxverb{\begin{pspicture} o \begin{pspicture*}} y \tcboxverb[algo]{\begin{pspicture} o {algo} o \begin{pspicture*}} 
 
Usamos \verb|\begin{pspicture} o \begin{pspicture*}| o \verb*|\begin{pspicture} o \begin{pspicture*}| (cambia)
 
\end{document}
IGNORAR
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{postscript}
Coloreado en 0.003 segundos,  usando GeSHi 1.0.8.4

donde la línea 85 del archivo de salida esta mal, debería ser:

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

Original anidado \mintinline{latexdos}{\begin{pspicture} y \end{pspicture}} text
Coloreado en 0.000 segundos,  usando GeSHi 1.0.8.4

lo cual me indica que tengo un error en una de las expresiones regulares y no logro dar con él.

Lo de tantos grep es por la forma de lo que deseo capturar, por ejemplo, en algunas ocasiones el texto sobre el cual hago la búsqueda es de la forma:

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

\DefineVerbatimEnvironment{% algo algo
     MyVerbatim % algo algo
                %%% algo algo
}
Coloreado en 0.000 segundos,  usando GeSHi 1.0.8.4

o

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

\DefineVerbatimEnvironment%
     {% algo algo
 
       MyVerbatim %%% algo algo
      %%% algo algo
 
}
Coloreado en 0.000 segundos,  usando GeSHi 1.0.8.4

y solo me interesa la palabra MyVerbatim, el símbolo % es el equivalente a # en Perl. Como no logré la expresión regular, me vi obligado a usar varias veces grep.

Agradecido de antemano.
Pablo

#!/usr/bin/perl
use v5.20;
use autodie;                                            # muere si ocurre un error
use File::Basename;                                     # separa el archivo de entrada
use Data::Dumper;
 
### Argumentos ---------------------------------------------------------
@ARGV == 1  or die "Uso: $0 <archivo TeX a procesar>\n";
my $nombre_archivo = shift;
-f $nombre_archivo or die "ERROR: No encuentro [$nombre_archivo]\n";
 
### Arreglo de la extensión --------------------------------------------
my @SuffixList = ('.tex', '', '.ltx');                  # posible extensión
my ($name, $path, $ext) = fileparse($nombre_archivo, @SuffixList);
$ext = '.tex' if not $ext;                              # fijamos la extensión
 
### Directorio para las imágenes y otros
my $imageDir  = "images";       
my $myverb    = "myverb";       
my $ignore    = "ignore";       
 
### Abrimos el archivo de entrada a modificar --------------------------
open my $ENTRADA, '<', $nombre_archivo;
my $archivo;
{
    local $/;
    $archivo = <$ENTRADA>;
}
close   $ENTRADA;
 
## Cambios a realizar
my %cambios = (
        '\pspicture'                => '\TRICKS',
        '\endpspicture'             => '\ENDTRICKS',
 
        '\begin{pspicture'          => '\begin{TRICKS',
        '\end{pspicture'            => '\end{TRICKS',
        
        '\begin{postscript}'        => '\begin{POSTRICKS}',
        '\end{postscript}'          => '\end{POSTRICKS}',
);
 
## Variables y constantes
my $no_del = "\0";
my $del    = $no_del;
 
## Reglas 
my $braces      = qr/ (?:\{)(.+?)(?:\})         /msx;
my $braquet     = qr/ (?:\[)(.+?)(?:\])         /msx;
my $llaves      = qr/ \{ .+? \}                 /x;
my $no_llaves   = qr/ (?:\{ .+? \})             /x;
my $no_corchete = qr/ (?:\[ .+? \])?            /msx;
my $delimitador = qr/\{ (?<del>.+?) \}          /x;
my $anidado     = qr/(\{(?:[^\{\}]++|(?1))*\})  /x;
 
# TCOLORBOX ... \begin{...} ... \end{...} del paquete tcolorbox
my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /msx;
my $tcbxpack = qr/\\ (?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) $braces /msx;
 
# MINTED ... \begin{...} ... \end{...}, inline del paquete minted
my $mintdenv   = qr/\\ newminted $braces (?:\{.+?\})            /x;
my $mintcenv   = qr/\\ newminted $braquet (?:\{.+?\})           /x;
my $mintdshrt  = qr/\\ newmint $braces (?:\{.+?\})              /x; 
my $mintcshrt  = qr/\\ newmint $braquet (?:\{.+?\})             /x; 
my $mintdline  = qr/\\ newmintinline $braces (?:\{.+?\})        /x;
my $mintcline  = qr/\\ newmintinline $braquet (?:\{.+?\})       /x;   
 
### Expresión regular pasada a un array
my @mint_denv  = $archivo =~ m/$mintdenv/xg;  # \newminted{$mintdenv}{options} (for)
my @mint_cenv  = $archivo =~ m/$mintcenv/xg;  # \newminted[$mintcenv]{lang} (for)
my @mint_dshrt = $archivo =~ m/$mintdshrt/xg; # \newmint{$mintdshrt}{options} (while)
my @mint_cshrt = $archivo =~ m/$mintcshrt/xg; # \newmint[$mintcshrt]{lang}{options} (while)
my @mint_dline = $archivo =~ m/$mintdline/xg; # \newmintinline{$mintdline}{options} (while)
my @mint_cline = $archivo =~ m/$mintcline/xg; # \newmintinline[$mintcline]{lang}{options} (while)
my @tcolorbox  = $archivo =~ m/$tcbxpack/gmsx; # \newenvironment[...]{$tcbxpack} (for)
 
### Quitamos los elementos duplicados del array
sub uniq {
    my %seen;
    grep !$seen{$_}++, @_;
}
@mint_denv  = uniq(@mint_denv) ; 
@mint_cenv  = uniq(@mint_cenv) ; 
@mint_dline = uniq(@mint_dline); 
@mint_cline = uniq(@mint_cline); 
@mint_dshrt = uniq(@mint_dshrt); 
@mint_cshrt = uniq(@mint_cshrt); 
@tcolorbox  = uniq(@tcolorbox) ; 
 
### Quitamos los espacios, % y líneas en blanco 
@mint_denv  = grep(!/\%/, @mint_denv);
@mint_cenv  = grep(!/\%/, @mint_cenv);
@mint_dline = grep(!/\%/, @mint_dline);
@mint_cline = grep(!/\%/, @mint_cline);
@mint_dshrt = grep(!/\%/, @mint_dshrt);
@mint_cshrt = grep(!/\%/, @mint_cshrt);
@tcolorbox  = grep(!/\%/, @tcolorbox);
 
@mint_denv  = grep /\S/, @mint_denv;
@mint_cenv  = grep /\S/, @mint_cenv;
@mint_dline = grep /\S/, @mint_dline;
@mint_cline = grep /\S/, @mint_cline;
@mint_dshrt = grep /\S/, @mint_dshrt;
@mint_cshrt = grep /\S/, @mint_cshrt;
@tcolorbox  = grep /\S/, @tcolorbox;
 
s{^\s+|\s+$}{}g foreach @mint_denv;
s{^\s+|\s+$}{}g foreach @mint_cenv;
s{^\s+|\s+$}{}g foreach @mint_dline;
s{^\s+|\s+$}{}g foreach @mint_cline;
s{^\s+|\s+$}{}g foreach @mint_dshrt;
s{^\s+|\s+$}{}g foreach @mint_cshrt;
s{^\s+|\s+$}{}g foreach @tcolorbox;
 
# Agregamos "code" e "inline" para usar en qr/
if (!@mint_denv == 0) {
    $mintdenv   = join "\n", map { qq/$_\Qcode\E/ } @mint_denv;
    @mint_denv  = split /\n/, $mintdenv; # (for)
}
if (!@mint_dline == 0) {
    $mintdline  = join "\n", map { qq/$_\Qinline\E/ } @mint_dline;
    @mint_dline = split /\n/, $mintdline; # (while)
}
 
# Agregamos la palabra "TMP" para crear el hash
my $mintdenv_hash   = join "\n", map { qq/TMP$_/ } @mint_denv; # default
my @mint_denv_hash  = split /\n/, $mintdenv_hash; # default
my $mintcenv_hash   = join "\n", map { qq/TMP$_/ } @mint_cenv; # custom
my @mint_cenv_hash  = split /\n/, $mintcenv_hash; # custom
my $tcolorbox_hash  = join "\n", map { qq/TMP$_/ } @tcolorbox; # default
my @tcolorbox_hash  = split /\n/, $tcolorbox_hash; # default
 
# Array para el hash de entrada con las palabras sin TMP
my @infile_verb;  
push(@infile_verb,@mint_denv, @mint_cenv, @tcolorbox);
 
# Array para el hash de salida con las palabras con TMP
my @outfile_verb;
push(@outfile_verb,@mint_denv_hash, @mint_cenv_hash, @tcolorbox_hash);
 
# Ahora creamos hash para la entrada y salida del archivo
my %hash_entrada;
@hash_entrada{@infile_verb} = @outfile_verb;
 
my %hash_salida;
@hash_salida{@outfile_verb} = @infile_verb;
 
# Creamos %nuevo = (%cambios,%hash_entrada) y lo pasamos por (for) y (while)
my %nuevo = (%cambios,%hash_entrada);
 
# Pasamos @infile_verb y minted a  \qr 
my $fileverb = join "|", map quotemeta, @infile_verb; # \begin{...} ... \end{...}
$mintdline   = join "|", map quotemeta, @mint_dline; # inline verbatim default
$mintcline   = join "|", map quotemeta, @mint_cline; # inline verbatim custom
$mintdshrt   = join "|", map quotemeta, @mint_dshrt; # inline verbatim default
$mintcshrt   = join "|", map quotemeta, @mint_cshrt; # inline verbatim custom
$fileverb       = qr/\b(?:$fileverb)/x; # se comporta \begin{...} ... \end{...} (for)
my $newmintinline   = qr/\b(?:$mintdline|$mintcline)/x; # se comporta como lst y tcbx anidado
$mintcshrt = qr/\b(?:$mintcshrt)/x; # se comporta como lst , no soporta anidado
$mintdshrt = qr/\b(?:$mintdshrt)/x; # se comporta como lst , no soporta anidado
 
### Reglas de captura
my $verb        = qr/(?:(spv|v|V)erb | $myverb) [*]?                                            /ix;
my $lst         = qr/(?:lstinline|$myverb|$newmintinline|$mintcshrt|$mintdshrt)(?!\*) $no_corchete /ix;
### mint y mintinline por defecto
my $mint        = qr/ mint(?:inline)?(?!\*) $no_corchete $llaves                                /ix;
my $marca       = qr/\\ (?:$verb | $lst| $mint ) (\S) .+? \g{-1}                                /x;
### Comentarios y delimitadores
my $comentario  = qr/^ \s* \%+ .+? $                                                            /mx;
my $definedel   = qr/\\ (?:   DefineShortVerb | lstMakeShortInline  ) $no_corchete $delimitador /ix;
my $indefinedel = qr/\\ (?: UndefineShortVerb | lstDeleteShortInline) $llaves                   /ix;
### tcbverb,minted,mintline anidados
my $mintd_ani   = qr/\\ mint(?:inline)? (?!\*) $no_corchete $no_llaves                          /ix;
my $tcbxverb    = qr/\\ (?: tcboxverb [*]?|$myverb [*]?|$newmintinline (?!\*))  $no_corchete    /ix;
my $tcbxmint    = qr/(?:$tcbxverb|$mintd_ani) $anidado                                          /x; 
 
### Cambiar cuando aparece en una sola línea
while ($archivo =~
        /   $tcbxmint
        |   $marca
        |   $comentario
        |   $definedel
        |   $indefinedel
        |   $del .+? $del                                                       # delimitado
        /pgmx) {
 
        my($pos_inicial, $pos_final) = ($-[0], $+[0]);                          # posiciones
        my $encontrado = ${^MATCH};                                             # lo encontrado
 
    if ($encontrado =~ /$definedel/){                                           # definimos delimitador
                        $del = $+{del};
                        $del = "\Q$+{del}" if substr($del,0,1) ne '\\';         # es necesario "escapar" el delimitador
                }
    elsif($encontrado =~ /$indefinedel/) {                                      # indefinimos delimitador
                 $del = $no_del;                                        
        }
    else {                                                                      # aquí se hacen los cambios
        while (my($busco, $cambio) = each %nuevo) {
                       $encontrado =~ s/\Q$busco\E/$cambio/g;                   # es necesario escapar $busco
        }
        substr $archivo, $pos_inicial, $pos_final-$pos_inicial, $encontrado;    # insertamos los nuevos cambios
 
        pos($archivo)= $pos_inicial + length $encontrado;                       # re posicionamos la siguiente búsqueda
    }
}
 
### Definimos los entornos en los cuales haremos los cambios
my $Verbatim  = qr/(?:(v|V)erbatim\*?     | # verbatim and fancyvrb 
(?:(?:P)?Center|(?:P)?SideBySide)?Example | # fancyvrb
                           PSTexample     | # pst-exa 
                           PSTcode        | # pst-exa 
                           LTXexample     | # showexpl 
                           $ignore\*?     | # $ignore 
                           tcblisting\*?  | # tcolorbox 
                        tcboutputlisting  | # tcolorbox 
                           tcbexternal    | # tcolorbox 
                           extcolorbox    | # tcolorbox 
                           extikzpicture  | # tcolorbox 
                           spverbatim     | # spverbatim
                           minted         | # minted
                           listing        | # minted
                           lstlisting     | # listing
                           alltt          | # alltt 
                           comment\*?     | # comment 
                           xcomment         # xcomment
                           )/x;
 
### Dividimos por líneas el archivo de entrada
my @lineas = split /\n/, $archivo;
 
### Del    
my $DEL;
 
### Hacemos los cambios dentro de los entornos \begin{...} ... \end{...}
for (@lineas) {
    if (/\\begin\{($fileverb\*?|$Verbatim)(?{ $DEL = "\Q$^N" })\}/ .. /\\end\{$DEL\}/) {
        while (my($busco, $cambio) = each %cambios) {
            s/\Q$busco\E/$cambio/g;
        }
    }
} # close 
 
### Volvemos 
$archivo = join("\n", @lineas); 
 
### Ahora dividimos el archivo de entrada
my($cabeza,$cuerpo,$final) = $archivo =~ m/\A (.+?) (\\begin\{document\} .+?)(\\end\{document\}.*)\z/msx;
 
### postscript environment
my $BPL        = '\begin{postscript}';
my $EPL        = '\end{postscript}';
my $POSTSCRIPT = qr/(?: postscript)/xi;
 
### tikzpicture environment
my $ENVIRONMENT    = qr/(?: tikzpicture | pspicture\*?)/xi;
 
### \pspicture a \begin{pspicture}
$cuerpo =~ s/\\pspicture(\*)?(.+?)\\endpspicture/\\begin{pspicture$1}$2\\end{pspicture$1}/gmsx;
 
### tikz/pst a Postscript
$cuerpo =~ s/\\begin\{($POSTSCRIPT)\}.+?\\end\{\g{-1}\}(*SKIP)(*F)|
        (
        (?:\\(psset|tikzset)(\{(?:\{.*?\}|[^\{])*\}).*?)?  # si está lo guardo
        (\\begin\{($ENVIRONMENT)\} (.*?)  \\end\{\g{-2}\})
    )
    /$BPL\n$1\n$EPL/gmsx;
 
### Convertir
my $grap  = "\\includegraphics[scale=1]{EXTRAIDO-fig-";
my $close = '}';
my $imgNo = 1; # 
my $BP    = '\\\\begin\{postscript\}';
my $EP    = '\\\\end\{postscript\}';
$cuerpo   =~ s/$BP.+?$EP/$grap@{[$imgNo++]}$close/msg; # 
 
my %cambios = (
# pst/tikz set    
    '\PSSET'                    =>      '\psset',
    '\TIKZSET'                  =>      '\tikzset',                     
# pspicture    
    '\TRICKS'                   =>      '\pspicture',
    '\ENDTRICKS'                =>      '\endpspicture',             
# pspicture
    '\begin{TRICKS'             =>      '\begin{pspicture',
    '\end{TRICKS'               =>      '\end{pspicture',
# postscript
    '\begin{POSTRICKS}'         =>      '\begin{postscript}',
    '\end{POSTRICKS}'           =>      '\end{postscript}',
);
 
%nuevo = (%cambios,%hash_salida);
 
### Reemplazamos y unimos
while (my($busco, $cambio) = each %nuevo) {
    $cabeza =~ s/\Q$busco\E/$cambio/g;
    $cuerpo =~ s/\Q$busco\E/$cambio/g;
    $final  =~ s/\Q$busco\E/$cambio/g;
}
            
### Escritura del resultado
open my $SALIDA, '>', "$name-out$ext";
print   $SALIDA "$cabeza$cuerpo$final";
close   $SALIDA;
 
__END__
#delete @cambios{'\begin{postscript}','\end{postscript}'}; 
#print Dumper(\%cambios);
 
Coloreado en 0.009 segundos,  usando GeSHi 1.0.8.4

Con un archivo de entrada de la siguiente forma:

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

\documentclass{article}
\usepackage{minted}
\usepackage{pstricks-add}
\usepackage{auto-pst-pdf}
\DefineVerbatimEnvironment{MyVerbatim}
\begin{document}
%Se convierte EXTRAIDO-fig-1
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se convierte 
\end{pspicture}
\end{postscript}
 
\begin{MyVerbatim}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{MyVerbatim}
 
\begin{Verbatim*}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{Verbatim*}
 
\newminted[langA]{latex}{linenos}
 
\begin{langA}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{langA}
%Se convierte EXTRAIDO-fig-2
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se convierte
\end{pspicture}
\end{postscript}
 
\section{minted inline default}
Original delimitado \mintinline{latex}|\mintinline{lang}<del> code <del>| text
Ejemplo delimitado \mintinline{latex}|\begin{langA} y\end{langA}| text
 
Original delimitado con opciones \mintinline{latex}|\mintinline[opt]{lang}<del> code <del>| text
Ejemplo delimitado con opciones \mintinline[linenos]{latex}/\begin{pspicture} y \end{pspicture}/ text
 
 
Original anidado \mintinline{latex}|\mintinline{lang}{ code }| text
Ejemplo original anidado \mintinline{latex}{\begin{pspicture} y \end{pspicture}} 
 
Original anidado con opciones \mintinline{latex}|\mintinline[opt]{lang}{ code }| text
Ejemplo original anidado con opciones \mintinline[linenos]{latex}{ \begin{pspicture} y \end{pspicture}} 
 
\section{minted inline custom}
 
Definicion por defecto del comando  \mintinline{latex}|\newmintinline{lang}{opt}|
\newmintinline{perl}{showspaces}
 
Ejemplo sin opciones X\perlinline/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\nameinline<del> code <del>|
 
Ejemplo con opciones X\perlinline[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\nameinline[opt]<del> code <del>|
 
Ejemplo con opciones anidado \perlinline[linenos]{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\nameinline[opt]{ code }|
 
Ejemplo sin opciones anidado \perlinline{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\nameinline{ code }|
 
Definicion personalizada del comando  \mintinline{latex}|\newmintinline[name]{lang}{opt}|
\newmintinline[name]{latex}{showspaces}
 
Ejemplo sin opciones X\name/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name<del> code <del>|
 
Ejemplo con opciones X\name[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
 
Ejemplo con opciones anidado \name[linenos]{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\name[opt]{ code }|
 
Ejemplo sin opciones anidado \name{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\name{ code }|
 
\section{mint short}
 
Original delimitado \mintinline{latex}|\mint{lang}<del> code <del>| text
Ejemplo delimitado \mint{latex}|\begin{pspicture} y \end{pspicture}| text
 
Original delimitado con opciones \mintinline{latex}|\mint[opt]{lang}<del> code <del>| text
Ejemplo delimitado con opciones \mint[linenos]{latex}/\begin{pspicture} y \end{pspicture}/ text
 
 
Original anidado \mintinline{latex}|\mint{lang}{ code }| text
Ejemplo original anidado \mint{latex}{\begin{pspicture} y \end{pspicture}} 
 
Original anidado con opciones \mintinline{latex}|\mint[opt]{lang}{ code }| text
Ejemplo original anidado con opciones \mint[linenos]{latex}{ \begin{pspicture} y \end{pspicture}} 
 
\section{mint short custom}
Definicion por defecto comando  \mintinline{latex}|\newmint{lang}{opt}|
\newmint{latex}{showspaces}
 
Ejemplo sin opciones X\latex/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\lang<del> code <del>|
 
Ejemplo con opciones X\latex[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\lang[opt]<del> code <del>|
 
Definicion personalizada del comando  \mintinline{latex}|\newmint[name]{lang}{opt}|
\newmint[mylatex]{latex}{showspaces}
 
 
Ejemplo sin opciones X\mylatex/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name<del> code <del>|
 
Ejemplo con opciones X\mylatex[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
 
%Ejemplo sin opciones anidado X\mylatex{\begin{pspicture} y \end{pspicture}}X de forma  \mintinline{latex}|\name<del> code <del>|
 
%Ejemplo con opciones X\mylatex[linenos]{\begin{pspicture} y \end{pspicture}}X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
 
%Se convierte EXTRAIDO-fig-3
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se convierte
\end{pspicture}
\end{postscript}
 
\end{document}
 
IGNORAR
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{postscript}
 
Coloreado en 0.003 segundos,  usando GeSHi 1.0.8.4

Obtengo el archivo de salida:

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

\documentclass{article}
\usepackage{minted}
\usepackage{pstricks-add}
\usepackage{auto-pst-pdf}
\DefineVerbatimEnvironment{MyVerbatim}
\begin{document}
%Se convierte EXTRAIDO-fig-1
\includegraphics[scale=1]{EXTRAIDO-fig-1}
 
\begin{MyVerbatim}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{MyVerbatim}
 
\begin{Verbatim*}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{Verbatim*}
 
\newminted[langA]{latex}{linenos}
 
\begin{langA}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{langA}
%Se convierte EXTRAIDO-fig-2
\includegraphics[scale=1]{EXTRAIDO-fig-2}
 
\section{minted inline default}
Original delimitado \mintinline{latex}|\mintinline{lang}<del> code <del>| text
Ejemplo delimitado \mintinline{latex}|\begin{langA} y\end{langA}| text
 
Original delimitado con opciones \mintinline{latex}|\mintinline[opt]{lang}<del> code <del>| text
Ejemplo delimitado con opciones \mintinline[linenos]{latex}/\begin{pspicture} y \end{pspicture}/ text
 
 
Original anidado \mintinline{latex}|\mintinline{lang}{ code }| text
Ejemplo original anidado \mintinline{latex}{\begin{pspicture} y \end{pspicture}} 
 
Original anidado con opciones \mintinline{latex}|\mintinline[opt]{lang}{ code }| text
Ejemplo original anidado con opciones \mintinline[linenos]{latex}{ \begin{pspicture} y \end{pspicture}} 
 
\section{minted inline custom}
 
Definicion por defecto del comando  \mintinline{latex}|\newmintinline{lang}{opt}|
\newmintinline{perl}{showspaces}
 
Ejemplo sin opciones X\perlinline/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\nameinline<del> code <del>|
 
Ejemplo con opciones X\perlinline[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\nameinline[opt]<del> code <del>|
 
Ejemplo con opciones anidado \perlinline[linenos]{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\nameinline[opt]{ code }|
 
Ejemplo sin opciones anidado \perlinline{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\nameinline{ code }|
 
Definicion personalizada del comando  \mintinline{latex}|\newmintinline[name]{lang}{opt}|
\newmintinline[name]{latex}{showspaces}
 
Ejemplo sin opciones X\name/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name<del> code <del>|
 
Ejemplo con opciones X\name[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
 
Ejemplo con opciones anidado \name[linenos]{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\name[opt]{ code }|
 
Ejemplo sin opciones anidado \name{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\name{ code }|
 
\section{mint short}
 
Original delimitado \mintinline{latex}|\mint{lang}<del> code <del>| text
Ejemplo delimitado \mint{latex}|\begin{pspicture} y \end{pspicture}| text
 
Original delimitado con opciones \mintinline{latex}|\mint[opt]{lang}<del> code <del>| text
Ejemplo delimitado con opciones \mint[linenos]{latex}/\begin{pspicture} y \end{pspicture}/ text
 
 
Original anidado \mintinline{latex}|\mint{lang}{ code }| text
Ejemplo original anidado \mint{latex}{\begin{pspicture} y \end{pspicture}} 
 
Original anidado con opciones \mintinline{latex}|\mint[opt]{lang}{ code }| text
Ejemplo original anidado con opciones \mint[linenos]{latex}{ \begin{pspicture} y \end{pspicture}} 
 
\section{mint short custom}
Definicion por defecto comando  \mintinline{latex}|\newmint{lang}{opt}|
\newmint{latex}{showspaces}
 
Ejemplo sin opciones X\latex/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\lang<del> code <del>|
 
Ejemplo con opciones X\latex[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\lang[opt]<del> code <del>|
 
Definicion personalizada del comando  \mintinline{latex}|\newmint[name]{lang}{opt}|
\newmint[mylatex]{latex}{showspaces}
 
 
Ejemplo sin opciones X\mylatex/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name<del> code <del>|
 
Ejemplo con opciones X\mylatex[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
 
%Ejemplo sin opciones anidado X\mylatex{\begin{pspicture} y \end{pspicture}}X de forma  \mintinline{latex}|\name<del> code <del>|
 
%Ejemplo con opciones X\mylatex[linenos]{\begin{pspicture} y \end{pspicture}}X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
 
%Se convierte EXTRAIDO-fig-3
\includegraphics[scale=1]{EXTRAIDO-fig-3}
 
\end{document}
 
IGNORAR
\begin{postscript}
\begin{pspicture}[showgrid](0,3)(10,10)
Se queda
\end{pspicture}
\end{postscript}
Coloreado en 0.003 segundos,  usando GeSHi 1.0.8.4

Que es lo que deseo.

Ahora me que da por resolver dos cosas:
1. Reducir las líneas de grep sobre array (pasarlos a una función) para reducir un poco el código.
2. Crear o modificar una expresión regular de la forma:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

my $braces   = qr/ (?:\{)(.+?)(?:\})                               /msx;
my $fancyvrb = qr/\\ (?:DefineVerbatimEnvironment)    $braces       /msx;
my @array    = $archivo =~ m/$fancyvrb/gmsx; # \newenvironment{...}(for)
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Para capturar líneas como:

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

\DefineVerbatimEnvironment{% ignorar
 
     MyVerbatim % ignorar ignorar
 
                %%% ignorar
}
Coloreado en 0.000 segundos,  usando GeSHi 1.0.8.4

y quedarme solo con la palabra MyVerbatim en este caso, es decir, no capturar nada que comience por %. Sé que lo que busco es solo una palabra (sin espacios ni caracteres de puntuación).

Cualquier ayuda con esto se agradece.
Saludos,
Pablo

por **pablgonz** » 2016-04-24 12:16 @553

Le dí un par de vueltas al asunto y creo que no es posible definir una expresión regular que "salte" las líneas que comienzan con % y busque solo aquellas que empiezan por espacios, única palabra y termine en % o } (sin incluir % o }).

Intente con (*SKIP), (*ACCEPT) y otras expresiones extendidas y no tuve suerte. ¿Habrá otra forma de abordar mi problema? o ¿no es posible mediante una expresión regular lograr lo que deseo?

Saludos.
Pablo

por **explorer** » 2016-04-24 18:20 @805

pablgonz escribiste:Le dí un par de vueltas al asunto y creo que no es posible definir una expresión regular que "salte" las líneas que comienzan con % y busque solo aquellas que empiezan por espacios, única palabra y termine en % o } (sin incluir % o }).

Esta frase, de por sí, ya es un patrón. Lo que falta es convertirlo a un patrón de expresiones regulares.

En algunos casos se puede resolver de forma global (procesar todas las líneas como un conjunto), y otras veces, local (línea a línea), y otras, haciendo un intérprete (parser), para que lo analice token a token.

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/env perl
use v5.14;
use autodie;
 
my $x = '
 
\DefineVerbatimEnvironment{% ignorar
 
        MyVerbatim % ignorar ignorar
 
                    %%% ignorar
}
 
';
 
#say $x;
 
my $palabra = qr/\w+/;
my $verbo   = qr/^ \\ $palabra \{ (.+) \}/msx;
 
if ($x =~ /$verbo/) {
 
    my $contenido = $1;
    #say $contenido;
 
    $contenido =~ s/%.*\n//mg;          # quitar comentarios
    $contenido =~ s/^\s*|\s*//mg;       # quitar espacios en blanco
 
    say "[$contenido]";
}
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

por **pablgonz** » 2016-04-24 20:05 @879

Genial, gracias por la respuesta, había leído por ahí algo relacionado a un intérprete o parser, claro que los ejemplos que encontré usaban (DEFINE) y eran bastante complicados para mi.

Probé el código que publicaste y lo adapte más menos a lo que deseo, claro solo funciona cuando el texto es único dentro del string que busco, es decir, si la entrada es algo así:

Sintáxis: [ Descargar ] [ Ocultar ]

Using latex Syntax Highlighting

\newtcblisting{% ignorar
 
    MyVerbatimUno % ignorar si sale {}{{{ o más %%ignorar%%
 
                     %%% ignorar
} % cerrar  
 
\DefineVerbatimEnvironment{% un comentario
        %% ignorar uno
        %% ignorar dos 
    MyVerbatimDOS % esto es lo que deseo capturar
        %% ignorar tres
}% cerrar 
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

no captura MyVerbatimUno y MyVerbatimDOS que son justo las palabras que deseo dejar en un array, ¿cómo modifico el código para lograrlo?
Por el momento lo tengo escrito así:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
use v5.14;
use autodie;    # muere si ocurre un error
 
# \begin{...} ... \end{...} del paquete tcolorbox y otros
my $no_corchete = qr/ (?:\[ .+? \])?            /msx;
my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /x;
my $tcbxpack = qr/(?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) /x;
 
my $x = '
 
\newtcblisting{% ignorar
 
    MyVerbatimUno % ignorar si sale {}{{{ o más %%ignorar%%
 
                     %%% ignorar
} % cerrar  
 
\DefineVerbatimEnvironment{% un comentario
        %% ignorar uno
        %% ignorar dos 
    MyVerbatimDOS % esto es lo que deseo capturar
        %% ignorar tres
}% cerrar 
 
';
 
my $verbo   = qr/^ \\ $tcbxpack \s*\{ (.+) \}/msx;
 
if ($x =~ /$verbo/) {
    my $contenido = $1;
    $contenido =~ s/%.*\n//mg;          # quitar comentarios
    $contenido =~ s/^\s*|\s*//mg;       # quitar espacios en blanco
 say "[$contenido]";
}
 
my @tcolorbox = $x =~ m/ $verbo /msxg;
 
say "@tcolorbox";
 
__END__
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

Agradecido nuevamente.
Saludos

por **explorer** » 2016-04-25 03:35 @191

Para facilitar las cosas, yo lo que haría, primero, es filtrar todo el texto, para quitar los comentarios, los espacios que hay de sobra al final de las líneas, y finalmente, las líneas en blanco.

Así, queda el código más compacto, y más fácil de pasar por las exp. reg.

por **pablgonz** » 2016-04-25 21:34 @940

explorer escribiste:Para facilitar las cosas, yo lo que haría, primero, es filtrar todo el texto, para quitar los comentarios, los espacios que hay de sobra al final de las líneas, y finalmente, las líneas en blanco...

Sería el ideal, pero, los caracteres de % si bien son comentarios, también significan otra cosa en algunos contextos, por ejemplo \% es un símbolo de porcentaje literal en Latex, y en algunas ocasiones sirve para marcar el final de una instrucción y que el kernel de latex no expanda la línea más allá de lo indicado.

Si entendí bien tendría que crear un array con $x, quitar los caracteres que estorban, guardar la palabra que busco y luego volver a $x (que representa mi archivo de entrada) y hacer las modificaciones que deseo, sin tocar el resto del archivo.

Esto es lo que estuve probando, pero mi array guarda más de lo que necesito

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
use v5.14;
use autodie;    # muere si ocurre un error
 
# \begin{...} ... \end{...} del paquete tcolorbox y otros
my $no_corchete = qr/ (?:\[ .+? \])?            /msx;
my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /x;
my $tcbxpack = qr/(?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) /x;
 
my $x = '
 
\newtcblisting{% ignorar
 
    MyVerbatimUno % ignorar si sale {}{{{ o más %%ignorar%%
 
                     %%% ignorar
} % cerrar  
 
\DefineVerbatimEnvironment{% un comentario
        %% ignorar uno
        %% ignorar dos 
    MyVerbatimDOS % esto es lo que deseo capturar
        %% ignorar tres
}% cerrar 
 
';
 
my $verbo   = qr/ \\ $tcbxpack \{ (.+) \}/msx;
 
#if ($x =~ /$verbo/) {
    #my $contenido = $1;
    #$contenido =~ s/%.*\n//mg;          # quitar comentarios
    #$contenido =~ s/^\s*|\s*//mg;       # quitar espacios en blanco
##say "[$contenido]";
#}
 
### pasamos a un array el contenido de entrada
my @tcolorbox = $x;
 
s/%.*\n//mg foreach @tcolorbox; # quitar comentarios
s/^\s*|\s*//mg foreach @tcolorbox; # quitar espacios en blanco
 
### filtramos con grep y regex para quedarnos con la palabra buscada
@tcolorbox = grep { /($verbo)/ } @tcolorbox;
 
say "@tcolorbox";
 
__END__
 
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

¿Era algo así la idea que propusiste?

Agradecido por todo.
Pablo

por **pablgonz** » 2016-04-29 15:33 @689

Ya lo logré, me faltaba unir los cambios, quedo así:

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

#!/usr/bin/perl
use v5.14;
use autodie;    # muere si ocurre un error
 
my $x = '
 
\newtcblisting{% ignorar
 
    MyVerbatimUno % ignorar si sale {}{{{ o más %%ignorar%%
 
                     %%% ignorar
} % cerrar  
 
\DefineVerbatimEnvironment{% un comentario
        %% ignorar uno
        %% ignorar dos 
    MyVerbatimDOS % esto es lo que deseo capturar
        %% ignorar tres
}% cerrar 
 
 
\DefineVerbatimEnvironment{% un comentario
        %% ignorar uno
        %% ignorar dos 
    MyVerbatimTres % esto es lo que deseo capturar
        %% ignorar tres
}% cerrar 
Y si coloco palabras por aqui %%%
y algunas otras cosas como \newtcblisting
\newtcblisting [algo]{% ignorar
 
    MyVerbatimCuatro % ignorar si sale {}{{{ o más %%ignorar%%
 
                     %%% ignorar
} % cerrar  
 
\RenewTCBListing[
                        opcion                  
                        ]{
                        opcionaluno
                        }
\DefineVerbatimEnvironment{MyVerbatimFinal}
 
';
 
### Pasamos a un array el contenido de entrada
my @tcolorbox = $x;
 
### Filtramos con grep y regex para quedarnos con la palabra buscada
s/%.*\n//mg foreach @tcolorbox; # quitar comentarios
s/^\s*|\s*//mg foreach @tcolorbox; # quitar espacios en blanco 
 
### Reglas 
my $braces      = qr/ (?:\{)(.+?)(?:\})         /msx;
my $no_corchete = qr/ (?:\[ .+? \])?            /msx;
 
### TCOLORBOX ... \begin{...} ... \end{...} del paquete tcolorbox
my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /msx;
my $tcbxpack = qr/\\ (?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) $braces /msx;
 
### Unimos los modificaciones
my $fileverb = join '', @tcolorbox; 
 
### Extraemos con regex 
@tcolorbox  = $fileverb =~ m/$tcbxpack/gmsx;  
 
### Pasamos @tcolorbox a  \qr 
$fileverb = join "|", map quotemeta, @tcolorbox; 
$fileverb       = qr/\b(?:$fileverb)/x; 
 
say "$fileverb";
 
__END__
 
Coloreado en 0.002 segundos,  usando GeSHi 1.0.8.4

Las líneas 50 y 51

Sintáxis: [ Descargar ] [ Ocultar ]

Using perl Syntax Highlighting

s/%.*\n//mg foreach @tcolorbox; # quitar comentarios
s/^\s*|\s*//mg foreach @tcolorbox; # quitar espacios en blanco 
Coloreado en 0.001 segundos,  usando GeSHi 1.0.8.4

quedaron un poco "feas" y es más que seguro que estoy escribiendo algunas líneas que me podría ahorrar y algunos modificadores están de sobra, pero, cumple el objetivo.

Agradecido por todo.
Pablo

Foro - Perl en Español

Pasar grep a una función y modificar expresión regular

Pasar grep a una función y modificar expresión regular

Publicidad

Re: Pasar grep a una función y modificar expresión regular

Re: Pasar grep a una función y modificar expresión regular

Re: Pasar grep a una función y modificar expresión regular

Re: Pasar grep a una función y modificar expresión regular

Re: Pasar grep a una función y modificar expresión regular

Re: Pasar grep a una función y modificar expresión regular

Re: Pasar grep a una función y modificar expresión regular

¿Quién está conectado?