Take the 2-minute tour ×
TeX - LaTeX Stack Exchange is a question and answer site for users of TeX, LaTeX, ConTeXt, and related typesetting systems. It's 100% free, no registration required.

\MakeUppercase and \uppercase use TeX's uccode, and they are not purely expandable. Say,

\edef\temp{\MakeUppercase{abc}}

will fail.

Sometimes purely expandable macros are very useful. They are robust, for example. I think we can use string substitution to implement such a function. Ideal result would be:

\Uppercase{abc} % expanded to -> ABC

And may also be:

\GetUppercase{abc} % \result is expanded to -> ABC

So far, what I can do, is this:

% \getuppercase{abc} => \result :-> A
\def\getupperchar#1{%
  \edef\result{\ifcase`#1\relax
     0\or 1\or 2\or 3\or 4\or 5\or 6\or 7\or 8\or 9\or
    10\or11\or12\or13\or14\or15\or16\or17\or18\or19\or
    20\or21\or22\or23\or24\or25\or26\or27\or28\or29\or
    30\or31\or32\or33\or34\or35\or36\or37\or38\or39\or
    40\or41\or42\or43\or44\or45\or46\or47\or48\or49\or
    50\or51\or52\or53\or54\or55\or56\or57\or58\or59\or
    60\or61\or62\or63\or64\or A\or B\or C\or D\or E\or
     F\or G\or H\or I\or J\or K\or L\or M\or N\or O\or
     P\or Q\or R\or S\or T\or U\or V\or W\or X\or Y\or
     Z\or91\or92\or93\or94\or95\or96\or A\or B\or C\or
     D\or E\or F\or G\or H\or I\or J\or K\or L\or M\or
     N\or O\or P\or Q\or R\or S\or T\or U\or V\or W\or
     X\or Y\or Z\or123\or124\or125\or126\or127\or128\or129\or
    \fi}}

And this can be used to implement a naive variant of mfirstuc:

% \getfirstupper{abc} => \result :-> Abc
\def\getfirstupper#1{%
  \getupperchar{#1}%
  \edef\result{\result\gobble#1}}
\def\gobble#1{}

However, I cannot implement the full \Uppercase or \GetUppercase this way. I wonder if there is a smart way to define such commands.

Any information is welcome. BTW, I know LuaTeX can be used, but I'm looking for a pure TeX solution.

share|improve this question
6  
While \uppercase isn't expandable, e.g. \edef\temp{\uppercase{abc}} doesn't work, it is normally used like this \uppercase{\def\temp{abc}}, which works fine. But you probably know this already. –  Martin Scharrer Feb 11 '11 at 0:26
3  
@Martin: Thanks. I'm not familar with uppercase/lowercase tricks. This should be an answer. –  Leo Liu Feb 11 '11 at 1:03
    
Please note that \uppercase doesn't work with special letters like German Umlauts and such. It simply changes all character tokens to uppercase and ignores all macros and active characters. –  Martin Scharrer Feb 11 '11 at 1:18
1  
> ... I'm looking for a pure TeX solution. I do not know of LuaTeX ‘s implementation, but in TeX, \uppercase and \lowercase are executed by the execution processor. They aren’t macro expansions like \number. I don’t think you will find a pure-TeX solution. –  Ahmed Musa Feb 11 '11 at 1:27
2  
@Ahmed: Indeed. That's why I (and @Bruno) do not use \uppercase here. –  Leo Liu Feb 11 '11 at 5:31

5 Answers 5

up vote 12 down vote accepted

For expl3, I wrote the following as the most robust approach I could find

\documentclass{article}
\usepackage{expl3}
\ExplSyntaxOn
\cs_new:Npn \tl_to_upper_case:n #1
  { \exp_args:Nf \__tl_to_upper_case:n {#1} }
\cs_new:Npn \__tl_to_upper_case:n #1
  { \__tl_to_upper_case:w #1 ~ \q_no_value \q_stop }
\cs_new:Npn \__tl_to_upper_case:w #1 ~ #2 \q_stop
  {
    \quark_if_no_value:nTF {#2}
      { 
        \tl_map_function:nN {#1} \__tl_to_upper_case_aux:N 
        \tl_trim_spaces:n { }
      }
      { \__tl_to_upper_case:w #1 { ~ } #2 \q_stop }
  }
\cs_new:Npn \__tl_to_upper_case_aux:N #1
  {
    \prg_case_str:nnn {#1}
      {
        { a } { \__tl_to_case_aux:nw { A } }
        { b } { \__tl_to_case_aux:nw { B } }
        { c } { \__tl_to_case_aux:nw { C } }
        { d } { \__tl_to_case_aux:nw { D } }
        { e } { \__tl_to_case_aux:nw { E } }
        { f } { \__tl_to_case_aux:nw { F } }
        { g } { \__tl_to_case_aux:nw { G } }
        { h } { \__tl_to_case_aux:nw { H } }
        { i } { \__tl_to_case_aux:nw { I } }
        { j } { \__tl_to_case_aux:nw { J } }
        { k } { \__tl_to_case_aux:nw { K } }
        { l } { \__tl_to_case_aux:nw { L } }
        { m } { \__tl_to_case_aux:nw { M } }
        { n } { \__tl_to_case_aux:nw { N } }
        { o } { \__tl_to_case_aux:nw { O } }
        { p } { \__tl_to_case_aux:nw { P } }
        { q } { \__tl_to_case_aux:nw { Q } }
        { r } { \__tl_to_case_aux:nw { R } }
        { s } { \__tl_to_case_aux:nw { S } }
        { t } { \__tl_to_case_aux:nw { T } }
        { u } { \__tl_to_case_aux:nw { U } }
        { v } { \__tl_to_case_aux:nw { V } }
        { w } { \__tl_to_case_aux:nw { W } }
        { x } { \__tl_to_case_aux:nw { X } }
        { y } { \__tl_to_case_aux:nw { Y } }
        { z } { \__tl_to_case_aux:nw { Z } }
      }
      { \__tl_to_case_aux:nw {#1 } }
  }
\cs_new:Npn \__tl_to_case_aux:nw #1#2 \tl_trim_spaces:n #3
  {
   #2
   \tl_trim_spaces:n { #3 #1 }
  }
\cs_set_eq:NN \MakeExpandableUppercase \tl_to_upper_case:n
\ExplSyntaxOff
\begin{document}
\MakeExpandableUppercase{Hello World}
\edef\test{\MakeExpandableUppercase{Hello World}}
\show\test
\MakeExpandableUppercase{Hello {World}}
\edef\test{\MakeExpandableUppercase{Hello {World}}}
\show\test
\edef\test{Hello\space\space World}
\MakeExpandableUppercase{\test}
\edef\test{\MakeExpandableUppercase{\test}}
\end{document}

The reason for the space stripping at the end of the input is that you can't avoid it at the start of the string, so I felt the best you could do was say 'spaces at the ends are stripped'. Spaces should be retained within the input. You can implement a lower case function in the same way, and if you do nesting

 \MakeExpandableUppercase{\MakeExpandableLowercase{Hello} World}

should work correctly. As illustrated by the last example, material is expanded before doing the case change. That applies even to protected macros, as the underlying expansion uses \romannumeral. So the argument needs to be made up of purely expandable material.

(As a note, this can of course be implemented without expl3.)


For completeness, a LuaTeX solution might read

\documentclass{article}
\usepackage{fontspec}
\newcommand*\MakeExpandableUppercase[1]{%
  \scantokens\expandafter{%
    \directlua{
      tex.write(string.upper("\luatexluaescapestring{\unexpanded{#1}}"))
    }%
  \noexpand
  }%
}%
\begin{document}
\MakeExpandableUppercase{hello world \oe}
\end{document}

(I'm no Lua expert: there may be a more efficient approach.)

share|improve this answer
    
Thank you @Joseph. I was searching it in source3. Although I know little about LaTeX3 syntax, it is of great help. –  Leo Liu Feb 11 '11 at 7:03
1  
@Leo. The above is currently in source3, as while I've proposed it as useful we have not yet got a consensus on that from all of the team. –  Joseph Wright Feb 11 '11 at 7:07
    
@Joseph: What can we do with non-English alphabets like \oe? –  Leo Liu Feb 11 '11 at 8:38
1  
@Leo: The bottom line is that the only way to do this expandably and deal with accents, etc., is at the engine level. That means only LuaTeX can offer a truly general solution, as this problem is trivial in Lua. –  Joseph Wright Feb 11 '11 at 8:57
1  
Programming in Lua, chapter 20: Both string.upper and string.lower follow the current locale. Therefore, if you work with the European Latin-1 locale, the expression string.upper("ação") results in "AÇÃO". And I suppose LuaTeX redefines this current locale thing to mean Unicode. –  Paŭlo Ebermann Feb 16 '11 at 12:10

Edit3: now the token list module in LaTeX3 provides \tl_expandable_uppercase:n and \tl_expandable_lowercase:n, which stem from that discussion but are more robust and much less greedy on the number of control sequences. Slower, as well.

EDIT2: after a first code which ate spaces and choked when it saw braces, and a second code which would crash for more than 600 or so tokens, I spent some time writing a clean code that still works with >5k tokens, although it gets slow. The new code actually lends itself to all sorts of generalizations (see near the bottom of the code). I got rid of the expansion control that was the cause of an "too many levels of expansion", and the code is now much less tricky.

(Sorry, code and explanations are long.) Now, after exactly three expansion steps, \Uppercase{ Hel{l }o\error World } expands to HEL{L }O\error WORLD, with spaces, braces, and macros kept (and not expanded).

Two ideas:

  • Check for braces and for spaces by using a delimited argument (see \UL_brace_check:nw and \UL_space_check:nw), after having placed a {\q_mark} \q_stop after all the tokens, to ensure that there is at least one brace or space after the argument.

  • Define tables of case change. For example, \UL_table_upper_p is a macro which expands to P, and \UL_table_lower_A expands to a. If the relevant entry of the table is not defined, then the token which is being read is not altered. See \UL_convert_token:nN for this. The last part of the code is all about setting up these tables ("case-tables"?).

We need to step inside brace groups and expand \UL_to_case:nn entirely before continuing. For this, we use \romannumeral-\\0`, closed by a space, which is introduced at the very end.

A few macros deserve some explanation.

  • \UL_expand_csname:n{...} replaces every \csname abc\endcsname construction by the corresponding \abc. I need this somewhere to explicit a csname which is quite deep in a definition.

  • \expandafter:nw{...}\foo will expand \foo before ....

  • \expandsome{\foo\expandthis\bar\baz\expandthis\foo{ABC}} will expand the macro following \expandthis once (that macro is allowed to take any kind of argument: in fact, we simply \expandafter it).

The code can also be found online. Finally, the code, with some tests at the end, and a few comments.

\catcode`\_=11\relax
\catcode`\:=11\relax

% ======================== Generic macros

% A few standard commands to manipulate arguments
\long\gdef\use_none:n#1{}
\long\gdef\use_none:nn#1#2{}
\long\gdef\use_i:nn#1#2{#1}
\long\gdef\use_ii:nn#1#2{#2}
\long\gdef\use_ii_i:nn#1#2{#2#1}
\long\gdef\use_ii_iii_i:nnn#1#2#3{#2#3#1}
\long\gdef\use_i_bbii:nn#1#2{#1{{#2}}}
\long\gdef\use_bii_bi:nn#1#2{{#2}{#1}}

% What expl3 calls "quarks", useful for |\ifx| comparisons.
\gdef\q_stop{\q_stop}
\gdef\q_mark{\q_mark}
\gdef\q_nil{\q_nil}
\long\gdef\use_none_until_q_stop:w#1\q_stop{}

% Two tests 
\long\gdef\UL_if_empty:nTF#1{%
  \expandafter\ifx\expandafter\q_nil\detokenize{#1}\q_nil%
  \expandafter\use_i:nn%
  \else%
  \expandafter\use_ii:nn%
  \fi}

\expandafter\long\expandafter\gdef\expandafter\UL_if_detok_qmark:wTF%
\expandafter#\expandafter1\detokenize{\q_mark}#2\q_stop{% 
  \UL_if_empty:nTF{#1}}

% ======================== Main command: |\UL_to_case:nn|
% Usage:       |\UL_to_case:nn{<table>}{<text>}|
% Expands in:  2 steps.
\long\gdef\UL_to_case:nn{\romannumeral\UL_to_case_aux:nn}
\long\gdef\UL_to_case_aux:nn#1#2{-`\0%
  \UL_brace_check:nw{#1}#2{\q_mark} \q_stop\UL_to_case_end:n{}}%

% Initially, I used |\q_mark{} \q_stop|: the braces and space are there
% to avoid runaway arguments in |\UL_brace_check:nw| and 
% |\UL_space_check:nw|, whose "w" arguments are delimited respectively
% by an open brace, and by a space. I changed to |{\q_mark} \q_stop|:
% then we only do the check for |\q_mark| in the case of a brace group, 
% and not at every step.

% |\UL_to_case_output:n| appends its argument to the argument of
% |\UL_to_case_end:n|.
\long\gdef\UL_to_case_output:n#1#2\UL_to_case_end:n#3{%
                                    #2\UL_to_case_end:n{#3#1}}
\long\gdef\UL_to_case_end:n#1{ #1}
% And |\UL_to_case_end:n| expands to 
% - a space, which stops the expansion of |\romannumeral-`\0|,
% - followed by its argument, which is the result we want.


% First, we check whether the next token is a brace. 
\long\gdef\UL_brace_check:nw#1#2#{%
  \UL_if_empty:nTF{#2}%
  {\UL_brace_yes:nn{#1}}%
  {\UL_space_check:nw{#1}#2}%
}
% If there is a brace, we might have reached {\q_mark}.
\long\gdef\UL_brace_yes:nn#1#2{%
  \expandafter\UL_if_detok_qmark:wTF \detokenize{#2 \q_mark}\q_stop{% 
    \use_none_until_q_stop:w% 
  }{% 
    \csname UL_table_#1_braces\endcsname{#1}{#2}%
    \UL_brace_check:nw{#1}%
  }%
}

% Then check whether the next token is a space.
\long\gdef\UL_space_check:nw#1#2 {%
  \UL_if_empty:nTF{#2}%
  {\UL_convert_token:nn{#1}{ }}%
  {\UL_convert_token:nn{#1}#2 }% we put the space back!
}

\long\gdef\UL_convert_token:nn#1#2{%
  \ifcsname UL_table_#1_\detokenize{#2}\endcsname%
  \expandafter\use_i:nn%
  \else%
  \expandafter\use_ii:nn%
  \fi% 
  {\csname UL_table_#1_\detokenize{#2}\endcsname}%
  {\csname UL_table_#1_default\endcsname{#2}}%
  \UL_brace_check:nw{#1}% Do the next token.
}


% ======================== Casecode tables.
% ============ Generic setup.
% Typical use:
% - |\UL_setup:nnn{u}{a}{A}| to define |a| uppercased as |A|.
% - |\UL_setup_cmd:nnpn{ULnil}{\NoCaseChange}#1{%
%      \UL_to_case_output:n{#1}}|
% Note that for the second, we have to grab all the arguments in one go.
% Also note that the second should not be used until we define the ULec 
% and ULea tables below.
%
% - |\UL_set_eq:nnnn{tableA}{tokenA}{tableB}{tokenB}| sets the entry
% |tokenA| of the table |tableA| to be equal to the entry |tokenB| of the
% table |tokenB|.
% - |\UL_new_table:nn{tableA}{tableB}| creates a new table, |tableA|, 
% which is a copy of |tableB|.

\protected\long\gdef\UL_content_of_table_add:nn#1#2{%
  \long\expandafter\gdef\csname UL_table_#1%
  \expandafter\expandafter\expandafter\endcsname%
  \expandafter\expandafter\expandafter{%
    \csname UL_table_#1\endcsname{#2}}%
}

\protected\long\gdef\UL_setup:nnn#1#2#3{%
  \UL_content_of_table_add:nn{#1}{#2}%
  \expandafter\long\expandafter\gdef%
  \csname UL_table_#1_\detokenize{#2}\endcsname%
  {\UL_to_case_output:n{#3}}%
}

\protected\long\gdef\UL_setup_cmd:nnpn#1#2#3#{%
  \UL_content_of_table_add:nn{#1}{#2}%
  \UL_expand_csname:n{%
    \long\gdef\csname UL_table_#1_\detokenize{#2}\endcsname##1##2{%
      \expandafter:nw{\use_ii_i:nn{##1{##2}}}%
      \csname UL_table_#1_\detokenize{#2}_aux\endcsname}%
  }%
  \use_i_bbii:nn{\expandafter\long\expandafter\gdef%
    \csname UL_table_#1_\detokenize{#2}_aux\endcsname#3}%
}

\protected\long\gdef\UL_set_eq:nnnn#1#2#3#4{%
  \UL_content_of_table_add:nn{#1}{#2}%
  {\expandafter}\expandafter\global\expandafter\let%
  \csname UL_table_#1_\detokenize{#2}\expandafter\endcsname%
  \csname UL_table_#3_\detokenize{#4}\endcsname%
}

\long\gdef\UL_new_table:nn#1#2{%
  \ifcsname UL_table_#1\endcsname%
  \PackageError{ULcase}{Table \detokenize{#1} already defined!}{}%
  \fi%
  \long\expandafter\gdef\csname UL_table_#1\endcsname{}%
  %
  \def\UL_tmpA{#1}%
  \def\UL_tmpB{#2}%
  \expandafter\expandafter\expandafter\UL_new_table_aux:nnn%
  \csname UL_table_#2\endcsname{}%
}
\long\gdef\UL_new_table_aux:nnn#1{%
  \UL_if_empty:nTF{#1}{}{%
    \UL_set_eq:nnnn{\UL_tmpA}{#1}{\UL_tmpB}{#1}%
    \UL_new_table_aux:nnn%
  }%
}%
\long\gdef\UL_new_table:n#1{\UL_new_table:nn{#1}{ULnil}}




% ============ Table ULea, \expandafter:nw
% 
% The |ULea| table puts |\expandafter| after each token (including braces
% and spaces). Allows us to define |\expandafter:nw|, which expands what
% follows its first argument once. 
% 
% |\expandafter:nw| takes 2-steps to act. For a 1-step version, use 
% |\MEA_trigger:f\MEA_expandafter:nw|. 

\long\gdef\UL_table_ULea_default#1{\UL_to_case_output:n{\expandafter#1}}%
\long\gdef\UL_table_ULea_braces#1#2{%
  \expandafter\expandafter\expandafter\UL_to_case_output:n%
  \expandafter\expandafter\expandafter{%
    \expandafter\expandafter\expandafter\expandafter%
    \expandafter\expandafter\expandafter{%
      \UL_to_case:nn{#1}{#2}\expandafter}%
  }%
}
\let\MEA_trigger:f\romannumeral
\def\MEA_expandafter:nw{\UL_to_case_aux:nn{ULea}}
\def\expandafter:nw{\MEA_trigger:f\MEA_expandafter:nw}


% ============ Table |ULec|, |\UL_expand_csname:n|
% The |ULec| table expands only the 
% |\csname ...\endcsname| constructions.
% 
\long\gdef\UL_table_ULec_default{\UL_to_case_output:n}%
\long\gdef\UL_table_ULec_braces#1#2{%
  \expandafter\expandafter\expandafter\UL_to_case_output:n%
  \expandafter\expandafter\expandafter{%
    \expandafter\expandafter\expandafter{\UL_to_case:nn{#1}{#2}}%
  }%
}
\long\expandafter\gdef\csname%
  UL_table_ULec_\detokenize{\csname}\endcsname#1#2{%
  \expandafter:nw{\use_ii_iii_i:nnn{#1{#2}}}%
  \expandafter\UL_to_case_output:n\csname%
}%

\def\UL_expand_csname:n{\MEA_trigger:f\UL_to_case_aux:nn{ULec}}


% ============ Table |ULexpandsome|, |\expandsome|
% The |ULexpandsome| table expands only the tokens following |\expandthis|.
% 
\long\gdef\UL_table_ULexpandsome_default{\UL_to_case_output:n}%
\long\gdef\UL_table_ULexpandsome_braces#1#2{%
  \expandafter\expandafter\expandafter\UL_to_case_output:n%
  \expandafter\expandafter\expandafter{%
    \expandafter\expandafter\expandafter{\UL_to_case:nn{#1}{#2}}%
  }%
}
\long\expandafter\gdef\csname%
  UL_table_ULexpandsome_\detokenize{\expandthis}\endcsname#1#2{%
  \expandafter:nw{#1{#2}}%
  %\expandafter\UL_to_case_output:n\csname%
}%

\def\expandsome{\MEA_trigger:f\UL_to_case_aux:nn{ULexpandsome}}


% ============ The default table, ULnil
\long\gdef\UL_table_ULnil{{default}{braces}{$}}%$
\long\gdef\UL_table_ULnil_default{\UL_to_case_output:n}
\long\gdef\UL_table_ULnil_braces#1#2{%
  \expandafter\expandafter\expandafter\UL_to_case_output:n%
  \expandafter\expandafter\expandafter{%
    \expandafter\expandafter\expandafter{\UL_to_case:nn{#1}{#2}}%
  }%
}
\UL_setup_cmd:nnpn{ULnil}{\NoCaseChange}#1{%
  \UL_to_case_output:n{#1}}


% ============ Working on math mode.
% 
% We add \q_mark so that \UL_dollar_aux:nw can read to the next dollar
% without unbracing the argument, so that ${...}$ --x-> $...$
\long\expandafter\gdef\csname UL_table_ULnil_\detokenize{$}\endcsname#1#2{%$
    \UL_dollar_aux:nw{#1{#2}}\q_mark%
}
% Grab until the next dollar, so #2={\q_mark Math Stuff}. 
% If \use_none:n #2 is empty, then we had only grabbed `\q_mark`, 
% which means there was $$, and we need to redo the same business. 
% Otherwise, we output, after stripping the \q_mark.
\long\gdef\UL_dollar_aux:nw#1#2${%$%
  \expandafter\UL_if_empty:nTF\expandafter{\use_none:n#2}{% eats \q_mark
    \UL_bidollar:nw{#1}\q_mark%
  }{%
    \expandafter\UL_to_case_output:n\expandafter{%
      \expandafter$\use_none:n#2$}#1%
  }%
}
\long\gdef\UL_bidollar:nw#1#2$${%
  \expandafter\UL_to_case_output:n\expandafter{%
    \expandafter$\expandafter$\use_none:n#2$$}#1}



% =========== Lowercase, Uppercase, Caesar
\long\gdef\Lowercase{\UL_to_case:nn{lower}}
\long\gdef\Uppercase{\UL_to_case:nn{upper}}
\long\gdef\CaesarCipher{\UL_to_case:nn{caesar}}

% Setup the uppercase and lowercase tables.
\UL_new_table:n{lower}
\UL_new_table:n{upper}

\protected\long\gdef\UL_setup_lower_upper:n#1{%
  \UL_if_empty:nTF{#1}{}{%
    \UL_setup:nnn{upper}#1%
    \expandafter:nw{\UL_setup:nnn{lower}}\use_bii_bi:nn#1%
    \UL_setup_lower_upper:n%
  }%
}
% should become user-firendly.
\UL_setup_lower_upper:n {{a}{A}} {{b}{B}} {{c}{C}} {{d}{D}} {{e}{E}} 
{{f}{F}} {{g}{G}} {{h}{H}} {{i}{I}} {{j}{J}} {{k}{K}} {{l}{L}} {{m}{M}} 
{{n}{N}} {{o}{O}} {{p}{P}} {{q}{Q}} {{r}{R}} {{s}{S}} {{t}{T}} {{u}{U}} 
{{v}{V}} {{w}{W}} {{x}{X}} {{y}{Y}} {{z}{Z}} {{\ae}{\AE}} {{\oe}{\OE}} 
{}


% Just for fun, we define the Caesar cipher.
\UL_new_table:n{caesar}
\begingroup
  \lccode`\x=1\relax
  \loop
    \lccode`\X=\numexpr\lccode`\x+2\relax
    \lowercase{\UL_setup:nnn{caesar}{x}{X}}%
    \lccode`\x=\numexpr\lccode`\x+1\relax
  \unless\ifnum\lccode`\x>126\relax
  \repeat
\endgroup
\UL_setup:nnn{caesar}{ }{ }




% ====== Various tests
\long\gdef\checkoutput{\ifx\a\b\message{Correct}\else\show\WRONG\fi}

\long\gdef\expandonce#1{% redefines #1 as #1 expanded once.
  \long\xdef#1{\unexpanded\expandafter\expandafter\expandafter{#1}}}
\def\0{\1}\def\1{\2}\def\2{\3}\def\3{\4}\def\4{\5}


% \Uppercase, \Lowercase, \NoCaseChange work (+ nesting)
% Spaces and braces are fine.
\long\gdef\a{\Uppercase{ Hello, { } W\Lowercase{O}r\NoCaseChange{lD}! }}
\expandonce\a\expandonce\a\expandonce\a
\long\gdef\b{ HELLO, { } W\Lowercase{O}RlD! }
\checkoutput

% Another test.
\long\gdef\a{\Lowercase{He l%
    \NoCaseChange{\Uppercase{ Lp\NoCaseChange{ o}}}o }}
\expandonce\a\expandonce\a\expandonce\a
\long\gdef\b{he l\Uppercase{ Lp\NoCaseChange{ o}}o }
\checkoutput
\long\edef\a{\a}
\long\gdef\b{he l LP oo }
\checkoutput

% Math works (both $$ and $). Nesting does not break, 
% although we would wish for better (i.e. "Letter"-> "letter").
\long\gdef\a{\Lowercase{{t}ExT, $$\frac{A}{B}$$ and $(\mbox{Letter $A$})$}}
\expandonce\a\expandonce\a\expandonce\a
\long\gdef\b{{t}ext, $$\frac{A}{B}$$ and $(\mbox{Letter $A$})$}
\checkoutput

\edef\a{\CaesarCipher{a{b}cdef@ ABCX}}
\edef\b{c{d}efghB CDEZ}
\checkoutput


\long\gdef\a{\Uppercase{%
    \0{ a${} {{abd}+cd}$\0{b$${\d $0$}$$ }}%
    \NoCaseChange{ Ac dD\relax\0ii}i cd }%
}
\expandonce\a\expandonce\a\expandonce\a
\long\gdef\b{\0{ A${} {{abd}+cd}$\0{B$${\d $0$}$$ }} %
  Ac dD\relax\0iiI CD }%
\checkoutput



% More on braces, spaces, and expansion (nothing is expanded, 
% as we expect).
\long\gdef\a{\Lowercase{ {} \0 { b{C} {dB\AE~}} \0{\0} }}
\expandonce\a\expandonce\a\expandonce\a
\long\gdef\b{ {} \0 { b{c} {db\ae ~}} \0{\0} }
\checkoutput

% Testing the ULec table (expanding only \csname)
\long\gdef\a{\UL_expand_csname:n{ \hello 
    {\csname Hdsf\endcsname}##1\space \csname el\endcsname{ }lo, my name}}
\expandonce\a\expandonce\a
\long\gdef\b{ \hello {\Hdsf}##1\space \el{ }lo, my name}
\checkoutput


% Custom table.
\UL_new_table:n{mytable}
\UL_setup:nnn{mytable}{h}{Hello}
\long\gdef\a{\UL_to_case:nn{mytable}{h{ h} {}\space \h}}
\expandonce\a\expandonce\a\expandonce\a\expandonce\a
\long\gdef\b{Hello{ Hello} {}\space \h}
\checkoutput


\def\mydo#1#2{(#1)-(#2)}
\long\gdef\a{\expandsome{\0\0{\expandthis\mydo{\0\expandthis\0}\0\0}}}
\expandonce\a\expandonce\a
\long\gdef\b{\0\0{(\0\1)-(\0)\0}}
\checkoutput

\long\gdef\a{\Uppercase{\NoCaseChange{The quick brown fox jumps over the lazy dog.} The quick brown fox jumps over the lazy dog. \NoCaseChange{The quick brown fox jumps over the lazy dog.} The quick brown fox jumps over the lazy dog. \NoCaseChange{The quick brown fox jumps over the lazy dog.} The quick brown fox jumps over the lazy dog. \NoCaseChange{The quick brown fox jumps over the lazy dog.} The quick brown fox jumps over the lazy dog. \NoCaseChange{The quick brown fox jumps over the lazy dog.} The quick brown fox jumps over the lazy dog. \NoCaseChange{The quick brown fox jumps over the lazy dog.} The quick brown fox jumps over the lazy dog. \NoCaseChange{The quick brown fox jumps over the lazy dog.} The quick brown fox jumps over the lazy dog. }}
\begingroup\tracingall\tracingonline=0\relax
\expandonce\a\expandonce\a\expandonce\a
\endgroup
\long\gdef\b{The quick brown fox jumps over the lazy dog. THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. The quick brown fox jumps over the lazy dog. THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. The quick brown fox jumps over the lazy dog. THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. The quick brown fox jumps over the lazy dog. THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. The quick brown fox jumps over the lazy dog. THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. The quick brown fox jumps over the lazy dog. THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. The quick brown fox jumps over the lazy dog. THE QUICK BROWN FOX JUMPS OVER THE LAZY DOG. }
\checkoutput
share|improve this answer
    
@Bruno: Repetitive calls to \defupper doesn’t seem attractive. How many \upper@xxx would you need? All the letters of the alphabet? And I don’t see how \EA\def\EA\foo\EA{\Uppercase{abz:}} will do the whole thing. It will only expand \Uppercase once. I assume \EA stands for \expandafter. –  Ahmed Musa Feb 11 '11 at 3:13
    
I am sorry, I didn't see it: \EA stands for seven \expandafter's. –  Ahmed Musa Feb 11 '11 at 3:34
1  
Thank you @Bruno. I like this solution. It works like toupper in C/C++, and is indeed expandable. –  Leo Liu Feb 11 '11 at 5:45
    
And we can test \ifcsname upper@#1\endcsname to get rid of \defupper{:}{:} etc. –  Leo Liu Feb 11 '11 at 5:46
1  
@Hendrik: Indeed there is. See news.gmane.org/group/gmane.comp.tex.latex.latex3 for the archive –  Joseph Wright Feb 13 '11 at 15:56

I use the following to get a fully expanded string with the first letter capitalized. I needed it to write the string to the AUX file as part of a message. It was posted long ago by Dan Luecking on CTT. The command \makefirstcap store the expanded string in \firstcaphold. You can make your own varients of this.

\documentclass{article}

\def\makefirstcap#1#2\nil{%
    \iffalse{\fi
    \uppercase{\edef\firstcaphold{\iffalse}\fi#1}#2}}

\begin{document}
\makefirstcap test\nil
\show\firstcaphold
\end{document} 
share|improve this answer
    
The \iffalse's are not necessary here. See above/below. –  Ahmed Musa Feb 11 '11 at 3:49
    
Thank you. I remembered that I have met this code before. –  Leo Liu Feb 11 '11 at 5:38
\def\makefirstcap#1#2\@nil{%
    \toks@{#2}%
    \uppercase{\edef\firstcaphold{#1\the\toks@}}%
}

% Test:

\makefirstcap test\@nil
\show\firstcaphold
share|improve this answer
    
Thank you, @Ahmed. –  Leo Liu Feb 11 '11 at 5:39
    
But it's not expandable! –  Joseph Wright Feb 11 '11 at 6:37
    
@Joseph: \uppercase isn't expandable anyway. –  Ahmed Musa Feb 11 '11 at 6:52
6  
I know :-) My understanding was that was the point of the question! –  Joseph Wright Feb 11 '11 at 6:57

Here is a tentative short solution. The only flaw I see so far with this solution is outer brace stripping of arguments when \ifconvertcs is false. I may find the time to look into that later. There may be more traps: eg, spaces. Converting to lowercase uses the same \lucasemap and requires only one additional macro (\lowercase@@do). Please comment.

% Preliminaries:
\catcode`\:=11
\newcommand*\ifstrcmp:TF[2]{%
  \@nameuse{@\ifnum\pdfstrcmp{\detokenize{#1}}%
  {\detokenize{#2}}=\z@ first\else second\fi oftwo}%
}
\let\@rnnm\romannumeral
\newcommand*\ifbool:TF[1]{%
  \@nameuse{@\@nameuse{if#1}first\else second\fi oftwo}%
}
\newcommand*\ifx:TF[2]{%
  \@nameuse{@\ifx#1#2\@empty first\else second\fi oftwo}%
}
% Should control sequences (cs) also be converted to lower or uppercase?
\newif\ifconvertcs
\convertcstrue
\def\everyscantokens{%
  \everyeof{\noexpand}%
  \endlinechar\m@ne
  \makeatletter
}
% The solution:
\long\def\ExpandableUppercase#1{%
  \ifbool:TF{convertcs}{%
    \scantokens\expandafter{\expandafter\protect
    \@rnnm-`\q\expandafter\uppercase@loop\detokenize{#1}\@nnil}%
  }{%
    \expandafter\protect\@rnnm-`\q\uppercase@loop#1\@nnil
  }%
}
\def\uppercase@loop#1{%
  \ifx:TF#1\@nnil{ }{\uppercase@do{#1}\uppercase@loop}%
}
\def\lucase@do#1{\expandafter\noexpand\expandafter#1\@rnnm-`\q}
\def\lucasemap{%
  {a}{A}{b}{B}{c}{C}{d}{D}{e}{E}{f}{F}{g}{G}{h}{H}{i}{I}{j}%
  {J}{k}{K}{l}{L}{m}{M}{n}{N}{o}{O}{p}{P}{q}{Q}{r}{R}{s}{S}%
  {t}{T}{u}{U}{v}{V}{w}{W}{x}{X}{y}{Y}{z}{Z}\lu@nil\lu@nil
}
\def\uppercase@do#1{%
  \expandafter\uppercase@@do\lucasemap\cpt@nil{#1}%
}
\def\uppercase@@do#1#2#3\cpt@nil#4{%
  \ifstrcmp:TF{#1}\lu@nil{%
    \lucase@do{#4}%
  }{%
    \ifstrcmp:TF{#1}{#4}{%
      \lucase@do{#2}%
    }{%
      \uppercase@@do#3\cpt@nil{#4}%
    }%
  }%
}

% Tests:
{
\everyscantokens
\let\@display@protect\string
%\let\protect\@unexpandable@protect
%\let\protect\@typeset@protect
%\let\protect\@display@protect
\let\protect\noexpand
\edef\x{\ExpandableUppercase{{\oe}{x}a}}
\toks@\expandafter{\x}
\ExpandableUppercase{\oe} % needs document
\edef\x{\ExpandableUppercase{abcd}}
\show\x

\def\abcd{abcd}
\def\ABCD{ABCD}
\convertcstrue
\edef\x{\ExpandableUppercase{\abcd}}
\show\x
\edef\x{\ExpandableUppercase{\ABCD}}
\show\x
}

\catcode`\:=12
share|improve this answer
    
Thank you for your answer. –  Leo Liu Feb 15 '11 at 21:21

Your Answer

 
discard

By posting your answer, you agree to the privacy policy and terms of service.

Not the answer you're looking for? Browse other questions tagged or ask your own question.