diff options
Diffstat (limited to 'Master/texmf-dist/source/latex/expl3/l3tlp.dtx')
-rw-r--r-- | Master/texmf-dist/source/latex/expl3/l3tlp.dtx | 2054 |
1 files changed, 0 insertions, 2054 deletions
diff --git a/Master/texmf-dist/source/latex/expl3/l3tlp.dtx b/Master/texmf-dist/source/latex/expl3/l3tlp.dtx deleted file mode 100644 index 2d722a77624..00000000000 --- a/Master/texmf-dist/source/latex/expl3/l3tlp.dtx +++ /dev/null @@ -1,2054 +0,0 @@ -% \iffalse -%% File: l3tlp.dtx Copyright (C) 1990-2008 LaTeX3 project -%% -%% It may be distributed and/or modified under the conditions of the -%% LaTeX Project Public License (LPPL), either version 1.3c of this -%% license or (at your option) any later version. The latest version -%% of this license is in the file -%% -%% http://www.latex-project.org/lppl.txt -%% -%% This file is part of the ``expl3 bundle'' (The Work in LPPL) -%% and all files in that bundle must be distributed together. -%% -%% The released version of this bundle is available from CTAN. -%% -%% ----------------------------------------------------------------------- -%% -%% The development version of the bundle can be found at -%% -%% http://www.latex-project.org/cgi-bin/cvsweb.cgi/ -%% -%% for those people who are interested. -%% -%%%%%%%%%%% -%% NOTE: %% -%%%%%%%%%%% -%% -%% Snapshots taken from the repository represent work in progress and may -%% not work or may contain conflicting material! We therefore ask -%% people _not_ to put them into distributions, archives, etc. without -%% prior consultation with the LaTeX Project Team. -%% -%% ----------------------------------------------------------------------- -% -%<*driver|package> -\RequirePackage{l3names} -%</driver|package> -%\fi -\GetIdInfo$Id: l3tlp.dtx 767 2008-08-05 19:44:21Z morten $ - {L3 Experimental Token List Pointers} -%\iffalse -%<*driver> -%\fi -\ProvidesFile{\filename.\filenameext} - [\filedate\space v\fileversion\space\filedescription] -%\iffalse -\documentclass{l3doc} -\begin{document} -\DocInput{\filename.\filenameext} -\end{document} -%</driver> -% \fi -% -% -% \title{The \textsf{l3tlp} package\thanks{This file -% has version number \fileversion, last -% revised \filedate.}\\ -% Token List Pointers} -% \author{\Team} -% \date{\filedate} -% \maketitle -% -% -% -% \section {Token list pointers} -% -% \LaTeX3 stores token lists in so called `token list pointers'. -% Variables of this type get the suffix "tlp" and functions of this type -% have the prefix "tlp". To use a token list pointer you simply call -% the corresponding variable. -% -% Often you find yourself with not a token list pointer but an -% arbitrary token list which has to undergo certain tests. We will -% prefix these functions with "tlist". While token list pointers are -% always single tokens, token lists are always surrounded by -% braces. Perhaps these token lists should have their own module but -% for now I decided to put them here because there is quite a bit of -% overlap with token list pointers. -% -% \subsection{Functions} -% -% \begin{function}{\tlp_new:N | -% \tlp_new:c | -% \tlp_new:Nn | -% \tlp_new:cn | -% \tlp_new:Nx } -% \begin{syntax} -% "\tlp_new:Nn" <tlp> "{" <initial token list> "}" -% \end{syntax} -% Defines <tlp> to be a new variable (or constant) of type token list -% pointer. <initial token list> is the initial value of <tlp>. This -% makes it possible to assign values to a constant token list pointer. -% -% The form "\tlp_new:N" initializes the token list pointer with an empty value. -% \end{function} -% -% \begin{function}{% -% \tlp_use:N | -% \tlp_use:c -% } -% \begin{syntax} -% "\tlp_use:N" <tlp> -% \end{syntax} -% Function that inserts the <tlp> into the processing stream. Instead of -% |\tlp_use:N| simply placing the <tlp> into the input stream is also -% supported.|\tlp_use:c| will complain is the <tlp> hasn't been declared -% previously! -% \end{function} -% -% \begin{function}{% -% \tlp_set:Nn | -% \tlp_set:Nc | -% \tlp_set:No | -% \tlp_set:Nd | -% \tlp_set:Nf | -% \tlp_set:Nx | -% \tlp_gset:Nn | -% \tlp_gset:Nc | -% \tlp_gset:No | -% \tlp_gset:Nd | -% \tlp_gset:Nx | -% \tlp_gset:cn | -% \tlp_gset:cx } -% \begin{syntax} -% "\tlp_set:Nn" <tlp> "{" <token list> "}" -% \end{syntax} -% Defines <tlp> to hold the token list <token list>. Global -% variants of this command assign the value globally the other variants -% expand the <token list> up to a certain level before the assignment -% or interpret the <token list> as a character list and form a control -% sequence out of it. -% \end{function} -% -% \begin{function}{% -% \tlp_clear:N | -% \tlp_clear:c | -% \tlp_gclear:N | -% \tlp_gclear:c -% } -% \begin{syntax} -% "\tlp_clear:N" <tlp> -% \end{syntax} -% The <tlp> is locally or globally cleared. The "c" variants will -% generate a control sequence name which is then interpreted as -% <tlp> before clearing. -% \end{function} -% -% \begin{function}{% -% \tlp_clear_new:N | -% \tlp_clear_new:c | -% \tlp_gclear_new:N | -% \tlp_gclear_new:c | -% } -% \begin{syntax} -% "\tlp_clear_new:N" <tlp> -% \end{syntax} -% These functions check if <tlp> exists. If it does it will be cleared; -% if it doesn't it will be allocated. -% \end{function} -% -% \begin{function}{% -% \tlp_put_left:Nn | -% \tlp_put_left:No | -% \tlp_put_left:Nx | -% \tlp_gput_left:Nn | -% \tlp_gput_left:No | -% \tlp_gput_left:Nx | -% \tlp_put_right:Nn | -% \tlp_put_right:No | -% \tlp_put_right:Nx | -% \tlp_put_right:cc | -% \tlp_gput_right:Nn | -% \tlp_gput_right:No| -% \tlp_gput_right:Nx| -% \tlp_gput_right:cn| -% \tlp_gput_right:co| -% } -% \begin{syntax} -% "\tlp_put_left:Nn" <tlp> "{" <token list> "}" -% \end{syntax} -% These functions will append <token list> to the left or right of -% <tlp>. Assignment is done either locally or globally and <token -% list> might be subject to expansion before assignment. -% \end{function} -% -% A word of warning is appropriate here: Token list pointers are -% implemented as macros and as such currently inherit some of the -% peculiarities of how \TeX\ handles "#"s in the argument of -% macros. In particular, the following actions are legal -% \begin{verbatim} -% \tlp_set:Nn \l_tmpa_tlp{##1} -% \tlp_put_right:Nn \l_tmpa_tlp{##2} -% \tlp_set:No \l_tmpb_tlp{\l_tmpa_tlp ##3} -% \end{verbatim} -% |x| type expansions where macros being expanded contain |#|s do not -% work and will not work until there is an |\expanded| primitive in -% the engine. If you want them to work you must double |#|s another -% level. -% -% -% \begin{function}{% -% \tlp_set_eq:NN | -% \tlp_set_eq:Nc | -% \tlp_set_eq:cN | -% \tlp_set_eq:cc | -% \tlp_gset_eq:NN | -% \tlp_gset_eq:Nc | -% \tlp_gset_eq:cN | -% \tlp_gset_eq:cc | -% } -% \begin{syntax} -% "\tlp_set_eq:NN" <tlp1> <tlp2> -% \end{syntax} -% Fast form for -% \begin{syntax} -% "\tlp_set:No" <tlp1> "{" <tlp2> "}" -% \end{syntax} -% when <tlp2> is known to be a variable of type token list pointer. -% \end{function} -% -% \begin{function}{\tlp_to_str:N | -% \tlp_to_str:c -% } -% \begin{syntax} -% "\tlp_to_str:N" <tlp> -% \end{syntax} -% This function returns the token list kept in <tlp> as a string list -% with all characters catcoded to `other'. -% \end{function} -% -% \subsection{Predicates and conditionals} -% -% \begin{function}{\tlp_if_empty_p:N| -% \tlp_if_empty_p:c -% } -% \begin{syntax} -% "\tlp_if_empty_p:N" <tlp> -% \end{syntax} -% This predicate returns `true' if <tlp> is `empty' i.e., doesn't -% contain any tokens. -% \end{function} -% -% \begin{function}{\tlp_if_empty:NTF| -% \tlp_if_empty:NT| -% \tlp_if_empty:NF| -% \tlp_if_empty:cTF | -% \tlp_if_empty:cT | -% \tlp_if_empty:cF -% } -% \begin{syntax} -% "\tlp_if_empty:NTF" <tlp> "{"<true code>"}""{"<false code>"}" -% \end{syntax} -% Execute <true code> if <tlp> is empty and <false code> if it -% contains any tokens. -% \end{function} -% -% \begin{function}{\tlp_if_eq_p:NN | -% \tlp_if_eq_p:cN | -% \tlp_if_eq_p:Nc | -% \tlp_if_eq_p:cc | -% } -% \begin{syntax} -% "\tlp_if_eq_p:NN" <tlp1> <tlp2> -% \end{syntax} -% Predicate function which returns `true' if the two token list -% pointers are identical and `false' otherwise. -% \end{function} -% -% \begin{function}{ -% \tlp_if_eq:NNTF | -% \tlp_if_eq:NNT | -% \tlp_if_eq:NNF | -% \tlp_if_eq:cNTF | -% \tlp_if_eq:cNT | -% \tlp_if_eq:cNF | -% \tlp_if_eq:NcTF | -% \tlp_if_eq:NcT | -% \tlp_if_eq:NcF | -% \tlp_if_eq:ccTF | -% \tlp_if_eq:ccT | -% \tlp_if_eq:ccF | -% } -% \begin{syntax} -% "\tlp_if_eq:NNTF" <tlp1> <tlp2> "{"<true code>"}""{"<false code>"}" -% \end{syntax} -% Execute <true code> if <tlp1> holds the same token list as <tlp2> -% and <false code> otherwise. -% \end{function} -% -% -% \subsection{Token lists} -% -% \begin{function}{\tlist_if_eq:nnTF | -% \tlist_if_eq:nnT | -% \tlist_if_eq:nnF | -% \tlist_if_eq:noTF | -% \tlist_if_eq:noT | -% \tlist_if_eq:noF | -% } -% \begin{syntax} -% "\tlist_if_eq:nnTF" "{"<tlist1>"}" "{"<tlist2>"}" "{"<true -% code>"}" "{"<false code>"}" -% \end{syntax} -% Execute <true code> if the two token lists <tlist1> and <tlist2> are -% identical. -% \end{function} -% -% -% \begin{function}{\tlist_if_empty_p:n | -% \tlist_if_empty_p:o | -% \tlist_if_empty:nTF | -% \tlist_if_empty:nT | -% \tlist_if_empty:nF | -% \tlist_if_empty:oTF | -% \tlist_if_empty:oT | -% \tlist_if_empty:oF | -% } -% \begin{syntax} -% "\tlist_if_empty:nTF" "{"<tlist>"}" "{"<true code>"}" "{"<false code>"}" -% \end{syntax} -% Execute <true code> if <tlist> doesn't contain any tokens and <false -% code> otherwise. -% \end{function} -% -% \begin{function}{\tlist_if_blank_p:n | -% \tlist_if_blank:nTF | -% \tlist_if_blank:nT | -% \tlist_if_blank:nF | -% \tlist_if_blank_p:o | -% \tlist_if_blank:oTF | -% \tlist_if_blank:oT | -% \tlist_if_blank:oF | -% } -% \begin{syntax} -% "\tlist_if_blank:nTF" "{"<tlist>"}" "{"<true code>"}" "{"<false code>"}" -% \end{syntax} -% Execute <true code> if <tlist> is blank meaning that it is either -% empty or contains only blank spaces. -% \end{function} -% -% \begin{function}{\tlist_to_lowercase:n | -% \tlist_to_uppercase:n -% } -% \begin{syntax} -% "\tlist_to_lowercase:n" "{"<tlist>"}" -% \end{syntax} -% "\tlist_to_lowercase:n" converts all tokens in <tlist> to their -% lower case representation. Similar for "\tlist_to_uppercase:n". -% \begin{texnote} -% These are the \TeX\ primitives \tn{lowercase} and \tn{uppercase} -% renamed. -% \end{texnote} -% \end{function} -% -% \begin{function}{\tlist_to_str:n -% } -% \begin{syntax} -% "\tlist_to_str:n" "{"<tlist>"}" -% \end{syntax} -% This function turns its argument into a string where all characters -% have catcode `other'. -% \begin{texnote} -% This is the \eTeX\ primitive \tn{detokenize}. -% \end{texnote} -% \end{function} -% -% \begin{function}{% -% \tlist_map_function:nN | -% \tlp_map_function:NN | -% \tlp_map_function:cN | -% } -% \begin{syntax} -% "\tlist_map_function:nN" "{"<tlist>"}" <function> \\ -% "\tlp_map_function:NN" <tlp> <function> -% \end{syntax} -% Runs through all elements in a |tlist| from left to right and places -% <function> in front of each element. As this function will also pick -% up elements in brace groups, the element is returned with braces and -% hence <function> should be a function with a |:n| suffix even though -% it may very well only deal with a single token. This function uses a -% purely expandable loop function and will stay so as long as -% <function> is expandable too. -% \end{function} -% -% \begin{function}{% -% \tlist_map_inline:nn | -% \tlp_map_inline:Nn | -% \tlp_map_inline:cn | -% } -% \begin{syntax} -% "\tlist_map_inline:nn" "{"<tlist>"}" "{"<inline~function>"}" \\ -% "\tlp_map_inline:Nn" <tlp> "{"<inline~function>"}" -% \end{syntax} -% Allows a syntax like "\tlist_map_inline:nn" "{"<tlist>"}" -% "{\token_to_string:N ##1}". This renders it non-expandable though. -% Remember to double the "#"s for each level. -% \end{function} -% -% -% \begin{function}{% -% \tlist_map_variable:nNn | -% \tlp_map_variable:NNn | -% \tlp_map_variable:cNn | -% } -% \begin{syntax} -% "\tlist_map_variable:nNn" "{"<tlist>"}" <temp> "{"<action>"}" \\ -% "\tlp_map_variable:NNn" <tlp> <temp> "{"<action>"}" -% \end{syntax} -% Assigns <temp> to each element on <tlist> and executes <action>. -% As there is an assignment in this process it is not expandable. -% \begin{texnote} -% This is the \LaTeX2{} function \tn{@tfor} but with a more sane syntax. -% Also it works by tail recursion and so is faster as lists grow longer. -% \end{texnote} -% \end{function} -% -% \begin{function}{% -% \tlist_map_break:w | -% \tlp_map_break:w | -% } -% \begin{syntax} -% "\tlist_map_break:w" -% \end{syntax} -% For breaking out of a loop. You should take note of the ":w" as -% its usage must be precise! -% \end{function} -% -% -% \begin{function}{% -% \tlist_reverse:n | -% } -% \begin{syntax} -% "\tlist_reverse:n" "{"<token$\sb1$><token$\sb2$>...<token$\sb n$>"}" -% \end{syntax} -% Reverse the token list to result in -% <token$\sb n$>\dots<token$\sb2$><token$\sb1$>. Note that spaces in this -% token list are gobbled in the process. -% \end{function} -% -% \begin{function}{% -% \tlist_elt_count:n | -% \tlist_elt_count:o | -% \tlp_elt_count:N | -% } -% \begin{syntax} -% "\tlist_elt_count:n" "{"<token list>"}" \\ -% "\tlp_elt_count:N" <tlp> -% \end{syntax} -% Returns the number of elements in the token list. Brace groups -% encountered count as one element. Note that spaces in this -% token list are gobbled in the process. -% \end{function} -% -% -% \subsubsection{Internal functions} -% -% -% \begin{function}{% -% \tlist_map_function_aux:Nn | -% \tlist_map_inline_aux:Nn | -% \tlist_map_variable_aux:Nnn | -% } -% \begin{syntax}\end{syntax} -% Internal helper functions for the <tlist> loops. -% \end{function} -% -% -% -% \begin{function}{\tlist_if_blank_p_aux:w -% } -% \end{function} -% -% -% -% \subsection{Variables and constants} -% -% \begin{variable}{\C_job_name_tlp} -% Constant that gets the `job name' assigned when \TeX{} starts. -% \begin{texnote} -% This is the new name for the primitive \tn{jobname}. It is a constant -% that will be set by \TeX{} and can not be overwritten by the package. -% Therefore the "C" -% \end{texnote} -% \end{variable} -% -% \begin{variable}{\c_empty_tlp} -% Constant that is always empty. -% \begin{texnote} -% This was named \tn{@empty} in \LaTeX2 and \tn{empty} in plain \TeX{}. -% \end{texnote} -% \end{variable} -% -% \begin{variable}{\c_relax_tlp} -% Constant holding the token that is assigned to a newly created control -% sequence by \TeX. -% \end{variable} -% -% \begin{variable}{% -% \l_tmpa_tlp | -% \l_tmpb_tlp | -% \g_tmpa_tlp | -% \g_tmpb_tlp -% } -% Scratch register for immediate use. They are not used by conditionals -% or predicate functions. -% \end{variable} -% -% -% \subsubsection{Internal functions} -% -% \begin{variable}{% -% \l_replace_tlp | -% } -% Internal register used in the replace functions. -% \end{variable} -% -% \begin{variable}{% -% \l_testa_tlp | -% \l_testb_tlp | -% \g_testa_tlp | -% \g_testb_tlp | -% } -% Registers used for conditional processing if the engine doesn't -% support arbitrary string comparison. -% \end{variable} -% -% -% \begin{function}{\tlp_to_str_aux:w} -% Function used to implement "\tlp_to_str:N". -% \end{function} -% -% -% \subsection{Search and replace} -% -% -% \begin{function}{ -% \tlp_if_in:NnTF | -% \tlp_if_in:cnTF | -% \tlp_if_in:NnT | -% \tlp_if_in:cnT | -% \tlp_if_in:NnF | -% \tlp_if_in:cnF | -% \tlist_if_in:nnTF | -% \tlist_if_in:onTF | -% } -% \begin{syntax} -% "\tlp_if_in:NnTF" <tlp> "{" <item> "}{" <true code> "}{" -% <false code> "}" -% \end{syntax} -% Function that tests if <item> is in <tlp>. Depending on the result -% either <true code> or <false code> is executed. Note that <item> -% cannot contain brace groups. -% \end{function} -% -% \begin{function}{ -% \tlp_replace_in:Nnn | -% \tlp_replace_in:cnn | -% \tlp_greplace_in:Nnn | -% \tlp_greplace_in:cnn | -% } -% \begin{syntax} -% "\tlp_replace_in:Nnn" <tlp> "{" <item1> "}{" <item2> "}" -% \end{syntax} -% Replaces the leftmost occurrence of <item1> in <tlp> with -% <item2> if present, otherwise the <tlp> is left untouched. -% \end{function} -% -% \begin{function}{ -% \tlp_replace_all_in:Nnn | -% \tlp_replace_all_in:cnn | -% \tlp_greplace_all_in:Nnn | -% \tlp_greplace_all_in:cnn | -% } -% \begin{syntax} -% "\tlp_replace_all_in:Nnn" <tlp> "{" <item1> "}{" <item2> "}" -% \end{syntax} -% Replaces \emph{all} occurrences of <item1> in <tlp> with -% <item2>. -% \end{function} -% -% -% \begin{function}{ -% \tlp_remove_in:Nn | -% \tlp_remove_in:cn | -% \tlp_gremove_in:Nn | -% \tlp_gremove_in:cn | -% } -% \begin{syntax} -% "\tlp_remove_in:Nn" <tlp> "{" <item> "}" -% \end{syntax} -% Removes the leftmost occurrence of <item> from <tlp> if present. -% \end{function} -% -% -% \begin{function}{ -% \tlp_remove_all_in:Nn | -% \tlp_remove_all_in:cn | -% \tlp_gremove_all_in:Nn | -% \tlp_gremove_all_in:cn | -% } -% \begin{syntax} -% "\tlp_remove_all_in:Nn" <tlp> "{" <item> "}" -% \end{syntax} -% Removes \emph{all} occurrences of <item> from <tlp>. -% \end{function} -% -% -% \subsection{Heads or tails?} -% -% Here are some functions for grabbing either the head or tail of a -% list and perform some tests on it. -% -% \begin{function}{% -% \tlist_head:n | -% \tlist_tail:n | -% \tlist_head_iii:n | -% \tlist_head_iii:f | -% \tlist_head:w | -% \tlist_tail:w | -% \tlist_head_iii:w -% } -% \begin{syntax} -% "\tlist_head:n" "{" <token1><token2>...<token-n> "}" \\ -% "\tlist_tail:n" "{" <token1><token2>...<token-n> "}" -% \end{syntax} -% These functions return either the head or the tail of a list, thus in -% the above example "\tlist_head:n" would return <token1> and "\tlist_tail:n" -% would return <token2>\dots<token-n>. "\tlist_head_iii:n" returns the first -% three tokens. The ":w" versions require some care as they use a -% delimited argument internally. -% \begin{texnote} -% These are the Lisp functions "car" and "cdr" but with \LaTeX3 names. -% \end{texnote} -% \end{function} -% -% -% -% -% \begin{function}{% -% \tlist_if_head_eq_meaning_p:nN | -% \tlist_if_head_eq_meaning:nNTF | -% \tlist_if_head_eq_meaning:nNTF | -% \tlist_if_head_eq_meaning:nNTF | -% } -% \begin{syntax} -% "\tlist_if_head_eq_meaning:nNTF" "{" <token list> "}" <token> -% "{"<true>"}""{"<false>"}" -% \end{syntax} -% Returns <true> if the first token in <token list> is equal to -% <token> and <false> otherwise. The |meaning| version compares the -% two tokens with |\if_meaning:NN|. -% \end{function} -% -% \begin{function}{% -% \tlist_if_head_eq_charcode_p:nN | -% \tlist_if_head_eq_charcode:nNTF | -% \tlist_if_head_eq_charcode:nNTF | -% \tlist_if_head_eq_charcode:nNTF | -% } -% \begin{syntax} -% "\tlist_if_head_eq_charcode:nNTF" "{" <token list> "}" <token> -% "{"<true>"}""{"<false>"}" -% \end{syntax} -% Returns <true> if the first token in <token list> is equal to -% <token> and <false> otherwise. The |meaning| version compares the -% two tokens with |\if_charcode:w| but it prevents expansion of -% them. If you want them to expand, you can use an |f| type expansion -% first (define |\tlist_if_head_eq_charcode:fNTF| or similar). -% \end{function} -% -% \begin{function}{% -% \tlist_if_head_eq_catcode_p:nN | -% \tlist_if_head_eq_catcode:nNTF | -% \tlist_if_head_eq_catcode:nNTF | -% \tlist_if_head_eq_catcode:nNTF | -% } -% \begin{syntax} -% "\tlist_if_head_eq_catcode:nNTF" "{" <token list> "}" <token> -% "{"<true>"}""{"<false>"}" -% \end{syntax} -% Returns <true> if the first token in <token list> is equal to -% <token> and <false> otherwise. This version uses |\if_catcode:w| for -% the test but is otherwise identical to the |charcode| version. -% \end{function} -% -% -% \StopEventually{} -% -% \subsection{The Implementation} -% -% We start by ensuring that the required packages are loaded. -% \begin{macrocode} -%<package>\ProvidesExplPackage -%<package> {\filename}{\filedate}{\fileversion}{\filedescription} -%<package&!check>\RequirePackage{l3basics} -%<package&check>\RequirePackage{l3chk} -% \end{macrocode} -% \begin{macrocode} -%<*initex|package> -% \end{macrocode} -% -% A token list pointer is a control sequence that holds tokens. The -% interface is similar to that for token registers, but beware that -% the behavior vis \'a vis |\def:Npx| etc. \ldots{} is different. (You -% see this comes from Denys' implementation.) -% -% -% -% \begin{macro}{\tlp_new:N} -% \begin{macro}{\tlp_new:c} -% \begin{macro}{\tlp_new:Nn} -% \begin{macro}{\tlp_new:cn} -% \begin{macro}{\tlp_new:Nx} -% We provide one allocation function (which checks that the name is -% not used) and two clear functions that locally or globally clear -% the token list. The allocation function has two arguments to -% specify an initial value. This is the only way to give values to -% constants. -% \begin{macrocode} -\def_long_new:Npn \tlp_new:Nn #1#2{ - \chk_new_cs:N #1 -% \end{macrocode} -% If checking we don't allow constants to be defined. -% \begin{macrocode} -%<*check> - \chk_var_or_const:N #1 -%</check> -% \end{macrocode} -% Otherwise any variable type is allowed. -% \begin{macrocode} - \gdef:Npn #1{#2} -} -\def_new:Npn \tlp_new:cn {\exp_args:Nc \tlp_new:Nn } -\def_long_new:Npn \tlp_new:Nx #1#2{ - \chk_new_cs:N #1 -%<check> \chk_var_or_const:N #1 - \gdef:Npx #1{#2} -} -\def_new:Npn \tlp_new:N #1{\tlp_new:Nn #1{}} -\def_new:Npn \tlp_new:c #1{\tlp_new:cn {#1}{}} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% \begin{macro}{\tlp_use:N} -% \begin{macro}{\tlp_use:c} -% Perhaps this should just be enabled when checking? -% \begin{macrocode} -\def_new:Npn \tlp_use:N #1 { - \if_meaning:NN #1 \scan_stop: -% \end{macrocode} -% If \m{tlp} equals |\scan_stop:| it is probably stemming from a -% |\cs:w ... \cd_end:| that was created by mistake somewhere. -% \begin{macrocode} - \err_latex_bug:x {Token~list~pointer~ `\token_to_string:N #1'~ - has~ an~ erroneous~ structure!} - \else: - \exp_after:NN #1 - \fi: -} -\def_new:Npn \tlp_use:c {\exp_args:Nc \tlp_use:N} -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% -% \begin{macro}{\tlp_set:Nn} -% \begin{macro}{\tlp_set:No} -% \begin{macro}{\tlp_set:Nd} -% \begin{macro}{\tlp_set:Nf} -% \begin{macro}{\tlp_set:Nx} -% \begin{macro}{\tlp_set:cn} -% \begin{macro}{\tlp_set:co} -% \begin{macro}{\tlp_set:cx} -% \begin{macro}{\tlp_gset:Nn} -% \begin{macro}{\tlp_gset:No} -% \begin{macro}{\tlp_gset:Nd} -% \begin{macro}{\tlp_gset:Nx} -% \begin{macro}{\tlp_gset:cn} -% \begin{macro}{\tlp_gset:cx} -% To set token lists to a specific value to type of functions are -% available: |\tlp_set_eq:NN| takes two token-lists as its -% arguments assign the first the contents of the second; -% |\tlp_set:Nn| has as its second argument a `real' list of tokens. -% One can view |\tlp_set_eq:NN| as a special form of |\tlp_set:No|. -% Both functions have global counterparts. -% -% During development we check if the token list that is being -% assigned to exists. If not, a warning will be issued. -% \begin{macrocode} -%<*check> -\def_long_new:Npn \tlp_set:Nn #1#2{ - \chk_exist_cs:N #1 \def:Npn #1{#2} -% \end{macrocode} -% We use |\chk_local_or_pref_global:N| after the assignment to -% allow constructs with |\pref_global_chk:|. But one should note -% that this is less efficient then using the real global variant -% since they are built-in. -% \begin{macrocode} - \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_set:Nx #1#2{ - \chk_exist_cs:N #1 \def:Npx #1{#2} \chk_local:N #1 -} -% \end{macrocode} -% The the global versions. -% \begin{macrocode} -\def_long_new:Npn \tlp_gset:Nn #1#2{ - \chk_exist_cs:N #1 \gdef:Npn #1{#2} \chk_global:N #1 -} -\def_long_new:Npn \tlp_gset:Nx #1#2{ - \chk_exist_cs:N #1 \gdef:Npx #1{#2} \chk_global:N #1 -} -%</check> -% \end{macrocode} -% For some functions like |\tlp_set:Nn| we need to define the -% `non-check' version with arguments since we want to allow -% constructions like |\tlp_set:Nn\l_tmpa_tlp\foo| and so we can't -% use the primitive \TeX{} command. -% \begin{macrocode} -%<*!check> -\def_long_new:Npn\tlp_set:Nn#1#2{\def:Npn#1{#2}} -\def_long_new:Npn\tlp_set:Nx#1#2{\def:Npx#1{#2}} -\def_long_new:Npn\tlp_gset:Nn#1#2{\gdef:Npn#1{#2}} -\def_long_new:Npn\tlp_gset:Nx#1#2{\gdef:Npx#1{#2}} -%</!check> -% \end{macrocode} -% The remaining functions can just be defined with help from the -% expansion module. -% \begin{macrocode} -\def_new:Npn \tlp_set:No {\exp_args:NNo \tlp_set:Nn} -\def_new:Npn \tlp_set:Nd {\exp_args:NNd \tlp_set:Nn} -\def_new:Npn \tlp_set:Nf {\exp_args:NNf \tlp_set:Nn} -\def_new:Npn \tlp_set:cn {\exp_args:Nc \tlp_set:Nn} -\def_new:Npn \tlp_set:co {\exp_args:Nco \tlp_set:Nn} -\def_new:Npn \tlp_set:cx {\exp_args:Nc \tlp_set:Nx} -\def_new:Npn \tlp_gset:No {\exp_args:NNo \tlp_gset:Nn} -\def_new:Npn \tlp_gset:Nd {\exp_args:NNd \tlp_gset:Nn} -\def_new:Npn \tlp_gset:cn {\exp_args:Nc \tlp_gset:Nn} -\def_new:Npn \tlp_gset:cx {\exp_args:Nc \tlp_gset:Nx} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlp_set_eq:NN} -% \begin{macro}{\tlp_set_eq:Nc} -% \begin{macro}{\tlp_set_eq:cN} -% \begin{macro}{\tlp_set_eq:cc} -% \begin{macro}{\tlp_gset_eq:NN} -% \begin{macro}{\tlp_gset_eq:Nc} -% \begin{macro}{\tlp_gset_eq:cN} -% \begin{macro}{\tlp_gset_eq:cc} -% For setting token list pointers equal to each other. First checking: -% \begin{macrocode} -%<*check> -\def_new:Npn \tlp_set_eq:NN #1#2{ - \chk_exist_cs:N #1 \let:NN #1#2 - \chk_local_or_pref_global:N #1 \chk_var_or_const:N #2 -} -\def_new:Npn \tlp_gset_eq:NN #1#2{ - \chk_exist_cs:N #1 \glet:NN #1#2 - \chk_global:N #1 \chk_var_or_const:N #2 -} -%</check> -% \end{macrocode} -% Non-checking versions are easy. -% \begin{macrocode} -%<*!check> -\let_new:NN \tlp_set_eq:NN \let:NN -\let_new:NN \tlp_gset_eq:NN \glet:NN -%</!check> -% \end{macrocode} -% The rest again with the expansion module. -% \begin{macrocode} -\def_new:Npn \tlp_set_eq:Nc {\exp_args:NNc \tlp_set_eq:NN} -\def_new:Npn \tlp_set_eq:cN {\exp_args:Nc \tlp_set_eq:NN} -\def_new:Npn \tlp_set_eq:cc {\exp_args:Ncc \tlp_set_eq:NN} -\def_new:Npn \tlp_gset_eq:Nc {\exp_args:NNc \tlp_gset_eq:NN} -\def_new:Npn \tlp_gset_eq:cN {\exp_args:Nc \tlp_gset_eq:NN} -\def_new:Npn \tlp_gset_eq:cc {\exp_args:Ncc \tlp_gset_eq:NN} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% -% \begin{macro}{\tlp_clear:N} -% \begin{macro}{\tlp_clear:c} -% \begin{macro}{\tlp_gclear:N} -% \begin{macro}{\tlp_gclear:c} -% Clearing a token list pointer. -% \begin{macrocode} -\def_new:Npn \tlp_clear:N #1{\tlp_set_eq:NN #1\c_empty_tlp} -\def_new:Npn \tlp_clear:c {\exp_args:Nc \tlp_clear:N} -\def_new:Npn \tlp_gclear:N #1{\tlp_gset_eq:NN #1\c_empty_tlp} -\def_new:Npn \tlp_gclear:c {\exp_args:Nc \tlp_gclear:N} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlp_clear_new:N} -% \begin{macro}{\tlp_clear_new:c} -% These macros check whether a token list exists. If it does it -% is cleared, if it doesn't it is allocated. -% \begin{macrocode} -%<*check> -\def_new:Npn \tlp_clear_new:N #1{ - \chk_var_or_const:N #1 - \if:w \cs_exist_p:N #1 - \tlp_clear:N #1 - \else: - \tlp_new:Nn #1{} - \fi: -} -%</check> -%<-check>\let_new:NN \tlp_clear_new:N \tlp_clear:N -\def_new:Npn \tlp_clear_new:c {\exp_args:Nc \tlp_clear_new:N} -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlp_gclear_new:N} -% \begin{macro}{\tlp_gclear_new:c} -% These are the global versions of the above. -% \begin{macrocode} -%<*check> -\def_new:Npn \tlp_gclear_new:N #1{ - \chk_var_or_const:N #1 - \if:w \cs_exist_p:N #1 - \tlp_gclear:N #1 - \else: - \tlp_new:Nn #1{} - \fi:} -%</check> -%<-check>\let_new:NN \tlp_gclear_new:N \tlp_gclear:N -\def_new:Npn \tlp_gclear_new:c {\exp_args:Nc \tlp_gclear_new:N} -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlp_put_left:Nn} -% \begin{macro}{\tlp_put_left:No} -% \begin{macro}{\tlp_put_left:Nx} -% \begin{macro}{\tlp_gput_left:Nn} -% \begin{macro}{\tlp_gput_left:No} -% \begin{macro}{\tlp_gput_left:Nx} -% We can add tokens to the left (either globally or locally). It is -% not quite as easy as we would like because we have to ensure the -% assignments -% \begin{verbatim} -% \tlp_set:Nn \l_tmpa_tlp{##1abc##2def} -% \tlp_set:Nn \l_tmpb_tlp{##1abc} -% \tlp_put_right:Nn \l_tmpb_tlp {##2def} -% \end{verbatim} -% cause |\l_tmpa_tlp| and |\l_tmpb_tlp| to be identical. The old -% code did not succeed in doing this (it gave an error) and so we -% use a different technique where the item(s) to be added are first -% stored in a temporary pointer and then added using an |x| type -% expansion combined with the appropriate level of -% non-expansion. Putting the tokens directly into one assignment -% does not work unless we want full expansion. Note (according to -% the warning earlier) \TeX\ does not allow us to treat |#|s the -% same in all cases. Tough. -% \begin{macrocode} -\def_long_new:Npn \tlp_put_left:Nn #1#2{ - \tlp_set:Nn \l_exp_tlp{#2} - \tlp_set:Nx #1{\exp_not:o{\l_exp_tlp}\exp_not:o{#1}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_put_left:No #1#2{ - \tlp_set:Nn \l_exp_tlp{#2} - \tlp_set:Nx #1{\exp_not:d{\l_exp_tlp}\exp_not:o{#1}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_put_left:Nx #1#2{ - \tlp_set:Nx #1{#2\exp_not:o{#1}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_gput_left:Nn #1#2{ - \tlp_set:Nn \l_exp_tlp{#2} - \tlp_gset:Nx #1{\exp_not:o{\l_exp_tlp}\exp_not:o{#1}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_gput_left:No #1#2{ - \tlp_set:Nn \l_exp_tlp{#2} - \tlp_gset:Nx #1{\exp_not:d{\l_exp_tlp}\exp_not:o{#1}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_gput_left:Nx #1#2{ - \tlp_gset:Nx #1{#2\exp_not:o{#1}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_put_left:cn{\exp_args:Nc\tlp_put_left:Nn} -\def_long_new:Npn \tlp_put_left:co{\exp_args:Nc\tlp_put_left:No} -\def_long_new:Npn \tlp_put_left:cx{\exp_args:Nc\tlp_put_left:Nx} -\def_long_new:Npn \tlp_gput_left:cn{\exp_args:Nc\tlp_gput_left:Nn} -\def_long_new:Npn \tlp_gput_left:co{\exp_args:Nc\tlp_gput_left:No} -\def_long_new:Npn \tlp_gput_left:cx{\exp_args:Nc\tlp_gput_left:Nx} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlp_put_right:Nn} -% \begin{macro}{\tlp_put_right:No} -% \begin{macro}{\tlp_put_right:Nx} -% \begin{macro}{\tlp_put_right:cc} -% \begin{macro}{\tlp_gput_right:Nn} -% \begin{macro}{\tlp_gput_right:No} -% \begin{macro}{\tlp_gput_right:cn} -% \begin{macro}{\tlp_gput_right:co} -% \begin{macro}{\tlp_gput_right:Nx} -% These are variants of the functions above, but for adding tokens -% to the right. -% \begin{macrocode} -\def_long_new:Npn \tlp_put_right:Nn #1#2{ - \tlp_set:Nn \l_exp_tlp{#2} - \tlp_set:Nx #1{\exp_not:o{#1}\exp_not:o{\l_exp_tlp}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_gput_right:Nn #1#2{ - \tlp_set:Nn \l_exp_tlp{#2} - \tlp_gset:Nx #1{\exp_not:o{#1}\exp_not:o{\l_exp_tlp}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_put_right:No #1#2{ - \tlp_set:Nn \l_exp_tlp{#2} - \tlp_set:Nx #1{\exp_not:o{#1}\exp_not:d{\l_exp_tlp}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long_new:Npn \tlp_gput_right:No #1#2{ - \tlp_set:Nn \l_exp_tlp{#2} - \tlp_gset:Nx #1{\exp_not:o{#1}\exp_not:d{\l_exp_tlp}} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long:Npn \tlp_put_right:Nx #1#2{ - \tlp_set:Nx #1{\exp_not:o{#1}#2} -%<check> \chk_local_or_pref_global:N #1 -} -\def_long:Npn \tlp_gput_right:Nx #1#2{ - \tlp_gset:Nx #1{\exp_not:o{#1}#2} -%<check> \chk_local_or_pref_global:N #1 -} -\def_new:Npn \tlp_gput_right:cn {\exp_args:Nc \tlp_gput_right:Nn} -\def_new:Npn \tlp_gput_right:co {\exp_args:Nc \tlp_gput_right:No} -\def_new:Npn \tlp_put_right:cc {\exp_args:Ncc \tlp_put_right:Nn} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% -% \begin{macro}{\tlp_gset:Nc} -% \begin{macro}{\tlp_set:Nc} -% These two functions are included because they are necessary in -% Denys' implementations. The |:Nc| convention (see the expansion -% module) is very unusual at first sight, but it works nicely -% over all modules, so we would like to keep it. -% -% Construct a control sequence on the fly from |#2| and save it in -% |#1|. -% \begin{macrocode} -\def_new:Npn \tlp_gset:Nc { -%<*check> - \pref_global_chk: -%</check> -%<-check> \pref_global:D - \tlp_set:Nc} -% \end{macrocode} -% |\pref_global_chk:| will turn the variable check in |\tlp_set:No| -% into a global check. -% \begin{macrocode} -\def_new:Npn \tlp_set:Nc #1#2{\tlp_set:No #1{\cs:w#2\cs_end:}} -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% -% We also provide a few conditionals, both in expandable form (with -% |\c_true|) and in `brace-form', the latter are denoted by |TF| at the -% end, as explained elsewhere. -% -% -% \begin{macro}{\tlp_if_empty_p:N} -% \begin{macro}{\tlp_if_empty_p:c} -% Returns |\c_true| iff the token list in the argument is empty. -% \begin{macrocode} -\def_new:Npn \tlp_if_empty_p:N #1{ - \if_meaning:NN#1\c_empty_tlp \c_true \else: \c_false \fi:} -\def_new:Npn \tlp_if_empty_p:c {\exp_args:Nc\tlp_if_empty_p:N} -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% -% \begin{macro}{\tlp_if_empty:NTF} -% \begin{macro}{\tlp_if_empty:NT} -% \begin{macro}{\tlp_if_empty:NF} -% \begin{macro}{\tlp_if_empty:cTF} -% \begin{macro}{\tlp_if_empty:cT} -% \begin{macro}{\tlp_if_empty:cF} -% These functions check whether the token list in the argument is -% empty and execute the proper code from their argument(s). -% \begin{macrocode} -\def_test_function_new:npn {tlp_if_empty:N} #1{ - \if_meaning:NN#1\c_empty_tlp} -\def_new:Npn \tlp_if_empty:cTF {\exp_args:Nc \tlp_if_empty:NTF} -\def_new:Npn \tlp_if_empty:cT {\exp_args:Nc \tlp_if_empty:NT} -\def_new:Npn \tlp_if_empty:cF {\exp_args:Nc \tlp_if_empty:NF} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlp_if_eq_p:NN} -% \begin{macro}{\tlp_if_eq_p:Nc} -% \begin{macro}{\tlp_if_eq_p:cN} -% \begin{macro}{\tlp_if_eq_p:cc} -% Returns |\c_true| iff the two token list pointers are equal. -% \begin{macrocode} -\def_new:Npn \tlp_if_eq_p:NN #1#2{ - \if_meaning:NN#1#2 \c_true \else: \c_false \fi:} -\def_new:Npn \tlp_if_eq_p:Nc {\exp_args:NNc\tlp_if_empty_p:NN} -\def_new:Npn \tlp_if_eq_p:cN {\exp_args:Nc\tlp_if_empty_p:NN} -\def_new:Npn \tlp_if_eq_p:cc {\exp_args:Ncc\tlp_if_empty_p:NN} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlp_if_eq:NNTF} -% \begin{macro}{\tlp_if_eq:NNT} -% \begin{macro}{\tlp_if_eq:NNF} -% \begin{macro}{\tlp_if_eq:NcTF} -% \begin{macro}{\tlp_if_eq:NcT} -% \begin{macro}{\tlp_if_eq:NcF} -% \begin{macro}{\tlp_if_eq:cNTF} -% \begin{macro}{\tlp_if_eq:cNT} -% \begin{macro}{\tlp_if_eq:cNF} -% \begin{macro}{\tlp_if_eq:ccTF} -% \begin{macro}{\tlp_if_eq:ccT} -% \begin{macro}{\tlp_if_eq:ccF} -% These function tests whether the token list pointers that are in its -% first two arguments are equal. -% \begin{macrocode} -\def_test_function_new:npn {tlp_if_eq:NN} #1#2{\if_meaning:NN#1#2} -\def_new:Npn \tlp_if_eq:cNTF{\exp_args:Nc \tlp_if_eq:NNTF} -\def_new:Npn \tlp_if_eq:cNT {\exp_args:Nc \tlp_if_eq:NNT} -\def_new:Npn \tlp_if_eq:cNF {\exp_args:Nc \tlp_if_eq:NNF} -\def_new:Npn \tlp_if_eq:NcTF{\exp_args:NNc \tlp_if_eq:NNTF} -\def_new:Npn \tlp_if_eq:NcT {\exp_args:NNc \tlp_if_eq:NNT} -\def_new:Npn \tlp_if_eq:NcF {\exp_args:NNc \tlp_if_eq:NNF} -\def_new:Npn \tlp_if_eq:ccTF{\exp_args:Ncc \tlp_if_eq:NNTF} -\def_new:Npn \tlp_if_eq:ccT {\exp_args:Ncc \tlp_if_eq:NNT} -\def_new:Npn \tlp_if_eq:ccF {\exp_args:Ncc \tlp_if_eq:NNF} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% -% \begin{macro}{\c_empty_tlp} -% \begin{macro}{\c_relax_tlp} -% Two constants which are often used. -% \begin{macrocode} -\tlp_new:Nn \c_empty_tlp {} -\tlp_new:Nn \c_relax_tlp {\scan_stop:} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \begin{macro}{\g_tmpa_tlp} -% \begin{macro}{\g_tmpb_tlp} -% Global temporary token list pointers. -% They are supposed to be set and used immediately, -% with no delay between the definition and the use because you -% can't count on other macros not to redefine them from under you. -% -% \begin{macrocode} -\tlp_new:Nn \g_tmpa_tlp{} -\tlp_new:Nn \g_tmpb_tlp{} -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\l_testa_tlp} -% \begin{macro}{\l_testb_tlp} -% \begin{macro}{\g_testa_tlp} -% \begin{macro}{\g_testb_tlp} -% Global and local temporaries. These are the ones for test -% routines. This means that one can safely use other temporaries -% when calling test routines. -% \begin{macrocode} -\tlp_new:Nn \l_testa_tlp {} -\tlp_new:Nn \l_testb_tlp {} -\tlp_new:Nn \g_testa_tlp {} -\tlp_new:Nn \g_testb_tlp {} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\l_tmpa_tlp} -% \begin{macro}{\l_tmpb_tlp} -% These are local temporary token list pointers. -% \begin{macrocode} -\tlp_new:Nn \l_tmpa_tlp{} -\tlp_new:Nn \l_tmpb_tlp{} -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlp_to_str:N} -% \begin{macro}{\tlp_to_str:c} -% \begin{macro}{\tlp_to_str_aux:w} -% These functions return the replacement text of a token list as a -% string list with all characters catcoded to `other'. -% \begin{macrocode} -\def_new:Npn \tlp_to_str:N {\exp_after:NN\tlp_to_str_aux:w - \token_to_meaning:N} -\def_new:Npn \tlp_to_str_aux:w #1>{} -\def_new:Npn\tlp_to_str:c{\exp_args:Nc\tlp_to_str:N} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% -% -% \begin{macro}{\tlist_if_empty_p:n} -% It would be tempting to just use "\if_meaning:NN\q_nil#1\q_nil" as -% a test since this works really well. However it fails on a token -% list starting with "\q_nil" of course but more troubling is the -% case where argument is a complete conditional such as "\if_true:" -% a "\else:" b "\fi:" because then "\if_true:" is used by -% "\if_meaning:NN", the test turns out false, the "\else:" executes -% the false branch, the "\fi:" ends it and the "\q_nil" at the end -% starts executing\dots{} A safer route is to convert the entire -% token list into harmless characters first and then compare -% that. This way the test will even accept "\q_nil" as the first -% token. -% \begin{macrocode} -\def_long_new:Npn \tlist_if_empty_p:n #1{ - \exp_after:NN\if_meaning:NN\exp_after:NN\q_nil\tlist_to_str:n{#1}\q_nil - \c_true - \else: - \c_false - \fi: -} -% \end{macrocode} -% \end{macro} -% -% \begin{macro}{\tlist_if_empty_p:o} -% \begin{macro}{\tlist_if_empty:nTF} -% \begin{macro}{\tlist_if_empty:nT} -% \begin{macro}{\tlist_if_empty:nF} -% \begin{macro}{\tlist_if_empty:oTF} -% \begin{macro}{\tlist_if_empty:oT} -% \begin{macro}{\tlist_if_empty:oF} -% \begin{macrocode} -\def_new:Npn \tlist_if_empty_p:o {\exp_args:No\tlist_if_empty_p:n} -\def_long_test_function_new:npn{tlist_if_empty:n}#1{ - \if:w\tlist_if_empty_p:n{#1}} -\def_long_test_function_new:npn{tlist_if_empty:o}#1{ - \if:w\tlist_if_empty_p:o{#1}} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlist_if_blank_p:n} -% \begin{macro}{\tlist_if_blank_p_aux:w} -% This is based on the answers in ``Around the Bend No~2'' but is -% safer as the tests listed there all have one small flaw: If the -% input in the test is two tokens with the same meaning as the -% internal delimiter, they will fail since one of them is mistaken -% for the actual delimiter. In our version below we make sure to -% pass the input through |\tlist_to_str:n| which ensures that all -% the tokens are converted to catcode 12. However we use an |a| with -% catcode 11 as delimiter so we can \emph{never} get into the same -% problem as the solutions in ``Around the Bend No~2''. -% \begin{macrocode} -\def_long_new:Npn \tlist_if_blank_p:n #1{ - \exp_after:NN\tlist_if_blank_p_aux:w\tlist_to_str:n{#1}aa..\q_nil -} -\def_new:Npn \tlist_if_blank_p_aux:w #1#2a#3#4\q_nil{ - \if_meaning:NN #3#4\c_true\else:\c_false\fi:} -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlist_if_blank:nTF} -% \begin{macro}{\tlist_if_blank:nT} -% \begin{macro}{\tlist_if_blank:nF} -% \begin{macro}{\tlist_if_blank_p:o} -% \begin{macro}{\tlist_if_blank:oTF} -% \begin{macro}{\tlist_if_blank:oT} -% \begin{macro}{\tlist_if_blank:oF} -% Variations on the original function above. -% \begin{macrocode} -\def_long_test_function_new:npn{tlist_if_blank:n}#1{ - \if:w\tlist_if_blank_p:n{#1}} -\def:Npn \tlist_if_blank_p:o{\exp_args:No\tlist_if_blank_p:n} -\def_long_test_function_new:npn{tlist_if_blank:o}#1{ - \if:w\tlist_if_blank_p:o{#1}} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlist_to_lowercase:n} -% \begin{macro}{\tlist_to_uppercase:n} -% Just some names for a few primitives. -% \begin{macrocode} -\let_new:NN \tlist_to_lowercase:n \tex_lowercase:D -\let_new:NN \tlist_to_uppercase:n \tex_uppercase:D -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlist_to_str:n} -% Another name for a primitive. -% \begin{macrocode} -\let_new:NN \tlist_to_str:n \etex_detokenize:D -% \end{macrocode} -% \end{macro} -% -% -% \begin{macro}{\tlist_map_function:nN} -% \begin{macro}{\tlp_map_function:NN} -% \begin{macro}{\tlp_map_function:cN} -% \begin{macro}{\tlist_map_function_aux:NN} -% Expandable loop macro for |tlist|s. These have the advantage of not -% needing to test if the argument is empty, because if it is, the stop -% marker will be read immediately and the loop terminated. -% \begin{macrocode} -\def_long_new:Npn \tlist_map_function:nN #1#2{ - \tlist_map_function_aux:Nn #2 #1 \q_recursion_tail \q_recursion_stop -} -\def_new:Npn \tlp_map_function:NN #1#2{ - \exp_after:NN \tlist_map_function_aux:Nn - \exp_after:NN #2 #1 \q_recursion_tail \q_recursion_stop -} -\def_long_new:Npn \tlist_map_function_aux:Nn #1#2{ - \quark_if_recursion_tail_stop:n{#2} - #1{#2} \tlist_map_function_aux:Nn #1 -} -\def_new:Npn\tlp_map_function:cN{\exp_args:Nc\tlp_map_function:NN} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% \begin{macro}{\tlist_map_inline:nn} -% \begin{macro}{\tlp_map_inline:Nn} -% \begin{macro}{\tlp_map_inline:cn} -% \begin{macro}{\tlist_map_inline_aux:n} -% \begin{macro}{\g_tlp_inline_level_num} -% The inline functions are straight forward by now. We use a little -% a trick with the fake counter |\g_tlp_inline_level_num| to make -% them nestable.\footnote{This should be a proper integer, but I -% don't want to mess with the dependencies right now\dots} We can -% also make use of |\tlist_map_function:Nn| from before. -% \begin{macrocode} -\def_long_new:Npn \tlist_map_inline:nn #1#2{ - \num_gincr:N \g_tlp_inline_level_num - \gdef_long:cpn {tlist_map_inline_ \num_use:N \g_tlp_inline_level_num :n} - ##1{#2} - \exp_args:Nc \tlist_map_function_aux:Nn - {tlist_map_inline_ \num_use:N \g_tlp_inline_level_num :n} - #1 \q_recursion_tail\q_recursion_stop - \num_gdecr:N \g_tlp_inline_level_num -} -\def_long_new:Npn \tlp_map_inline:Nn #1#2{ - \num_gincr:N \g_tlp_inline_level_num - \gdef_long:cpn {tlist_map_inline_ \num_use:N \g_tlp_inline_level_num :n} - ##1{#2} - \exp_args:NcE \tlist_map_function_aux:Nn - {tlist_map_inline_ \num_use:N \g_tlp_inline_level_num :n} - #1 \q_recursion_tail\q_recursion_stop - \num_gdecr:N \g_tlp_inline_level_num -} -\def_new:Npn\tlp_map_inline:cN{\exp_args:Nc\tlp_map_inline:NN} -\tlp_new:Nn \g_tlp_inline_level_num{0} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% \begin{macro}{\tlist_map_variable:nNn} -% \begin{macro}{\tlp_map_variable:NNn} -% \begin{macro}{\tlp_map_variable:cNn} -% |\tlist_map:nNn| \zz{tlist} \zz{temp} \zz{action} assigns -% \zz{temp} to each element and executes \zz{action}. -% \begin{macrocode} -\def_long_new:Npn \tlist_map_variable:nNn #1#2#3{ - \tlist_map_variable_aux:Nnn #2 {#3} #1 \q_recursion_tail \q_recursion_stop -} -\def_new:Npn \tlp_map_variable:NNn {\exp_args:No \tlist_map_variable:nNn} -\def_new:Npn \tlp_map_variable:cNn {\exp_args:Nc \tlp_map_variable:NNn} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlist_map_variable_aux:NnN} -% The general loop. Assign the temp variable |#1| to the current item -% |#3| and then check if that's the stop marker. If it is, break the -% loop. If not, execute the action |#2| and continue. -% \begin{macrocode} -\def_long_new:Npn \tlist_map_variable_aux:Nnn #1#2#3{ - \tlp_set:Nn #1{#3} - \quark_if_recursion_tail_stop:N #1 - #2 \tlist_map_variable_aux:Nnn #1{#2} -} -% \end{macrocode} -% \end{macro} -% -% \begin{macro}{\tlist_map_break:w} -% \begin{macro}{\tlp_map_break:w} -% The break statement. -% \begin{macrocode} -\let_new:NN \tlist_map_break:w \use_none_delimit_by_q_recursion_stop:w -\let_new:NN \tlp_map_break:w \tlist_map_break:w -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% -% \begin{macro}{\tlist_elt_count:n} -% \begin{macro}{\tlist_elt_count:o} -% \begin{macro}{\tlp_elt_count:n} -% Count number of elements within a token list or token list -% pointer. Brace groups within the list are read as a single -% element. -% "\num_elt_count:n" grabs the element and replaces it by "+1". The -% "0" to ensure it works on an empty list. -% \begin{macrocode} -\def_long_new:Npn \tlist_elt_count:n #1{ - \num_value:w \num_eval:w 0 - \tlist_map_function:nN {#1}\num_elt_count:n - \num_eval_end: -} -\def_new:Npn \tlist_elt_count:o {\exp_args:No\tlist_elt_count:n} -\def_new:Npn \tlp_elt_count:N #1{ - \num_value:w \num_eval:w 0 - \tlp_map_function:NN #1 \num_elt_count:n - \num_eval_end: -} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% -% -% \begin{macro}{\tlist_if_eq:nnTF} -% \begin{macro}{\tlist_if_eq:nnT} -% \begin{macro}{\tlist_if_eq:nnF} -% Test if two token lists are identical. pdf\TeX\ contains a most -% interesting primitive for expandable string comparison so we make -% use of it if available. Presumable it will be in the final -% version. -% -% Firstly we give it an appropriate name. Note that this primitive -% actually performs an \texttt{x} type expansion but it is still -% expandable! Hence we must program these functions backwards to add -% \verb|\exp_not:n|. We provide the combinations for the types -% \texttt{n}, \texttt{o} and \texttt{x}. -% \begin{macrocode} -\let_new:NN \tlist_compare:xx \pdfstrcmp -\def_long_new:NNn \tlist_compare:nn 2{ - \tlist_compare:xx{\exp_not:n{#1}}{\exp_not:n{#2}} -} -\def_long_new:NNn \tlist_compare:nx 1{ - \tlist_compare:xx{\exp_not:n{#1}} -} -\def_long_new:NNn \tlist_compare:xn 2{ - \tlist_compare:xx{#1}{\exp_not:n{#2}} -} -\def_long_new:NNn \tlist_compare:no 2{ - \tlist_compare:xx{\exp_not:n{#1}}{\exp_not:n\exp_after:NN{#2}} -} -\def_long_new:NNn \tlist_compare:on 2{ - \tlist_compare:xx{\exp_not:n\exp_after:NN{#1}}{\exp_not:n{#2}} -} -\def_long_new:NNn \tlist_compare:oo 2{ - \tlist_compare:xx{\exp_not:n\exp_after:NN{#1}}{\exp_not:n\exp_after:NN{#2}} -} -\def_long_new:NNn \tlist_compare:xo 2{ - \tlist_compare:xx{#1}{\exp_not:n\exp_after:NN{#2}} -} -\def_long_new:NNn \tlist_compare:ox 2{ - \tlist_compare:xx{\exp_not:n\exp_after:NN{#1}}{\exp_not:n{#2}} -} -% \end{macrocode} -% Since we have a lot of basically identical functions to define we -% define one to define the rest. Unfortunately we aren't quite set up -% to use the new \verb|\tlist_map_inline:nn| function yet. -% \begin{macrocode} -\def:Npn \tmp:w #1{ - \def_long_new:cNx {tlist_if_eq_p:#1} 2{ - \exp_not:N \if_num:w - \exp_after:NN \exp_not:N \cs:w tlist_compare:#1\cs_end:{##1}{##2} - \exp_not:n{ =\c_zero \c_true \else: \c_false \fi: } - } - \def_long_test_function_new:npx{tlist_if_eq:#1}##1##2{ - \exp_not:N \if_num:w - \exp_after:NN \exp_not:N \cs:w tlist_compare:#1\cs_end:{##1}{##2} - \exp_not:n{ =\c_zero } - } -} -\tmp:w{xx} \tmp:w{nn} \tmp:w{oo} \tmp:w{xn} \tmp:w{nx} -\tmp:w{on} \tmp:w{no} \tmp:w{xo} \tmp:w{ox} -% \end{macrocode} -% However all of this only makes sense if we actually have that -% primitive. Therefore we disable it again if it is not there and -% define \verb|\tlist_if_eq:nn| the old fashioned (and unexpandable) -% way. -% \begin{macrocode} -\cs_if_really_free:cT{pdf_strcmp:D}{ - \def_long_test_function:npn{tlist_if_eq:nn}#1#2{ - \tlp_set:Nx \l_testa_tlp {\exp_not:n{#1}} - \tlp_set:Nx \l_testb_tlp {\exp_not:n{#2}} - \if_meaning:NN\l_testa_tlp \l_testb_tlp - } - \def_long_test_function:npn{tlist_if_eq:no}#1#2{ - \tlp_set:Nx \l_testa_tlp {\exp_not:n{#1}} - \tlp_set:Nx \l_testb_tlp {\exp_not:o{#2}} - \if_meaning:NN\l_testa_tlp \l_testb_tlp - } - \def_long_test_function:npn{tlist_if_eq:nx}#1#2{ - \tlp_set:Nx \l_testa_tlp {\exp_not:n{#1}} - \tlp_set:Nx \l_testb_tlp {#2} - \if_meaning:NN\l_testa_tlp \l_testb_tlp - } - \def_long_test_function:npn{tlist_if_eq:on}#1#2{ - \tlp_set:Nx \l_testa_tlp {\exp_not:o{#1}} - \tlp_set:Nx \l_testb_tlp {\exp_not:n{#2}} - \if_meaning:NN\l_testa_tlp \l_testb_tlp - } - \def_long_test_function:npn{tlist_if_eq:oo}#1#2{ - \tlp_set:Nx \l_testa_tlp {\exp_not:o{#1}} - \tlp_set:Nx \l_testb_tlp {\exp_not:o{#2}} - \if_meaning:NN\l_testa_tlp \l_testb_tlp - } - \def_long_test_function:npn{tlist_if_eq:ox}#1#2{ - \tlp_set:Nx \l_testa_tlp {\exp_not:o{#1}} - \tlp_set:Nx \l_testb_tlp {#2} - \if_meaning:NN\l_testa_tlp \l_testb_tlp - } - \def_long_test_function:npn{tlist_if_eq:xn}#1#2{ - \tlp_set:Nx \l_testa_tlp {#1} - \tlp_set:Nx \l_testb_tlp {\exp_not:n{#2}} - \if_meaning:NN\l_testa_tlp \l_testb_tlp - } - \def_long_test_function:npn{tlist_if_eq:xo}#1#2{ - \tlp_set:Nx \l_testa_tlp {#1} - \tlp_set:Nx \l_testb_tlp {\exp_not:o{#2}} - \if_meaning:NN\l_testa_tlp \l_testb_tlp - } - \def_long_test_function:npn{tlist_if_eq:xx}#1#2{ - \tlp_set:Nx \l_testa_tlp {#1} - \tlp_set:Nx \l_testb_tlp {#2} - \if_meaning:NN\l_testa_tlp \l_testb_tlp - } -} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% -% -% \subsubsection{Checking for and replacing tokens} -% -% \begin{macro}{\tlp_if_in:NnTF} -% \begin{macro}{\tlp_if_in:cnTF} -% \begin{macro}{\tlp_if_in:NnT} -% \begin{macro}{\tlp_if_in:cnT} -% \begin{macro}{\tlp_if_in:NnF} -% \begin{macro}{\tlp_if_in:cnF} -% \begin{macro}{\tlist_if_in:nnTF} -% \begin{macro}{\tlist_if_in:onTF} -% See the replace functions for further comments. In this part we -% don't care too much about brace stripping since we are not -% interested in passing on the tokens which are split off in the -% process. -% \begin{macrocode} -\def_long:Npn \tlp_if_in:NnTF #1#2{ - \def_long:Npn\tmp:w ##1 #2 ##2\q_stop{ - \quark_if_no_value:nFT{##2} - } - \exp_after:NN \tmp:w #1 #2 \q_no_value \q_stop -} -\def_new:Npn \tlp_if_in:cnTF {\exp_args:Nc\tlp_if_in:NnTF} -\def_long:Npn \tlp_if_in:NnT #1#2{ - \def_long:Npn\tmp:w ##1 #2 ##2\q_stop{ - \quark_if_no_value:nF{##2} - } - \exp_after:NN \tmp:w #1 #2 \q_no_value \q_stop -} -\def_new:Npn \tlp_if_in:cnT {\exp_args:Nc\tlp_if_in:NnT} -\def_long:Npn \tlp_if_in:NnF #1#2{ - \def_long:Npn\tmp:w ##1 #2 ##2\q_stop{ - \quark_if_no_value:nT{##2} - } - \exp_after:NN \tmp:w #1 #2 \q_no_value \q_stop -} -\def_new:Npn \tlp_if_in:cnF {\exp_args:Nc\tlp_if_in:NnF} -\def_long_new:Npn \tlist_if_in:nnTF #1#2{ - \def_long:Npn\tmp:w ##1 #2 ##2\q_stop{ - \quark_if_no_value:nFT{##2} - } - \tmp:w #1 #2 \q_no_value \q_stop -} -\def_new:Npn \tlist_if_in:onTF {\exp_args:No\tlist_if_in:nnTF} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\l_tlp_replace_tlp} -% A temp variable for the replace operations. -% \begin{macrocode} -\tlp_new:Nn\l_tlp_replace_tlp{} -% \end{macrocode} -% \end{macro} -% -% \begin{macro}{\tlp_replace_in:Nnn} -% \begin{macro}{\tlp_replace_in:cnn} -% \begin{macro}{\tlp_greplace_in:Nnn} -% \begin{macro}{\tlp_greplace_in:cnn} -% \begin{macro}{\tlp_replace_in_aux:NNnn} -% Replacing the first item in a token list pointer goes like this: -% Define a temporary function with delimited arguments containing -% the search term and take a closer look at what is left. We append -% the expansion of the tlp with the search term plus the quark -% |\q_no_value|. If the search term isn't present this last one is -% found and the following token is the quark, so we test for -% that. If the search term is present we will have to split off the -% |#3\q_no_value| we had, so we define yet another function with -% delimited arguments to do this. The advantage here is that now we -% have a special end sequence so there is no problem if the search -% term appears more than once. Only problem left is to prevent brace -% stripping in both ends, so we prepend the expansion of the tlp -% with |\q_mark| later to be gobbled and also prepend the remainder -% of the first split operation with |\q_mark| also to be gobbled -% again later on. -% \begin{macrocode} -\def_long_new:NNn \tlp_replace_in_aux:NNnn 4{ - \def_long:Npn \tmp:w ##1#3##2\q_stop{ - \quark_if_no_value:nF{##2} - { -% \end{macrocode} -% At this point |##1| starts with a |\q_mark| so remove it. -% \begin{macrocode} - \tlp_set:Nx\l_tlp_replace_tlp{\exp_not:o{\use_none:n##1#4}} - \def_long:Npn \tmp:w ####1#3\q_no_value{ - \tlp_put_right:Nx \l_tlp_replace_tlp {\exp_not:o{\use_none:n ####1}} - } - \tmp:w \q_mark ##2 - } -% \end{macrocode} -% Now all that is done is setting the token list pointer equal to the -% expansion of the token register. -% \begin{macrocode} - #1#2\l_tlp_replace_tlp - } -% \end{macrocode} -% Here is where we start the process. Note that the tlp might start -% with a space token so we use this little trick with |\use_arg_i:n| -% to prevent it from being removed. -% \begin{macrocode} - \use_arg_i:n{\exp_after:NN \tmp:w\exp_after:NN\q_mark} - #2#3 \q_no_value\q_stop -} -% \end{macrocode} -% Now the various versions doing the replacement either globally or -% locally. -% \begin{macrocode} -\def_new:Npn \tlp_replace_in:Nnn {\tlp_replace_in_aux:NNnn \tlp_set_eq:NN} -\def_new:Npn \tlp_replace_in:cnn{\exp_args:Nc\tlp_replace_in:Nnn} -\def_new:Npn \tlp_greplace_in:Nnn {\tlp_replace_in_aux:NNnn \tlp_gset_eq:NN} -\def_new:Npn \tlp_greplace_in:cnn{\exp_args:Nc\tlp_greplace_in:Nnn} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlp_replace_all_in:Nnn} -% \begin{macro}{\tlp_greplace_all_in:cnn} -% \begin{macro}{\tlp_replace_all_in:Nnn} -% \begin{macro}{\tlp_greplace_all_in:cnn} -% \begin{macro}{\tlp_replace_all_in_aux:NNnn} -% The version for replacing \emph{all} occurrences of the search -% term is fairly easy since we just have to keep doing the -% replacement on the split-off part until all are -% replaced. Otherwise it is pretty much the same as above. -% \begin{macrocode} -\def_long:NNn \tlp_replace_all_in_aux:NNnn 4{ - \tlp_clear:N \l_tlp_replace_tlp - \def_long:Npn \tmp:w ##1#3##2\q_stop{ - \quark_if_no_value:nTF{##2} - { - \tlp_put_right:Nx \l_tlp_replace_tlp {\exp_not:o{\use_none:n##1}} - } - { - \tlp_put_right:Nx \l_tlp_replace_tlp {\exp_not:o{\use_none:n##1 #4}} - \tmp:w \q_mark##2 \q_stop - } - } - \use_arg_i:n{\exp_after:NN \tmp:w\exp_after:NN\q_mark} - #2#3 \q_no_value\q_stop - #1#2\l_tlp_replace_tlp -} -% \end{macrocode} -% Now the various forms. -% \begin{macrocode} -\def_new:Npn \tlp_replace_all_in:Nnn { - \tlp_replace_all_in_aux:NNnn \tlp_set_eq:NN} -\def_new:Npn \tlp_replace_all_in:cnn{\exp_args:Nc\tlp_replace_all_in:Nnn} -\def_new:Npn \tlp_greplace_all_in:Nnn { - \tlp_replace_all_in_aux:NNnn \tlp_gset_eq:NN} -\def_new:Npn \tlp_greplace_all_in:cnn{\exp_args:Nc\tlp_greplace_all_in:Nnn} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% -% \begin{macro}{\tlp_remove_in:Nn} -% \begin{macro}{\tlp_remove_in:cn} -% \begin{macro}{\tlp_gremove_in:Nn} -% \begin{macro}{\tlp_gremove_in:cn} -% Next comes a series of removal functions. I have just implemented -% them as subcases of the replace functions for now (I'm lazy). -% \begin{macrocode} -\def_long_new:NNn \tlp_remove_in:Nn 2{\tlp_replace_in:Nnn #1{#2}{}} -\def_long_new:NNn \tlp_gremove_in:Nn 2{\tlp_greplace_in:Nnn #1{#2}{}} -\def_new:Npn \tlp_remove_in:cn{\exp_args:Nc\tlp_remove_in:Nn} -\def_new:Npn \tlp_gremove_in:cn{\exp_args:Nc\tlp_gremove_in:Nn} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% \begin{macro}{\tlp_remove_all_in:Nn} -% \begin{macro}{\tlp_remove_all_in:Nn} -% \begin{macro}{\tlp_gremove_all_in:Nn} -% \begin{macro}{\tlp_gremove_all_in:Nn} -% Same old, same old. -% \begin{macrocode} -\def_long_new:Npn \tlp_remove_all_in:Nn #1#2{ - \tlp_replace_all_in:Nnn #1{#2}{} -} -\def_long_new:Npn \tlp_gremove_all_in:Nn #1#2{ - \tlp_greplace_all_in:Nnn #1{#2}{} -} -\def_new:Npn \tlp_remove_all_in:cn{\exp_args:Nc\tlp_remove_all_in:Nn} -\def_new:Npn \tlp_gremove_all_in:cn{\exp_args:Nc\tlp_gremove_all_in:Nn} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% \subsubsection{Heads or tails?} -% -% \begin{macro}{\tlist_head:n} -% \begin{macro}{\tlist_head_i:n} -% \begin{macro}{\tlist_tail:n} -% \begin{macro}{\tlist_tail:f} -% \begin{macro}{\tlist_head_iii:n} -% \begin{macro}{\tlist_head_iii:f} -% \begin{macro}{\tlist_head:w} -% \begin{macro}{\tlist_tail:w} -% \begin{macro}{\tlist_head_iii:w} -% These functions pick up either the head or the tail of a list. -% "\tlist_head_iii:n" returns the first three items on a list. -% \begin{macrocode} -\def_long_new:Npn \tlist_head:n #1{\tlist_head:w #1\q_nil} -\let_new:NN \tlist_head_i:n \tlist_head:n -\def_long_new:Npn \tlist_tail:n #1{\tlist_tail:w #1\q_nil} -\def_new:Npn \tlist_tail:f {\exp_args:Nf \tlist_tail:n} -\def_long_new:Npn \tlist_head_iii:n #1{\tlist_head_iii:w #1\q_nil} -\def_new:Npn \tlist_head_iii:f {\exp_args:Nf \tlist_head_iii:n} -\let_new:NN \tlist_head:w \use_arg_i_delimit_by_q_nil:nw -\def_long_new:Npn \tlist_tail:w #1#2\q_nil{#2} -\def_long_new:Npn \tlist_head_iii:w #1#2#3#4\q_nil{#1#2#3} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% \begin{macro}{\tlist_if_head_eq_meaning_p:nN} -% \begin{macro}{\tlist_if_head_eq_meaning:nNTF} -% \begin{macro}{\tlist_if_head_eq_meaning:nNT} -% \begin{macro}{\tlist_if_head_eq_meaning:nNF} -% \begin{macro}{\tlist_if_head_eq_charcode_p:nNTF} -% \begin{macro}{\tlist_if_head_eq_charcode:nNTF} -% \begin{macro}{\tlist_if_head_eq_charcode:nNT} -% \begin{macro}{\tlist_if_head_eq_charcode:nNF} -% \begin{macro}{\tlist_if_head_eq_catcode_p:nNTF} -% \begin{macro}{\tlist_if_head_eq_catcode:nNTF} -% \begin{macro}{\tlist_if_head_eq_catcode:nNT} -% \begin{macro}{\tlist_if_head_eq_catcode:nNF} -% When we want to check if the first token of a list equals something -% specific it is usually either to see if it is a control sequence or -% a character. Hence we make two different functions as the internal -% test is different. -% |\tlist_if_head_meaning_eq:nNTF| uses |\if_meaning:NN| and will -% consider the tokens |b|$\sb{11}$ and |b|$\sb{12}$ different. -% |\tlist_if_head_char_eq:nNTF| on the other hand only compares -% character codes so would regard |b|$\sb{11}$ and |b|$\sb{12}$ as -% equal but would also regard two primitives as equal. -% \begin{macrocode} -\def_long_new:Npn \tlist_if_head_eq_meaning_p:nN #1#2{ - \exp_after:NN \if_meaning:NN \tlist_head:w #1\q_nil#2 - \c_true - \else: - \c_false - \fi: -} -\def_long_test_function_new:npn {tlist_if_head_eq_meaning:nN}#1#2{ - \if:w \tlist_if_head_eq_meaning_p:nN{#1}#2} -% \end{macrocode} -% For the charcode and catcode versions we insert |\exp_not:N| in -% front of both tokens. If you need them to expand fully as \TeX{} -% does itself with these you can use an |f| type expansion. -% \begin{macrocode} -\def_long_new:Npn \tlist_if_head_eq_charcode_p:nN #1#2{ - \exp_after:NN\if_charcode:w \exp_after:NN\exp_not:N - \tlist_head:w #1\q_nil\exp_not:N#2 - \c_true - \else: - \c_false - \fi: -} -\def_long_test_function_new:npn {tlist_if_head_eq_charcode:nN}#1#2{ - \if:w\tlist_if_head_eq_charcode_p:nN{#1}#2} -% \end{macrocode} -% Actually the default is already an |f| type expansion. -% \begin{macrocode} -\def_long_new:Npn \tlist_if_head_eq_charcode_p:fN #1#2{ - \exp_after:NN\if_charcode:w \tlist_head:w #1\q_nil\exp_not:N#2 - \c_true - \else: - \c_false - \fi: -} -\def_long_test_function_new:npn {tlist_if_head_eq_charcode:fN}#1#2{ - \if:w\tlist_if_head_eq_charcode_p:fN{#1}#2} -\def_long_new:Npn \tlist_if_head_eq_catcode_p:nN #1#2{ - \exp_after:NN\if_charcode:w \exp_after:NN\exp_not:N - \tlist_head:w #1\q_nil\exp_not:N#2 - \c_true - \else: - \c_false - \fi: -} -\def_long_test_function_new:npn {tlist_if_head_eq_catcode:nN}#1#2{ - \if:w\tlist_if_head_eq_catcode_p:nN{#1}#2} -% \end{macrocode} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% \end{macro} -% -% -% \begin{macro}{\tlist_reverse:n} -% \begin{macro}{\tlist_reverse_aux:nN} -% Reversal of a token list is done by taking one token at a time -% and putting it in front of the ones before it. -% \begin{macrocode} -\def_long_new:Npn \tlist_reverse:n #1{ - \tlist_reverse_aux:nN {} #1 \q_recursion_tail\q_recursion_stop -} -\def_long_new:Npn \tlist_reverse_aux:nN #1#2{ - \quark_if_recursion_tail_stop_do:nn {#2}{ #1 } - \tlist_reverse_aux:nN {#2#1} -} -% \end{macrocode} -% \end{macro} -% \end{macro} -% -% -% -% As this package relies heavily on a lot of the expansion tricks used -% in \textsf{l3expan} we make sure to load it automatically at the end -% when used as a package. Probably not needed but I'm just such a nice -% guy\dots -% \begin{macrocode} -%<package>\RequirePackage{l3expan} -%<package>\RequirePackage{l3num}\par -% \end{macrocode} -% Show token usage: -% \begin{macrocode} -%</initex|package> -%<*showmemory> -\showMemUsage -%</showmemory> -% \end{macrocode} -% -% \endinput -% -% $Log$ -% Revision 1.28 2006/07/30 15:51:53 morten -% Made \tlist_map_inline:nn and variants nestable. Reimplemented -% \tlp_if_in:..., \tlp_replace_in:..., \tlp_replace_all_in:... -% -% Revision 1.27 2006/07/25 15:32:48 morten -% More \tlist_if_blank functions -% -% Revision 1.26 2006/07/06 14:58:50 morten -% Documentation touch-ups. Added more functions plus some new comparison -% functions which are dependent on a reasonably new pdfTeX. -% -% Revision 1.25 2006/06/05 14:55:14 morten -% Function for reversing a list of tokens. -% -% Revision 1.24 2006/06/03 16:31:19 morten -% Another version of \tlist_head... -% -% Revision 1.23 2006/03/20 18:26:41 braams -% Updated the copyright notice (2006) and demoted all implementation -% sections to subsections and so on to clean up the toc for source3.tex -% -% Revision 1.22 2006/01/26 14:00:42 morten -% Added a few missing functions (that were documented to be there!) -% -% Revision 1.21 2006/01/19 22:27:08 morten -% Added \tlp_replace_ and \tlp_remove_if_in functions. -% -% Revision 1.20 2006/01/17 23:07:06 morten -% Added "if_in" functions. -% -% Revision 1.19 2005/12/27 10:09:07 morten -% Changed RCS information retrieval, imported all tlist functions since -% half of them dealt with token list pointers anyway -% -% Revision 1.18 2005/07/25 19:50:40 morten -% Fixed the \long-ness aspects. -% -% Revision 1.17 2005/04/12 16:43:03 morten -% Minor updates -% -% Revision 1.16 2005/04/12 12:10:28 morten -% Rearranged and cleaned up code to avoid much doubling. -% -% Revision 1.15 2005/04/06 21:34:07 morten -% Fixed all tlp_set:XX so that they're \long. Added \tlp_set:Nf -% -% Revision 1.14 2005/03/22 23:20:43 morten -% Fixed \long versions according to Benjamin's suggestions. Slightly reorganized. -% -% Revision 1.13 2005/03/16 22:35:41 braams -% Added the tweaks necessary to be able to load with initex -% -% Revision 1.12 2005/03/11 21:43:58 braams -% Fixed the use of RCS information; -% Fixed a documentation typo -% |