# Recursive String Parsing

I have been working on writing a recursive stream processor in latex that converts a shorthand version of a set of highly used commands into a much longer form. The code below represents what I had done so far before realizing that xstrings cannot allow you to nest macros.

The program is supposed to do the following:

• Checks to see if the input is 0 length.
• otherwise it checks to see if there are any commands in the first set (right now there is just rotate)
• otherwise it checks to see if there are any commands in the second set (where flip is)
• otherwise it just returns the symbol

if it finds a symbol it nests and recursively calls with the remaining characters in the input stream, otherwise it just appends the recursive call to the current character.

I want to keep the recursive nature of the program because that makes the most logical sense because there is the possibility of things being nested

\newcommand{\processSymbol}[1]{
\IfEq{0}{\StrLen{#1}}{}{\CheckRotate{\firstChar{#1}}{\restChars{#1}}}
}

\newcommand{\AECheckRotate}[2]{
\begin{switch}{#1}
\case{c}{\AEccwRotate{\processSymbol{#2}}}
\AECheckFlip{#1}{#2}
\end{switch}
}
\newcommand{\AECheckFlip}[2]{
\begin{switch}
\case{v}{\flipv{\processSymbol{#2}}}
#1\processSymbol{#2}
\end{switch}
}


although the command set is arbitrary, a sample input for the sample code that I wrote would be something like:

vccb

which should in my full code return something that will look like:

P

because it would rotate, rotate and vertically flip the letter b.

I'm trying to figure out another way to do nested string parsing in this way. and I have a feeling that it can't be done with xstrings. If I need to switch to using LuaTex then so be it. just trying to do this in LaTeX before I need to learn Lua

• Please make your code compilable (if possible), or at least complete it with \documentclass{...}, the required \usepackage's, \begin{document}, and \end{document}. That is much more useful than a fragment as it can be copy-pasted and (try-to) compile to reproduce the issue. – cfr Feb 17 '15 at 2:23
• While I understand your point, my full code base and no subset thereof will compile. I also have a full understanding of why it won't compile and am really here to ask generally how to approach recursive string parsing, because my current approach is severely flawed because of how xstrings does its work. Essentially, anything I post would be pseudocode because I know what is wrong with my code (what's wrong is that I'm using xstring macros in a nested fashion) – Daniel Fallon Feb 17 '15 at 2:31

Here, I define macros for horizontal-relection, vertical-reflection, and clockwise rotation. I first show how they may be nested as \myvreflect{\myrotate{\myrotate{b}}}. I then show how macro \mytransform may be used to take shorthand, such as vccb to recursively accomplish the same thing.

(Note in my MWE, "vertical" is defined as "flip across a vertical axis" and not "vertically flip across a horizontal axis". I do this, so that I can match the OP's nomenclature. Likewise for "horizontal", meaning "flip across a horizontal axis".)

EDITED to handle null arguments. REEDITED to show how to operate recursively on arguments larger than a single character.

\documentclass{article}
\usepackage{graphicx}
\def\myhreflect#1{\scalebox{1}[-1]{#1}}
\def\myvreflect#1{\scalebox{-1}[1]{#1}}
\def\myrotate#1{\rotatebox{90}{#1}}
\newcommand\mytransform[1]{\mytransformhelp#1\relax\relax}
\def\mytransformhelp#1#2\relax{%
\if\relax#2\relax#1\else%
\if v#1\myvreflect{\mytransformhelp#2\relax}\else%
\if h#1\myhreflect{\mytransformhelp#2\relax}\else%
\if c#1\myrotate{\mytransformhelp#2\relax}%
\fi%
\fi%
\fi%
\fi%
}
\begin{document}
b \myvreflect{\myrotate{\myrotate{b}}}

\mytransform{hcb}

\def\x{test}
\mytransform{vcc\x}
\end{document}


Here is a method with xstring:

\documentclass{article}
\usepackage{xstring,graphicx}
\def\nestcommand#1#2{%
\ifx#1\relax \StrSubstitute#1\relax{#2\relax}[#1]%
\else        \StrSubstitute#1\relax{#2{\relax}}[#1]%
\fi
}
\def\processSymbol#1{%
\def\processcommand{\relax}%
\edef\tempcommandset{,\unexpanded\expandafter{\commandcharlist},}%
\def\remaining{#1}%
\saveexpandmode\expandarg\saveexploremode\exploregroups
\processSymbolRecurse
}
\def\processSymbolRecurse{%
\unless\ifx\remaining\empty
\StrSplit\remaining 1\firstchar\tempremaining
\IfSubStr\tempcommandset{\expandafter,\firstchar=}
{\let\remaining=\tempremaining
\StrBehind\tempcommandset{\expandafter,\firstchar=}[\currentcommand]%
\StrBefore\currentcommand,[\currentcommand]%
\nestcommand\processcommand\currentcommand
\expandafter\processSymbolRecurse
}
{\StrSubstitute\processcommand\relax\remaining[\processcommand]%
\restoreexpandmode\restoreexploremode
\expandafter\processcommand
}%
\fi
}
\begin{document}
\def\commandcharlist{r=\rotatebox{90},h=\scalebox{1}[-1],v=\scalebox{-1}[1],f=\fbox,b=\bfseries}%

\processSymbol{rhfy}% same as \rotate{90}{\scalebox{1}[-1]{\fbox{y}}}

\def\test{Test}
\processSymbol{fb\test} or \processSymbol{fbTest}

\def\test{b}
\processSymbol{hrr\test}
\end{document}


Here's an expl3 version. I'm not sure about what you want to achieve, so this is just an attempt.

A symbol that should be printed rather than interpreted must be enclosed in double braces.

\documentclass{article}
\usepackage{xparse}
\usepackage{graphicx}

\ExplSyntaxOn
\NewDocumentCommand\processSymbol{m}
{
\fallon_process_symbol:n { #1 }
}

\tl_new:N \l__fallon_tail_tl

\tl_const:Nn \c_fallon_bgroup_tl { \if_true: { \else: } \fi: }
\tl_const:Nn \c_fallon_egroup_tl { \if_false: { \else: } \fi: }

\cs_new_protected:Npn \fallon_process_symbol:n #1
{
\tl_clear:N \l__fallon_tail_tl
\tl_map_inline:nn { #1 }
{
\str_case:nnF { ##1 }
{
}
{
\fallon_output:n { ##1 }
}
}
}

{
\tl_put_right:Nn \l__fallon_head_tl { #1 \c_fallon_bgroup_tl }
\tl_put_left:Nn \l__fallon_tail_tl { \c_fallon_egroup_tl }
}

\cs_new_protected:Npn \fallon_output:n #1
{
\tl_put_right:Nn \l__fallon_head_tl { \exp_not:n { #1 } }
\tl_clear:N \l__fallon_tail_tl
}

\ExplSyntaxOff

\NewDocumentCommand\fhreflect{m}{\scalebox{1}[-1]{#1}}
\NewDocumentCommand\fvreflect{m}{\scalebox{-1}[1]{#1}}
\NewDocumentCommand\frotate{m}{\rotatebox{90}{#1}}

\begin{document}

\processSymbol{hc{{v}}}

\def\x{test}
\processSymbol{vcc\x}

\processSymbol{vccbvccy}

\end{document}


The various command letters are transformed into a command that's appended to a token list together with an implicit open brace and a matching implicit open brace is added in another token list. When a symbol that's not among the command letters is found, the token lists are joined, fully expanded and delivered; the process is started over.

I don't think you need any packages other than for the rotation, but I may have misunderstood as I get

But I don't think you specified what rotate was supposed to do exactly. (I assumed \rotatebox{90} here.

\documentclass{article}
\usepackage{graphicx}
\def\zz#1{\zzz#1\zzz}

\def\zzz#1{%
\expandafter\ifx\csname\string#1!\endcsname\relax
#1%
\expandafter\zzz
\else
\csname\string#1!\expandafter\endcsname
\fi}

\expandafter\def\csname\string\zzz!\endcsname{}

\expandafter\def\csname c!\endcsname#1\zzz{%
\rotatebox{90}{\zz{#1}}}

\expandafter\def\csname v!\endcsname#1\zzz{%
\scalebox{1}[-1]{\zz{#1}}}

\begin{document}

\zz{vccb}

\end{document}