`\StrSubstitute` command with a conditional as its argument - TeX

TopAnswers TeX

Top Answer

Phelype Oleinik

As I said in the comment, but was to lazy to write a proper answer :P:

The problem is `\StrSubstitute` does (by default) a full expansion of its arguments (something equivalent to `\edef\x{\footrue}`), but `\footrue` breaks in an `\edef`.  There's an explanation in the `xstring` documentation, section [3.1 Expansion of arguments](http://mirrors.ctan.org/macros/generic/xstring/xstring-en.pdf#23).  In short, it has three expansion modes: `\fullexpandarg`, `\expandarg` and `\noexpandarg` (if you're familiar with `expl3`, those are `x`, `o`, and `n`-types, respectively).

You have two options:

1. Do `\expandarg` before the `\StrSubstitute`, so the arguments are expanded only once (but then if you have `\def\tmpstrA{A}\def\tmpstrB{B}` then `\StrSubstitute{\tmpstrA\tmpstrB}{B}{X}` the `B` won't be seen, for examle);  
Since you're inside a group you don't need to bother restoring the expansion behaviour manually, otherwise you could use
   ```
   \saveexpandmode
     \expandarg
     \StrSubstitute ...
   \restoreexpandmode
   ```


2. Make `\footrue` (and `\foofalse`) `\protected` so they don't expand in the `\edef` (optionally include `\global` in the definition, if the conditionals are to be always changed globally):  
   ```  
   \protected\def\footrue{\global\let\iffoo\iftrue}
   \protected\def\foofalse{\global\let\iffoo\iffalse}
   ```
   
Without knowing what `\footext` is supposed to do it's hard to say, but it seems it should take “text” (in general) as argument, in which case it is usually a bad idea to `\edef` it, so I'd use option 1 or maybe both:
```
\documentclass{article}
\usepackage{xparse}
\usepackage{xstring}
\newif\iffoo
\protected\def\footrue{\global\let\iffoo\iftrue}
\protected\def\foofalse{\global\let\iffoo\iffalse}
%
\NewDocumentCommand{\footext}{+m}{%
\begingroup
  \def\tmpstr{#1}
  \expandarg
  \StrSubstitute{\tmpstr}{A}{X\footrue}[\tmpstr]%
  \tmpstr
\endgroup
}%

\begin{document}
\footext{A}
\end{document}
```

> you declare \tipaunicolon with \DeclareTextCommand which by design makes a non-expandable command I meant is the non-expandable nature changed to something else when the `\let` command is used with `\:`

`\:` becomes something like `\TUcmd \tipaunicolon \TUtipaunicolon`, which does some sanity checking on the encoding before calling the actual `\tipaunicolon` command. What do you mean with “is something changed”?

Okay, the code seems to only work with full expansion, which is odd because you declare `\tipaunicolon` with `\DeclareTextCommand` which _by design_ makes a non-expandable command, so I'm not sure what I'm missing here... Strange, but if it ain't broke... :)

Do you think `\x` should be defined as `\:t` directly? Because as demonstrated in the small snippet above, `\:t` is undefined outside `\textipa`. Only in `\textipa` accent commands like `\tipaunistar`, `\tipaunicolon`, `\tipaunisemicolon` are `let` to be `\*`, `\:`, `\;`. So shall `\x` be defined as `\textipa{\:t}` then?

`\expandarg` expands the argument with an `\expandafter`, so it expands `\tmpstr` only once into the argument `#1` (which seems to be what you want). `\fullexpandarg` expands with `\edef`, so it expands `\tmpstr` and everything inside it. I'll take a look at your code

If that's the case then maybe it won't be a problem to fully expand it, but you have to make sure that `\:` will not explode in an `\edef` (you can test: if `\def\x{\:t}\edef\y{\x}\ifx\x\y true\else false\fi` returns `false` then you probably can't fully expand.

TBH I don't know what the difference between `\expandarg` and `\fullexpandarg` is. I have tried to read about it, but the expansion thing is itself a bit too complicated for a newbie like me. But `\fullexpandarg` works for me in a specific condition where `\expandarg` doesn't seem to work. Try the following example - ``` \documentclass{article} \usepackage{tipauni} \begin{document} \textipa{\*m} \end{document} ``` The `\*m` thing is coded as follows in the package - ``` \documentclass{article} \usepackage{xparse} \usepackage{xstring} \usepackage{fontspec} \setmainfont{CharisSIL} % https://ctan.org/pkg/charissil \DeclareTextCommand{\tipaunistar}{TU}[1]{{#1}} \DeclareTextAccentDefault{\tipaunistar}{TU} \DeclareTextComposite{\tipaunistar}{TU}{m}{"270} \NewDocumentCommand{\textipa}{m}% {% \begingroup \let\*\tipaunistar \def\tmpstr{#1}% \tmpstr \endgroup }% \begin{document} \textipa{\*m} \end{document} ``` This should result in a warning because on the line 426 of the .sty file I have issued ``` \IfEq{\tmpstr}{ɰ}{\nontipatrue}{\relax} ``` At the end of the document, I check whether nontipa is true or not and issue a warning. If I use `\expandarg`; I don't get that warning, but I do get it when I use `\fullexpandarg`. Honestly I don't know why. I have tried to present to you the brief picture of the package. Let me know what you think about the expansion now.

TIPA is an old package (last updated in 2004) for typesetting phonetic alphabets with ASCII inputs. It is used widely in linguistics, but unfortunately it uses T3 encoding which is not as useful as Unicode. What I am trying to achieve in this package is converting the commands of the TIPA package to Unicode characters. `\textipa{}` is a command which takes input like `\:t` for outputting characters like `ʈ`. This command doesn't contain anything other than the characters in that special tipa code. So no `\textbf{}`, no normal text inside `\textipa`. It in fact is problematic to write normal text in `\textipa` as it converts every upper-case character into IPA characters. eg. Try this - ``` \documentclass{article} \usepackage{tipa} % Use package `tipauni` for Unicode \begin{document} \textschwa\textphi\textglotstop \textipa{ABCDEFGHIJKLMNOPQRSTUVWXYZ} \end{document} ```

Ah, I see, in your package you are doing the replacements in `\textipa`, so in that case you _definitely_ don't want `\fullexpandarg`. Expanding “user text” is rather dangerous because several commands don't behave well in `\edef` (to the example of `\textbf`)

If you say `\exploregroups` before `\StrSubstitute`, then `xstring` will also look for the search pattern inside braced groups, without issues with the terrifying “new kernel code”. You could also use `\regex_replace_all:NnN` to do a regex-based replacement

No, because `\textbf` is not expandable. Meaning that, without further ado, you can either leave it unexpanded, which however will hide its argument, or try to protect `\textbf` against expansion. Unfortunately, IMHO with the new kernel it is much harder to find a way that works, previously one could fool around and the error messages will guide one to find a solution...

@Phelype, your code is magic! I don't think I have fully understood what it can do, but it helped me to achieve literally everything that was desired! Thanks a ton. If you want to see the implementation of your answer, you can check it on the following link <https://gitlab.com/niruvt/tipauni>. This is an unreleased package. I'll complete it soon and release it. Your contribution is duly attributed in the documentation of the package.

@निरंजन, re: [your question](#question), to see if something is contained in a macro or an argument is a common task, which often gets solved with `\in@`. So you can do ``` \documentclass{article} \usepackage{xparse} \usepackage{xstring} \newif\iffoo % \makeatletter \NewDocumentCommand{\footext}{+m}{% \begingroup \StrSubstitute{#1}{A}{X}[\tmpstr]% \tmpstr \expanded{\noexpand\in@{#1}{A}}% \ifin@ \global\footrue \fi \endgroup }% \makeatother \begin{document} \iffoo foo is true\else foo is false\fi \footext{A} \iffoo foo is true\else foo is false\fi \end{document} ``` Since I do not know the context so I do not know how important the actual `\StrSubstitute{#1}{A}{X}[\tmpstr]` is. This code does not work with `\footext{\textbf{A}}`, say, but with this input I'd expect the current answer also to have difficulties detecting the `A`.

The problem is `\StrSubstitute` does a full expansion of its arguments (something equivalent to `\edef\x{\footrue}`), but `\footrue` breaks in an `\edef`. You have two options: 1. Do `\expandarg` before the `\StrSubstitute`, so the arguments are expanded only once (but then if you have `\def\tmpstrA{A}\def\tmpstrB{B}` then `\StrSubstitute{\tmpstrA\tmpstrB}{B}{X}` the `B` won't be seen, for examle); 2. Make `\footrue` (and `\foofalse`) `\protected` so they don't expand in the `\edef`: ``` \protected\def\footrue{\let\iffoo\iftrue} \protected\def\foofalse{\let\iffoo\iffalse} ```

@निरंजन, re: [your question](#question), Can you test for the outcome of `\tmpstr`? Or even for the content of `\tmpstr` before the substitution? ``` \documentclass{article} \usepackage{xparse} \usepackage{xstring} \newif\iffoo \NewDocumentCommand{\footext}{+m}{% \begingroup \def\tmpstr{#1} \global\foofalse \StrSubstitute{\tmpstr}{A}{X}[\tmpstr]% \tmpstr \IfEq{\tmpstr}{X}{\global\footrue}{} \endgroup }% \begin{document} \footext{A} \iffoo true \else false \fi \footext{B} \iffoo true \else false \fi \end{document} ```

1 Answer