☰

Zusammengesetzter Glossarbefehl mit korrekten tiefgestellten und hochgestellten Zeichen und benutzerdefinierten Argumenten

tag-icon • tag-icon macros glossaries expl3 expansion
Zusammengesetzter Glossarbefehl mit korrekten tiefgestellten und hochgestellten Zeichen und benutzerdefinierten Argumenten

Ich möchte ein Makro erstellen, das beim Kombinieren von GLS-Symbolen hilft. Jedes zusammengesetzte Symbol sollte aus einem Hauptteil und (optional) einem Hoch- und Tiefgestellten bestehen (die selbst GLS-Symbole sind und in einer anderen Symbolliste für Hoch- und Tiefgestellte aufgeführt werden). Darüber hinaus möchte ich für einige der zusammengesetzten Symbole benutzerdefinierte Argumente hinzufügen. Ein Beispiel dafür, was ich erreichen möchte: Bildbeschreibung hier eingeben

Folgendes ist mein Problem:

  1. Um sicherzustellen, dass die nach dem zusammengesetzten Zeichen hinzugefügten Hoch-/Tiefstellungen auch zu den „zusammengesetzten“ Hoch-/Tiefstellungen hinzugefügt werden, muss ich die Verschönerungsfunktionalität aus xparseals die letzten beiden Parameter meines definierten Makros verwenden ( E{^_}{{}{}})
  2. Da ich nicht im Voraus weiß, wie viele benutzerdefinierte Argumente hinzugefügt werden, args=weiß ich nicht, welche Parameternummern die Verzierungen haben werden (d. h. ich muss die Anzahl der Argumente zählen und die Parameternummern dynamisch hinzufügen).

Ich habe mir den folgenden Code ausgedacht (der nicht funktioniert). Ich denke, das Hauptproblem hier ist die korrekte Erweiterung, sodass die Variablen, die die Parameternummern für die Verschönerungen ( \l_compound_supparameter_tlund \l_compound_subparameter_tl) enthalten, erweitert werden, bevor das Makro endgültig definiert wird. Darüber hinaus konnte ich nur durch Kommas getrennte Argumentspezifikationen an übergeben args.

\documentclass[margin=5mm]{standalone}

\usepackage[symbols]{glossaries}
\newglossaryentry{body}{
    type=symbols,
    name={body},
    symbol={B},
    description={A body.}
}
\newglossaryentry{phase}{
    type=symbols,
    name={phase},
    symbol={\alpha},
    description={A material phase.}
}
\newglossaryentry{index}{
    type=symbols,
    name={index},
    symbol={i},
    description={A body index.}
}

\ExplSyntaxOn

% Define the keys
\keys_define:nn { my/glscompound }{
    body        .tl_set:N = \l_compound_body_tl,
    args        .tl_set:N = \l_compound_args_tl,
    superscript .tl_set:N = \l_compound_superscript_tl,
    superscript .initial:n = {},
    subscript   .tl_set:N = \l_compound_subscript_tl,
    subscript   .initial:n = {},
}

\tl_new:N \l_compound_supparameter_tl  % stores the macro parameter for superscript (e.g. #3)
\tl_new:N \l_compound_subparameter_tl  % stores the macro parameter for subscript (e.g. #4)

\cs_generate_variant:Nn \exp_args:Nnnx { NnVx }

\NewDocumentCommand{\NewGlsCompound}{ m m }{
    \tl_clear:N \l_compound_body_tl
    \tl_clear:N \l_compound_args_tl
    \tl_clear:N \l_compound_superscript_tl
    \tl_clear:N \l_compound_subscript_tl
    \tl_set:Nn \l_compound_supparameter_tl { # }
    \tl_set:Nn \l_compound_subparameter_tl { # }

    \keys_set:nn { my/glscompound } { #2 }

    % convert tl to sequence of arguments
    \seq_set_split:NnV \l_tmpa_seq { , } \l_compound_args_tl

    % get the count of the seq to determine the number of custom arguments
    \int_set:Nn \l_tmpa_int { \seq_count:N \l_tmpa_seq }

    % parameter number of superscript
    \int_incr:N \l_tmpa_int 
    \tl_put_right:NV \l_compound_supparameter_tl \l_tmpa_int

    % parameter number of subscript
    \int_incr:N \l_tmpa_int 
    \tl_put_right:NV \l_compound_subparameter_tl \l_tmpa_int

    % convert the arument seq to a single tl
    \tl_set:No \l_compound_args_tl { \seq_use:Nn \l_tmpa_seq { , } }

    % append the sub/superscript arguments
    \tl_put_right:Nn \l_compound_args_tl { ~E{^_}{{}{}} }

    % Define the new command
    \exp_args:NnVx \NewDocumentCommand {#1} \l_compound_args_tl {
        \l_compound_body_tl

        % superscript

        % evaluated during runtime, if an additional superscript as parameter
        % '\l_compound_supparameter_tl' is given
        \IfValueT{ \l_compound_supparameter_tl }{ 
            % append the custom superscript to the body of the compound superscript
            \tl_put_right:Nn \l_compound_superscript_tl { \l_compound_supparameter_tl } 
        }
        % if the body of the superscript is not empty, call the superscript macro
        \tl_if_blank:VF \l_compound_superscript_tl { \sp{ \l_compound_superscript_tl } } 
        
        % subscript (same as superscript)
        \IfValueT{ \l_compound_supparameter_tl }{ 
            \tl_put_right:Nn \l_compound_subscript_tl { \l_compound_supparameter_tl }
        }
        \tl_if_blank:VF \l_compound_subscript_tl { \sb{ \l_compound_subscript_tl } }
    }
}
\ExplSyntaxOff

\NewGlsCompound{\Body}{
    body = { \glssymbol{body} },
    args = { O{arg1}, O{arg2} }, % this is comma separated list of arguments
    superscript = { \glssymbol{phase},#1 },
    subscript   = { \glssymbol{index},#2 },
}

\begin{document}
\begin{minipage}{.7\textwidth}
\renewcommand{\arraystretch}{1.5}
\begin{tabular}{l l}
    \verb+\Body+                &\(\rightarrow \Body\)\\
    \verb+\Body^{,a}_{,y}+      &\(\rightarrow \Body^{,a}_{,y}\)\\
    \verb+\Body[foo]+           &\(\rightarrow \Body[foo]\)\\
    \verb+\Body[foo]^{,x}+      &\(\rightarrow \Body[foo]^{,x}\)\\
    \verb+\Body[foo][bar]^{,x}+ &\(\rightarrow \Body[foo][bar]^{,x}\)
\end{tabular}
\end{minipage}
\end{document}

Wenn Sie mir bei diesem Erweiterungschaos helfen könnten, wäre ich sehr dankbar!

Antwort1

  • Zunächst benötigen Sie eine Routine zum Zählen der Anzahl der durch eine Xparse-Argument-Signatur angegebenen Argumente.

    Im folgenden Beispiel ist dies die Routine \MYSTUFF_xparse_arg_signature_count:n.

    Ich habe es geschrieben, indem ich den Code der Routine plagiiert habe \__cmd_split_signature:n, die imkommentierte LaTeX 2ε Quellen, Datei g: ltcmd.dtx Datum: 19.08.2023 Version v1.2a, Abschnitt „1.7.2 Anzeigen der Definition eines Befehls“.

    Die Routine \MYSTUFF_xparse_arg_signature_count:nnimmt ein Argument entgegen, das eine x-parse-argument-signature für eine Instanz von bilden soll \NewDocumentCommand.
    Die Routine gibt nach zwei Erweiterungsschritten eine Folge von Zifferntoken zurück, die die Anzahl der durch die x-parse-argument-signature angegebenen Argumente in Dezimalschreibweise angeben.

  • Ein weiteres Problem könnte darin bestehen, einen Unterstrich ( _) der Kategorie 8 (Index) in die Verschönerungsspezifikation des E-Typ-Arguments des durch definierten Befehls zu bekommen, während \NewGlsCompounddie Definition wirksam ist, sodass der Unterstrich den Kategoriecode 11 (Buchstabe) hat.\NewGlsCompound\ExplSyntaxOn

So könnte ich vorgehen:

%\errorcontextlines=10000
\ExplSyntaxOn
%-------------------------------------------------------------------------------
\cs_new:Nn \MYSTUFF_xparse_arg_signature_count:n 
  {
    \exp:w \exp_after:wN \exp_after:wN \exp_after:wN \exp_end:
    \int_eval:n
      {
        0 \__MYSTUFF_xparse_arg_signature_count_loop:Nw #1 
        \q_recursion_tail \q_recursion_stop
      }
  }
\cs_new:Npn \__MYSTUFF_xparse_arg_signature_count_loop:Nw #1
  {
    \quark_if_recursion_tail_stop:N #1
    \tl_if_exist:cTF
      { c_MYSTUFF_xparse_map_arg_type_to_argclass_\tl_to_str:n{#1}_tl }
      {
        \tl_use:c
          { c_MYSTUFF_xparse_map_arg_type_to_argclass_\tl_to_str:n{#1}_tl }
      }
      { +1 \__MYSTUFF_xparse_arg_signature_count_loop:Nw }
  }
\cs_set:Npn \__cmd_tmp:w #1 #2
  {
    \quark_if_nil:nF
      {#1}
      { 
        \tl_const:cn { c_MYSTUFF_xparse_map_arg_type_to_argclass_#1_tl } {#2} 
        \__cmd_tmp:w 
      }
  }
\__cmd_tmp:w
  t{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_delim:w}
  r{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_delims:w}
  d{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_delims:w}
  R{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_delims_opt:w}
  D{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_delims_opt:w}
  O{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_opt:w}
  e{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_e:w}
  E{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_E:w}
  +{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_prefix:w}
  !{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_prefix:w}
  >{\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_processor:w}
  ={\__MYSTUFF_xparse_arg_remove_arg_specification_of_class_processor:w}
  \q_nil \q_nil
  %------------
\cs_new:Npn \__MYSTUFF_xparse_arg_remove_arg_specification_of_class_delim:w
            #1
            { +1 \__MYSTUFF_xparse_arg_signature_count_loop:Nw }
\cs_new:Npn \__MYSTUFF_xparse_arg_remove_arg_specification_of_class_delims:w
            #1 #2
            { +1 \__MYSTUFF_xparse_arg_signature_count_loop:Nw }
\cs_new:Npn \__MYSTUFF_xparse_arg_remove_arg_specification_of_class_delims_opt:w
            #1 #2 #3
            { +1 \__MYSTUFF_xparse_arg_signature_count_loop:Nw }
\cs_new:Npn \__MYSTUFF_xparse_arg_remove_arg_specification_of_class_opt:w
            #1
            { +1 \__MYSTUFF_xparse_arg_signature_count_loop:Nw }
\cs_new:Npn \__MYSTUFF_xparse_arg_remove_arg_specification_of_class_e:w
            #1
            { +\tl_count:n{#1} \__MYSTUFF_xparse_arg_signature_count_loop:Nw }
\cs_new:Npn \__MYSTUFF_xparse_arg_remove_arg_specification_of_class_E:w
            #1 #2
            { +\tl_count:n{#1} \__MYSTUFF_xparse_arg_signature_count_loop:Nw }
\cs_new:Npn \__MYSTUFF_xparse_arg_remove_arg_specification_of_class_prefix:w
            { \__MYSTUFF_xparse_arg_signature_count_loop:Nw }
\cs_new:Npn \__MYSTUFF_xparse_arg_remove_arg_specification_of_class_processor:w
            #1
            { \__MYSTUFF_xparse_arg_signature_count_loop:Nw }
%-------------------------------------------------------------------------------
\cs_if_exist:NF \IfBlankF { \cs_new_eq:NN \IfBlankF \tl_if_blank:nF }
\cs_if_exist:NF \IfBlankT { \cs_new_eq:NN \IfBlankT \tl_if_blank:nT }
\cs_if_exist:NF \IfBlankTF { \cs_new_eq:NN \IfBlankTF \tl_if_blank:nTF }
%-------------------------------------------------------------------------------
\tl_new:N \l_MYSTUFF_GLSCOMPOUND_body_tl
\tl_new:N \l_MYSTUFF_GLSCOMPOUND_args_tl
\tl_new:N \l_MYSTUFF_GLSCOMPOUND_superscript_tl
\tl_new:N \l_MYSTUFF_GLSCOMPOUND_subscript_tl
\tl_new:N \l_MYSTUFF_GLSCOMPOUND_supparameter_tl
\tl_new:N \l_MYSTUFF_GLSCOMPOUND_subparameter_tl
%-------------------------------------------------------------------------------
\keys_define:nn { MYSTUFF/GLSCOMPOUND }{
  body.tl_set:N = \l_MYSTUFF_GLSCOMPOUND_body_tl,
  args.tl_set:N = \l_MYSTUFF_GLSCOMPOUND_args_tl,
  superscript.tl_set:N = \l_MYSTUFF_GLSCOMPOUND_superscript_tl,
  subscript.tl_set:N = \l_MYSTUFF_GLSCOMPOUND_subscript_tl,
}
% ------------------------------------------------------------------------------
% Use expl3-infrastructure for providing error-message in case the key
% "body" is not specified in the 2nd argument of \NewGlsCompound.
% ..............................................................................
\prop_gput:Nnn \g_msg_module_type_prop { MYSTUFF_GLSCOMPOUND } {}
\prop_gput:Nnn
  \g_msg_module_name_prop
  { MYSTUFF_GLSCOMPOUND } 
  {Macro-Defined-In-Preamble:}
\msg_new:nnnn {MYSTUFF_GLSCOMPOUND} 
              {No Value specified}
              {Macro~#1:~No~value~for~key~"#3"~specified.}
              {In~the~#2~argument~a~value~for~key~"#3"~must~be~specified~%
               when~calling~macro~#1.}
\cs_new:Npn \NoValueSpecifiedError #1#2#3 {
  \exp_args:Nne \use:nn {
    \msg_error:nnnnn {MYSTUFF_GLSCOMPOUND} {No Value specified}
   }{{\iow_char:N \\ \cs_to_str:N#1}}{#2}{#3}
}%
%-------------------------------------------------------------------------------
% In order to get _ of category 8(subscript) and ^ of category 7(superscript)
% into the embellishment specification of the E-type argument of the command
% defined via \NewGlsCompound, define a scratch variant of \NewGlsCompound
% which as arguments grabs these tokens and redefines itself.
\group_begin:
\cs_set:Npn \NewGlsCompound #1#2
  {
    \group_end:
    \NewDocumentCommand \NewGlsCompound {mm} {
      \group_begin:
      \exp_args:Nnx \keys_set:nn { MYSTUFF/GLSCOMPOUND } { 
        body={\exp_not:o{\c_novalue_tl}},
        args={},
        superscript={},
        subscript={}
      }
      \keys_set:nn { MYSTUFF/GLSCOMPOUND } { ##2 }
      \exp_args:NV \tl_if_novalue:nTF
        \l_MYSTUFF_GLSCOMPOUND_body_tl
        { \group_end: \NoValueSpecifiedError{\NewGlsCompound}{second}{body} }
        {
          \tl_set:Nf \l_MYSTUFF_GLSCOMPOUND_supparameter_tl 
            {
              \int_eval:n
                {
                  \exp_args:No \MYSTUFF_xparse_arg_signature_count:n
                               {\l_MYSTUFF_GLSCOMPOUND_args_tl} + 1 
                } 
            }
          \tl_set:Nf \l_MYSTUFF_GLSCOMPOUND_subparameter_tl
            {
              \int_eval:n
                {
                  \tl_use:N \l_MYSTUFF_GLSCOMPOUND_supparameter_tl + 1
                }
            }
          \tl_put_left:Nn \l_MYSTUFF_GLSCOMPOUND_supparameter_tl {####}
          \tl_put_left:Nn \l_MYSTUFF_GLSCOMPOUND_subparameter_tl {####}
          \tl_put_right:Nn \l_MYSTUFF_GLSCOMPOUND_args_tl { E{#1#2}{{}{}} }
          \__MYSTUFF_GLSCOMPOUND_set_scriptdirective_to_tokenlist:NNN
              \l_MYSTUFF_GLSCOMPOUND_superscript_tl
              \l_MYSTUFF_GLSCOMPOUND_supparameter_tl
              #1
          \__MYSTUFF_GLSCOMPOUND_set_scriptdirective_to_tokenlist:NNN
              \l_MYSTUFF_GLSCOMPOUND_subscript_tl
              \l_MYSTUFF_GLSCOMPOUND_subparameter_tl
              #2
          \exp_args:Nnx 
            \use:nn 
            { \group_end: \NewDocumentCommand {##1} }
            {
              { \exp_not:o{\l_MYSTUFF_GLSCOMPOUND_args_tl} }
              {
                \exp_not:o{ \l_MYSTUFF_GLSCOMPOUND_body_tl}
                \exp_not:o{\l_MYSTUFF_GLSCOMPOUND_superscript_tl}
                \exp_not:o{\l_MYSTUFF_GLSCOMPOUND_subscript_tl} 
              }
            }
        }
    }
  }
\char_set_catcode_math_superscript:N \^
\char_set_catcode_math_subscript:N \_
\NewGlsCompound{^}{_}
% Scratch-\NewGlsCompound im the line above does 
% \group_end:
%--------------------
\cs_new:Nn \__MYSTUFF_GLSCOMPOUND_set_scriptdirective_to_tokenlist:NNN
  {
    % #1 = \l_MYSTUFF_GLSCOMPOUND_superscript_tl / 
    %      \l_MYSTUFF_GLSCOMPOUND_subscript_tl
    % #2 = \l_MYSTUFF_GLSCOMPOUND_supparameter_tl /
    %      \l_MYSTUFF_GLSCOMPOUND_subparameter_tl
    % #3 = _ (subscript) or  ^ (subscript)
    \__MYSTUFF_GLSCOMPOUND_set_scriptdirective_to_tokenlist:NVVN#1#1#2#3
  }
\cs_new:Nn \__MYSTUFF_GLSCOMPOUND_set_scriptdirective_to_tokenlist:NnnN
  {
    % #1 = \l_MYSTUFF_GLSCOMPOUND_superscript_tl /
    %      \l_MYSTUFF_GLSCOMPOUND_subscript_tl
    % #2 = content of \l_MYSTUFF_GLSCOMPOUND_superscript_tl /
    %      content of \l_MYSTUFF_GLSCOMPOUND_subscript_tl
    % #3 = content of \l_MYSTUFF_GLSCOMPOUND_supparameter_tl /
    %      content of \l_MYSTUFF_GLSCOMPOUND_subparameter_tl
    % #4 = _ (subscript) or  ^ (subscript)
    \tl_if_blank:nTF{#2}
      {
        \tl_set:Nn
          #1 
          { 
            \tl_if_blank:oF 
              {
                \exp:w
                \tl_if_blank:nTF{#3}{\use:n}{\use_ii_i:nn{#3}}{\exp_end:} 
              }
              {
                #4
                {
                  \exp:w
                  \tl_if_blank:nTF{#3}{\use:n}{\use_ii_i:nn{#3}}{\exp_end:}
                }
              }
          }
      }
      {
        \tl_set:Nn
          #1
          { 
            \tl_if_blank:oF
              {
                \exp:w 
                \tl_if_blank:nTF{#3}{\use:n}{\use_ii_i:nn{,#3}}{\exp_end:#2}
              }
              {
                #4
                {
                  \exp:w
                  \tl_if_blank:nTF{#3}{\use:n}{\use_ii_i:nn{,#3}}{\exp_end: #2}
                }
              }
          }
      }
  }
\cs_generate_variant:Nn
  \__MYSTUFF_GLSCOMPOUND_set_scriptdirective_to_tokenlist:NnnN
  { NVVN }
\ExplSyntaxOff


\documentclass[margin=5mm]{standalone}

\usepackage{array}

\usepackage[symbols]{glossaries}
\newglossaryentry{body}{
    type=symbols,
    name={body},
    symbol={B},
    description={A body.}
}
\newglossaryentry{phase}{
    type=symbols,
    name={phase},
    symbol={\alpha},
    description={A material phase.}
}
\newglossaryentry{index}{
    type=symbols,
    name={index},
    symbol={i},
    description={A body index.}
}

\NewGlsCompound{\Body}{
  body = {\glssymbol{body}},
  args = {O{arg1} O{arg2}}, 
  superscript = {\glssymbol{phase}\IfBlankF{#1}{,#1}},
  subscript   = {\glssymbol{index}\IfBlankF{#2}{,#2}}
}

%\NewGlsCompound{\Stuff}{
%%  body = {stuff},
%  args = { }, 
%  superscript = {up},
%  subscript   = {down}
%}

\begin{document}

\begin{minipage}{\textwidth}
%  \(\Stuff^{2up}_{2down}\) \par\bigskip
\renewcommand{\arraystretch}{1.5}
\begin{tabular}{l>{\(\rightarrow\)}c>{\(}l<{\)}}
\verb|\Body|&&\Body\\
\verb|\Body[foo]|&&\Body[foo]\\
\verb|\Body[foo][bar]|&&\Body[foo][bar]\\
\verb|\Body^{X}|&&\Body^{X}\\
\verb|\Body[foo]^{X}|&&\Body[foo]^{X}\\
\verb|\Body[foo][bar]^{X}|&&\Body[foo][bar]^{X}\\
\verb|\Body_{Y}|&&\Body_{Y}\\
\verb|\Body[foo]_{Y}|&&\Body[foo]_{Y}\\
\verb|\Body[foo][bar]_{Y}|&&\Body[foo][bar]_{Y}\\
\verb|\Body^{X}_{Y}|&&\Body^{X}_{Y}\\
\verb|\Body[foo]^{X}_{Y}|&&\Body[foo]^{X}_{Y}\\
\verb|\Body[foo][bar]^{X}_{Y}|&&\Body[foo][bar]^{X}_{Y}\\
\multicolumn{3}{l}{Behavior when specifying optional arguments blank:}\\
\verb|\Body[ ]|&&\Body[ ]\\
\verb|\Body[ ][ ]|&&\Body[ ][ ]\\
\verb|\Body[ ]^{X}|&&\Body[ ]^{X}\\
\verb|\Body[ ][ ]^{X}|&&\Body[ ][ ]^{X}\\
\verb|\Body[ ]_{Y}|&&\Body[ ]_{Y}\\
\verb|\Body[ ][ ]_{Y}|&&\Body[ ][ ]_{Y}\\
\verb|\Body[ ]^{X}_{Y}|&&\Body[ ]^{X}_{Y}\\
\verb|\Body[ ][ ]^{X}_{Y}|&&\Body[ ][ ]^{X}_{Y}\\
\multicolumn{3}{l}{Behavior when specifying embellishments blank:}\\
\verb|\Body^{ }|&&\Body^{ }\\
\verb|\Body[foo]^{ }|&&\Body[foo]^{ }\\
\verb|\Body[foo][bar]^{ }|&&\Body[foo][bar]^{ }\\
\verb|\Body_{ }|&&\Body_{ }\\
\verb|\Body[foo]_{ }|&&\Body[foo]_{ }\\
\verb|\Body[foo][bar]_{ }|&&\Body[foo][bar]_{ }\\
\verb|\Body^{ }_{ }|&&\Body^{ }_{ }\\
\verb|\Body[foo]^{ }_{ }|&&\Body[foo]^{ }_{ }\\
\verb|\Body[foo][bar]^{ }_{ }|&&\Body[foo][bar]^{ }_{ }\\
\multicolumn{3}{l}{Behavior when specifying optional args and
                   embellishments blank:}\\
\verb|\Body[ ]^{ }|&&\Body[ ]^{ }\\
\verb|\Body[ ][ ]^{ }|&&\Body[ ][ ]^{ }\\
\verb|\Body[ ]_{ }|&&\Body[ ]_{ }\\
\verb|\Body[ ][ ]_{ }|&&\Body[ ][ ]_{ }\\
\verb|\Body[ ]^{ }_{ }|&&\Body[ ]^{ }_{ }\\
\verb|\Body[ ][ ]^{ }_{ }|&&\Body[ ][ ]^{ }_{ }
\end{tabular}
\end{minipage}

\end{document}

Bildbeschreibung hier eingeben

Vorbehalte:

  • Bitte machen Sie keine Dinge wie „ \Body^_{down}wo _wird der Wert des Verschönerungsarguments übernommen“ ^.

  • Neben den optionalen Verschönerungsargumenten, die durch ^und gekennzeichnet sind, hat _das Makro \Bodyauch zwei nachfolgende [...]-getrennte optionale Argumente. Daher gibt es keine Möglichkeit, nur für das zweite dieser [...]-getrennten optionalen Argumente vom Standardwert abzuweichen und dabei den Standardwert des ersten [...]-getrennten optionalen Arguments beizubehalten, außer das erste -getrennte optionale Argument ebenfalls explizit anzugeben und [...]seinen Standardwert anzugeben.

  • Derzeit (13. Januar 2024, 07:18:40 (UTC + 0000)) scheint es keine richtige offizielle Schnittstelle zum Zählen der Argumente zu geben, die durch eine xparse-Argument-Signatur gekennzeichnet sind.
    Dies \MYSTUFF_xparse_arg_signature_count:nkönnte daher nicht mehr funktionieren, wenn sich bei zukünftigen LaTeX-Versionen interne Dinge ändern – z. B. wenn weitere xparse-Argument-Typen mit nicht standardmäßiger Analyse/Zählung hinzugefügt werden, sodass der Mechanismus zum Analysieren der Argument-Signatur angepasst werden muss.

  • Bei \MYSTUFF_xparse_arg_signature_count:nwird keine Fehlerprüfung durchgeführt, ob das Argument eine gültige xparse-Argumentsignatur ist. Ebenso wenig wird eine Fehlerprüfung durchgeführt, ob der Wert des Schlüssels argsdes zweiten Arguments des Makros \NewGlsCompoundeine gültige xparse-Argumentsignatur ist. Falls dieser Wert also keine gültige xparse-Argumentsignatur bildet, können Versuche, die durch \NewGlsCompounddie Definition über \NewDocumentCommandden in seinem ersten Argument angegebenen Befehl ausgelöst werden, Fehlermeldungen über unbekannte Argumenttypen und dergleichen liefern.

verwandte Informationen