• Publicidad

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

¿Apenas comienzas con Perl? En este foro podrás encontrar y hacer preguntas básicas de Perl con respuestas aptas a tu nivel.

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

Notapor 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
  1. #!/usr/bin/perl
  2. use v5.20;
  3. use autodie;                                            # muere si ocurre un error
  4. use File::Basename;                                     # separa el archivo de entrada
  5. use Data::Dumper;
  6. ### Argumentos ---------------------------------------------------------
  7. @ARGV == 1  or die "Uso: $0 <archivo TeX a procesar>\n";
  8. my $nombre_archivo = shift;
  9. -f $nombre_archivo or die "ERROR: No encuentro [$nombre_archivo]\n";
  10.  
  11. ### Arreglo de la extensión --------------------------------------------
  12. my @SuffixList = ('.tex', '', '.ltx');                  # posible extensión
  13. my ($name, $path, $ext) = fileparse($nombre_archivo, @SuffixList);
  14. $ext = '.tex' if not $ext;                              # fijamos la extensión
  15.  
  16. ### Directorio para las imágenes y otros
  17. my $imageDir  = "images";      
  18. my $myverb    = "myverb";      
  19. my $ignore    = "ignore";      
  20.  
  21. ### Abrimos el archivo de entrada a modificar --------------------------
  22. open my $ENTRADA, '<', $nombre_archivo;
  23. my $archivo;
  24. {
  25.     local $/;
  26.     $archivo = <$ENTRADA>;
  27. }
  28. close   $ENTRADA;
  29.  
  30. ## Cambios a realizar
  31. my %cambios = (
  32.         '\pspicture'                => '\TRICKS',
  33.         '\endpspicture'             => '\ENDTRICKS',
  34.  
  35.         '\begin{pspicture'          => '\begin{TRICKS',
  36.         '\end{pspicture'            => '\end{TRICKS',
  37.        
  38.         '\begin{postscript}'        => '\begin{POSTRICKS}',
  39.         '\end{postscript}'          => '\end{POSTRICKS}',
  40. );
  41.  
  42. ## Variables y constantes
  43. my $no_del = "\0";
  44. my $del    = $no_del;
  45.  
  46. ## Reglas
  47. my $braces      = qr/ (?:\{)(.+?)(?:\})         /msx;
  48. my $braquet     = qr/ (?:\[)(.+?)(?:\])         /msx;
  49. my $llaves      = qr/\{ .+? \}                  /x;
  50. my $no_corchete = qr/(?:\[ .+? \])?             /msx;
  51. my $delimitador = qr/\{ (?<del>.+?) \}          /x;
  52. my $anidado     = qr/(\{(?:[^\{\}]++|(?1))*\})  /x;
  53.  
  54. # TCOLORBOX ... \begin{...} ... \end{...} del paquete tcolorbox
  55. my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
  56. my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
  57. my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
  58. my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
  59. my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /msx;
  60. my $tcbxpack = qr/\\ (?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) $braces /msx;
  61.  
  62. # MINTED ... \begin{...} ... \end{...}, inline del paquete minted
  63. my $mintdenv   = qr/\\ newminted $braces (?:\{.+?\})            /x;
  64. my $mintcenv   = qr/\\ newminted $braquet (?:\{.+?\})           /x;
  65. my $mintdshrt  = qr/\\ newmint $braces (?:\{.+?\})              /x;
  66. my $mintcshrt  = qr/\\ newmint $braquet (?:\{.+?\})             /x;
  67. my $mintdline  = qr/\\ newmintinline $braces (?:\{.+?\})        /x;
  68. my $mintcline  = qr/\\ newmintinline $braquet (?:\{.+?\})       /x;  
  69.  
  70. ### Expresión regular pasada a un array
  71. my @mint_denv  = $archivo =~ m/$mintdenv/xg;  # \newminted{$mintdenv}{options} (for)
  72. my @mint_cenv  = $archivo =~ m/$mintcenv/xg;  # \newminted[$mintcenv]{lang} (for)
  73. my @mint_dshrt = $archivo =~ m/$mintdshrt/xg; # \newmint{$mintdshrt}{options} (while)
  74. my @mint_cshrt = $archivo =~ m/$mintcshrt/xg; # \newmint[$mintcshrt]{lang}{options} (while)
  75. my @mint_dline = $archivo =~ m/$mintdline/xg; # \newmintinline{$mintdline}{options} (while)
  76. my @mint_cline = $archivo =~ m/$mintcline/xg; # \newmintinline[$mintcline]{lang}{options} (while)
  77. my @tcolorbox  = $archivo =~ m/$tcbxpack/gmsx; # \newenvironment[...]{$tcbxpack} (for)
  78.  
  79. ### Quitamos los elementos duplicados del array
  80. sub uniq {
  81.     my %seen;
  82.     grep !$seen{$_}++, @_;
  83. }
  84. @mint_denv  = uniq(@mint_denv) ;
  85. @mint_cenv  = uniq(@mint_cenv) ;
  86. @mint_dline = uniq(@mint_dline);
  87. @mint_cline = uniq(@mint_cline);
  88. @mint_dshrt = uniq(@mint_dshrt);
  89. @mint_cshrt = uniq(@mint_cshrt);
  90. @tcolorbox  = uniq(@tcolorbox) ;
  91.  
  92. ### Quitamos los espacios, % y líneas en blanco
  93. @mint_denv  = grep(!/\%/, @mint_denv);
  94. @mint_cenv  = grep(!/\%/, @mint_cenv);
  95. @mint_dline = grep(!/\%/, @mint_dline);
  96. @mint_cline = grep(!/\%/, @mint_cline);
  97. @mint_dshrt = grep(!/\%/, @mint_dshrt);
  98. @mint_cshrt = grep(!/\%/, @mint_cshrt);
  99. @tcolorbox  = grep(!/\%/, @tcolorbox);
  100.  
  101. @mint_denv  = grep /\S/, @mint_denv;
  102. @mint_cenv  = grep /\S/, @mint_cenv;
  103. @mint_dline = grep /\S/, @mint_dline;
  104. @mint_cline = grep /\S/, @mint_cline;
  105. @mint_dshrt = grep /\S/, @mint_dshrt;
  106. @mint_cshrt = grep /\S/, @mint_cshrt;
  107. @tcolorbox  = grep /\S/, @tcolorbox;
  108.  
  109. s{^\s+|\s+$}{}g foreach @mint_denv;
  110. s{^\s+|\s+$}{}g foreach @mint_cenv;
  111. s{^\s+|\s+$}{}g foreach @mint_dline;
  112. s{^\s+|\s+$}{}g foreach @mint_cline;
  113. s{^\s+|\s+$}{}g foreach @mint_dshrt;
  114. s{^\s+|\s+$}{}g foreach @mint_cshrt;
  115. s{^\s+|\s+$}{}g foreach @tcolorbox;
  116.  
  117. # Agregamos "code" e "inline" para usar en qr/
  118. if (!@mint_denv == 0){
  119. $mintdenv   = join "\n", map { qq/$_\Qcode\E/ } @mint_denv;
  120. @mint_denv  = split /\n/, $mintdenv; # (for)
  121. }
  122. if (!@mint_dline == 0){
  123. $mintdline  = join "\n", map { qq/$_\Qinline\E/ } @mint_dline;
  124. @mint_dline = split /\n/, $mintdline; # (while)
  125. }
  126. # Agregamos la palabra "TMP" para crear el hash
  127. my $mintdenv_hash   = join "\n", map { qq/TMP$_/ } @mint_denv; # default
  128. my @mint_denv_hash  = split /\n/, $mintdenv_hash; # default
  129. my $mintcenv_hash   = join "\n", map { qq/TMP$_/ } @mint_cenv; # custom
  130. my @mint_cenv_hash  = split /\n/, $mintcenv_hash; # custom
  131. my $mintdline_hash  = join "\n", map { qq/TMP$_/ } @mint_dline; # default
  132. my @mint_dline_hash = split /\n/, $mintdline_hash; # default
  133. my $mintcline_hash  = join "\n", map { qq/TMP$_/ } @mint_cline; # default
  134. my @mint_cline_hash = split /\n/, $mintcline_hash; # default
  135. my $mintdshrt_hash  = join "\n", map { qq/TMP$_/ } @mint_dshrt; # default
  136. my @mint_dshrt_hash = split /\n/, $mintdshrt_hash; # default
  137. my $mintcshrt_hash  = join "\n", map { qq/TMP$_/ } @mint_cshrt; # default
  138. my @mint_cshrt_hash = split /\n/, $mintcshrt_hash; # default
  139. my $tcolorbox_hash  = join "\n", map { qq/TMP$_/ } @tcolorbox; # default
  140. my @tcolorbox_hash  = split /\n/, $tcolorbox_hash; # default
  141.  
  142. # Array para el hash de entrada con las palabras sin TMP
  143. my @infile_verb;  
  144. push(@infile_verb,@mint_denv, @mint_cenv, @tcolorbox);
  145.  
  146. # Array para el hash de salida con las palabras con TMP
  147. my @outfile_verb;
  148. push(@outfile_verb,@mint_denv_hash, @mint_cenv_hash, @tcolorbox_hash);
  149.  
  150. # Ahora creamos hash para la entrada y salida del archivo
  151. my %hash_entrada;
  152. @hash_entrada{@infile_verb} = @outfile_verb;
  153.  
  154. my %hash_salida;
  155. @hash_salida{@outfile_verb} = @infile_verb;
  156.  
  157. # Creamos %nuevo = (%cambios,%hash_entrada) y lo pasamos por (for) y (while)
  158. my %nuevo = (%cambios,%hash_entrada);
  159.  
  160. # Pasamos @infile_verb y minted a  \qr
  161. my $fileverb = join "|", map quotemeta, @infile_verb; # \begin{...} ... \end{...}
  162. $mintdline   = join "|", map quotemeta, @mint_dline; # inline verbatim default
  163. $mintcline   = join "|", map quotemeta, @mint_cline; # inline verbatim custom
  164. $mintdshrt   = join "|", map quotemeta, @mint_dshrt; # inline verbatim default
  165. $mintcshrt   = join "|", map quotemeta, @mint_cshrt; # inline verbatim custom
  166. my $mintedpack  = qr/\b(?:$mintdline|$mintcline|$mintdshrt|$mintcshrt)/x;
  167. $fileverb       = qr/\b(?:$fileverb)/x;
  168.  
  169. ### Reglas de captura
  170. my $verb        = qr/(?:(spv|v|V)erb | $myverb) [*]?                                            /ix;
  171. my $lst         = qr/(?:lstinline|$mintedpack|$myverb) (?!\*) $no_corchete                      /ix;
  172. my $mint        = qr/ mint(?:inline)?(?!\*) $no_corchete $llaves                                /ix;
  173. my $marca       = qr/\\ (?:$verb | $lst| $mint ) (\S) .+? \g{-1}                                /x;
  174. ### Comentarios y delimitadores
  175. my $comentario  = qr/^ \s* \%+ .+? $                                                            /mx;
  176. my $definedel   = qr/\\ (?:   DefineShortVerb | lstMakeShortInline  ) $no_corchete $delimitador /ix;
  177. my $indefinedel = qr/\\ (?: UndefineShortVerb | lstDeleteShortInline) $llaves                   /ix;
  178. ### tcbverb,minted,mintline anidados
  179. my $mintverb    = qr/\\ (?:mint(?:inline)?(?!\*)) $no_corchete $llaves                          /ix;
  180. my $tcbxverb    = qr/\\ (?: tcboxverb | $myverb |$mintedpack(?!\*)) $no_corchete                /ix;
  181. my $tcbxmint    = qr/(?:$tcbxverb|$mintverb) $anidado                                           /x;
  182.  
  183. ### Cambiar cuando aparece en una sola línea
  184. while ($archivo =~
  185.         /   $tcbxmint
  186.         |   $marca
  187.         |   $comentario
  188.         |   $definedel
  189.         |   $indefinedel
  190.         |   $del .+? $del                                                       # delimitado
  191.         /pgmx) {
  192.  
  193.         my($pos_inicial, $pos_final) = ($-[0], $+[0]);                          # posiciones
  194.         my $encontrado = ${^MATCH};                                             # lo encontrado
  195.  
  196.     if ($encontrado =~ /$definedel/){                                           # definimos delimitador
  197.                         $del = $+{del};
  198.                         $del = "\Q$+{del}" if substr($del,0,1) ne '\\';         # es necesario "escapar" el delimitador
  199.                 }
  200.     elsif($encontrado =~ /$indefinedel/) {                                      # indefinimos delimitador
  201.                  $del = $no_del;                                       
  202.         }
  203.     else {                                                                      # aquí se hacen los cambios
  204.         while (my($busco, $cambio) = each %nuevo) {
  205.                        $encontrado =~ s/\Q$busco\E/$cambio/g;                   # es necesario escapar $busco
  206.                         }
  207.         substr $archivo, $pos_inicial, $pos_final-$pos_inicial, $encontrado;    # insertamos los nuevos cambios
  208.  
  209.         pos($archivo)= $pos_inicial + length $encontrado;                       # re posicionamos la siguiente búsqueda
  210.         }
  211. }
  212.  
  213. ### Definimos los entornos en los cuales haremos los cambios
  214. my $Verbatim  = qr/(?:(v|V)erbatim\*?     | # verbatim and fancyvrb
  215. (?:(?:P)?Center|(?:P)?SideBySide)?Example | # fancyvrb
  216.                            PSTexample     | # pst-exa
  217.                            PSTcode        | # pst-exa
  218.                            LTXexample     | # showexpl
  219.                            $ignore\*?     | # $ignore
  220.                            tcblisting\*?  | # tcolorbox
  221.                         tcboutputlisting  | # tcolorbox
  222.                            tcbexternal    | # tcolorbox
  223.                            extcolorbox    | # tcolorbox
  224.                            extikzpicture  | # tcolorbox
  225.                            spverbatim     | # spverbatim
  226.                            minted         | # minted
  227.                            listing        | # minted
  228.                            lstlisting     | # listing
  229.                            alltt          | # alltt
  230.                            comment\*?     | # comment
  231.                            xcomment         # xcomment
  232.                            )/x;
  233.  
  234. ### Dividimos por líneas el archivo de entrada
  235. my @lineas = split /\n/, $archivo;
  236.  
  237. ### Del    
  238. my $DEL;
  239.  
  240. ### Hacemos los cambios dentro de los entornos \begin{...} ... \end{...}
  241. for (@lineas) {
  242.     if (/\\begin\{($fileverb\*?|$Verbatim)(?{ $DEL = "\Q$^N" })\}/ .. /\\end\{$DEL\}/) {
  243.         while (my($busco, $cambio) = each %cambios) {
  244.             s/\Q$busco\E/$cambio/g;
  245.         }
  246.     }
  247. } # close
  248.  
  249. ### Volvemos
  250. $archivo = join("\n", @lineas);
  251.  
  252. ### Ahora dividimos el archivo de entrada
  253. my($cabeza,$cuerpo,$final) = $archivo =~ m/\A (.+?) (\\begin\{document\} .+?)(\\end\{document\}.*)\z/msx;
  254.  
  255. ### postscript environment
  256. my $BPL        = '\begin{postscript}';
  257. my $EPL        = '\end{postscript}';
  258. my $POSTSCRIPT = qr/(?: postscript)/xi;
  259.  
  260. ### tikzpicture environment
  261. my $ENVIRONMENT    = qr/(?: tikzpicture | pspicture\*?)/xi;
  262.  
  263. ### \pspicture a \begin{pspicture}
  264. $cuerpo =~ s/\\pspicture(\*)?(.+?)\\endpspicture/\\begin{pspicture$1}$2\\end{pspicture$1}/gmsx;
  265.  
  266. ### tikz/pst a Postscript
  267. $cuerpo =~ s/\\begin\{($POSTSCRIPT)\}.+?\\end\{\g{-1}\}(*SKIP)(*F)|
  268.         (
  269.         (?:\\(psset|tikzset)(\{(?:\{.*?\}|[^\{])*\}).*?)?  # si está lo guardo
  270.         (\\begin\{($ENVIRONMENT)\} (.*?)  \\end\{\g{-2}\})
  271.     )
  272.     /$BPL\n$1\n$EPL/gmsx;
  273.  
  274. ### Convertir
  275. my $grap="\\includegraphics[scale=1]{EXTRAIDO-fig-";
  276. my $close = '}';
  277. my $imgNo = 1; #
  278. my $BP        = '\\\\begin\{postscript\}';
  279. my $EP        = '\\\\end\{postscript\}';
  280. $cuerpo =~ s/$BP.+?$EP/$grap@{[$imgNo++]}$close/msg; #
  281.  
  282. my %cambios = (
  283. # pst/tikz set    
  284.     '\PSSET'                    =>      '\psset',
  285.     '\TIKZSET'                  =>      '\tikzset',                    
  286. # pspicture    
  287.     '\TRICKS'                   =>      '\pspicture',
  288.     '\ENDTRICKS'                =>      '\endpspicture',            
  289. # pspicture
  290.     '\begin{TRICKS'             =>      '\begin{pspicture',
  291.     '\end{TRICKS'               =>      '\end{pspicture',
  292. # postscript
  293.     '\begin{POSTRICKS}'         =>      '\begin{postscript}',
  294.     '\end{POSTRICKS}'           =>      '\end{postscript}',
  295. );
  296.  
  297. %nuevo = (%cambios,%hash_salida);
  298.  
  299. ### Reemplazamos y unimos
  300. while (my($busco, $cambio) = each %nuevo) {
  301.     $cabeza =~ s/\Q$busco\E/$cambio/g;
  302.     $cuerpo =~ s/\Q$busco\E/$cambio/g;
  303.     $final  =~ s/\Q$busco\E/$cambio/g;
  304.             }
  305.            
  306. ### Escritura del resultado
  307. open my $SALIDA, '>', "$name-out$ext";
  308. print   $SALIDA "$cabeza$cuerpo$final";
  309. close   $SALIDA;
  310.  
  311. __END__
  312. #delete @cambios{'\begin{postscript}','\end{postscript}'};
  313. #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
  1. \documentclass{article}
  2. \usepackage{minted}
  3. \usepackage{pstricks-add}
  4. \newtcblisting[opcional]{mytcbliting}
  5. %\renewtcblisting[opcional]{nombre_2}
  6. %\newtcblisting{nombre_1a}
  7. %\renewtcblisting{nombre_2a}
  8. %\DeclareTCBListing[opcional]{nombre_3}
  9. %\NewTCBListing[opcional]{nombre_4}
  10. %\ProvideTCBListing[opcional]{nombre_6}
  11. %\newtcbexternalizeenvironment{nombre_7}
  12. %\renewtcbexternalizeenvironment{nombre_8}
  13. %\newtcbexternalizetcolorbox{nombre_9}
  14. %\renewtcbexternalizetcolorbox{nombre_10}
  15. \RenewTCBListing[
  16.                         opcion                 
  17.                         ]{
  18.                         opcionaluno
  19.                         }
  20. \DefineVerbatimEnvironment{MyVerbatim}
  21. {Verbatim}
  22. {gobble=2,frame=lines,framerule=0.8mm}
  23. \begin{document}
  24. %Se convierte
  25. \begin{postscript}
  26. \begin{pspicture}[showgrid](0,3)(10,10)
  27. Se convierte
  28. \end{pspicture}
  29. \end{postscript}
  30.  
  31. \begin{mytcbliting}
  32. \begin{postscript}
  33. \begin{pspicture}[showgrid](0,3)(10,10)
  34. Se queda
  35. \end{pspicture}
  36. \end{postscript}
  37. \end{mytcbliting}
  38. %Se convierte
  39. \begin{postscript}
  40. \begin{pspicture}[showgrid](0,3)(10,10)
  41. Se convierte
  42. \end{pspicture}
  43. \end{postscript}
  44.  
  45. \begin{opcionaluno}
  46. \begin{pspicture}[showgrid](0,3)(10,10)
  47. Se queda
  48. \end{pspicture}
  49. \end{opcionaluno}
  50.  
  51. \begin{MyVerbatim*}
  52. \begin{pspicture}[showgrid](0,3)(10,10)
  53. Se queda
  54. \end{pspicture}
  55. \end{MyVerbatim*}
  56.  
  57. \newminted{algun}{options}
  58. \begin{alguncode*}
  59. \begin{pspicture}[showgrid](0,3)(10,10)
  60. Se queda
  61. \end{pspicture}
  62. \end{alguncode*}
  63.  
  64. \newminted[langA]{lang1}{options}
  65.  
  66. \begin{langA}[opciones]
  67. \begin{pspicture}[showgrid](0,3)(10,10)
  68. Se queda
  69. \end{pspicture}
  70. \end{langA}
  71.  
  72. \begin{langArm}[opciones]
  73. %Se convierte
  74. \begin{pspicture}[showgrid](0,3)(10,10)
  75. Se convierte
  76. \end{pspicture}
  77. \end{langArm}
  78.  
  79. \section{minted inline}
  80. \subsection{delimitado}
  81. Original delimitado \mintinline{latex}|\begin{langA} ... \end{langA}| text
  82. Original delimitado \mintinline{latex}|\begin{MyVerbatim*}| text
  83. Original delimitado con opciones \mintinline[opciones]{latex}/\begin{pspicture}/ text
  84.  
  85. Definiendo nuevo mintinline delimitado \newmintinline{mylatex}{showspaces}
  86. Definiendo nuevo mintinline delimitado \newmintinline{myotrolatex}{showspaces}
  87. con opciones \mylatexinline[opciones]|\begin{pspicture}| y sin opciones \mylatexinline|\begin{pspicture}|
  88. con opciones \myotrolatexinline[opciones]|\begin{pspicture}| y sin opciones \myotrolatexinline|\begin{pspicture}|
  89.  
  90. Definiendo nuevo mintinline con nombre propio delimitado \newmintinline[personal]{latex}{showspaces}
  91. con opciones \personal[opciones]|\begin{pspicture}| y sin opciones \personal[opciones]|\begin{pspicture}|
  92.  
  93. \subsection{anidado}
  94. Original anidado \mintinline{latexdos}{\begin{pspicture} y \end{pspicture}} text
  95. Original anidado con opciones \mintinline[opciones]{latexdos}{\begin{pspicture} y \end{pspicture}} text
  96.  
  97. Definiendo nuevo mintinline anidado \newmintinline{mylatexdos}{showspaces}
  98. con opciones \mylatexdosinline[opciones]{\begin{pspicture} y \end{pspicture}} y sin opciones \mylatexdosinline{\begin{pspicture} y \end{pspicture}}
  99.  
  100. Definiendo nuevo mintinline con nombre propio anidado \newmintinline[personal]{latex}{showspaces}
  101. con opciones \personal[opciones]{\begin{pspicture} y \end{pspicture}} y sin opciones \personal[opciones]{\begin{pspicture} y \end{pspicture}}
  102.  
  103. \subsection{new short minted}
  104. \subsection{delimitado}
  105. Original short \mint{python}|\begin{pspicture}|
  106.  
  107. Definiendo nuevo mint short default \newmint{mylenguaje}{showspaces}
  108. \mylenguaje/\begin{pspicture}/ y \mylenguaje[opciones]/\begin{pspicture}/
  109.  
  110. Definiendo nuevo mint short custom \newmint[mymint]{mylenguaje}{showspaces}
  111. \mymint/\begin{pspicture}/ \mymint[opciones]/\begin{pspicture}/
  112.  
  113. \subsection{anidado}
  114. Original short \mint{lenguaje}{\begin{pspicture}}
  115.  
  116. \mylenguaje{\begin{pspicture} y \end{pspicture}}
  117.  
  118. \mymint{\begin{pspicture} y \end{pspicture}} \mymint[opciones]{\begin{pspicture} y \end{pspicture}}
  119.  
  120. \section{tcolorbox}
  121. \tcboxverb{\begin{pspicture} o \begin{pspicture*}} y \tcboxverb[algo]{\begin{pspicture} o {algo} o \begin{pspicture*}}
  122.  
  123. Usamos \verb|\begin{pspicture} o \begin{pspicture*}| o \verb*|\begin{pspicture} o \begin{pspicture*}| (cambia)
  124.  
  125. \end{document}
  126. IGNORAR
  127. \begin{postscript}
  128. \begin{pspicture}[showgrid](0,3)(10,10)
  129. Se queda
  130. \end{pspicture}
  131. \end{postscript}
  132.  
Coloreado en 0.004 segundos, usando GeSHi 1.0.8.4
Obtengo:
Sintáxis: [ Descargar ] [ Ocultar ]
Using latex Syntax Highlighting
  1. \documentclass{article}
  2. \usepackage{minted}
  3. \usepackage{pstricks-add}
  4. \newtcblisting[opcional]{mytcbliting}
  5. %\renewtcblisting[opcional]{nombre_2}
  6. %\newtcblisting{nombre_1a}
  7. %\renewtcblisting{nombre_2a}
  8. %\DeclareTCBListing[opcional]{nombre_3}
  9. %\NewTCBListing[opcional]{nombre_4}
  10. %\ProvideTCBListing[opcional]{nombre_6}
  11. %\newtcbexternalizeenvironment{nombre_7}
  12. %\renewtcbexternalizeenvironment{nombre_8}
  13. %\newtcbexternalizetcolorbox{nombre_9}
  14. %\renewtcbexternalizetcolorbox{nombre_10}
  15. \RenewTCBListing[
  16.                         opcion                 
  17.                         ]{
  18.                         opcionaluno
  19.                         }
  20. \DefineVerbatimEnvironment{MyVerbatim}
  21. {Verbatim}
  22. {gobble=2,frame=lines,framerule=0.8mm}
  23. \begin{document}
  24. %Se convierte
  25. \includegraphics[scale=1]{EXTRAIDO-fig-1}
  26.  
  27. \begin{mytcbliting}
  28. \begin{postscript}
  29. \begin{pspicture}[showgrid](0,3)(10,10)
  30. Se queda
  31. \end{pspicture}
  32. \end{postscript}
  33. \end{mytcbliting}
  34. %Se convierte
  35. \includegraphics[scale=1]{EXTRAIDO-fig-2}
  36.  
  37. \begin{opcionaluno}
  38. \begin{pspicture}[showgrid](0,3)(10,10)
  39. Se queda
  40. \end{pspicture}
  41. \end{opcionaluno}
  42.  
  43. \begin{MyVerbatim*}
  44. \begin{pspicture}[showgrid](0,3)(10,10)
  45. Se queda
  46. \end{pspicture}
  47. \end{MyVerbatim*}
  48.  
  49. \newminted{algun}{options}
  50. \begin{alguncode*}
  51. \begin{pspicture}[showgrid](0,3)(10,10)
  52. Se queda
  53. \end{pspicture}
  54. \end{alguncode*}
  55.  
  56. \newminted[langA]{lang1}{options}
  57.  
  58. \begin{langA}[opciones]
  59. \begin{pspicture}[showgrid](0,3)(10,10)
  60. Se queda
  61. \end{pspicture}
  62. \end{langA}
  63.  
  64. \begin{langArm}[opciones]
  65. %Se convierte
  66. \includegraphics[scale=1]{EXTRAIDO-fig-3}
  67. \end{langArm}
  68.  
  69. \section{minted inline}
  70. \subsection{delimitado}
  71. Original delimitado \mintinline{latex}|\begin{langA} ... \end{langA}| text
  72. Original delimitado \mintinline{latex}|\begin{MyVerbatim*}| text
  73. Original delimitado con opciones \mintinline[opciones]{latex}/\begin{pspicture}/ text
  74.  
  75. Definiendo nuevo mintinline delimitado \newmintinline{mylatex}{showspaces}
  76. Definiendo nuevo mintinline delimitado \newmintinline{myotrolatex}{showspaces}
  77. con opciones \mylatexinline[opciones]|\begin{pspicture}| y sin opciones \mylatexinline|\begin{pspicture}|
  78. con opciones \myotrolatexinline[opciones]|\begin{pspicture}| y sin opciones \myotrolatexinline|\begin{pspicture}|
  79.  
  80. Definiendo nuevo mintinline con nombre propio delimitado \newmintinline[personal]{latex}{showspaces}
  81. con opciones \personal[opciones]|\begin{pspicture}| y sin opciones \personal[opciones]|\begin{pspicture}|
  82.  
  83. \subsection{anidado}
  84. Original anidado \mintinline{latexdos}{\begin{pspicture} y \end{pspicture}} text
  85. Original anidado con opciones \mintinline[opciones]{latexdos}{\includegraphics[scale=1]{EXTRAIDO-fig-4}} text
  86.  
  87. Definiendo nuevo mintinline anidado \newmintinline{mylatexdos}{showspaces}
  88. con opciones \mylatexdosinline[opciones]{\begin{pspicture} y \end{pspicture}} y sin opciones \mylatexdosinline{\begin{pspicture} y \end{pspicture}}
  89.  
  90. Definiendo nuevo mintinline con nombre propio anidado \newmintinline[personal]{latex}{showspaces}
  91. con opciones \personal[opciones]{\begin{pspicture} y \end{pspicture}} y sin opciones \personal[opciones]{\begin{pspicture} y \end{pspicture}}
  92.  
  93. \subsection{new short minted}
  94. \subsection{delimitado}
  95. Original short \mint{python}|\begin{pspicture}|
  96.  
  97. Definiendo nuevo mint short default \newmint{mylenguaje}{showspaces}
  98. \mylenguaje/\begin{pspicture}/ y \mylenguaje[opciones]/\begin{pspicture}/
  99.  
  100. Definiendo nuevo mint short custom \newmint[mymint]{mylenguaje}{showspaces}
  101. \mymint/\begin{pspicture}/ \mymint[opciones]/\begin{pspicture}/
  102.  
  103. \subsection{anidado}
  104. Original short \mint{lenguaje}{\begin{pspicture}}
  105.  
  106. \mylenguaje{\begin{pspicture} y \end{pspicture}}
  107.  
  108. \mymint{\begin{pspicture} y \end{pspicture}} \mymint[opciones]{\begin{pspicture} y \end{pspicture}}
  109.  
  110. \section{tcolorbox}
  111. \tcboxverb{\begin{pspicture} o \begin{pspicture*}} y \tcboxverb[algo]{\begin{pspicture} o {algo} o \begin{pspicture*}}
  112.  
  113. Usamos \verb|\begin{pspicture} o \begin{pspicture*}| o \verb*|\begin{pspicture} o \begin{pspicture*}| (cambia)
  114.  
  115. \end{document}
  116. IGNORAR
  117. \begin{postscript}
  118. \begin{pspicture}[showgrid](0,3)(10,10)
  119. Se queda
  120. \end{pspicture}
  121. \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
  1. 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
  1. \DefineVerbatimEnvironment{% algo algo
  2.      MyVerbatim % algo algo
  3.                 %%% algo algo
  4. }
Coloreado en 0.000 segundos, usando GeSHi 1.0.8.4
o
Sintáxis: [ Descargar ] [ Ocultar ]
Using latex Syntax Highlighting
  1. \DefineVerbatimEnvironment%
  2.      {% algo algo
  3.  
  4.        MyVerbatim %%% algo algo
  5.       %%% algo algo
  6.  
  7. }
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
pablgonz
Perlero nuevo
Perlero nuevo
 
Mensajes: 236
Registrado: 2010-09-08 21:03 @919
Ubicación: Concepción (Chile)

Publicidad

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

Notapor pablgonz » 2016-04-21 09:23 @432

Tengo un avance en mi problema: ya corregí la expresión regular para los anidados entre {...} (faltaba colocar las reglas correctas y validar mi archivo de ejemplo :)) y eliminé un par de array que no necesitaba, el nuevo código quedó así:
Sintáxis: [ Descargar ] [ Ocultar ]
Using perl Syntax Highlighting
  1. #!/usr/bin/perl
  2. use v5.20;
  3. use autodie;                                            # muere si ocurre un error
  4. use File::Basename;                                     # separa el archivo de entrada
  5. use Data::Dumper;
  6.  
  7. ### Argumentos ---------------------------------------------------------
  8. @ARGV == 1  or die "Uso: $0 <archivo TeX a procesar>\n";
  9. my $nombre_archivo = shift;
  10. -f $nombre_archivo or die "ERROR: No encuentro [$nombre_archivo]\n";
  11.  
  12. ### Arreglo de la extensión --------------------------------------------
  13. my @SuffixList = ('.tex', '', '.ltx');                  # posible extensión
  14. my ($name, $path, $ext) = fileparse($nombre_archivo, @SuffixList);
  15. $ext = '.tex' if not $ext;                              # fijamos la extensión
  16.  
  17. ### Directorio para las imágenes y otros
  18. my $imageDir  = "images";      
  19. my $myverb    = "myverb";      
  20. my $ignore    = "ignore";      
  21.  
  22. ### Abrimos el archivo de entrada a modificar --------------------------
  23. open my $ENTRADA, '<', $nombre_archivo;
  24. my $archivo;
  25. {
  26.     local $/;
  27.     $archivo = <$ENTRADA>;
  28. }
  29. close   $ENTRADA;
  30.  
  31. ## Cambios a realizar
  32. my %cambios = (
  33.         '\pspicture'                => '\TRICKS',
  34.         '\endpspicture'             => '\ENDTRICKS',
  35.  
  36.         '\begin{pspicture'          => '\begin{TRICKS',
  37.         '\end{pspicture'            => '\end{TRICKS',
  38.        
  39.         '\begin{postscript}'        => '\begin{POSTRICKS}',
  40.         '\end{postscript}'          => '\end{POSTRICKS}',
  41. );
  42.  
  43. ## Variables y constantes
  44. my $no_del = "\0";
  45. my $del    = $no_del;
  46.  
  47. ## Reglas
  48. my $braces      = qr/ (?:\{)(.+?)(?:\})         /msx;
  49. my $braquet     = qr/ (?:\[)(.+?)(?:\])         /msx;
  50. my $llaves      = qr/ \{ .+? \}                 /x;
  51. my $no_llaves   = qr/ (?:\{ .+? \})             /x;
  52. my $no_corchete = qr/ (?:\[ .+? \])?            /msx;
  53. my $delimitador = qr/\{ (?<del>.+?) \}          /x;
  54. my $anidado     = qr/(\{(?:[^\{\}]++|(?1))*\})  /x;
  55.  
  56. # TCOLORBOX ... \begin{...} ... \end{...} del paquete tcolorbox
  57. my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
  58. my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
  59. my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
  60. my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
  61. my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /msx;
  62. my $tcbxpack = qr/\\ (?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) $braces /msx;
  63.  
  64. # MINTED ... \begin{...} ... \end{...}, inline del paquete minted
  65. my $mintdenv   = qr/\\ newminted $braces (?:\{.+?\})            /x;
  66. my $mintcenv   = qr/\\ newminted $braquet (?:\{.+?\})           /x;
  67. my $mintdshrt  = qr/\\ newmint $braces (?:\{.+?\})              /x;
  68. my $mintcshrt  = qr/\\ newmint $braquet (?:\{.+?\})             /x;
  69. my $mintdline  = qr/\\ newmintinline $braces (?:\{.+?\})        /x;
  70. my $mintcline  = qr/\\ newmintinline $braquet (?:\{.+?\})       /x;  
  71.  
  72. ### Expresión regular pasada a un array
  73. my @mint_denv  = $archivo =~ m/$mintdenv/xg;  # \newminted{$mintdenv}{options} (for)
  74. my @mint_cenv  = $archivo =~ m/$mintcenv/xg;  # \newminted[$mintcenv]{lang} (for)
  75. my @mint_dshrt = $archivo =~ m/$mintdshrt/xg; # \newmint{$mintdshrt}{options} (while)
  76. my @mint_cshrt = $archivo =~ m/$mintcshrt/xg; # \newmint[$mintcshrt]{lang}{options} (while)
  77. my @mint_dline = $archivo =~ m/$mintdline/xg; # \newmintinline{$mintdline}{options} (while)
  78. my @mint_cline = $archivo =~ m/$mintcline/xg; # \newmintinline[$mintcline]{lang}{options} (while)
  79. my @tcolorbox  = $archivo =~ m/$tcbxpack/gmsx; # \newenvironment[...]{$tcbxpack} (for)
  80.  
  81. ### Quitamos los elementos duplicados del array
  82. sub uniq {
  83.     my %seen;
  84.     grep !$seen{$_}++, @_;
  85. }
  86. @mint_denv  = uniq(@mint_denv) ;
  87. @mint_cenv  = uniq(@mint_cenv) ;
  88. @mint_dline = uniq(@mint_dline);
  89. @mint_cline = uniq(@mint_cline);
  90. @mint_dshrt = uniq(@mint_dshrt);
  91. @mint_cshrt = uniq(@mint_cshrt);
  92. @tcolorbox  = uniq(@tcolorbox) ;
  93.  
  94. ### Quitamos los espacios, % y líneas en blanco
  95. @mint_denv  = grep(!/\%/, @mint_denv);
  96. @mint_cenv  = grep(!/\%/, @mint_cenv);
  97. @mint_dline = grep(!/\%/, @mint_dline);
  98. @mint_cline = grep(!/\%/, @mint_cline);
  99. @mint_dshrt = grep(!/\%/, @mint_dshrt);
  100. @mint_cshrt = grep(!/\%/, @mint_cshrt);
  101. @tcolorbox  = grep(!/\%/, @tcolorbox);
  102.  
  103. @mint_denv  = grep /\S/, @mint_denv;
  104. @mint_cenv  = grep /\S/, @mint_cenv;
  105. @mint_dline = grep /\S/, @mint_dline;
  106. @mint_cline = grep /\S/, @mint_cline;
  107. @mint_dshrt = grep /\S/, @mint_dshrt;
  108. @mint_cshrt = grep /\S/, @mint_cshrt;
  109. @tcolorbox  = grep /\S/, @tcolorbox;
  110.  
  111. s{^\s+|\s+$}{}g foreach @mint_denv;
  112. s{^\s+|\s+$}{}g foreach @mint_cenv;
  113. s{^\s+|\s+$}{}g foreach @mint_dline;
  114. s{^\s+|\s+$}{}g foreach @mint_cline;
  115. s{^\s+|\s+$}{}g foreach @mint_dshrt;
  116. s{^\s+|\s+$}{}g foreach @mint_cshrt;
  117. s{^\s+|\s+$}{}g foreach @tcolorbox;
  118.  
  119. # Agregamos "code" e "inline" para usar en qr/
  120. if (!@mint_denv == 0) {
  121.     $mintdenv   = join "\n", map { qq/$_\Qcode\E/ } @mint_denv;
  122.     @mint_denv  = split /\n/, $mintdenv; # (for)
  123. }
  124. if (!@mint_dline == 0) {
  125.     $mintdline  = join "\n", map { qq/$_\Qinline\E/ } @mint_dline;
  126.     @mint_dline = split /\n/, $mintdline; # (while)
  127. }
  128.  
  129. # Agregamos la palabra "TMP" para crear el hash
  130. my $mintdenv_hash   = join "\n", map { qq/TMP$_/ } @mint_denv; # default
  131. my @mint_denv_hash  = split /\n/, $mintdenv_hash; # default
  132. my $mintcenv_hash   = join "\n", map { qq/TMP$_/ } @mint_cenv; # custom
  133. my @mint_cenv_hash  = split /\n/, $mintcenv_hash; # custom
  134. my $tcolorbox_hash  = join "\n", map { qq/TMP$_/ } @tcolorbox; # default
  135. my @tcolorbox_hash  = split /\n/, $tcolorbox_hash; # default
  136.  
  137. # Array para el hash de entrada con las palabras sin TMP
  138. my @infile_verb;  
  139. push(@infile_verb,@mint_denv, @mint_cenv, @tcolorbox);
  140.  
  141. # Array para el hash de salida con las palabras con TMP
  142. my @outfile_verb;
  143. push(@outfile_verb,@mint_denv_hash, @mint_cenv_hash, @tcolorbox_hash);
  144.  
  145. # Ahora creamos hash para la entrada y salida del archivo
  146. my %hash_entrada;
  147. @hash_entrada{@infile_verb} = @outfile_verb;
  148.  
  149. my %hash_salida;
  150. @hash_salida{@outfile_verb} = @infile_verb;
  151.  
  152. # Creamos %nuevo = (%cambios,%hash_entrada) y lo pasamos por (for) y (while)
  153. my %nuevo = (%cambios,%hash_entrada);
  154.  
  155. # Pasamos @infile_verb y minted a  \qr
  156. my $fileverb = join "|", map quotemeta, @infile_verb; # \begin{...} ... \end{...}
  157. $mintdline   = join "|", map quotemeta, @mint_dline; # inline verbatim default
  158. $mintcline   = join "|", map quotemeta, @mint_cline; # inline verbatim custom
  159. $mintdshrt   = join "|", map quotemeta, @mint_dshrt; # inline verbatim default
  160. $mintcshrt   = join "|", map quotemeta, @mint_cshrt; # inline verbatim custom
  161. $fileverb       = qr/\b(?:$fileverb)/x; # se comporta \begin{...} ... \end{...} (for)
  162. my $newmintinline   = qr/\b(?:$mintdline|$mintcline)/x; # se comporta como lst y tcbx anidado
  163. $mintcshrt = qr/\b(?:$mintcshrt)/x; # se comporta como lst , no soporta anidado
  164. $mintdshrt = qr/\b(?:$mintdshrt)/x; # se comporta como lst , no soporta anidado
  165.  
  166. ### Reglas de captura
  167. my $verb        = qr/(?:(spv|v|V)erb | $myverb) [*]?                                            /ix;
  168. my $lst         = qr/(?:lstinline|$myverb|$newmintinline|$mintcshrt|$mintdshrt)(?!\*) $no_corchete /ix;
  169. ### mint y mintinline por defecto
  170. my $mint        = qr/ mint(?:inline)?(?!\*) $no_corchete $llaves                                /ix;
  171. my $marca       = qr/\\ (?:$verb | $lst| $mint ) (\S) .+? \g{-1}                                /x;
  172. ### Comentarios y delimitadores
  173. my $comentario  = qr/^ \s* \%+ .+? $                                                            /mx;
  174. my $definedel   = qr/\\ (?:   DefineShortVerb | lstMakeShortInline  ) $no_corchete $delimitador /ix;
  175. my $indefinedel = qr/\\ (?: UndefineShortVerb | lstDeleteShortInline) $llaves                   /ix;
  176. ### tcbverb,minted,mintline anidados
  177. my $mintd_ani   = qr/\\ mint(?:inline)? (?!\*) $no_corchete $no_llaves                          /ix;
  178. my $tcbxverb    = qr/\\ (?: tcboxverb [*]?|$myverb [*]?|$newmintinline (?!\*))  $no_corchete    /ix;
  179. my $tcbxmint    = qr/(?:$tcbxverb|$mintd_ani) $anidado                                          /x;
  180.  
  181. ### Cambiar cuando aparece en una sola línea
  182. while ($archivo =~
  183.         /   $tcbxmint
  184.         |   $marca
  185.         |   $comentario
  186.         |   $definedel
  187.         |   $indefinedel
  188.         |   $del .+? $del                                                       # delimitado
  189.         /pgmx) {
  190.  
  191.         my($pos_inicial, $pos_final) = ($-[0], $+[0]);                          # posiciones
  192.         my $encontrado = ${^MATCH};                                             # lo encontrado
  193.  
  194.     if ($encontrado =~ /$definedel/){                                           # definimos delimitador
  195.                         $del = $+{del};
  196.                         $del = "\Q$+{del}" if substr($del,0,1) ne '\\';         # es necesario "escapar" el delimitador
  197.                 }
  198.     elsif($encontrado =~ /$indefinedel/) {                                      # indefinimos delimitador
  199.                  $del = $no_del;                                       
  200.         }
  201.     else {                                                                      # aquí se hacen los cambios
  202.         while (my($busco, $cambio) = each %nuevo) {
  203.                        $encontrado =~ s/\Q$busco\E/$cambio/g;                   # es necesario escapar $busco
  204.         }
  205.         substr $archivo, $pos_inicial, $pos_final-$pos_inicial, $encontrado;    # insertamos los nuevos cambios
  206.  
  207.         pos($archivo)= $pos_inicial + length $encontrado;                       # re posicionamos la siguiente búsqueda
  208.     }
  209. }
  210.  
  211. ### Definimos los entornos en los cuales haremos los cambios
  212. my $Verbatim  = qr/(?:(v|V)erbatim\*?     | # verbatim and fancyvrb
  213. (?:(?:P)?Center|(?:P)?SideBySide)?Example | # fancyvrb
  214.                            PSTexample     | # pst-exa
  215.                            PSTcode        | # pst-exa
  216.                            LTXexample     | # showexpl
  217.                            $ignore\*?     | # $ignore
  218.                            tcblisting\*?  | # tcolorbox
  219.                         tcboutputlisting  | # tcolorbox
  220.                            tcbexternal    | # tcolorbox
  221.                            extcolorbox    | # tcolorbox
  222.                            extikzpicture  | # tcolorbox
  223.                            spverbatim     | # spverbatim
  224.                            minted         | # minted
  225.                            listing        | # minted
  226.                            lstlisting     | # listing
  227.                            alltt          | # alltt
  228.                            comment\*?     | # comment
  229.                            xcomment         # xcomment
  230.                            )/x;
  231.  
  232. ### Dividimos por líneas el archivo de entrada
  233. my @lineas = split /\n/, $archivo;
  234.  
  235. ### Del    
  236. my $DEL;
  237.  
  238. ### Hacemos los cambios dentro de los entornos \begin{...} ... \end{...}
  239. for (@lineas) {
  240.     if (/\\begin\{($fileverb\*?|$Verbatim)(?{ $DEL = "\Q$^N" })\}/ .. /\\end\{$DEL\}/) {
  241.         while (my($busco, $cambio) = each %cambios) {
  242.             s/\Q$busco\E/$cambio/g;
  243.         }
  244.     }
  245. } # close
  246.  
  247. ### Volvemos
  248. $archivo = join("\n", @lineas);
  249.  
  250. ### Ahora dividimos el archivo de entrada
  251. my($cabeza,$cuerpo,$final) = $archivo =~ m/\A (.+?) (\\begin\{document\} .+?)(\\end\{document\}.*)\z/msx;
  252.  
  253. ### postscript environment
  254. my $BPL        = '\begin{postscript}';
  255. my $EPL        = '\end{postscript}';
  256. my $POSTSCRIPT = qr/(?: postscript)/xi;
  257.  
  258. ### tikzpicture environment
  259. my $ENVIRONMENT    = qr/(?: tikzpicture | pspicture\*?)/xi;
  260.  
  261. ### \pspicture a \begin{pspicture}
  262. $cuerpo =~ s/\\pspicture(\*)?(.+?)\\endpspicture/\\begin{pspicture$1}$2\\end{pspicture$1}/gmsx;
  263.  
  264. ### tikz/pst a Postscript
  265. $cuerpo =~ s/\\begin\{($POSTSCRIPT)\}.+?\\end\{\g{-1}\}(*SKIP)(*F)|
  266.         (
  267.         (?:\\(psset|tikzset)(\{(?:\{.*?\}|[^\{])*\}).*?)?  # si está lo guardo
  268.         (\\begin\{($ENVIRONMENT)\} (.*?)  \\end\{\g{-2}\})
  269.     )
  270.     /$BPL\n$1\n$EPL/gmsx;
  271.  
  272. ### Convertir
  273. my $grap  = "\\includegraphics[scale=1]{EXTRAIDO-fig-";
  274. my $close = '}';
  275. my $imgNo = 1; #
  276. my $BP    = '\\\\begin\{postscript\}';
  277. my $EP    = '\\\\end\{postscript\}';
  278. $cuerpo   =~ s/$BP.+?$EP/$grap@{[$imgNo++]}$close/msg; #
  279.  
  280. my %cambios = (
  281. # pst/tikz set    
  282.     '\PSSET'                    =>      '\psset',
  283.     '\TIKZSET'                  =>      '\tikzset',                    
  284. # pspicture    
  285.     '\TRICKS'                   =>      '\pspicture',
  286.     '\ENDTRICKS'                =>      '\endpspicture',            
  287. # pspicture
  288.     '\begin{TRICKS'             =>      '\begin{pspicture',
  289.     '\end{TRICKS'               =>      '\end{pspicture',
  290. # postscript
  291.     '\begin{POSTRICKS}'         =>      '\begin{postscript}',
  292.     '\end{POSTRICKS}'           =>      '\end{postscript}',
  293. );
  294.  
  295. %nuevo = (%cambios,%hash_salida);
  296.  
  297. ### Reemplazamos y unimos
  298. while (my($busco, $cambio) = each %nuevo) {
  299.     $cabeza =~ s/\Q$busco\E/$cambio/g;
  300.     $cuerpo =~ s/\Q$busco\E/$cambio/g;
  301.     $final  =~ s/\Q$busco\E/$cambio/g;
  302. }
  303.            
  304. ### Escritura del resultado
  305. open my $SALIDA, '>', "$name-out$ext";
  306. print   $SALIDA "$cabeza$cuerpo$final";
  307. close   $SALIDA;
  308.  
  309. __END__
  310. #delete @cambios{'\begin{postscript}','\end{postscript}'};
  311. #print Dumper(\%cambios);
  312.  
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
  1. \documentclass{article}
  2. \usepackage{minted}
  3. \usepackage{pstricks-add}
  4. \usepackage{auto-pst-pdf}
  5. \DefineVerbatimEnvironment{MyVerbatim}
  6. \begin{document}
  7. %Se convierte EXTRAIDO-fig-1
  8. \begin{postscript}
  9. \begin{pspicture}[showgrid](0,3)(10,10)
  10. Se convierte
  11. \end{pspicture}
  12. \end{postscript}
  13.  
  14. \begin{MyVerbatim}
  15. \begin{pspicture}[showgrid](0,3)(10,10)
  16. Se queda
  17. \end{pspicture}
  18. \end{MyVerbatim}
  19.  
  20. \begin{Verbatim*}
  21. \begin{pspicture}[showgrid](0,3)(10,10)
  22. Se queda
  23. \end{pspicture}
  24. \end{Verbatim*}
  25.  
  26. \newminted[langA]{latex}{linenos}
  27.  
  28. \begin{langA}
  29. \begin{pspicture}[showgrid](0,3)(10,10)
  30. Se queda
  31. \end{pspicture}
  32. \end{langA}
  33. %Se convierte EXTRAIDO-fig-2
  34. \begin{postscript}
  35. \begin{pspicture}[showgrid](0,3)(10,10)
  36. Se convierte
  37. \end{pspicture}
  38. \end{postscript}
  39.  
  40. \section{minted inline default}
  41. Original delimitado \mintinline{latex}|\mintinline{lang}<del> code <del>| text
  42. Ejemplo delimitado \mintinline{latex}|\begin{langA} y\end{langA}| text
  43.  
  44. Original delimitado con opciones \mintinline{latex}|\mintinline[opt]{lang}<del> code <del>| text
  45. Ejemplo delimitado con opciones \mintinline[linenos]{latex}/\begin{pspicture} y \end{pspicture}/ text
  46.  
  47.  
  48. Original anidado \mintinline{latex}|\mintinline{lang}{ code }| text
  49. Ejemplo original anidado \mintinline{latex}{\begin{pspicture} y \end{pspicture}}
  50.  
  51. Original anidado con opciones \mintinline{latex}|\mintinline[opt]{lang}{ code }| text
  52. Ejemplo original anidado con opciones \mintinline[linenos]{latex}{ \begin{pspicture} y \end{pspicture}}
  53.  
  54. \section{minted inline custom}
  55.  
  56. Definicion por defecto del comando  \mintinline{latex}|\newmintinline{lang}{opt}|
  57. \newmintinline{perl}{showspaces}
  58.  
  59. Ejemplo sin opciones X\perlinline/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\nameinline<del> code <del>|
  60.  
  61. Ejemplo con opciones X\perlinline[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\nameinline[opt]<del> code <del>|
  62.  
  63. Ejemplo con opciones anidado \perlinline[linenos]{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\nameinline[opt]{ code }|
  64.  
  65. Ejemplo sin opciones anidado \perlinline{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\nameinline{ code }|
  66.  
  67. Definicion personalizada del comando  \mintinline{latex}|\newmintinline[name]{lang}{opt}|
  68. \newmintinline[name]{latex}{showspaces}
  69.  
  70. Ejemplo sin opciones X\name/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name<del> code <del>|
  71.  
  72. Ejemplo con opciones X\name[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
  73.  
  74. Ejemplo con opciones anidado \name[linenos]{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\name[opt]{ code }|
  75.  
  76. Ejemplo sin opciones anidado \name{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\name{ code }|
  77.  
  78. \section{mint short}
  79.  
  80. Original delimitado \mintinline{latex}|\mint{lang}<del> code <del>| text
  81. Ejemplo delimitado \mint{latex}|\begin{pspicture} y \end{pspicture}| text
  82.  
  83. Original delimitado con opciones \mintinline{latex}|\mint[opt]{lang}<del> code <del>| text
  84. Ejemplo delimitado con opciones \mint[linenos]{latex}/\begin{pspicture} y \end{pspicture}/ text
  85.  
  86.  
  87. Original anidado \mintinline{latex}|\mint{lang}{ code }| text
  88. Ejemplo original anidado \mint{latex}{\begin{pspicture} y \end{pspicture}}
  89.  
  90. Original anidado con opciones \mintinline{latex}|\mint[opt]{lang}{ code }| text
  91. Ejemplo original anidado con opciones \mint[linenos]{latex}{ \begin{pspicture} y \end{pspicture}}
  92.  
  93. \section{mint short custom}
  94. Definicion por defecto comando  \mintinline{latex}|\newmint{lang}{opt}|
  95. \newmint{latex}{showspaces}
  96.  
  97. Ejemplo sin opciones X\latex/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\lang<del> code <del>|
  98.  
  99. Ejemplo con opciones X\latex[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\lang[opt]<del> code <del>|
  100.  
  101. Definicion personalizada del comando  \mintinline{latex}|\newmint[name]{lang}{opt}|
  102. \newmint[mylatex]{latex}{showspaces}
  103.  
  104.  
  105. Ejemplo sin opciones X\mylatex/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name<del> code <del>|
  106.  
  107. Ejemplo con opciones X\mylatex[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
  108.  
  109. %Ejemplo sin opciones anidado X\mylatex{\begin{pspicture} y \end{pspicture}}X de forma  \mintinline{latex}|\name<del> code <del>|
  110.  
  111. %Ejemplo con opciones X\mylatex[linenos]{\begin{pspicture} y \end{pspicture}}X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
  112.  
  113. %Se convierte EXTRAIDO-fig-3
  114. \begin{postscript}
  115. \begin{pspicture}[showgrid](0,3)(10,10)
  116. Se convierte
  117. \end{pspicture}
  118. \end{postscript}
  119.  
  120. \end{document}
  121.  
  122. IGNORAR
  123. \begin{postscript}
  124. \begin{pspicture}[showgrid](0,3)(10,10)
  125. Se queda
  126. \end{pspicture}
  127. \end{postscript}
  128.  
Coloreado en 0.003 segundos, usando GeSHi 1.0.8.4
Obtengo el archivo de salida:
Sintáxis: [ Descargar ] [ Ocultar ]
Using latex Syntax Highlighting
  1. \documentclass{article}
  2. \usepackage{minted}
  3. \usepackage{pstricks-add}
  4. \usepackage{auto-pst-pdf}
  5. \DefineVerbatimEnvironment{MyVerbatim}
  6. \begin{document}
  7. %Se convierte EXTRAIDO-fig-1
  8. \includegraphics[scale=1]{EXTRAIDO-fig-1}
  9.  
  10. \begin{MyVerbatim}
  11. \begin{pspicture}[showgrid](0,3)(10,10)
  12. Se queda
  13. \end{pspicture}
  14. \end{MyVerbatim}
  15.  
  16. \begin{Verbatim*}
  17. \begin{pspicture}[showgrid](0,3)(10,10)
  18. Se queda
  19. \end{pspicture}
  20. \end{Verbatim*}
  21.  
  22. \newminted[langA]{latex}{linenos}
  23.  
  24. \begin{langA}
  25. \begin{pspicture}[showgrid](0,3)(10,10)
  26. Se queda
  27. \end{pspicture}
  28. \end{langA}
  29. %Se convierte EXTRAIDO-fig-2
  30. \includegraphics[scale=1]{EXTRAIDO-fig-2}
  31.  
  32. \section{minted inline default}
  33. Original delimitado \mintinline{latex}|\mintinline{lang}<del> code <del>| text
  34. Ejemplo delimitado \mintinline{latex}|\begin{langA} y\end{langA}| text
  35.  
  36. Original delimitado con opciones \mintinline{latex}|\mintinline[opt]{lang}<del> code <del>| text
  37. Ejemplo delimitado con opciones \mintinline[linenos]{latex}/\begin{pspicture} y \end{pspicture}/ text
  38.  
  39.  
  40. Original anidado \mintinline{latex}|\mintinline{lang}{ code }| text
  41. Ejemplo original anidado \mintinline{latex}{\begin{pspicture} y \end{pspicture}}
  42.  
  43. Original anidado con opciones \mintinline{latex}|\mintinline[opt]{lang}{ code }| text
  44. Ejemplo original anidado con opciones \mintinline[linenos]{latex}{ \begin{pspicture} y \end{pspicture}}
  45.  
  46. \section{minted inline custom}
  47.  
  48. Definicion por defecto del comando  \mintinline{latex}|\newmintinline{lang}{opt}|
  49. \newmintinline{perl}{showspaces}
  50.  
  51. Ejemplo sin opciones X\perlinline/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\nameinline<del> code <del>|
  52.  
  53. Ejemplo con opciones X\perlinline[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\nameinline[opt]<del> code <del>|
  54.  
  55. Ejemplo con opciones anidado \perlinline[linenos]{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\nameinline[opt]{ code }|
  56.  
  57. Ejemplo sin opciones anidado \perlinline{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\nameinline{ code }|
  58.  
  59. Definicion personalizada del comando  \mintinline{latex}|\newmintinline[name]{lang}{opt}|
  60. \newmintinline[name]{latex}{showspaces}
  61.  
  62. Ejemplo sin opciones X\name/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name<del> code <del>|
  63.  
  64. Ejemplo con opciones X\name[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
  65.  
  66. Ejemplo con opciones anidado \name[linenos]{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\name[opt]{ code }|
  67.  
  68. Ejemplo sin opciones anidado \name{\begin{pspicture} y \end{pspicture}} de forma  \mintinline{latex}|\name{ code }|
  69.  
  70. \section{mint short}
  71.  
  72. Original delimitado \mintinline{latex}|\mint{lang}<del> code <del>| text
  73. Ejemplo delimitado \mint{latex}|\begin{pspicture} y \end{pspicture}| text
  74.  
  75. Original delimitado con opciones \mintinline{latex}|\mint[opt]{lang}<del> code <del>| text
  76. Ejemplo delimitado con opciones \mint[linenos]{latex}/\begin{pspicture} y \end{pspicture}/ text
  77.  
  78.  
  79. Original anidado \mintinline{latex}|\mint{lang}{ code }| text
  80. Ejemplo original anidado \mint{latex}{\begin{pspicture} y \end{pspicture}}
  81.  
  82. Original anidado con opciones \mintinline{latex}|\mint[opt]{lang}{ code }| text
  83. Ejemplo original anidado con opciones \mint[linenos]{latex}{ \begin{pspicture} y \end{pspicture}}
  84.  
  85. \section{mint short custom}
  86. Definicion por defecto comando  \mintinline{latex}|\newmint{lang}{opt}|
  87. \newmint{latex}{showspaces}
  88.  
  89. Ejemplo sin opciones X\latex/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\lang<del> code <del>|
  90.  
  91. Ejemplo con opciones X\latex[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\lang[opt]<del> code <del>|
  92.  
  93. Definicion personalizada del comando  \mintinline{latex}|\newmint[name]{lang}{opt}|
  94. \newmint[mylatex]{latex}{showspaces}
  95.  
  96.  
  97. Ejemplo sin opciones X\mylatex/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name<del> code <del>|
  98.  
  99. Ejemplo con opciones X\mylatex[linenos]/\begin{pspicture} y \end{pspicture}/X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
  100.  
  101. %Ejemplo sin opciones anidado X\mylatex{\begin{pspicture} y \end{pspicture}}X de forma  \mintinline{latex}|\name<del> code <del>|
  102.  
  103. %Ejemplo con opciones X\mylatex[linenos]{\begin{pspicture} y \end{pspicture}}X de forma  \mintinline{latex}|\name[opt]<del> code <del>|
  104.  
  105. %Se convierte EXTRAIDO-fig-3
  106. \includegraphics[scale=1]{EXTRAIDO-fig-3}
  107.  
  108. \end{document}
  109.  
  110. IGNORAR
  111. \begin{postscript}
  112. \begin{pspicture}[showgrid](0,3)(10,10)
  113. Se queda
  114. \end{pspicture}
  115. \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
  1. my $braces   = qr/ (?:\{)(.+?)(?:\})                               /msx;
  2. my $fancyvrb = qr/\\ (?:DefineVerbatimEnvironment)    $braces       /msx;
  3. 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
  1. \DefineVerbatimEnvironment{% ignorar
  2.  
  3.      MyVerbatim % ignorar ignorar
  4.  
  5.                 %%% ignorar
  6. }
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
pablgonz
Perlero nuevo
Perlero nuevo
 
Mensajes: 236
Registrado: 2010-09-08 21:03 @919
Ubicación: Concepción (Chile)

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

Notapor 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
pablgonz
Perlero nuevo
Perlero nuevo
 
Mensajes: 236
Registrado: 2010-09-08 21:03 @919
Ubicación: Concepción (Chile)

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

Notapor 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
  1. #!/usr/bin/env perl
  2. use v5.14;
  3. use autodie;
  4.  
  5. my $x = '
  6.  
  7. \DefineVerbatimEnvironment{% ignorar
  8.  
  9.         MyVerbatim % ignorar ignorar
  10.  
  11.                     %%% ignorar
  12. }
  13.  
  14. ';
  15.  
  16. #say $x;
  17.  
  18. my $palabra = qr/\w+/;
  19. my $verbo   = qr/^ \\ $palabra \{ (.+) \}/msx;
  20.  
  21. if ($x =~ /$verbo/) {
  22.  
  23.     my $contenido = $1;
  24.     #say $contenido;
  25.  
  26.     $contenido =~ s/%.*\n//mg;          # quitar comentarios
  27.     $contenido =~ s/^\s*|\s*//mg;       # quitar espacios en blanco
  28.  
  29.     say "[$contenido]";
  30. }
Coloreado en 0.001 segundos, usando GeSHi 1.0.8.4
JF^D Perl programming & Raku programming. Grupo en Telegram: https://t.me/Perl_ES
Avatar de Usuario
explorer
Administrador
Administrador
 
Mensajes: 14476
Registrado: 2005-07-24 18:12 @800
Ubicación: Valladolid, España

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

Notapor 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
  1. \newtcblisting{% ignorar
  2.  
  3.     MyVerbatimUno % ignorar si sale {}{{{ o más %%ignorar%%
  4.  
  5.                      %%% ignorar
  6. } % cerrar  
  7.  
  8. \DefineVerbatimEnvironment{% un comentario
  9.         %% ignorar uno
  10.         %% ignorar dos
  11.     MyVerbatimDOS % esto es lo que deseo capturar
  12.         %% ignorar tres
  13. }% 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
  1. #!/usr/bin/perl
  2. use v5.14;
  3. use autodie;    # muere si ocurre un error
  4.  
  5. # \begin{...} ... \end{...} del paquete tcolorbox y otros
  6. my $no_corchete = qr/ (?:\[ .+? \])?            /msx;
  7. my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
  8. my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
  9. my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
  10. my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
  11. my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /x;
  12. my $tcbxpack = qr/(?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) /x;
  13.  
  14. my $x = '
  15.  
  16. \newtcblisting{% ignorar
  17.  
  18.    MyVerbatimUno % ignorar si sale {}{{{ o más %%ignorar%%
  19.  
  20.                     %%% ignorar
  21. } % cerrar  
  22.  
  23. \DefineVerbatimEnvironment{% un comentario
  24.         %% ignorar uno
  25.         %% ignorar dos
  26.    MyVerbatimDOS % esto es lo que deseo capturar
  27.         %% ignorar tres
  28. }% cerrar
  29.  
  30. ';
  31.  
  32. my $verbo   = qr/^ \\ $tcbxpack \s*\{ (.+) \}/msx;
  33.  
  34. if ($x =~ /$verbo/) {
  35.     my $contenido = $1;
  36.     $contenido =~ s/%.*\n//mg;          # quitar comentarios
  37.     $contenido =~ s/^\s*|\s*//mg;       # quitar espacios en blanco
  38.  say "[$contenido]";
  39. }
  40.  
  41. my @tcolorbox = $x =~ m/ $verbo /msxg;
  42.  
  43. say "@tcolorbox";
  44.  
  45. __END__
Coloreado en 0.001 segundos, usando GeSHi 1.0.8.4

Agradecido nuevamente.
Saludos
pablgonz
Perlero nuevo
Perlero nuevo
 
Mensajes: 236
Registrado: 2010-09-08 21:03 @919
Ubicación: Concepción (Chile)

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

Notapor 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.
JF^D Perl programming & Raku programming. Grupo en Telegram: https://t.me/Perl_ES
Avatar de Usuario
explorer
Administrador
Administrador
 
Mensajes: 14476
Registrado: 2005-07-24 18:12 @800
Ubicación: Valladolid, España

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

Notapor 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
  1. #!/usr/bin/perl
  2. use v5.14;
  3. use autodie;    # muere si ocurre un error
  4.  
  5. # \begin{...} ... \end{...} del paquete tcolorbox y otros
  6. my $no_corchete = qr/ (?:\[ .+? \])?            /msx;
  7. my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
  8. my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
  9. my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
  10. my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
  11. my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /x;
  12. my $tcbxpack = qr/(?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) /x;
  13.  
  14. my $x = '
  15.  
  16. \newtcblisting{% ignorar
  17.  
  18.    MyVerbatimUno % ignorar si sale {}{{{ o más %%ignorar%%
  19.  
  20.                     %%% ignorar
  21. } % cerrar  
  22.  
  23. \DefineVerbatimEnvironment{% un comentario
  24.         %% ignorar uno
  25.         %% ignorar dos
  26.    MyVerbatimDOS % esto es lo que deseo capturar
  27.         %% ignorar tres
  28. }% cerrar
  29.  
  30. ';
  31.  
  32. my $verbo   = qr/ \\ $tcbxpack \{ (.+) \}/msx;
  33.  
  34. #if ($x =~ /$verbo/) {
  35.     #my $contenido = $1;
  36.     #$contenido =~ s/%.*\n//mg;          # quitar comentarios
  37.     #$contenido =~ s/^\s*|\s*//mg;       # quitar espacios en blanco
  38. ##say "[$contenido]";
  39. #}
  40.  
  41. ### pasamos a un array el contenido de entrada
  42. my @tcolorbox = $x;
  43.  
  44. s/%.*\n//mg foreach @tcolorbox; # quitar comentarios
  45. s/^\s*|\s*//mg foreach @tcolorbox; # quitar espacios en blanco
  46.  
  47. ### filtramos con grep y regex para quedarnos con la palabra buscada
  48. @tcolorbox = grep { /($verbo)/ } @tcolorbox;
  49.  
  50. say "@tcolorbox";
  51.  
  52. __END__
  53.  
Coloreado en 0.001 segundos, usando GeSHi 1.0.8.4
¿Era algo así la idea que propusiste?

Agradecido por todo.
Pablo
pablgonz
Perlero nuevo
Perlero nuevo
 
Mensajes: 236
Registrado: 2010-09-08 21:03 @919
Ubicación: Concepción (Chile)

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

Notapor 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
  1. #!/usr/bin/perl
  2. use v5.14;
  3. use autodie;    # muere si ocurre un error
  4.  
  5. my $x = '
  6.  
  7. \newtcblisting{% ignorar
  8.  
  9.    MyVerbatimUno % ignorar si sale {}{{{ o más %%ignorar%%
  10.  
  11.                     %%% ignorar
  12. } % cerrar  
  13.  
  14. \DefineVerbatimEnvironment{% un comentario
  15.         %% ignorar uno
  16.         %% ignorar dos
  17.    MyVerbatimDOS % esto es lo que deseo capturar
  18.         %% ignorar tres
  19. }% cerrar
  20.  
  21.  
  22. \DefineVerbatimEnvironment{% un comentario
  23.         %% ignorar uno
  24.         %% ignorar dos
  25.    MyVerbatimTres % esto es lo que deseo capturar
  26.         %% ignorar tres
  27. }% cerrar
  28. Y si coloco palabras por aqui %%%
  29. y algunas otras cosas como \newtcblisting
  30. \newtcblisting [algo]{% ignorar
  31.  
  32.    MyVerbatimCuatro % ignorar si sale {}{{{ o más %%ignorar%%
  33.  
  34.                     %%% ignorar
  35. } % cerrar  
  36.  
  37. \RenewTCBListing[
  38.                         opcion                 
  39.                         ]{
  40.                         opcionaluno
  41.                         }
  42. \DefineVerbatimEnvironment{MyVerbatimFinal}
  43.  
  44. ';
  45.  
  46. ### Pasamos a un array el contenido de entrada
  47. my @tcolorbox = $x;
  48.  
  49. ### Filtramos con grep y regex para quedarnos con la palabra buscada
  50. s/%.*\n//mg foreach @tcolorbox; # quitar comentarios
  51. s/^\s*|\s*//mg foreach @tcolorbox; # quitar espacios en blanco
  52.  
  53. ### Reglas
  54. my $braces      = qr/ (?:\{)(.+?)(?:\})         /msx;
  55. my $no_corchete = qr/ (?:\[ .+? \])?            /msx;
  56.  
  57. ### TCOLORBOX ... \begin{...} ... \end{...} del paquete tcolorbox
  58. my $tcbxnlst = qr/ (?:re)?newtcblisting $no_corchete                    /x;
  59. my $tcbxplst = qr/ (?:Declare|Provide|New|Renew)TCBListing $no_corchete /x;
  60. my $tcbxnext = qr/ (?:re)?newtcbexternalize(?:environment|tcolorbox)    /x;
  61. my $lstnewen = qr/ (?:lstnewenvironment)                                /x;
  62. my $fancyvrb = qr/ (?:DefineVerbatimEnvironment)                        /msx;
  63. my $tcbxpack = qr/\\ (?:$tcbxnlst| $tcbxplst| $tcbxnext| $lstnewen|$fancyvrb) $braces /msx;
  64.  
  65. ### Unimos los modificaciones
  66. my $fileverb = join '', @tcolorbox;
  67.  
  68. ### Extraemos con regex
  69. @tcolorbox  = $fileverb =~ m/$tcbxpack/gmsx;  
  70.  
  71. ### Pasamos @tcolorbox a  \qr
  72. $fileverb = join "|", map quotemeta, @tcolorbox;
  73. $fileverb       = qr/\b(?:$fileverb)/x;
  74.  
  75. say "$fileverb";
  76.  
  77. __END__
  78.  
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
  1. s/%.*\n//mg foreach @tcolorbox; # quitar comentarios
  2. 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
pablgonz
Perlero nuevo
Perlero nuevo
 
Mensajes: 236
Registrado: 2010-09-08 21:03 @919
Ubicación: Concepción (Chile)


Volver a Básico

¿Quién está conectado?

Usuarios navegando por este Foro: No hay usuarios registrados visitando el Foro y 3 invitados

cron