[latex3-commits] [git/LaTeX3-latex3-latex3] peek-analysis: Implement \peek_analysis_map_inline:n (b7f5d0426)
Bruno Le Floch
bruno at le-floch.fr
Tue Jul 14 17:18:51 CEST 2020
Repository : https://github.com/latex3/latex3
On branch : peek-analysis
Link : https://github.com/latex3/latex3/commit/b7f5d04269a4c387cd693f5addd7b94281e5799f
>---------------------------------------------------------------
commit b7f5d04269a4c387cd693f5addd7b94281e5799f
Author: Bruno Le Floch <bruno at le-floch.fr>
Date: Tue Jul 14 16:01:28 2020 +0200
Implement \peek_analysis_map_inline:n
>---------------------------------------------------------------
b7f5d04269a4c387cd693f5addd7b94281e5799f
l3kernel/l3tl-analysis.dtx | 460 ++++++++++++++++++++++++++++++++++++++++++---
1 file changed, 436 insertions(+), 24 deletions(-)
diff --git a/l3kernel/l3tl-analysis.dtx b/l3kernel/l3tl-analysis.dtx
index a5662491e..32b54d06d 100644
--- a/l3kernel/l3tl-analysis.dtx
+++ b/l3kernel/l3tl-analysis.dtx
@@ -52,10 +52,27 @@
%
% \section{\pkg{l3tl-analysis} documentation}
%
-% This module mostly provides internal functions for use in the
-% \pkg{l3regex} module. However, it provides as a side-effect a user
-% debugging function, very similar to the \cs{ShowTokens} macro from the
-% \pkg{ted} package.
+% This module provides functions that are particularly useful in the
+% \pkg{l3regex} module for mapping through a token list one \meta{token}
+% at a time (including begin-group/end-group tokens). The token list is
+% either given as an argument or found in the input stream. In both
+% cases the user provides \meta{inline code} that receives three
+% arguments for each \meta{token}:
+% \begin{itemize}
+% \item \meta{tokens}, which both \texttt{o}-expand and
+% \texttt{x}-expand to the \meta{token}. The detailed form of
+% \meta{token} may change in later releases.
+% \item \meta{char code}, a decimal representation of the character
+% code of the \meta{token}, $-1$ if it is a control sequence.
+% \item \meta{catcode}, a capital hexadecimal digit which denotes the
+% category code of the \meta{token} (0: control sequence, 1:
+% begin-group, 2: end-group, 3: math shift, 4: alignment tab, 6:
+% parameter, 7: superscript, 8: subscript, A: space, B: letter,
+% C:other, D:active). This can be converted to an integer by
+% writing |"|\meta{catcode}.
+% \end{itemize}
+% In addition, there is a debugging function \cs{tl_analysis_show:n},
+% very similar to the \cs{ShowTokens} macro from the \pkg{ted} package.
%
% \begin{function}[added = 2018-04-09]{\tl_analysis_show:N, \tl_analysis_show:n}
% \begin{syntax}
@@ -74,23 +91,33 @@
% \end{syntax}
% Applies the \meta{inline function} to each individual \meta{token}
% in the \meta{token list}. The \meta{inline function} receives three
-% arguments:
-% \begin{itemize}
-% \item \meta{tokens}, which both \texttt{o}-expand and
-% \texttt{x}-expand to the \meta{token}. The detailed form of
-% \meta{token} may change in later releases.
-% \item \meta{char code}, a decimal representation of the character
-% code of the token, $-1$ if it is a control sequence (with
-% \meta{catcode} $0$).
-% \item \meta{catcode}, a capital hexadecimal digit which denotes
-% the category code of the \meta{token} (0: control sequence, 1:
-% begin-group, 2: end-group, 3: math shift, 4: alignment tab, 6:
-% parameter, 7: superscript, 8: subscript, A: space, B: letter,
-% C:other, D:active).
-% \end{itemize}
-% As all other mappings the mapping is done at the current group
-% level, \emph{i.e.}~any local assignments made by the \meta{inline
-% function} remain in effect after the loop.
+% arguments as explained above. As all other mappings the mapping is
+% done at the current group level, \emph{i.e.}~any local assignments
+% made by the \meta{inline function} remain in effect after the loop.
+% \end{function}
+%
+% \begin{function}[added = 2020-07-14]{\peek_analysis_map_inline:n}
+% \begin{syntax}
+% \cs{peek_analysis_map_inline:n} \Arg{inline function}
+% \end{syntax}
+% Applies the \meta{inline function} to each individual \meta{token}
+% in the input stream that follows. The \meta{inline function}
+% receives three arguments as explained above. As all other mappings
+% the mapping is done at the current group level, \emph{i.e.}~any
+% local assignments made by the \meta{inline function} remain in
+% effect after the loop. The tokens are removed from the input
+% stream. The loop can be stopped by \cs{peek_analysis_map_break:}.
+% Within the code, \cs{l_peek_token} is set equal (as a token, not a
+% token list) to the token under consideration.
+% \end{function}
+%
+% \begin{function}[added = 2020-07-14]{\peek_analysis_map_break:, \peek_analysis_map_break:n}
+% \begin{syntax}
+% \cs{peek_analysis_map_inline:n} |{| \dots{} \cs{peek_analysis_map_break:n} \Arg{code} |}|
+% \end{syntax}
+% Stops the \cs{peek_analysis_map_inline:n} loop from seeking more
+% tokens, and inserts \meta{code} in the input stream (empty for
+% \cs{peek_analysis_map_break:}).
% \end{function}
%
% \end{documentation}
@@ -182,18 +209,51 @@
% \end{macrocode}
% \end{variable}
%
-% \begin{variable}{\l_@@_analysis_token}
-% \begin{variable}{\l_@@_analysis_char_token}
+% \begin{variable}
+% {\l_@@_analysis_token, \l_@@_analysis_char_token, \l_@@_analysis_next_token}
% The tokens in the token list are probed with the \TeX{} primitive
% \tn{futurelet}. We use \cs{l_@@_analysis_token} in that
% construction. In some cases, we convert the following token to a
% string before probing it: then the token variable used is
-% \cs{l_@@_analysis_char_token}.
+% \cs{l_@@_analysis_char_token}. When getting tokens from the input
+% stream we may need to look two tokens ahead, for which we use
+% \cs{l_@@_analysis_next_token}.
% \begin{macrocode}
\cs_new_eq:NN \l_@@_analysis_token ?
\cs_new_eq:NN \l_@@_analysis_char_token ?
+\cs_new_eq:NN \l_@@_analysis_next_token ?
+% \end{macrocode}
+% \end{variable}
+%
+% \begin{variable}{\l_@@_peek_code_tl}
+% Holds some code to be run once the next token has been fully
+% analysed in \cs{peek_analysis_map_inline:n}.
+% \begin{macrocode}
+\tl_new:N \l_@@_peek_code_tl
% \end{macrocode}
% \end{variable}
+%
+% \begin{variable}{\c_@@_peek_catcodes_tl}
+% A token list containing the character number~$32$ (space) with all
+% possible category codes except $1$ and $2$ (begin-group and
+% end-group). Why $32$? Because some \LuaTeX{} versions only allow
+% creation of catcode~$10$ (space) tokens with this character code,
+% and because even in other engines it is much easier to produce since
+% \cs{char_generate:nn} refuses to produce spaces.
+% \begin{macrocode}
+\tl_const:Nx \c_@@_peek_catcodes_tl
+ {
+ \char_generate:nn { 32 } { 3 } 3
+ \char_generate:nn { 32 } { 4 } 4
+ # \char_generate:nn { 32 } { 6 } 6
+ \char_generate:nn { 32 } { 7 } 7
+ \char_generate:nn { 32 } { 8 } 8
+ \c_space_tl \token_to_str:N A
+ \char_generate:nn { 32 } { 11 } \token_to_str:N B
+ \char_generate:nn { 32 } { 12 } \token_to_str:N C
+ \char_generate:nn { 32 } { 13 } \token_to_str:N D
+ }
+% \end{macrocode}
% \end{variable}
%
% \begin{variable}{\l_@@_analysis_normal_int}
@@ -1075,6 +1135,358 @@
% \end{macro}
% \end{macro}
%
+% \subsection{Peeking ahead}
+%
+% \begin{macro}[EXP]{\peek_analysis_map_break:, \peek_analysis_map_break:n}
+% The break statements use the general \cs{prg_map_break:Nn}.
+% \begin{macrocode}
+\cs_new:Npn \peek_analysis_map_break:
+ { \prg_map_break:Nn \peek_analysis_map_break: { } }
+\cs_new:Npn \peek_analysis_map_break:n
+ { \prg_map_break:Nn \peek_analysis_map_break: }
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{variable}{\l_@@_peek_charcode_int}
+% \begin{macrocode}
+\int_new:N \l_@@_peek_charcode_int
+% \end{macrocode}
+% \end{variable}
+%
+% \begin{macro}{\@@_analysis_char_arg:Nw, \@@_analysis_char_arg_aux:Nw}
+% After a call to \tn{futurelet} \cs{l_@@_analysis_token} followed by
+% a stringified character token (either explicit space or catcode
+% other character), grab the argument and pass it to |#1|. We only
+% need to do anything in the case of a space.
+% \begin{macrocode}
+\cs_new:Npn \@@_analysis_char_arg:Nw
+ {
+ \if_meaning:w \l_@@_analysis_token \c_space_token
+ \exp_after:wN \@@_analysis_char_arg_aux:Nw
+ \fi:
+ }
+\cs_new:Npn \@@_analysis_char_arg_aux:Nw #1 ~ { #1 { ~ } }
+% \end{macrocode}
+% \end{macro}
+%
+% \begin{macro}
+% {
+% \peek_analysis_map_inline:n,
+% \@@_peek_analysis_loop:NNn, \@@_peek_analysis_test:,
+% \@@_peek_analysis_normal:N, \@@_peek_analysis_cs:,
+% \@@_peek_analysis_char:N, \@@_peek_analysis_char:nN,
+% \@@_peek_analysis_special:, \@@_peek_analysis_retest:,
+% \@@_peek_analysis_next:, \@@_peek_analysis_str:,
+% \@@_peek_analysis_str:w, \@@_peek_analysis_str:n,
+% \@@_peek_analysis_active_str:n, \@@_peek_analysis_explicit:n,
+% \@@_peek_analysis_escape:, \@@_peek_analysis_collect:w,
+% \@@_peek_analysis_collect:n, \@@_peek_analysis_collect_loop:,
+% \@@_peek_analysis_collect_test:, \@@_peek_analysis_collect_end:NNN
+% }
+% Save the user's code in a control sequence that is suitable for
+% nested maps. We may wish to pass to this function an \tn{outer}
+% control sequence or active character; for this we will undefine
+% potentially-\tn{outer} tokens within a group, closed after the
+% function receives its arguments. This user's code function also
+% calls the loop auxiliary, and includes the trailing
+% \cs{prg_break_point:Nn} for when the user wants to stop the loop.
+% The loop auxiliary must remove that break point because it must look
+% at the input stream.
+% \begin{macrocode}
+\cs_new_protected:Npn \peek_analysis_map_inline:n #1
+ {
+ \int_gincr:N \g__kernel_prg_map_int
+ \cs_set_protected:cpn
+ { @@_analysis_map_ \int_use:N \g__kernel_prg_map_int :nnN }
+ ##1##2##3
+ {
+ \group_end:
+ #1
+ \@@_peek_analysis_loop:NNn
+ \prg_break_point:Nn \peek_analysis_map_break: { }
+ }
+ \@@_peek_analysis_loop:NNn ? ? ?
+ }
+% \end{macrocode}
+% The loop starts a group (closed by the user-code function defined
+% above) with a normalized escape character, and checks if the next
+% token is special or \texttt{N}-type.
+% \begin{macrocode}
+\cs_new_protected:Npn \@@_peek_analysis_loop:NNn #1#2#3
+ {
+ \group_begin:
+ \tl_set:Nx \l_@@_peek_code_tl
+ {
+ \exp_not:c
+ { @@_analysis_map_ \int_use:N \g__kernel_prg_map_int :nnN }
+ }
+ \int_set:Nn \tex_escapechar:D { `\\ }
+ \peek_after:Nw \@@_peek_analysis_test:
+ }
+\cs_new_protected:Npn \@@_peek_analysis_test:
+ {
+ \if_int_odd:w
+ \if_catcode:w \exp_not:N \l_peek_token { 1 \exp_stop_f: \fi:
+ \if_catcode:w \exp_not:N \l_peek_token } 1 \exp_stop_f: \fi:
+ \if_meaning:w \l_peek_token \c_space_token 1 \exp_stop_f: \fi:
+ 0 \exp_stop_f:
+ \exp_after:wN \@@_peek_analysis_special:
+ \else:
+ \exp_after:wN \exp_after:wN
+ \exp_after:wN \@@_peek_analysis_normal:N
+ \exp_after:wN \exp_not:N
+ \fi:
+ }
+% \end{macrocode}
+% Normal tokens are not too hard, but can be \tn{outer}, hence the
+% \cs{exp_not:N} in the code above. If the token is expandable then
+% it might be an \tn{outer} or a \TeX{} conditional, so to be safe we
+% set it to \cs{scan_stop:} (the assignment is local and stopped by
+% the \cs{group_end:} upon calling the user's code). Then distinguish
+% characters (including active ones and macro parameter characters)
+% from control sequences (whose string representation is more than one
+% character because the escape character is printable). For a control
+% sequence call the user code with suitable arguments.
+% \begin{macrocode}
+\cs_new_protected:Npn \@@_peek_analysis_normal:N #1
+ {
+ \exp_after:wN \reverse_if:N \exp_after:wN \if_meaning:w
+ \exp_not:N #1 #1
+ \tex_let:D #1 \scan_stop:
+ \tl_put_right:Nn \l_@@_peek_code_tl { { \exp_not:N #1 } }
+ \else:
+ \tl_put_right:Nn \l_@@_peek_code_tl { { \exp_not:n {#1} } }
+ \fi:
+ \if_charcode:w
+ \scan_stop:
+ \exp_after:wN \use_none:n \token_to_str:N #1 \prg_do_nothing:
+ \scan_stop:
+ \exp_after:wN \@@_peek_analysis_char:N
+ \exp_after:wN #1
+ \else:
+ \exp_after:wN \@@_peek_analysis_cs:
+ \fi:
+ }
+\cs_new_protected:Npn \@@_peek_analysis_cs:
+ { \l_@@_peek_code_tl { -1 } 0 }
+\cs_new_protected:Npn \@@_peek_analysis_char:N #1
+ {
+ \char_set_lccode:nn { `#1 } { 32 }
+ \tex_lowercase:D { \@@_peek_analysis_char:nN {#1} } #1
+ }
+\cs_new_protected:Npn \@@_peek_analysis_char:nN #1#2
+ {
+ \cs_set_protected:Npn \@@_tmp:w ##1 #1 ##2 ##3 \scan_stop:
+ { \exp_args:No \l_@@_peek_code_tl { \int_value:w `#2 } ##2 }
+ \exp_after:wN \@@_tmp:w \c_@@_peek_catcodes_tl \scan_stop:
+ }
+% \end{macrocode}
+% For special characters the idea is to eventually act with
+% \cs{token_to_str:N}, then pick up one by one the characters of this
+% string representation until hitting the token that follows. First
+% determine the character code of (the meaning of) the \meta{token}
+% (which we know is a special token), make sure the escape character
+% is different from it, normalize the meanings of two active
+% characters and the empty control sequence, and filter out these
+% cases in \cs{@@_peek_analysis_retest:}.
+% \begin{macrocode}
+\cs_new_protected:Npn \@@_peek_analysis_special:
+ {
+ \tex_let:D \l_@@_analysis_token = ~ \l_peek_token
+ \int_set:Nn \l_@@_peek_charcode_int
+ { \@@_analysis_extract_charcode: }
+ \if_int_compare:w \l_@@_peek_charcode_int = \tex_escapechar:D
+ \int_set:Nn \tex_escapechar:D { `\/ }
+ \fi:
+ \char_set_active_eq:nN { \l_@@_peek_charcode_int } \scan_stop:
+ \char_set_active_eq:nN { \tex_escapechar:D } \scan_stop:
+ \cs_set_eq:cN { } \scan_stop:
+ \tex_futurelet:D \l_@@_analysis_token
+ \@@_peek_analysis_retest:
+ }
+\cs_new_protected:Npn \@@_peek_analysis_retest:
+ {
+ \if_meaning:w \l_@@_analysis_token \scan_stop:
+ \exp_after:wN \@@_peek_analysis_normal:N
+ \else:
+ \exp_after:wN \@@_peek_analysis_next:
+ \fi:
+ }
+% \end{macrocode}
+% At this point we know the meaning of the \meta{token} in the input
+% stream is \cs{l_peek_token}, either a space (32, 10) or a
+% begin-group or end-group token (catcode $1$ or~$2$), and we excluded
+% a few cases that would be difficult later (empty control sequence,
+% active character with the same character code as its meaning or as
+% the escape character). Now look at the \meta{next token} following
+% it using a combination of \tn{afterassignment} and \tn{futurelet}.
+% The syntax of this primitive is \tn{futurelet} \meta{peek token}
+% \meta{first token} \meta{next token}, and it sets \meta{peek token}
+% equal to \meta{next token}. Traditionally, one takes \meta{first
+% token} to be some macro that regains control of the code and, e.g.,
+% analyses \meta{peek token}. Here, both \meta{first token} and
+% \meta{next token} are mostly unknown tokens in the input stream (but
+% we know the \meta{first token} has catcode $1$, $2$ or $10$), where
+% \meta{first token} was already stored as \cs{l_peek_token}, and we
+% regain control using \tn{afterassignment}, which inserts its
+% argument after the assignment, hence after \meta{peek token} but
+% before \meta{first token}.
+% \begin{macrocode}
+\cs_new_protected:Npn \@@_peek_analysis_next:
+ {
+ \tl_if_empty:oT { \tex_the:D \tex_everyeof:D }
+ { \tex_everyeof:D { \scan_stop: } }
+ \tex_afterassignment:D \@@_peek_analysis_str:
+ \tex_futurelet:D \l_@@_analysis_next_token
+ }
+% \end{macrocode}
+% We then hit the \meta{first token} with \cs{token_to_str:N} and grab
+% characters until finding \cs{l_@@_analysis_next_token}. More
+% precisely, by looking at the first character in the string
+% representation of the \meta{first token} we distinguish three cases:
+% a stringified control sequence starts with the escape character; for
+% an explicit character we find that same character; for an explicit
+% character we find anything else (we made sure to exclude the case of
+% an active character whose string representation coincides with the
+% other two cases).
+% \begin{macrocode}
+\cs_new_protected:Npn \@@_peek_analysis_str:
+ {
+ \exp_after:wN \tex_futurelet:D
+ \exp_after:wN \l_@@_analysis_token
+ \exp_after:wN \@@_peek_analysis_str:w
+ \token_to_str:N
+ }
+\cs_new_protected:Npn \@@_peek_analysis_str:w
+ { \@@_analysis_char_arg:Nw \@@_peek_analysis_str:n }
+\cs_new_protected:Npn \@@_peek_analysis_str:n #1
+ {
+ \int_case:nnF { `#1 }
+ {
+ { \l_@@_peek_charcode_int }
+ { \@@_peek_analysis_explicit:n {#1} }
+ { \tex_escapechar:D } { \@@_peek_analysis_escape: }
+ }
+ { \@@_peek_analysis_active_str:n {#1} }
+ }
+% \end{macrocode}
+% When |#1| is a stringified active character we pass appropriate
+% arguments to the user's code; thankfully \cs{char_generate:nn}
+% can make active characters.
+% \begin{macrocode}
+\cs_new_protected:Npn \@@_peek_analysis_active_str:n #1
+ {
+ \tl_put_right:Nx \l_@@_peek_code_tl
+ {
+ { \char_generate:nn { `#1 } { 13 } }
+ { \int_value:w `#1 }
+ \token_to_str:N D
+ }
+ \l_@@_peek_code_tl
+ }
+% \end{macrocode}
+% When |#1| matches the character we had extracted from the meaning of
+% \cs{l_peek_token}, the token was an explicit character, which can be
+% a standard space, or a begin-group or end-group character with some
+% character code. In the latter two cases we call
+% \cs{char_generate:nn} with suitable arguments and put suitable
+% \cs{if_false:} \cs{fi:} constructions to make the result balanced
+% and such that \texttt{o}-expanding or \texttt{x}-expanding gives
+% back a single (unbalanced) begin-group or end-group character.
+% \begin{macrocode}
+\cs_new_protected:Npn \@@_peek_analysis_explicit:n #1
+ {
+ \tl_put_right:Nx \l_@@_peek_code_tl
+ {
+ \if_meaning:w \l_peek_token \c_space_token
+ { ~ } { 32 } \token_to_str:N A
+ \else:
+ \if_catcode:w \l_peek_token \c_group_begin_token
+ {
+ \exp_not:N \exp_after:wN
+ \char_generate:nn { `#1 } { 1 }
+ \exp_not:N \if_false:
+ \if_false: { \fi: }
+ \exp_not:N \fi:
+ }
+ { \int_value:w `#1 }
+ 1
+ \else:
+ {
+ \exp_not:N \if_false:
+ { \if_false: } \fi:
+ \exp_not:N \fi:
+ \char_generate:nn { `#1 } { 2 }
+ }
+ { \int_value:w `#1 }
+ 2
+ \fi:
+ \fi:
+ }
+ \l_@@_peek_code_tl
+ }
+% \end{macrocode}
+% Finally there is the case of a special token whose string
+% representation starts with an escape character, namely the token was
+% a control sequence. In that case we could have grabbed the token
+% directly as an \texttt{N}-type argument, but of course we couldn't
+% know that until we had run all the various tests including
+% stringifying the token. We are thus left with the hard work of
+% picking up one by one the characters in the csname (being careful
+% about spaces), until finding a token that matches the \meta{next
+% token} picked up earlier (which was not stringified), such that the
+% control sequence that we found so far indeed has the expected
+% meaning \cs{l_peek_token}. This comparison with \cs{l_peek_token}
+% catches a reasonably common case like \cs{c_group_begin_token} |_|
+% in which the trailing |_| has category code other: without
+% comparison of the constructed csname with \cs{l_peek_token}
+% collection would stop at \cs[no-index]{c}, which is wrong.
+% \begin{macrocode}
+\cs_new_protected:Npn \@@_peek_analysis_escape:
+ {
+ \tl_clear:N \l_@@_internal_a_tl
+ \tex_futurelet:D \l_@@_analysis_token
+ \@@_peek_analysis_collect:w
+ }
+\cs_new_protected:Npn \@@_peek_analysis_collect:w
+ { \@@_analysis_char_arg:Nw \@@_peek_analysis_collect:n }
+\cs_new_protected:Npn \@@_peek_analysis_collect:n #1
+ {
+ \tl_put_right:Nn \l_@@_internal_a_tl {#1}
+ \@@_peek_analysis_collect_loop:
+ }
+\cs_new_protected:Npn \@@_peek_analysis_collect_loop:
+ {
+ \tex_futurelet:D \l_@@_analysis_token
+ \@@_peek_analysis_collect_test:
+ }
+\cs_new_protected:Npn \@@_peek_analysis_collect_test:
+ {
+ \if_meaning:w \l_@@_analysis_token \l_@@_analysis_next_token
+ \exp_after:wN \if_meaning:w \cs:w \l_@@_internal_a_tl \cs_end: \l_peek_token
+ \@@_peek_analysis_collect_end:NNN
+ \fi:
+ \fi:
+ \@@_peek_analysis_collect:w
+ }
+% \end{macrocode}
+% End by calling the user code with suitable arguments (here |#1|,
+% |#2| are \cs{fi:}), which closes the group begun early on.
+% \begin{macrocode}
+\cs_new_protected:Npn \@@_peek_analysis_collect_end:NNN #1#2#3
+ {
+ #1 #2
+ \tl_put_right:Nx \l_@@_peek_code_tl
+ {
+ { \exp_not:N \exp_not:n { \exp_not:c { \l_@@_internal_a_tl } } }
+ { -1 }
+ 0
+ }
+ \l_@@_peek_code_tl
+ }
+% \end{macrocode}
+% \end{macro}
+%
% \subsection{Messages}
%
% \begin{variable}{\c_@@_analysis_show_etc_str}
More information about the latex3-commits
mailing list.