Passing the complete argument in luacode - TeX

TopAnswers TeX

Meta

Databases

TeX

Code Golf

APL

C++

.net

db<>fiddle

Java

*nix

PHP

PowerShell

Python

Rust

टेक्-मराठी

Typst

Web Client Dev

Web Server Dev

Passing the complete argument in luacode

add tag

निरंजन

With the help of [this](https://tex.stackexchange.com/a/563447/174620) amazing answer I have formed the following code. What I am trying to achieve here is to pass the argument of `\textbf` command to `\textit` command before processing the document. It seems that it works for single characters (like in `\textbf{a}`), but not for LaTeX control sequences (like in `\textbf{\oe}`). What shall I do to pass the entire argument of a command to another one in this setup?

PS - If anybody knows a way in l3programming to achieve what I am trying to get, I would love to hear about it. I don't have any preference for Lua per se, it's just that I found a solution for my purpose and hence I am using it.

```
\documentclass{article}
\usepackage{luacode}
\begin{luacode}
  function testlua ( s )
  s = unicode.utf8.gsub
  (s,'\\textbf{(%a)}','\\textit{%1}')
  return s
  end
\end{luacode}
\directlua{%
  luatexbase.add_to_callback("process_input_buffer",
  testlua, "testlua")
}%

\begin{document}
\textbf{a}

\textbf{\oe}
\end{document}
```

Top Answer

samcarter

I'm by no means a pattern matching expert, so please correct me if this is wrong, but I think there are two problems:

- with `%a` you only catch normal letters and not special characters like `\`. Try with `.` for all characters instead 

- to capture a multi-character string, add a `*`

(I found https://www.lua.org/manual/5.3/manual.html#6.4.1 useful to look up character classes)

```
% !TeX TS-program = lualatex

\documentclass{article}
\usepackage{luacode}
\begin{luacode}
  function testlua ( s )
  s = unicode.utf8.gsub
  (s,'\\textbf{(.*)}','\\textit{%1}')
  return s
  end
\end{luacode}
\directlua{%
  luatexbase.add_to_callback("process_input_buffer",
  testlua, "testlua")
}%


\begin{document}
\Huge

\textbf{a}

\textbf{\oe}

\textbf{abc}
\end{document}
```

![Screen Shot 2021-03-26 at 21.57.12.png](/image?hash=692a88fbb2bd804f7926152fb90e1e088a9b09e93ffc804af974cbbb0c4c0eeb)

I am working on a specific case which in my opinion won't cause any serious risks, but I will post here my entire code when it's ready as a CR post for you all to check it and express your opinions. You can then point out the risks involved in the selected approach and even suggest alternatives if possible :)

Just for the records, I agree Jairo A. del Rio. If anything then this example already gives you a glimpse of what could be going wrong. I think that for each of the suggestions one could construct an (admittedly corner-case) example in which something goes wrong. While you will very likely be fine in this example, and as long as you are the only one who is using it, and you know what you are doing, I think that this may not be something that one should recommend without mentioning the possibility of pitfalls. (The problem here resembles a good old BibTex problem, where one had/has to wrap e.g. `\"u` in braces in the bibliography data base.)

`\relax` needs two backslashes. ``` \documentclass{article} \usepackage{luacode} \begin{luacode} function testlua ( s ) s = unicode.utf8.gsub (s,'\\textbf{(.*)}','\\textit{%1\\relax bc}') return s end \end{luacode} \directlua{% luatexbase.add_to_callback("process_input_buffer", testlua, "testlua") }% \begin{document} \Huge \textbf{a} \textbf{\oe} \textbf{abc} \end{document} ```

In contrast with - ``` % !TeX TS-program = lualatex \documentclass{article} \usepackage{luacode} \begin{luacode} function testlua ( s ) s = unicode.utf8.gsub (s,'\\textbf{(.*)}','\\textit{{%1}bc}') return s end \end{luacode} \directlua{% luatexbase.add_to_callback("process_input_buffer", testlua, "testlua") }% \begin{document} \Huge \textbf{a} \textbf{\oe} \textbf{abc} \end{document} ```

``` % !TeX TS-program = lualatex \documentclass{article} \usepackage{luacode} \begin{luacode} function testlua ( s ) s = unicode.utf8.gsub (s,'\\textbf{(.*)}','\\textit{%1\relax bc}') return s end \end{luacode} \directlua{% luatexbase.add_to_callback("process_input_buffer", testlua, "testlua") }% \begin{document} \Huge \textbf{a} \textbf{\oe} \textbf{abc} \end{document} ```

@samcarter, Oops, but there is a new problem that I have seen in the code now. Suppose I want to add `bc` after the passed argument, I can put `\textit{%1bc}`, it works also if I use simple characters like `a` in the argument of `\textbf`, but if I input a control sequence like `\oe` I get an "Undefined control sequence error", which is kinda obvious as `\oebc` is undefined :( So basically what I need is stopping a control sequence manually, so that `bc` doesn't become a part of it and there will be no space added after `a`. Is there such a command in LaTeX?

What do you mean by fragile? Can you give an example of any potential risk with this? I have noticed one problem already, but found it trivial and hence ignored it. When I pre-process the whole text and replace `\textbf{a}` with `\textit{abc}`, it is literally changed everywhere. e.g. I can't even use `\verb|\textbf{a}|`, because in the output I always see `\textit{abc}` even if it is verbatim. I am not quiet happy with this, but it currently doesn't a big threat to my purpose.

No. What I am actually trying to achieve is much more complicated than just renewing `\textbf`. For example I might expect `\textit{abc}` in the output when I type `\textbf{a}`. I just used this for a small example. Thanks for the suggestion though!

I wouldn't rely on input processing as it is very fragile. So, unless your document is more complex, @marmot's answer seems sensible IMO (use braces or `\begingroup ... \endgroup` to keep content isolated)

1 Answer