asciimth.sty

\NeedsTeXFormat{LaTeX2e}[1994/12/01]
\ProvidesPackage{asciimth}[2009/12/11 v0.1 ASCIIMath support for LaTeX]
\RequirePackage{amsmath}% for \matrix, others?
\RequirePackage{amsfonts}% for \mathbb et. al.

\def\appendToks@#1#2{%
    \edef\tmpA{\the#1}%
    #1=\expandafter{\tmpA#2}%
}

% Do this before setting the catcode of `, so we can refer to "`\@".
\def\setupASCII@{%
    \catcode32=\active% space
    \catcode126=12% "~"
    \def\sspace{ }% Do it here so the inside space is lexed as active
    \newlinechar=`\$\relax
    \defineTokTypes@
}

\def\makeQuoteActive{\catcode96=13}
\def\makeQuoteOther{\catcode96=12}

\makeQuoteActive
\protected\def`{%
    \begingroup% don't pollute the environment with macros defined in ifNextTokIs@.
    \ifNextTokIs@`%
        {\endgroup\char96\char96}%
        {\setupASCII@\startParse@}%
}

\newtoks\lexedTokens@
\def\addLexed@{\appendToks@\lexedTokens@}
\def\addBlock@#1{\addLexed@{\block0{}{#1}}}

\newtoks\parsedTokens@

\def\startParse@#1`{%
    \ifmmode\let\mathdelim=\relax\else\let\mathdelim=$\fi
    \def\useParse##1{\mathdelim##1\mathdelim\endgroup}%
    \runParse@{#1}%
}

\def\runParse@#1{%
    \lexedTokens@={}\lexTokens@#1\endScan@
    %\message{Lexed: \the\lexedTokens@.$}%
    \expandafter\readOList@\the\lexedTokens@\endScan@
    %\message{Parsed: \the\parsedTokens@.$}%
    \expandafter\useParse\expandafter{\the\parsedTokens@}%
}

% Usage: \newMathEnv{alignA*}{align*}
% Defines a new math environment that takes ASCIIMath input.
\def\newMathEnv@#1#2{%
    \newenvironment{#1}{%
        \begingroup\setupASCII@
        \def\useParse####1{\begin{#2}####1\end{#2}\endgroup\end{#1}}%
        \collectInput@
    }{\ignorespacesafterend}%
}


% Scans everything until the next \end{..},
% and calls \runParse@ on it.
% Callers of this should set \useParse@.
% Correctly handles nested environments, using tricks that I learned/borrowed
% from the amsmath package.
\def\collectInput@{%
    \asciiInput@={}%
    \def\bStack{bx}%
    \def\emptyStack{x}%
    \loopCollectInput@
}

\newtoks\asciiInput@
\def\addAsciiInput@#1{%
    \edef\tmpA{\the\asciiInput@}%
    \global\asciiInput@=\expandafter{\tmpA#1}%
}

% Usage: \pushBegins@...\begin\end
% (internals is assumed to not contain an end)
% Expands to a sequence of b's, one for each \begin in the "..."
\def\scanBegins@#1\begin#2{%
    \ifx\end#2\else b\expandafter\scanBegins@\fi
}
\def\gobbleOne@#1{}

\def\loopCollectInput@#1\end#2{%
    % Turn all of the begins in #1 into b's, add them to the stack,
    % and delete one b from the stack.
    \edef\bStack{\scanBegins@#1\begin\end\expandafter\gobbleOne@\bStack}%
    % If the stack is empty, we're done.
    % Otherwise, we need to read more \ends, so keep going.
    \ifx\bStack\emptyStack
        \addAsciiInput@{#1}%
        \def\next{\expandafter\runParse@\expandafter{\the\asciiInput@}}%
    \else
        \addAsciiInput@{#1\end{#2}}%
        \loopCollectorInput@
    \fi
    \next
}


%\def\collectInput@#1\end#2{\runParse@{#1}}

\newMathEnv@{alignA}{align}
\newMathEnv@{alignA*}{align*}
\newMathEnv@{asciimth}{equation}
\newMathEnv@{asciimth*}{equation*}

% sentinel value
% Since we do comparisons, I try to make sure this is unique.
\def\endScan@{\errmessage{Oops, went over the end!}\let\fooAM@=\endScan@}

%%%%%%%%%%%%%%%%%%%%%%%%%%%%
% Lexing
% 
% TODO (maybe these shouldn't go here):
% * Register \sqrt (maybe that shouldn't go here?)
% * Try using operator precedence: a^2/b_3 == (a^2)/(b_3)
% * also a^2_1 should work better
%
\begingroup
\catcode32=13
%\catcode40=13
\gdef\sspace@{ }
\endgroup

\def\lexTokens@{\futurelet\nextTok\lexTokensA@}
% First, check if the next token starts a {...} subexpression :
\def\lexTokensA@{%
    \ifx\nextTok\bgroup\let\next=\lexTokenGroup@
    \else\let\next=\lexTokensB@
    \fi\next
}

\def\lexTokenGroup@#1{%
    \begingroup
    \def\useParse##1{\endgroup\addLexed@{\subblock{##1}}\lexTokens@}%
    \runParse@{#1}
}

\let\lbraceTok@=\{
\let\rbraceTok@=\}

\def\lexTokensB@#1{%
    \ifx#1\endScan@\let\next=\relax
    \else\if\sspace@\noexpand#1\let\next=\lexTokens@% ignore spaces
    \else\ifcat\noexpand#1a\def\next{\parseLetterOrCS@#1}%
    \else\ifcat\noexpand#1^\def\next{\addLexed@{^}\lexTokens@}%
    \else\ifcat\noexpand#1_\def\next{\addLexed@{_}\lexTokens@}%
    \else\ifx#1\lbraceTok@\def\next{\addLexed@{\startParen{\lbraceTok@}}\lexTokens@}%
    \else\ifx#1\rbraceTok@\def\next{\addLexed@{\endParen{\rbraceTok@}}\lexTokens@}%
    \else\ifcat\noexpand#1/\def\next{\processOtherChar@#1}%
    \else\def\next{\addBlock@{#1}\lexTokens@}%
    \fi\fi\fi\fi\fi\fi\fi\fi
    \next
}%

\def\processOtherChar@#1{%
    \ifx#1/\let\next=\scanFracOrDiv@
    \else\ifx#1(\def\next{\addLexed@{\startParen(}\lexTokens@}%
    \else\ifx#1[\def\next{\addLexed@{\startParen[}\lexTokens@}%
    \else\ifx#1)\def\next{\addLexed@{\endParen)}\lexTokens@}%
    \else\ifx#1]\def\next{\addLexed@{\endParen]}\lexTokens@}%
    \else\ifx#1"\let\next\scanRomanText@%
    \else
        \ifisdigitchar@#1{\def\next{\scanNumber@{#1}}}%
            {\def\next{\scanOtherChars@{#1}}}%
    \fi\fi\fi\fi\fi\fi
    \next
}

\def\scanFracOrDiv@{\futurelet\nextTok\scanFracOrDivA@}
\def\scanFracOrDivA@{%
    \ifx\nextTok/\def\next##1{\addBlock@{/}\lexTokens@}%
    \else\def\next{\addLexed@{/}\lexTokens@}%
    \fi
    \next
}

\def\scanRomanText@#1"{\addBlock@{\text{#1}}\lexTokens@}

% There must be a more efficient way to do this...
\newif\ifisDigitCharCond@
\def\ifisdigitchar@#1#2#3{%
    \isDigitCharCond@false
    \ifx0#1\isDigitCharCond@true\fi
    \ifx1#1\isDigitCharCond@true\fi
    \ifx2#1\isDigitCharCond@true\fi
    \ifx3#1\isDigitCharCond@true\fi
    \ifx4#1\isDigitCharCond@true\fi
    \ifx5#1\isDigitCharCond@true\fi
    \ifx6#1\isDigitCharCond@true\fi
    \ifx7#1\isDigitCharCond@true\fi
    \ifx8#1\isDigitCharCond@true\fi
    \ifx9#1\isDigitCharCond@true\fi
    \ifisDigitCharCond@#2\else#3\fi
}

\def\scanNumber@#1{\def\todo{\scanNumberA@{#1}}\futurelet\nextTok\todo}
\def\scanNumberA@#1{%
    \ifisdigitchar@\nextTok{\def\next##1{\scanNumber@{#1##1}}}%
        {\def\next{\addBlock@{#1}\lexTokens@}}%
    \next
}

\newtoks\csNameStr@
\def\parseLetterOrCS@#1{%
    % First check whether the next unparsed token is a letter.
    \def\todo{\ifcat\noexpand\nextTok a\def\next{\csNameStr@={#1}\parseCS@}%
                \else\def\next{\addBlock@#1\lexTokens@}\fi\next}%
    \futurelet\nextTok\todo
}
\def\parseCS@{\futurelet\nextTok\parseCSa@}
\def\parseCSa@{%
    \ifcat\noexpand\nextTok a\let\next=\addToCSAndCont@%
    \else\let\next=\emitCSAndLex@%
    \fi\next
}
\def\addToCSAndCont@#1{%
    \appendToks@\csNameStr@#1%
    \parseCS@
}

\def\leftName@{@left@asciimacro@}
\def\rightName@{@right@asciimacro@}
\def\matrixName@{@matrix@asciimacro@}
\def\rawName@{@raw@asciimacro@}
\def\envName@{@env@asciimacro@}
\def\labelName@{@label@asciimacro@}
\def\emitCSAndLex@{%
    \edef\asciiCmdName{@\the\csNameStr@ @asciimacro@}%
    % First, check whether this name has been set with \addASCIIMathCmd:
    \expandafter\ifcsname\asciiCmdName\endcsname
        \def\next{\expandafter\addPredefinedName@\expandafter{\asciiCmdName}%
                    \lexTokens@}%
    % Next, check if it's left or right:
    \else\ifx\asciiCmdName\leftName@\def\next{\lexDelim@\startParen}%
    \else\ifx\asciiCmdName\rightName@\def\next{\lexDelim@\endParen}%
    % Next, check if it's the start of a matrix:
    \else\ifx\asciiCmdName\matrixName@\def\next{\addLexed@\startMatrix\lexTokens@}%
    % Next, check if it's a label:
    \else\ifx\asciiCmdName\labelName@\def\next##1{\addBlock@{\label{##1}}\lexTokens@}%
    % Next, check if it's a "raw" command:
    \else\ifx\asciiCmdName\rawName@\def\next##1{\addBlock@{##1}\lexTokens@}%
    % Next, check if it's an "env" command:
    \else\ifx\asciiCmdName\envName@
            \def\next##1{\addLexed@{\asciiCmd{\latexEnv@{##1}}{1}}\lexTokens@}%
    % Otherwise, check if it's set as a normal macro:
    \else\expandafter\ifcsname\the\csNameStr@\endcsname
        \def\next{%
            \expandafter\expandafter\expandafter
                \addBlock@\expandafter\csname\the\csNameStr@\endcsname
                \lexTokens@
        }%
    \else\def\next{%
            \errmessage{Oops, command "\the\csNameStr@" is not defined!}
        }%
    \fi\fi\fi\fi\fi\fi\fi\fi\next
}

% If the longest possible sequence of "other" characters is defined,
% set it to a name.
% Otherwise, output each as a block (though any "-" should be on their own).
% 
\def\scanOtherChars@#1{\csNameStr@={#1}\loopOtherChars@}
\def\loopOtherChars@{\futurelet\nextTok\loopOtherCharsA@}
\def\loopOtherCharsA@{%
    \ifcat\noexpand\nextTok+%
        % TODO: annoying to duplicate the list from processOtherChar@ here.
        \ifx\nextTok/\let\next=\processOtherChars@
        \else\ifx\nextTok(\let\next=\processOtherChars@
        \else\ifx\nextTok[\let\next=\processOtherChars@
        \else\ifx\nextTok)\let\next=\processOtherChars@
        \else\ifx\nextTok]\let\next=\processOtherChars@
        \else\ifisdigitchar@\nextTok{\let\next=\processOtherChars@}%
                                {\let\next=\addOtherToCS@}%
        \fi\fi\fi\fi\fi
    \else\let\next=\processOtherChars@
    \fi\next
}
\def\addOtherToCS@#1{\appendToks@\csNameStr@#1\loopOtherChars@}
\def\processOtherChars@{%
    \edef\asciiCmdName{@\the\csNameStr@ @asciimacro@}%
    % First, check whether this name has been set with \addASCIIMathCmd:
    \expandafter\ifcsname\asciiCmdName\endcsname
        \def\next{\expandafter\addPredefinedName@\expandafter{\asciiCmdName}}%
    % Otherwise, emit each token in turn:
    \else\def\next{\expandafter\emitLoneOtherChars@%
                        \the\csNameStr@\endScan@}%
    \fi\next\lexTokens@
}
% TODO: have to dupe processOtherChar@ here...
% Annoying.  Must be better abstraction.
\def\emitLoneOtherChars@#1{%
    \ifx#1\endScan@\let\next=\relax
    \else\ifx#1-\def\next{\addLexed@{-}\emitLoneOtherChars@}%
    \else\ifx#1,\def\next{\addLexed@{,}\emitLoneOtherChars@}%
    \else\ifx#1;\def\next{\addLexed@{;}\emitLoneOtherChars@}%
    \else\def\next{\addBlock@{#1}\emitLoneOtherChars@}%
    \fi\fi\fi\fi\next
}
    
    

\def\addPredefinedName@#1{%
    \expandafter\expandafter\expandafter\addPredefinedNameA@\csname#1\endcsname
}
\def\addPredefinedNameA@#1#2{%
    \addLexed@{\asciiCmd{#1}{#2}}%
}

% TODO: I'd like to be able to peek first, but I can't figure out how
% to get the delcode of a token.
\def\lexDelim@#1#2{\addLexed@{#1{#2}}\lexTokens@}%

%%%%%%%%%%%%%%
%% Parsing lexed tokens into a large structure
%
% Grammar is:
% 
% E ->  O E  | <empty>
% O ->  S    | S / S
% S ->  T    | S_Tm     | S^Tm
% Tm -> T | -T
% T -> <block> or (E)   | <func> T_1 ... T_n
% Each <func> was defined by addASCIIMathCmd
% and expects a fixed number of arguments.
%
% Note that an expression like 2^x^x will be accepted by asciimth,
% and passed to TeX which will complain with a useful error message.
%
% Objects inside are:
% Raw operations /,^,_,-
% \block#1#2#3: #1 is 1 if this should be wrapped with parens when not a
%                   subexpr of a fraction, exponent, etc., and 0 otherwise.
%               #2 is eg "()" or "[)" if this should be wrapped
%               #3 is the internals of the block.
% \subblock#1: block of stuff surrounded by {}.  Treated like a <block>.
% \startParen#1: #1 is '(', '[', etc.
% \endParen#1: #1 is ')', ']', etc.
% \startMatrix: A parenthesized expression follows.
% \asciiCmd#1#2: #1 is code, #2 is number of args.
% 
% These definitions should never actually be expanded.  However, they
% are necessary for \ifx to distinguish between the tokens.
\def\defineTokTypes@{%
    \def\block{\readO@\block}%
    \def\startParen{\readO@\startParen}%
    \def\endParen##1{\errmessage{Oops; found an unmatched "##1".}}%
    \def\startMatrix{\readO@\startMatrix}%
    \def\asciiCmd{\readO@\asciiCmd}%
    \def\subblock{\readO@\subblock}%
}

\def\readOList@{%
    \parsedTokens@={}%
    \def\useO##1{\appendToks@\parsedTokens@{##1}\readOListLoop@}%
    \readOListLoop@
}

\def\readOListLoop@{\ifNextTokIs@\endScan@\relax\readO@}

\def\readO@{\let\useS=\maybeDoFraction@\readS@}

\def\maybeDoFraction@#1#2#3{%
    \ifNextTokIs@/{\readFraction@{#3}}
        {\let\useBlock=\useO\renderBlock@#1{#2}{#3}}%
}

% Checks whether the next token is #1.  If so, eats it and runs #2.
% Otherwise, leaves it alone and runs #3.
\def\ifNextTokIs@#1#2#3{%
    \def\todo{\ifx#1\nextTok\def\next####1{#2}\else\def\next{#3}\fi\next}%
    \futurelet\nextTok\todo
}
        
% Given the numerator to a fraction (#1)
% parses the next S and returns the resulting fraction.
\def\readFraction@#1{%
    \def\useS##1##2##3{\useO{\frac{#1}{##3}}}%
    \readS@
}

% Reads an S nonterminal and passes the result to useS.
\def\readS@{\let\useT=\addSubSupScript@\readT@}

% Given an already-read block, read more ^ and _ if possible.
% Note: if they do eg x_y_y it will parse and TeX will complain, but
% it's the same error they'd get with $..$.
\def\addSubSupScript@#1#2#3{%
    \ifNextTokIs@_%
        {\def\useBlock{\doSubSupScript@_}\renderBlock@#1{#2}{#3}}%
        {\ifNextTokIs@^%
            {\def\useBlock{\doSubSupScript@^}\renderBlock@#1{#2}{#3}}%
            {\useS#1{#2}{#3}}}%
}

% #1 is _ or ^.  #2 is the rendered base.
\def\doSubSupScript@#1#2{\ifNextTokIs@-%
    {\doNegatedScript@#1{#2}}%
    {\doSimpleScript@#1{#2}}%
}
\def\doNegatedScript@#1#2{%
    \def\useT##1##2##3{%
        \def\useBlock####1{\addSubSupScript@0{}{#2#1{-####1}}}%
        \renderBlock@##1{##2}{##3}%
    }%
    \readT@
}
\def\doSimpleScript@#1#2{%
    \def\useT##1##2##3{\addSubSupScript@0{}{#2#1{##3}}}%
    \readT@
}

% Wraps the argument #3 in the parentheses (#2) unless there are none (#1==0).
% Passes the result to \useBlock.
\def\renderBlock@#1#2#3{%
    \ifx0#1\def\next{\useBlock{#3}}%
    \else\def\next{\expandafter\useBlock\expandafter{\wrapBlock@#2{#3}}}%
    \fi\next
}
% #1 is the open-delim, #2 is the close-delim.
% Note: using \left..\right makes the object in parentheses act like
% \mathinner, which isn't great since this happens to EVERY parenthesis.
% For example, in $f\left(x\right)$ there's too much space between
% the "f" and the "(". 
% Fix this by making it act like a \mathopen+\mathclose.
% Note we do still lose a tiny bit of kern between $f(x)$ and `f(x)`, but
% it's less noticeable.
% TODO: we could try checking the height of the inner formula ourselves, and
% use plain "(" and ")" if it's no bigger than those characters.
\def\wrapBlock@#1#2#3{\mathopen{}\mathclose{\left#1#3\right#2}}

% Reads a "T" terminal (a lone block or a parenthesized expression)
% and then passes it as an argument to \useT.
\def\readT@#1{%
    \ifx#1\block\let\next=\readTBlock@
    \else\ifx#1-\def\next{\useT0{}{#1}}%
    \else\ifx#1,\def\next{\useT0{}{#1}}%
    \else\ifx#1;\def\next{\useT0{}{#1}}%
    \else\ifx#1\startParen\let\next=\readTParen@
    \else\ifx#1\startMatrix\let\next=\readTMatrix@
    \else\ifx#1\asciiCmd\let\next=\readTASCIICmd@
    \else\ifx#1\subblock\let\next=\parseSubblock@
    \else\ifx#1/\def\next{\useT0{}{#1}}%
    % Give a more helpful error message if we hit the end:
    \else\def\next{\reportError@{#1}}%
    \fi\fi\fi\fi\fi\fi\fi\fi\fi
    \next
}
\def\reportError@#1{%
    \ifx#1\endScan@\def\next{%
        \errmessage{Oops: Ran into the end of input;
            may be missing a closing delimiter}}%
    \else\ifx#1\endParen\def\next##1{%
        \errmessage{Oops: Extra unmatched right delimiter '\noexpand##1'}}%
    \else\def\next{\errmessage{Oops: ran into a non-block:\noexpand#1}}%
    \fi\fi
    \next
}

\def\readTBlock@#1#2#3{\useT#1{#2}{#3}}

\def\parseSubblock@#1{\useT0{}{{#1}}}

% OK, this uses a couple of tricks:
% 1) The #1 of asciiCmdLoop@ is a partial application of the macro.
%    So appending something to that parameter means applying the macro
%    to an additional argument.
%
% 2) This function recursively calls readT.  So it saves the relevant
%    parameters by putting the readT call in a new group.
\newcount\cmdArgsNeeded@
\def\readTASCIICmd@#1#2{\cmdArgsNeeded@=#2\relax\asciiCmdLoop@{#1}}
\def\asciiCmdLoop@#1{%
    \ifnum\cmdArgsNeeded@=0%
        \def\next{\useT0{}{#1}}%
    \else
        \def\next{%
            \advance\cmdArgsNeeded@ by -1\relax%
            % start a new group since we need to keep around the old
            % version of useT and cmdArgsNeeded.
            \bgroup
            \def\useT####1####2####3{%
                \egroup
                \asciiCmdLoop@{#1{####3}}%
            }%
            \readT@
        }%
    \fi\next
}

% Read parentheses in a similar style as above:
% Keep a token list of the parenthesis contents
% And continually read O's and append them into the token list
% until you hit an endParen.
% (Nested endParens will be automatically gobbled up by the
% recursive call to readO).
\newtoks\parenContents@
\def\readTParen@#1{%
    \def\parenStarter{#1}%
    \parenContents@={}%
    \loopForEndParen@%
}

\def\loopForEndParen@{\ifNextTokIs@\endParen
    {\expandafter\finishParen@\parenStarter}%
    {\readMoreParenContents@}%
}
\def\readMoreParenContents@{%
    \begingroup
    \def\useO##1{%
            \endgroup
            \appendToks@\parenContents@{##1}%
            \loopForEndParen@%
    }%
    \readO@
}
\def\finishParen@#1#2{%
    \expandafter\useT\expandafter1\expandafter{%
        \expandafter#1\expandafter#2\expandafter}%
        \expandafter{\the\parenContents@}%
}

% Read matrices, basically the same way as for parentheses. 
% (TODO: don't duplicate so much code.)
% The lexer is supposed to return:
% \startMatrix\startParen(...\endParen)
% where the stuff inside of the ... is a sequence of O's, commas and semicolons.
% Each comma/semicolon is replaced by "&" or "\\".
\def\readTMatrix@\startParen#1{%
    \def\parenStarter{#1}%
    \parenContents@={}%
    \loopTillEndMatrix@
}

\def\loopTillEndMatrix@{\futurelet\nextTok\loopTillEndMatrixA@}
\def\loopTillEndMatrixA@{%
    \ifx\nextTok\endParen
        \def\next##1##2{\expandafter\finishMatrix@\parenStarter##2}%
    \else\ifx\nextTok,%
        \def\next##1{\appendToks@\parenContents@{&}\loopTillEndMatrix@}%
    \else\ifx\nextTok;%
        \def\next##1{\appendToks@\parenContents@{\\}\loopTillEndMatrix@}%
    \else\def\next{\anotherMatrixElt@}%
    \fi\fi\fi
    \next
}

\def\anotherMatrixElt@{%
    \begingroup
    \def\useO##1{%
        \endgroup
        \appendToks@\parenContents@{##1}%
        \loopTillEndMatrix@
    }%
    \readO@
}

\def\amBeginMatrix@{\begin{matrix}}
\def\amEndMatrix@{\end{matrix}}

% matrix(a,b,c) should expand to:
% \useT 1{()}{\amBeginMatrix@ a&b&c \amEndMatrix@}
\def\finishMatrix@#1#2{%
    \expandafter\useT\expandafter1%
        \expandafter{\expandafter#1\expandafter#2\expandafter}%
        \expandafter{\expandafter\amBeginMatrix@\the\parenContents@
        \amEndMatrix@}%
}



%%%%%%%%%%%%%
% Using TeX macros inside of ASCIIMath:
%
% A macro which takes no arguments (for example, \alpha or \Sum) can always
% be referred to by name.  And a build-in macro like \sqrt will work.  But
% other macros which take an argument will not work by default.
%
% The following macro tells the ASCIIMath engine that a macro takes arguments:
% It works by setting a corresponding macro name which the engine will look up.
% Outermost parentheses of arguments will be eliminated (just like for sqrt).
% The format is:
% <name> -> @name@asciimacro@
% The macro definition will internally keep track of the number of args.
%
% Usage example:
% 
% \newcommand{\myroot}[2]{\sqrt[#1]{#2}}
% \addASCIIMathCmd{root}{\myroot}{2}
%
\def\addASCIIMathCmd#1#2#3{%
    \begingroup
    \makeatletter
    \edef\name{@#1@asciimacro@}%
    \def\macroValue{{#3}#2}%
    \expandafter\global\expandafter\let\csname\name\endcsname=\macroValue
    \endgroup
}

% Start off with a couple of definitions:
% sqrt, root, hat, bb@
\addASCIIMathCmd{sqrt}{1}{\sqrt}
\def\myrootn@#1#2{{\sqrt[#1]{#2}}}
\addASCIIMathCmd{root}{2}{\myrootn@}
\addASCIIMathCmd{bb}{1}{\mathbb}
\addASCIIMathCmd{bf}{1}{\mathbf}
\addASCIIMathCmd{cal}{1}{\mathcal}
\addASCIIMathCmd{hat}{1}{\hat}
\addASCIIMathCmd{tilde}{1}{\tilde}
\addASCIIMathCmd{bar}{1}{\bar}
\addASCIIMathCmd{widehat}{1}{\widehat}
\addASCIIMathCmd{overline}{1}{\overline}

% Symbols
\addASCIIMathCmd{,...,}{0}{,\ldots,}
\addASCIIMathCmd{,...}{0}{,\ldots}
\addASCIIMathCmd{...,}{0}{\ldots,}
\addASCIIMathCmd{...}{0}{\cdots}
\addASCIIMathCmd{->}{0}{\to}
\addASCIIMathCmd{<-}{0}{\leftarrow}
\addASCIIMathCmd{>=}{0}{\ge}
\addASCIIMathCmd{<=}{0}{\le}
\addASCIIMathCmd{=>}{0}{\implies}
\addASCIIMathCmd{<=>}{0}{\iff}
\addASCIIMathCmd{|->}{0}{\mapsto}
\addASCIIMathCmd{!=}{0}{\ne}
\addASCIIMathCmd{==}{0}{\equiv}
\addASCIIMathCmd{+-}{0}{\pm}

\begingroup
\catcode126=12\relax% "~"
\addASCIIMathCmd{~}{0}{\sim}
\addASCIIMathCmd{~=}{0}{\cong}
\addASCIIMathCmd{~~}{0}{\approx}
\addASCIIMathCmd{~-}{0}{\simeq}
\endgroup

\addASCIIMathCmd{substack}{1}{\substack}

% Embedded LaTeX environments:
% Goal is for `env{pmatrix}(...)` to turn into \begin{pmatrix}...\end{pmatrix}.
% The command "env" is hard-coded in \emitCSAndLex@.
\def\latexEnv@#1#2{\begin{#1}#2\end{#1}}

% OK, plan is:
% big(..), Big[...]
% will scale both delimiters.
% My idea is for "big" to be lexed as a macro,
% and have addASCIIMathCmd hard-code the handling of parentheses.
% (Actually, that's a useful thing to have, e.g. if you use sin[x] vs sin(x)).