¿Existe una macro (razonablemente) eficiente que haga algo similar a
\long\def\comparets#1#2{\def\aa{#1}\def\bb{#2}\ifx\aa\bb true\else false\fi}
excepto que sea expandible (es decir, \newcomparets{<tokens1>}{<tokens2>}se expandiría a "verdadero" o "falso", incluido el interior \edef)? Estoy buscando una solución TeX "pura" (es decir, sin extensiones, como e-TeX). He mirado l3tlmacros pero parecen usar e-TeX. La solución debería funcionar con secuencias de tokens arbitrarias (incluidas aquellas que contienen varios tipos de "espacios divertidos" y llaves y secuencias de control arbitrarias). Parece que no puedo encontrar una manera de hacer esto sin realizar varias pasadas.
Respuesta1
No estoy seguro de si publicar esto como respuesta a mi propia pregunta es kosher, ya que en realidad no la responde, pero no lo marcaré como tal (aun suponiendo que pueda hacerlo), así que si alguien tiene un destello de inspiración que resuelva el problema original, Con mucho gusto la etiquetaré como una respuesta verdadera.
Ahora sobre las macros. Pido disculpas de antemano por el estado en el que se encuentran. Han sido extraídos (y renombrados) de una variedad de código que he escrito a lo largo de los años, por lo que el estilo es un poco... ecléctico, digamos. Se pueden optimizar muchas cosas a continuación, pero el problema de los pases múltiples persiste, como explicaré más adelante, así que si alguien tiene un truco inteligente para resolverlo, hágamelo saber.
Hay un par de advertencias:
1) Faltan las macros de comparación reales, solo está presente la parte de análisis, que entrega, en forma de 'prefijo expandible' (por ejemplo, funciona con el \romannumeral-1truco) una cadena de tokens de categoría 11 y 12 que contiene suficiente información para identificar cada token en el secuencia en cuanto a su categoría, código de carácter, si lo hay, si es una llave, su código de carácter, etc. Estas cadenas se pueden comparar directamente si se desea.
2) Bueno, 1) es una mentira piadosa por dos motivos:
a) cualquier token que pueda tomarse como parámetro (es decir, sin espacio, sin llave) es (tomado y) simplemente reemplazado por su \meaning
cadena encerrada en t ... e (tanto t como e son categoría 11); tenga en cuenta que los tokens de categoría 10 con un código de carácter distinto del 32 entran en esta categoría (nunca mejor dicho). \yygrabtokenrawse puede ajustar para proporcionar un mejor análisis (imprescindible si el objetivo es comparar listas arbitrarias y equilibradas de tokens, pero se reduce a unos pocos condicionales cuidadosamente escritos). Tenga en cuenta que \stringtampoco es suficiente, ya que \escapecharpuede ser -1.
b) falta el paso de recursividad de 'nivel superior'; el principal problema aquí son las llaves del código de carácter 32; se tratan en la última etapa cuando se conoce la duración de la secuencia y uno puede simplemente \stringencontrar cada uno de ellos o descubrir su \meaning. Bueno, no tan rápido porque si tienen el código de categoría 32, ambos los \meaningconvierten \stringen espacios comunes ( \meaningterminarán en dos espacios, lo cual tampoco ayuda), que es un problema que \detokenize
se inventó para corregir. Por lo tanto, debemos decidir cómo agarrarlos. La única garantía que ofrece el código es que cada llave de apertura se identificará correctamente como código de carácter 32 ( o1eo c1e) o código de carácter distinto de 32 ( o2e, c2e). El código que hace esto estropea algunas de las llaves de cierre que siguen (sus códigos de caracteres) para poder consumir la llave de manera segura, por lo que los c2e'marcadores' que siguen al primero no son confiables (sin embargo, si se encuentra otro o1e, o1eo o2e
, es una llave del código de carácter 32). La siguiente iteración puede tomar las llaves que se 'descifran' sin estropear la siguiente llave. Después de muchas más pasadas (hasta tantas como llaves de cierre, lamentablemente), todo se puede solucionar. Si alguien está interesado, puedo terminar las macros para hacer esto. Sólo si Knuth terminara cada uno \meaningcon un punto...
3) El código dedica mucho tiempo a "propagar la expansión". Una situación típica es
\somemacro{<long list of benign tokens>}{\string}; \stringAquí es necesario expandirlo antes de que pueda suceder algo más, por lo que \somemacrodedica mucho tiempo a insertar \expandaftercorreos electrónicos en el archivo <long list ...>. Tenga en cuenta que \romannumeralfallará si <long list ...>es muy largo, por lo que codificar todo como dígitos no ayudará. Es posible usarlo \csname <long ...>\endcsname(con un \expandafterseguimiento), pero en este caso me inquieta contaminar la tabla hash de TeX.
Las macros intentan identificar 'espacios divertidos' en la primera pasada; este es el único uso para \meaningy \yymatchblankspace
a continuación. Sólo se puede hacer con \string.
Al final se incluye un caso de prueba para la macro. Si pasé por alto algo estúpido, mis disculpas (cuando Joseph Wright y otros sospechan, yo también tiendo a sospechar).
EDITAR:Además de cualquier otra cosa que pueda estar mal con estos, omití \longcada definición para mayor claridad, por lo que \parlo arruinaré.
Para ampliarproporcionar un mejor análisisarriba: para resolver casos patológicos (como \escapechar=-1 \let\#=#) se pueden preparar un montón de macros (una (o incluso dos) por carácter, como \expandafter\def\csname match#\endcsname #1\##{...}% last '#' is \catcode 13) o algunas macros con una \defed que \def\maintest #1<a list of all active characters and single letter cs's>{...}haga todo el trabajo pesado (insertando recursivamente el ' token "agarrado" en el "delimitador" potencial). También son posibles opciones intermedias (cambiar tiempo por espacio). En cuanto a "son muchas macros", es una preocupación, por supuesto. Mi opinión (imperfecta) sobre esto es: "si uno puede permitirse tantos \catcoderegistros, también puede permitirse esos 'condicionales' especiales).
tengo miedo de quepropagación de expansiónEl problema mencionado anteriormente es simplemente el precio de hacer recursividad en TeX. Este problema se puede mitigar en cierta medida codificando (durante el primer paso) los tokens con \yysx ?dónde \def\yysx#1#2{\expandafter\space\expandafter\yysx\expandafter#1\romannumeral-1#2}. De esta manera, un elemento \romannumeral-1delante de una lista de \yysx ?entradas "pasará" la expansión al final de la lista mientras permanece intacta.
El 'postprocesamiento de llaves' se siente asídeberíaser evitable.
Finalmente, muchas veces me han preguntado '¿por qué no e-TeX?'. No estoy seguro de que éste sea el lugar adecuado para discutirlo, pero tengo razones (probablemente subjetivas) para evitarlo. Si alguien puede sugerir un lugar mejor para discutir dichas preferencias, se lo agradecería.
% helper macros (to build test cases, etc); @ is a letter
\def\yyreplacestring#1\in#2\with#3{%
\expandafter\def\expandafter\r@placestring\expandafter##\expandafter1\the#1##2\end{%
\def\r@placestring{##2}% is this the string at the very end?
\ifx\r@placestring\empty % then it is the one we inserted, report
\errmessage{string <\the#1> not present in \the#2}% do not change the register if the string is not there
\else % remove the extra copy of #1\end at the end
\expandafter#2\expandafter\expandafter\expandafter
{\expandafter\r@plac@string\expandafter{\the#3}{##1}##2\end}%
\fi}% end of \r@placestring definition
\expandafter\def\expandafter\r@plac@string
\expandafter##\expandafter1%
\expandafter##\expandafter2%
\expandafter##\expandafter3%
\the#1\end{##2##1##3}%
\expandafter\expandafter\expandafter\r@placestring\expandafter\the\expandafter#2\the#1\end
}
\newtoks\toksa
\newtoks\toksb
\newtoks\toksc
\newtoks\toksd
\def\yybreak#1#2\yycontinue{\fi#1}
\def\eatone#1{}
\def\eatonespace#1 {}
\def\identity#1{#1}
\def\yyfirstoftwo#1#2{#1}
\def\yysecondoftwo#1#2{#2}
\def\yysecondofthree#1#2#3{#2}
\def\yythirdofthree#1#2#3{#3}
% #1 -- `call stack'
% #2 -- remaining sequence
% #3 -- `parsed' sequence
\def\yypreparsetokensequenc@#1#2#3{%
\yystringempty{#2}{#1{#3}}{\yypreparsetokensequen@@{#1}{#2}{#3}}%
}
\def\yypreparsetokensequen@@#1#2#3{% remaining sequence is nonempty
\yystartsinbrace{#2}{\yydealwithbracedgroup{#1}{#2}{#3}}{\yypreparsetokensequ@n@@{#1}{#2}{#3}}%
}
\def\yydealwithbracedgroup#1#2#3{% the first token of the remaining sequence is a brace
\iffalse{\fi\yydealwithbracedgro@p#2}{#1}{#3}%
}
\def\yydealwithbracedgro@p#1{%
\yypreparsetokensequenc@{\yyrepackagesequence}{#1}{}%
}
% #1 -- parsed sequence
% this is a sequence to `propagate expansion' into the next parameter.
% the same can be achieved by packaging the whole sequence with a
% \csname ... \endcsname pair and using a simple \expandafter
% maybe that would be a better idea ...
\def\yyrepackagesequence#1{%
\yyrepackagesequenc@{}#1\end
}
% #1 -- `packaged' sequence (\expandafter\expandafter\expandafter ? ...)
% #2 -- the next category 12 character or \end
\def\yyrepackagesequenc@#1#2{%
\ifx#2\end
\yybreak{\yyrepackagesequ@nc@{#1\expandafter\expandafter\expandafter}}%
\else
\yybreak{\yyrepackagesequenc@{#1\expandafter\expandafter\expandafter#2}}%
\yycontinue
}
% #1 -- `packaged' sequence (\expandafter\expandafter\expandafter ? ...)
% this macro is followed by the remainder of the original sequence with a so far
% unmatched right brace, the `call stack' and the parsed sequence.
\def\yyrepackagesequ@nc@#1{%
\expandafter\expandafter\expandafter\yyrepackagesequ@nc@swap#1{\expandafter\eatone\string}%
}
% #1 -- parsed sequence without packaging
\def\yyrepackagesequ@nc@swap#1#{%
\yyrepackagesequ@nc@sw@p{#1}%
}
% #1 -- parsed `inner' sequence
% #2 -- remainder of the original sequence
% #3 -- `call stack'
% #4 -- parsed sequence so far
\def\yyrepackagesequ@nc@sw@p#1#2#3#4{%
\yypreparsetokensequenc@{#3}{#2}{#4[#1]}%
}
% `braced group' thread ends here
% #1 -- `call stack'
% #2 -- remaining sequence
% #3 -- `parsed' sequence
\def\yypreparsetokensequ@n@@#1#2#3{% the remaining group in #2 is nonempty and does not start with a brace
\yystartsinspace{#2}{\yyconsumetruespace{#1}{#2}{#3}}{\yypreparsetokenseq@@n@@{#1}{#2}{#3}}%
}
\def\yyconsumetruespace#1#2#3{%
\expandafter\yyconsumetruespac@swap\expandafter{\eatonespace#2}{#1}{#3.}%
}
\def\yyconsumetruespac@swap#1#2#3{%
\yypreparsetokensequenc@{#2}{#1}{#3}%
}
% `group starting with a true (character code 32, category code 10) space' thread ends here
% #1 -- `call stack'
% #2 -- remaining sequence
% #3 -- `parsed' sequence
\def\yypreparsetokenseq@@n@@#1#2#3{% a nonempty group, that does not start with a brace or a true space
\yymatchblankspace{#2}{\yyrescanblankspace{#2}{#1}{#3}}{\yypreparsetokens@q@@n@@{#1}{#2}{#3}}%
}
% #1 -- remaining sequence
% #2 -- `call stack'
% #3 -- `parsed' sequence
\def\yyrescanblankspace#1#2#3{%
\expandafter\expandafter\expandafter
\yyrescanblankspac@swap
\expandafter\expandafter\expandafter{\expandafter\yynormalizeblankspac@\meaning#1}{#2}{#3*}%
}
\def\yyrescanblankspac@swap#1#2#3{%
\yystartsinspace{#1}{%
\expandafter\yyrescanblankspac@sw@p\expandafter{\eatonespace#1}{#2}{#3}%
}{%
\expandafter\yyrescanblankspac@sw@p\expandafter{\eatone#1}{#2}{#3}%
}%
}
\def\yyrescanblankspac@sw@p#1#2#3{%
\yypreparsetokensequenc@{#2}{#1}{#3}%
}
% `group starting with a blank space' ends here
% #1 -- `call stack'
% #2 -- remaining sequence
% #3 -- `parsed' sequence
\def\yypreparsetokens@q@@n@@#1#2#3{% nonempty group starting with a non blank, non brace token
\expandafter\yypreparsetokens@q@@n@@swap\expandafter{\eatone#2}{#1}{#30}%
}
\def\yypreparsetokens@q@@n@@swap#1#2#3{%
\yypreparsetokensequenc@{#2}{#1}{#3}%
}
% #1 -- string of category code 12 or 10 characters
% #2 -- string of category code 12 or 10 characters
\def\yycomparesimplestrings#1#2{%
\yystringempty{#1}{%
\yystringempty{#2}{\yyfirstoftwo}{\yysecondoftwo}%
}{\yycomparesimplestrings@{#1}{#2}}%
}
\def\yycomparesimplestrings@#1#2{% the first string is nonempty
\yystringempty{#2}{\yysecondoftwo}{\yycomparesimplestrings@@{#1}{#2}}%
}
\def\yycomparesimplestrings@@#1#2{% both strings are nonempty
\yystartsinspace{#1}{%
\yystartsinspace{#2}{\yyabsorbfirstspace{#1}{#2}}{\yysecondoftwo}%
}{%
\yystartsinspace{#2}{\yysecondoftwo}{\yyabsorbfirstnonspace{#1}{#2}}%
}
}
\def\yyabsorbfirstspace#1#2{%
\expandafter\yyabsorbfirstspac@swap\expandafter{\eatonespace#1}{#2}%
}
\def\yyabsorbfirstspac@swap#1#2{%
\expandafter\yyabsorbfirst@swap\expandafter{\eatonespace#2}{#1}%
}
\def\yyabsorbfirstnonspace#1#2{%
\expandafter\yyabsorbfirstnonspac@swap\expandafter{\eatone#1}{#2}%
}
\def\yyabsorbfirstnonspac@swap#1#2{%
\expandafter\yyabsorbfirst@swap\expandafter{\eatone#2}{#1}%
}
\def\yyabsorbfirst@swap#1#2{%
\yycomparesimplestrings{#2}{#1}%
}
% `compare strings of category code 12' thread ends here
% #1 -- remaining parsed sequence
% #2 -- analysed sequence
\def\yyanalysetokens@#1#2{%
\yystringempty{#1}{{#2}}%
{\yyanalysetok@ns@#1\end{#2}}%
}
\def\yyanalysetok@ns@#1#2\end{%
\ifx#1.%
\expandafter\yyfirstoftwo
\else
\expandafter\yysecondoftwo
\fi
{\yygrabablank{#2}}%
{%
\ifx#1[% not a space, an opening brace
\expandafter\yyfirstoftwo
\else
\expandafter\yysecondoftwo
\fi
{%
\yydisableobrace{#2}%
}{%
\ifx#1]% not a space, a closing brace
\expandafter\yyfirstoftwo
\else
\expandafter\yysecondoftwo
\fi
{%
\yydisablecbrace{#2}%
}{% neither space nor brace
\yygrabtokenraw{#2}%
}%
}%
}%
}
% #1 -- remaining parsed sequence
% #2 -- analysed sequence
% #3 -- next token
\def\yygrabtokenraw#1#2#3{%
\expandafter\yyanalysetokens@swap\expandafter{\meaning#3}{#1}{#2}%
}
\def\yyanalysetokens@swap#1#2#3{%
\yyanalysetokens@{#2}{#3t#1e}%
}
\def\yygrabablank#1#2 {%
\yyanalysetokens@{#1}{#2s0e}%
}
% #1 -- remaining parsed sequence
% #2 -- analysed sequence
\def\yydisablecbrace#1#2{%
\yydisablecbrac@{}#1\relax#2\end
}
\def\yydisablecbrac@#1#2{%
\ifx#2\end
\yybreak{\yydisablecbrac@@{#1\expandafter\expandafter\expandafter}}%
\else
\yybreak{\yydisablecbrac@{#1\expandafter\expandafter\expandafter#2}}%
\yycontinue
}
\def\yydisablecbrac@@#1{%
\expandafter\expandafter\expandafter
\yydisablecbrace@@@#1\end
\expandafter\expandafter\expandafter
{\iffalse}\fi\string
}
\def\yydisablecbrace@@@#1\relax#2\end#3{%
\yystartsinspace{#3}%
{\expandafter\yyanalysetok@nsswap\expandafter{\eatonespace#3}{#1}{#2c1e}}%
{\expandafter\yyanalysetok@nsswap\expandafter{\eatone#3}{#1}{#2c2e}}%
}
\def\yyanalysetok@nsswap#1#2#3{%
\iffalse{\fi\yyanalysetokens@{#2}{#3}#1}%
}
% #1 -- remaining parsed sequence
% #2 -- analysed sequence
\def\yydisableobrace#1#2{%
\yydisableobrac@{}#1\relax#2\end
}
\def\yydisableobrac@#1#2{%
\ifx#2\end
\yybreak{\yydisableobrac@@{#1\expandafter\expandafter\expandafter}}%
\else
\yybreak{\yydisableobrac@{#1\expandafter\expandafter\expandafter#2}}%
\yycontinue
}
\def\yydisableobrac@@#1{%
\expandafter\expandafter\expandafter
\yydisableobrace@@@#1\end
\expandafter\expandafter\expandafter
{\iffalse}\fi\string
}
\def\yydisableobrace@@@#1\relax#2\end#3{%
\yystartsinspace{#3}%
{\expandafter\yyanalysetok@nsswap\expandafter{\eatonespace#3}{#1}{#2o1e}}%
{\expandafter\yyanalysetok@nsswap\expandafter{\eatone#3}{#1}{#2o2e}}%
}
\uccode`\ =`\-
% \dotspace expands into a character code `\-, category code 10 token (funny space)
\uppercase{\def\dotspace{ }}
\toksa\expandafter\expandafter\expandafter{\expandafter\meaning\dotspace}
\toksb{-}
\toksc{#2}
\toksd\toksa
\yyreplacestring\toksb\in\toksa\with\toksc
\toksc{}
\yyreplacestring\toksb\in\toksd\with\toksc
\expandafter\def\expandafter\yymatchblankspac@\expandafter#\expandafter1\the\toksd{%
\yystringempty{#1}{\expandafter\yysecondofthree\expandafter{\string}}%
{\expandafter\yythirdofthree\expandafter{\string}}%
}
\edef\yymatchblankspace#1{% is it \catcode 10 token?
\noexpand\iffalse{\noexpand\fi
\noexpand\expandafter
\noexpand\yymatchblankspac@
\noexpand\meaning#1\the\toksd}%
}
% the idea behind the sequence below is that a leading character of category code 10
% is replaced either by a character of category code 10 and charachter code 32 or a character
% of category code 12 and character code other than 32
% note that while it is tempting to replace the definition below by something that ends in
% ... blank space #2{ ... with the hope of absorbing the result of \meaning in one step,
% this will not give the desired result in case of an active character,
% say, `~' that had been \let to the normal blank space
\expandafter\def\expandafter\yynormalizeblankspac@\expandafter#\expandafter1\the\toksd{}
\def\yystartsinspace#1{% is it \charcode 32, \catcode 10 token?
\iffalse{\fi\yystartsinspac@#1 }%
}
\def\yystartsinspac@#1 {%
\yystringempty{#1}{\expandafter\yysecondofthree\expandafter{\string}}{\expandafter\yythirdofthree\expandafter{\string}}%
}
\def\yystartsinbrace#1{%
\iffalse{{\fi
\if!\yytoks@mpty#1}}!%
\expandafter\yysecondoftwo
\else
\expandafter\yyfirstoftwo
\fi
}
\def\yystringempty#1{%
\iffalse{{{\fi
\ifcase\yytoks@mpty#1}}\@ne}\z@
\expandafter\yyfirstoftwo
\else
\expandafter\yysecondoftwo
\fi
}
\def\yytoks@mpty{%
\expandafter\eatone\expandafter{\expandafter{%
\ifcase\expandafter1\expandafter}\expandafter}\expandafter\fi\string
}
%% test code begins here
%\tracingmacros=3
%\tracingonline=3
\catcode`\ =13\relax%
\def\actspace{ }%
\catcode`\ =10\relax%
\catcode`\.=13\relax%
\def\actdotspace{.}%
\catcode`\.=12\relax%
\edef\makefunkydotspace{\let\expandafter\noexpand\actdotspace= \dotspace}
\edef\makefunkyspace{\let\expandafter\noexpand\actspace= \space}
\makefunkyspace
\makefunkydotspace
\catcode`\<=1
\catcode`\>=2
\uccode`\<=32
\uccode`\>=32
% inside the following sequence, < and > will become braces with character code 32 (space),
% \actspace will expand into an active character with character code 32, that has been \let to a
% character code 32, category code 10 token (space)
\uppercase{\edef\temptest{{ } \space\space\dotspace\expandafter\noexpand\actspace\expandafter\noexpand\actdotspace{<> {{}{{ u o l k kk
\end\noexpand\fi\noexpand\else\noexpand\iffalse{}} }}}}}
%\uppercase{\edef\temptest{\dotspace E <>}}
\show\temptest
\def\displaypreparse#1{%
\expandafter\errmessage\expandafter{\romannumeral-1\yypreparsetokensequenc@{\yyanalysetokens@}{#1}{}{}#1}%
}
\expandafter\displaypreparse\expandafter{\temptest}
\end