Parser for decimal numbers in (plain) TeX

Question

I need help writing a parser for decimal numbers using only TeX and plain TeX. The set of accepted inputs is given by the regular expression:

(+-)?(0-9)*(.,)?(0-9)+

The parser need not do anything other than typeset the sign, the integer part and the fractional part.

EDIT:

It looks like this question needs some clarification so here it is. I am trying to design and implement a macro (similar to \num) that will read a number passed as an argument and format it in its own way. So far I've broken down this task to the following steps:

1. check if the argument is a valid number, i.e. if it agrees with the regular expression above (this is the difficult part for me to do in TeX). I would specifically like to know if we can detect spaces in a macro argument, e.g. in "12 345", "12 .3", "12. 34", "- 1", "+ 1", and how to detect other non-digits in a macro argument such as primitive control sequences and letters (\num does it);

2. "extract" the sign, the integer part and the decimal part, each in a separate macro (I recon this is easy to do once I know how to implement step 1);

3. format and typeset the number given the macros with the sign, the integer and the fractional parts (already implemented).

So, basically I need help with step 1.

EDIT 2:

In the regular expression above, ? means zero or one occurrence of a character from the preceding set, * means zero or more occurrences, + -- one or more occurrences.

Answer 1

EDITED to seamlessly handle dots and/or commas as the decimal separator.

REEDITED to provide error checking. The error handler works by pre-processing the string and removing "numerically valid" tokens from it (any numeral, leading + or -, and a single . or ,). If the processed string is not a null string at the end of this error-checking process, then it implies the number is formatted incorrectly and sets an error flag.

If no error is found, then the normal parsing is invoked to extract, successively, a leading + or -, the pre-decimal portion, and the post-decimal portion from the original argument.

\def\parsenum#1{%
\leavevmode\llap{#1} %REMOVE THIS ECHO LINE FOR GENERAL USE
  \errcheck{#1}%
  \if T\badchars \def\errcode{1}\def\psign{}\def\pint{}\def\pdec{}\else%
    \def\errcode{0}%
    \expandafter\parsedots#1,\relax%
    \expandafter\parsesign\pdots\relax\relax\relax%
  \fi%
}
\def\parsedots#1,#2\relax{\ifx\relax#2\relax\gdef\pdots{#1}\else%
  \parsedotshelper#1.#2\fi}
\def\parsedotshelper#1,{\gdef\pdots{#1}}
\def\parsesign#1#2\relax{%
  \if+#1\gdef\psign{#1}\parseint#2.\relax\relax\else%
    \if-#1\gdef\psign{#1}\parseint#2.\relax\relax\else%
      \gdef\psign{+}\parseint#1#2.\relax\relax%
    \fi%
  \fi%
}
\def\parseint#1.#2\relax{\gdef\pint{#1}\parsedec#2.\relax}
\def\parsedec#1.#2\relax{\gdef\pdec{#1}}

\def\errcheck#1{%
  \def\dwindling{}%
  \rmplus#1\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmminus\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmone\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmtwo\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmthree\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmfour\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmfive\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmsix\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmseven\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmeight\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmnine\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmzero\tmp\relax\relax%
  \edef\tmp{\dwindling}\def\dwindling{}%
  \expandafter\rmdot\tmp\relax\relax%
  \if F\dotfind%
    \edef\tmp{\dwindling}\def\dwindling{}%
    \expandafter\rmcomma\tmp\relax\relax%
  \fi
  \if\relax\dwindling\relax\gdef\badchars{F}\else\gdef\badchars{T}\fi%
}
\def\rmplus#1#2\relax{\if+#1\edef\dwindling{\dwindling#2}\else%
  \edef\dwindling{\dwindling#1#2}\fi%
}
\def\rmminus#1#2\relax{\if-#1\edef\dwindling{\dwindling#2}\else%
  \edef\dwindling{\dwindling#1#2}\fi%
}
\def\rmone#1#2\relax{\if1#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmone#2\relax\fi
}
\def\rmtwo#1#2\relax{\if2#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmtwo#2\relax\fi
}
\def\rmthree#1#2\relax{\if3#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmthree#2\relax\fi
}
\def\rmfour#1#2\relax{\if4#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmfour#2\relax\fi
}
\def\rmfive#1#2\relax{\if5#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmfive#2\relax\fi
}
\def\rmsix#1#2\relax{\if6#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmsix#2\relax\fi
}
\def\rmseven#1#2\relax{\if7#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmseven#2\relax\fi
}
\def\rmeight#1#2\relax{\if8#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmeight#2\relax\fi
}
\def\rmnine#1#2\relax{\if9#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmnine#2\relax\fi
}
\def\rmzero#1#2\relax{\if0#1\else\edef\dwindling{\dwindling#1}\fi%
  \ifx\relax#2\relax\else\expandafter\rmzero#2\relax\fi
}
\def\rmdot#1#2\relax{\if.#1\edef\dwindling{\dwindling#2}\def\dotfind{T}\else%
  \edef\dwindling{\dwindling#1}%
  \ifx\relax#2\relax\def\dotfind{F}\else\expandafter\rmdot#2\relax\fi\fi
}
\def\rmcomma#1#2\relax{\if,#1\edef\dwindling{\dwindling#2}\else%
  \edef\dwindling{\dwindling#1}%
  \ifx\relax#2\relax\else\expandafter\rmcomma#2\relax\fi\fi
}

\parsenum{123} [\psign][\pint][\pdec]:\errcode\par
\parsenum{+123.34} [\psign][\pint][\pdec]:\errcode\par
\parsenum{-123.} [\psign][\pint][\pdec]:\errcode\par
\def\x{-123}\parsenum{\x} [\psign][\pint][\pdec]:\errcode\par
\parsenum{+123,34} [\psign][\pint][\pdec]:\errcode\par
\parsenum{-123,} [\psign][\pint][\pdec]:\errcode\par
\def\x{-123,45}\parsenum{\x} [\psign][\pint][\pdec]:\errcode\par
\parsenum{-123,A} [\psign][\pint][\pdec]:\errcode\par
\parsenum{X-123,} [\psign][\pint][\pdec]:\errcode\par
\parsenum{12+3,} [\psign][\pint][\pdec]:\errcode\par
\parsenum{-12-3,} [\psign][\pint][\pdec]:\errcode\par
\parsenum{-123,2,5} [\psign][\pint][\pdec]:\errcode\par
\parsenum{-123,2.5} [\psign][\pint][\pdec]:\errcode\par
\bye

Answer 2

this version is not expandable but it doesn't need any terminator, it just gobbles up as far as the end of the number. It is restricted to integers that fit in a tex count register.

\newcount\ca
\newcount\cb
\def\p#1{%
\def\digitone{}%
\ifx+#1\def\sign{#1}\else
\ifx-#1\def\sign{#1}\else
\def\sign{}\def\digitone{#1}\fi\fi
\afterassignment\n\ca=1\digitone}

\def\n#1{%
\def\digitone{}%
\ifx,#1\def\point{#1}\else
\ifx.#1\def\point{.}\else
\def\point{}\def\digitone{#1}\fi\fi
\afterassignment\nn\cb=1\digitone}

\def\gobble#1{}

\def\nn{\par
[sign=\sign]
[n1=\expandafter\gobble\the\ca]
[point=\point]
[n2=\expandafter\gobble\the\cb]
\par}


\p 123 hello \p456,99 hafa \p ggg \p-12,88

\bye

Answer 3

The code inside siunitx (v2) uses a loop over each token in the input before comparing this to the various lists of possible 'number parts'. As that process cannot make assumptions about the nature of the tokens and as it covers a variety of input forms, it's rather complex. I'm currently re-writing it all to be more efficient and clear but the need to work with a range of inputs means its still non-trivial.

With the more restricted input form given here a number of concepts can be hard-coded to produce a much faster parser. For example, the following uses a simple token-by-token loop over the input with the knowledge that the first token can be a + or -, other tokens can be 01234567890 and that exactly one . or , is allowed to break between the integer and decimal parts.

\catcode`\@=11 %
\def\num#1{%
  \begingroup
    \edef\num@temp{#1}%
    \def\num@int@part{}%
    \def\num@dec@part{}%
    \ifx\num@temp\empty
    \else
      \expandafter\num@first\num@temp\num@stop 
    \fi
    \ifx\num@int@part\empty
      \ifx\num@dec@part\empty
        \ERROR
      \fi
    \fi
    $
      \num@sign@part
      \ifx\num@int@part\empty
        0%
      \else
        \num@int@part
      \fi
      \ifx\num@dec@part\empty
      \else
        .\num@dec@part
      \fi  
    $%
  \endgroup
}
\def\num@first#1#2\num@stop{%
  \ifnum
    \ifx#1+ 1\fi
    \ifx#1- 1\fi
    0>0 %
    \def\num@sign@part{#1}%
    \expandafter\num@first@auxi
  \else
    \def\num@sign@part{}%
    \expandafter\num@first@auxii
  \fi
    {#1}{#2}%
}
\def\num@first@auxi#1#2{\num@int#2\num@stop}
\def\num@first@auxii#1#2{\num@int#1#2\num@stop}
\def\num@int#1{%
  \ifx\num@stop#1%
  \else
    \ifnum
      \ifx#1. 1\fi
      \ifx#1, 1\fi
      0>0 %
      \expandafter\expandafter\expandafter\num@dec
    \else
      \num@digit@check#1\num@int@part
      \expandafter\expandafter\expandafter\num@int
    \fi
  \fi
}
\def\num@dec#1{%
  \ifx\num@stop#1%
  \else
    \num@digit@check#1\num@dec@part
    \expandafter\num@dec
  \fi
}

\def\num@digit@check#1#2{%
  \begingroup
    \def\num@digit@check@aux##1#1{}%
    \toks0\expandafter{\num@digit@check@aux0123456789{}{}#1}%
    \edef\num@digit@check@aux{\the\toks0}%
  \expandafter\endgroup
  \ifx\num@digit@check@aux\empty
    \def#2{}%
    \ERROR
  \else
    \edef#2{#2#1}%
  \fi
}
\def\num@stop{\num@stop}
\long\def\gobble#1{}
\num{1234.56789010}
\bye

I've used a simple error trap: an undefined control sequence. A real version would of course need to be a bit more verbose here.

Spaces in arguments are awkward. In siunitx I simply ignore them, which is easy as a normal token-based mapping will do it at the TeX level. If you really want to check for spaces in such a case it is doable but more tedious and I'm not sure worth the effort. (Usually the input should be something 'reasonable'.)

In my revisions for siunitx I'm going with a path a bit more like Steven B. Segletes's answer. For me, that makes sense as I can divide up parts with different restrictions and only need a subset of tests. With the simpler number here such division is probably not much of a saving so I've gone with a single mapping.

---

An alternative approach to checking the digits is to use TeX, which limits us to the range for count registers but does avoid needing a loop over everything. That might for example read

\catcode`\@=11 %
\def\num#1{%
  \begingroup
    \edef\num@temp{#1}%
    \def\num@int@part{}%
    \def\num@dec@part{}%
    \ifx\num@temp\empty
    \else
      \expandafter\num@first\num@temp\num@stop 
    \fi
    \ifx\num@int@part\empty
      \ifx\num@dec@part\empty
        \ERROR
      \fi
    \fi
    $
      \num@sign@part
      \ifx\num@int@part\empty
        0%
      \else
        \num@int@part
      \fi
      \ifx\num@dec@part\empty
      \else
        .\num@dec@part
      \fi  
    $%
  \endgroup
}
\def\num@first#1#2\num@stop{%
  \ifnum
    \ifx#1+ 1\fi
    \ifx#1- 1\fi
    0>0 %
    \def\num@sign@part{#1}%
    \expandafter\num@first@auxi
  \else
    \def\num@sign@part{}%
    \expandafter\num@first@auxii
  \fi
    {#1}{#2}%
}
\def\num@first@auxi#1#2{\num@int{#2}}
\def\num@first@auxii#1#2{\num@int{#1#2}}
\def\num@int#1{%
  \ifx\relax#1\relax
    \expandafter\gobble
  \else
    \expandafter\num@int@auxi
  \fi
    {#1}%
}
\def\num@int@auxi#1{\num@int@auxii#1\num@stop}
\def\num@int@auxii#1#2\num@stop{%
  \ifnum
    \ifx#1. 1\fi
    \ifx#1, 1\fi
    0>0 %
      \num@dec{#1#2}%
  \else
    \num@digit@check{#1#2}\num@int@part\num@dec
  \fi
}
\def\num@dec#1{%
  \ifx\relax#1\relax
  \else
    \num@dec@auxi#1\num@stop
  \fi
}
\def\num@dec@auxi#1#2\num@stop{%
   \num@dec@auxii{#2}%
}
\def\num@dec@auxii#1{%
  \ifx\relax#1\relax
  \else
    \num@dec@auxiii#1\num@stop
  \fi
}
\def\num@dec@auxiii#1#2\num@stop{%
  \ifnum
    \ifx#1+ 1\fi
    \ifx#1- 1\fi
    0>0 %
    \ERROR
  \else
    \num@digit@check{#1#2}\num@dec@part\num@end
  \fi
}
\def\num@end#1{%
  \ifx\relax#1\relax\else\ERROR\fi
}
\def\num@digit@check#1#2#3{%
  \begingroup
    \def\num@digit@check@aux##1\relax{%
      \edef\num@digit@check@aux{%
        \def\noexpand#2{\the\count0 }%
        \noexpand#3{##1}%
      }%
    }%
    \afterassignment\num@digit@check@aux\count0=#1\relax
  \expandafter\endgroup
  \num@digit@check@aux
}

\def\num@stop{\num@stop}
\long\def\gobble#1{}

\num{1234.56789010}
\bye

Again, I've not forbidden every possible space: doable but tedious and I'd rather not!