#!/usr/pkg/bin/python3.9
#   math2html: convert LaTeX equations to HTML output.
#
#   Copyright (C) 2009-2011 Alex Fernández, 2021 Günter Milde
#
#   Released under the terms of the `2-Clause BSD license'_, in short:
#   Copying and distribution of this file, with or without modification,
#   are permitted in any medium without royalty provided the copyright
#   notice and this notice are preserved.
#   This file is offered as-is, without any warranty.
#
# .. _2-Clause BSD license: https://opensource.org/licenses/BSD-2-Clause

#   Based on eLyXer: convert LyX source files to HTML output.
#   http://alexfernandez.github.io/elyxer/

# Versions:
# 1.2.5  2015-02-26  eLyXer standalone formula conversion to HTML.
# 1.3    2021-06-02  Removed code for conversion of LyX files not
#                    required for LaTeX math.
#                    Support for more math commands from the AMS "math-guide".
# 2.0    2021-12-31  Drop 2.7 compatibility code.

import pathlib
import sys
import unicodedata

from docutils.utils.math import tex2unichar


__version__ = '1.3 (2021-06-02)'


class Trace:
    "A tracing class"

    debugmode = False
    quietmode = False
    showlinesmode = False

    prefix = None

    def debug(cls, message):
        "Show a debug message"
        if not Trace.debugmode or Trace.quietmode:
            return
        Trace.show(message, sys.stdout)

    def message(cls, message):
        "Show a trace message"
        if Trace.quietmode:
            return
        if Trace.prefix and Trace.showlinesmode:
            message = Trace.prefix + message
        Trace.show(message, sys.stdout)

    def error(cls, message):
        "Show an error message"
        message = '* ' + message
        if Trace.prefix and Trace.showlinesmode:
            message = Trace.prefix + message
        Trace.show(message, sys.stderr)

    def fatal(cls, message):
        "Show an error message and terminate"
        Trace.error('FATAL: ' + message)
        exit(-1)

    def show(cls, message, channel):
        "Show a message out of a channel"
        channel.write(message + '\n')

    debug = classmethod(debug)
    message = classmethod(message)
    error = classmethod(error)
    fatal = classmethod(fatal)
    show = classmethod(show)


class ContainerConfig:
    "Configuration class from elyxer.config file"

    extracttext = {
        'allowed': ['FormulaConstant'],
        'extracted': ['AlphaCommand',
                      'Bracket',
                      'BracketCommand',
                      'CombiningFunction',
                      'EmptyCommand',
                      'FontFunction',
                      'Formula',
                      'FormulaNumber',
                      'FormulaSymbol',
                      'OneParamFunction',
                      'OversetFunction',
                      'RawText',
                      'SpacedCommand',
                      'SymbolFunction',
                      'TextFunction',
                      'UndersetFunction',
                      ],
    }


class EscapeConfig:
    "Configuration class from elyxer.config file"

    chars = {
        '\n': '',
        "'": '’',
        '`': '‘',
    }

    entities = {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
    }


class FormulaConfig:
    "Configuration class from elyxer.config file"

    alphacommands = {
        '\\AmS': '<span class="textsc">AmS</span>',
        '\\AA':        'Å',
        '\\AE':        'Æ',
        '\\DH':        'Ð',
        '\\L':         'Ł',
        '\\O':         'Ø',
        '\\OE':        'Œ',
        '\\TH':        'Þ',
        '\\aa':        'å',
        '\\ae':        'æ',
        '\\dh':        'ð',
        '\\i':         'ı',
        '\\j':         'ȷ',
        '\\l':         'ł',
        '\\o':         'ø',
        '\\oe':        'œ',
        '\\ss':        'ß',
        '\\th':        'þ',
    }
    for key, value in tex2unichar.mathalpha.items():
        alphacommands['\\'+key] = value

    array = {
        'begin': r'\begin',
        'cellseparator': '&',
        'end': r'\end',
        'rowseparator': r'\\',
    }

    bigbrackets = {'(': ['⎛', '⎜', '⎝'],
                   ')': ['⎞', '⎟', '⎠'],
                   '[': ['⎡', '⎢', '⎣'],
                   ']': ['⎤', '⎥', '⎦'],
                   '{': ['⎧', '⎪', '⎨', '⎩'],
                   '}': ['⎫', '⎪', '⎬', '⎭'],
                   # TODO: 2-row brackets with ⎰⎱ (\lmoustache \rmoustache)
                   '|': ['|'],  # 007C VERTICAL LINE
                   # '|': ['⎮'],  # 23AE INTEGRAL EXTENSION
                   # '|': ['⎪'],  # 23AA CURLY BRACKET EXTENSION
                   '‖': ['‖'],  # 2016 DOUBLE VERTICAL LINE
                   # '∥': ['∥'],  # 2225 PARALLEL TO
                   }

    bracketcommands = {
        '\\left': 'span class="stretchy"',
        '\\left.': '<span class="leftdot"></span>',
        '\\middle': 'span class="stretchy"',
        '\\right': 'span class="stretchy"',
        '\\right.': '<span class="rightdot"></span>',
    }

    combiningfunctions = {
        "\\'":           '\u0301',  # x́
        '\\"':           '\u0308',  # ẍ
        '\\^':           '\u0302',  # x̂
        '\\`':           '\u0300',  # x̀
        '\\~':           '\u0303',  # x̃
        '\\c':           '\u0327',  # x̧
        '\\r':           '\u030a',  # x̊
        '\\s':           '\u0329',  # x̩
        '\\textcircled': '\u20dd',  # x⃝
        '\\textsubring': '\u0325',  # x̥
        '\\v':           '\u030c',  # x̌
    }
    for key, value in tex2unichar.mathaccent.items():
        combiningfunctions['\\'+key] = value

    commands = {
        '\\\\': '<br/>',
        '\\\n': ' ',  # escaped whitespace
        '\\\t': ' ',  # escaped whitespace
        '\\centerdot': '\u2B1D',  # BLACK VERY SMALL SQUARE, mathbin
        '\\colon': ': ',
        '\\copyright': '©',
        '\\dotminus': '∸',
        '\\dots': '…',
        '\\dotsb': '⋯',
        '\\dotsc': '…',
        '\\dotsi': '⋯',
        '\\dotsm': '⋯',
        '\\dotso': '…',
        '\\euro': '€',
        '\\guillemotleft': '«',
        '\\guillemotright': '»',
        '\\hbar': '<i>\u0127</i>',  # ħ LATIN SMALL LETTER H WITH STROKE
        '\\lVert': '‖',
        '\\Arrowvert':  '\u2016',  # ‖
        '\\lvert': '|',
        '\\newline': '<br/>',
        '\\nobreakspace': ' ',
        '\\nolimits': '',
        '\\nonumber': '',
        '\\qquad': '  ',
        '\\rVert': '‖',
        '\\rvert': '|',
        '\\textasciicircum': '^',
        '\\textasciitilde': '~',
        '\\textbackslash': '\\',
        '\\textcopyright': '©',
        '\\textdegree': '°',
        '\\textellipsis': '…',
        '\\textemdash': '—',
        '\\textendash': '—',
        '\\texteuro': '€',
        '\\textgreater': '>',
        '\\textless': '<',
        '\\textordfeminine': 'ª',
        '\\textordmasculine': 'º',
        '\\textquotedblleft': '“',
        '\\textquotedblright': '”',
        '\\textquoteright': '’',
        '\\textregistered': '®',
        '\\textrightarrow': '→',
        '\\textsection': '§',
        '\\texttrademark': '™',
        '\\texttwosuperior': '²',
        '\\textvisiblespace': ' ',
        '\\thickspace': '<span class="thickspace"> </span>',  # 5/13 em
        '\\;': '<span class="thickspace"> </span>',  # 5/13 em
        '\\triangle': '\u25B3',  # WHITE UP-POINTING TRIANGLE, mathord
        '\\triangledown': '\u25BD',  # WHITE DOWN-POINTING TRIANGLE, mathord
        '\\varnothing': '\u2300',  # ⌀ DIAMETER SIGN
        # functions
        '\\Pr': 'Pr',
        '\\arccos': 'arccos',
        '\\arcsin': 'arcsin',
        '\\arctan': 'arctan',
        '\\arg': 'arg',
        '\\cos': 'cos',
        '\\cosh': 'cosh',
        '\\cot': 'cot',
        '\\coth': 'coth',
        '\\csc': 'csc',
        '\\deg': 'deg',
        '\\det': 'det',
        '\\dim': 'dim',
        '\\exp': 'exp',
        '\\gcd': 'gcd',
        '\\hom': 'hom',
        '\\injlim': 'inj lim',
        '\\ker': 'ker',
        '\\lg': 'lg',
        '\\liminf': 'lim inf',
        '\\limsup': 'lim sup',
        '\\ln': 'ln',
        '\\log': 'log',
        '\\projlim': 'proj lim',
        '\\sec': 'sec',
        '\\sin': 'sin',
        '\\sinh': 'sinh',
        '\\tan': 'tan',
        '\\tanh': 'tanh',
    }
    cmddict = {}
    cmddict.update(tex2unichar.mathbin)  # TODO: spacing around binary operators
    cmddict.update(tex2unichar.mathopen)
    cmddict.update(tex2unichar.mathclose)
    cmddict.update(tex2unichar.mathfence)
    cmddict.update(tex2unichar.mathord)
    cmddict.update(tex2unichar.mathpunct)
    cmddict.update(tex2unichar.space)
    commands.update(('\\' + key, value) for key, value in cmddict.items())

    oversetfunctions = {
        # math accents (cf. combiningfunctions)
        # '\\acute':    '´',
        '\\bar':      '‒',  # FIGURE DASH
        # '\\breve':    '˘',
        # '\\check':    'ˇ',
        '\\dddot':    '<span class="smallsymbol">⋯</span>',
        # '\\ddot':     '··', # ¨ too high
        # '\\dot':      '·',
        # '\\grave':    '`',
        # '\\hat':      '^',
        # '\\mathring': '˚',
        # '\\tilde':    '~',
        '\\vec':      '<span class="smallsymbol">→</span>',
        # embellishments
        '\\overleftarrow': '⟵',
        '\\overleftrightarrow': '⟷',
        '\\overrightarrow': '⟶',
        '\\widehat': '^',
        '\\widetilde': '～',
    }

    undersetfunctions = {
        '\\underleftarrow': '⟵',
        '\\underleftrightarrow': '⟷',
        '\\underrightarrow': '⟶',
    }

    endings = {
        'bracket': '}',
        'complex': '\\]',
        'endafter': '}',
        'endbefore': '\\end{',
        'squarebracket': ']',
    }

    environments = {
        'align': ['r', 'l'],
        'eqnarray': ['r', 'c', 'l'],
        'gathered': ['l', 'l'],
        'smallmatrix': ['c', 'c'],
    }

    fontfunctions = {
        '\\boldsymbol': 'b', '\\mathbb': 'span class="blackboard"',
        '\\mathbb{A}': '𝔸', '\\mathbb{B}': '𝔹', '\\mathbb{C}': 'ℂ',
        '\\mathbb{D}': '𝔻', '\\mathbb{E}': '𝔼', '\\mathbb{F}': '𝔽',
        '\\mathbb{G}': '𝔾', '\\mathbb{H}': 'ℍ', '\\mathbb{J}': '𝕁',
        '\\mathbb{K}': '𝕂', '\\mathbb{L}': '𝕃', '\\mathbb{N}': 'ℕ',
        '\\mathbb{O}': '𝕆', '\\mathbb{P}': 'ℙ', '\\mathbb{Q}': 'ℚ',
        '\\mathbb{R}': 'ℝ', '\\mathbb{S}': '𝕊', '\\mathbb{T}': '𝕋',
        '\\mathbb{W}': '𝕎', '\\mathbb{Z}': 'ℤ', '\\mathbf': 'b',
        '\\mathcal': 'span class="scriptfont"',
        '\\mathcal{B}': 'ℬ', '\\mathcal{E}': 'ℰ', '\\mathcal{F}':
        'ℱ', '\\mathcal{H}': 'ℋ', '\\mathcal{I}': 'ℐ',
        '\\mathcal{L}': 'ℒ', '\\mathcal{M}': 'ℳ', '\\mathcal{R}': 'ℛ',
        '\\mathfrak': 'span class="fraktur"',
        '\\mathfrak{C}': 'ℭ', '\\mathfrak{F}': '𝔉', '\\mathfrak{H}': 'ℌ',
        '\\mathfrak{I}': 'ℑ', '\\mathfrak{R}': 'ℜ', '\\mathfrak{Z}': 'ℨ',
        '\\mathit': 'i',
        '\\mathring{A}': 'Å', '\\mathring{U}': 'Ů',
        '\\mathring{a}': 'å', '\\mathring{u}': 'ů', '\\mathring{w}': 'ẘ',
        '\\mathring{y}': 'ẙ',
        '\\mathrm': 'span class="mathrm"',
        '\\mathscr': 'span class="mathscr"',
        '\\mathscr{B}': 'ℬ', '\\mathscr{E}': 'ℰ', '\\mathscr{F}': 'ℱ',
        '\\mathscr{H}': 'ℋ', '\\mathscr{I}': 'ℐ', '\\mathscr{L}': 'ℒ',
        '\\mathscr{M}': 'ℳ', '\\mathscr{R}': 'ℛ',
        '\\mathsf': 'span class="mathsf"',
        '\\mathtt': 'span class="mathtt"',
        '\\operatorname': 'span class="mathrm"',
    }

    hybridfunctions = {
        '\\addcontentsline': ['{$p!}{$q!}{$r!}', 'f0{}', 'ignored'],
        '\\addtocontents': ['{$p!}{$q!}', 'f0{}', 'ignored'],
        '\\backmatter': ['', 'f0{}', 'ignored'],
        '\\binom': ['{$1}{$2}', 'f2{(}f0{f1{$1}f1{$2}}f2{)}', 'span class="binom"', 'span class="binomstack"', 'span class="bigdelimiter size2"'],
        '\\boxed': ['{$1}', 'f0{$1}', 'span class="boxed"'],
        '\\cfrac': ['[$p!]{$1}{$2}', 'f0{f3{(}f1{$1}f3{)/(}f2{$2}f3{)}}', 'span class="fullfraction"', 'span class="numerator align-$p"', 'span class="denominator"', 'span class="ignored"'],
        '\\color': ['{$p!}{$1}', 'f0{$1}', 'span style="color: $p;"'],
        '\\colorbox': ['{$p!}{$1}', 'f0{$1}', 'span class="colorbox" style="background: $p;"'],
        '\\dbinom': ['{$1}{$2}', '(f0{f1{f2{$1}}f1{f2{ }}f1{f2{$2}}})', 'span class="binomial"', 'span class="binomrow"', 'span class="binomcell"'],
        '\\dfrac': ['{$1}{$2}', 'f0{f3{(}f1{$1}f3{)/(}f2{$2}f3{)}}', 'span class="fullfraction"', 'span class="numerator"', 'span class="denominator"', 'span class="ignored"'],
        '\\displaystyle': ['{$1}', 'f0{$1}', 'span class="displaystyle"'],
        '\\fancyfoot': ['[$p!]{$q!}', 'f0{}', 'ignored'],
        '\\fancyhead': ['[$p!]{$q!}', 'f0{}', 'ignored'],
        '\\fbox': ['{$1}', 'f0{$1}', 'span class="fbox"'],
        '\\fboxrule': ['{$p!}', 'f0{}', 'ignored'],
        '\\fboxsep': ['{$p!}', 'f0{}', 'ignored'],
        '\\fcolorbox': ['{$p!}{$q!}{$1}', 'f0{$1}', 'span class="boxed" style="border-color: $p; background: $q;"'],
        '\\frac': ['{$1}{$2}', 'f0{f3{(}f1{$1}f3{)/(}f2{$2}f3{)}}', 'span class="fraction"', 'span class="numerator"', 'span class="denominator"', 'span class="ignored"'],
        '\\framebox': ['[$p!][$q!]{$1}', 'f0{$1}', 'span class="framebox align-$q" style="width: $p;"'],
        '\\frontmatter': ['', 'f0{}', 'ignored'],
        '\\href': ['[$o]{$u!}{$t!}', 'f0{$t}', 'a href="$u"'],
        '\\hspace': ['{$p!}', 'f0{ }', 'span class="hspace" style="width: $p;"'],
        '\\leftroot': ['{$p!}', 'f0{ }', 'span class="leftroot" style="width: $p;px"'],
        # TODO: convert 1 mu to 1/18 em
        # '\\mspace': ['{$p!}', 'f0{ }', 'span class="hspace" style="width: $p;"'],
        '\\nicefrac': ['{$1}{$2}', 'f0{f1{$1}⁄f2{$2}}', 'span class="fraction"', 'sup class="numerator"', 'sub class="denominator"', 'span class="ignored"'],
        '\\parbox': ['[$p!]{$w!}{$1}', 'f0{1}', 'div class="Boxed" style="width: $w;"'],
        '\\raisebox': ['{$p!}{$1}', 'f0{$1.font}', 'span class="raisebox" style="vertical-align: $p;"'],
        '\\renewenvironment': ['{$1!}{$2!}{$3!}', ''],
        '\\rule': ['[$v!]{$w!}{$h!}', 'f0/', 'hr class="line" style="width: $w; height: $h;"'],
        '\\scriptscriptstyle': ['{$1}', 'f0{$1}', 'span class="scriptscriptstyle"'],
        '\\scriptstyle': ['{$1}', 'f0{$1}', 'span class="scriptstyle"'],
        # TODO: increase √-size with argument (\frac in display mode, ...)
        '\\sqrt': ['[$0]{$1}', 'f0{f1{$0}f2{√}f4{(}f3{$1}f4{)}}', 'span class="sqrt"', 'sup class="root"', 'span class="radical"', 'span class="root"', 'span class="ignored"'],
        '\\stackrel': ['{$1}{$2}', 'f0{f1{$1}f2{$2}}', 'span class="stackrel"', 'span class="upstackrel"', 'span class="downstackrel"'],
        '\\tbinom': ['{$1}{$2}', '(f0{f1{f2{$1}}f1{f2{ }}f1{f2{$2}}})', 'span class="binomial"', 'span class="binomrow"', 'span class="binomcell"'],
        '\\tfrac':  ['{$1}{$2}', 'f0{f3{(}f1{$1}f3{)/(}f2{$2}f3{)}}', 'span class="textfraction"', 'span class="numerator"', 'span class="denominator"', 'span class="ignored"'],
        '\\textcolor': ['{$p!}{$1}', 'f0{$1}', 'span style="color: $p;"'],
        '\\textstyle': ['{$1}', 'f0{$1}', 'span class="textstyle"'],
        '\\thispagestyle': ['{$p!}', 'f0{}', 'ignored'],
        '\\unit': ['[$0]{$1}', '$0f0{$1.font}', 'span class="unit"'],
        '\\unitfrac': ['[$0]{$1}{$2}', '$0f0{f1{$1.font}⁄f2{$2.font}}', 'span class="fraction"', 'sup class="unit"', 'sub class="unit"'],
        '\\uproot': ['{$p!}', 'f0{ }', 'span class="uproot" style="width: $p;px"'],
        '\\url': ['{$u!}', 'f0{$u}', 'a href="$u"'],
        '\\vspace': ['{$p!}', 'f0{ }', 'span class="vspace" style="height: $p;"'],
    }

    hybridsizes = {
        '\\binom': '$1+$2', '\\cfrac': '$1+$2', '\\dbinom': '$1+$2+1',
        '\\dfrac': '$1+$2', '\\frac': '$1+$2', '\\tbinom': '$1+$2+1',
    }

    labelfunctions = {
        '\\label': 'a name="#"',
    }

    limitcommands = {
        '\\biginterleave': '⫼',
        '\\inf': 'inf',
        '\\lim': 'lim',
        '\\max': 'max',
        '\\min': 'min',
        '\\sup': 'sup',
        '\\ointop':    '<span class="bigoperator integral">∮</span>',
        '\\bigcap':    '<span class="bigoperator">⋂</span>',
        '\\bigcup':    '<span class="bigoperator">⋃</span>',
        '\\bigodot':   '<span class="bigoperator">⨀</span>',
        '\\bigoplus':  '<span class="bigoperator">⨁</span>',
        '\\bigotimes': '<span class="bigoperator">⨂</span>',
        '\\bigsqcap':  '<span class="bigoperator">⨅</span>',
        '\\bigsqcup':  '<span class="bigoperator">⨆</span>',
        '\\biguplus':  '<span class="bigoperator">⨄</span>',
        '\\bigvee':    '<span class="bigoperator">⋁</span>',
        '\\bigwedge':  '<span class="bigoperator">⋀</span>',
        '\\coprod':    '<span class="bigoperator">∐</span>',
        '\\intop':     '<span class="bigoperator integral">∫</span>',
        '\\prod':      '<span class="bigoperator">∏</span>',
        '\\sum':       '<span class="bigoperator">∑</span>',
        '\\varprod':   '<span class="bigoperator">⨉</span>',
        '\\zcmp': '⨟', '\\zhide': '⧹', '\\zpipe': '⨠', '\\zproject': '⨡',
        # integrals have limits in index position with LaTeX default settings
        # TODO: move to commands?
        '\\int': '<span class="bigoperator integral">∫</span>',
        '\\iint': '<span class="bigoperator integral">∬</span>',
        '\\iiint': '<span class="bigoperator integral">∭</span>',
        '\\iiiint': '<span class="bigoperator integral">⨌</span>',
        '\\fint': '<span class="bigoperator integral">⨏</span>',
        '\\idotsint': '<span class="bigoperator integral">∫⋯∫</span>',
        '\\oint': '<span class="bigoperator integral">∮</span>',
        '\\oiint': '<span class="bigoperator integral">∯</span>',
        '\\oiiint': '<span class="bigoperator integral">∰</span>',
        '\\ointclockwise': '<span class="bigoperator integral">∲</span>',
        '\\ointctrclockwise': '<span class="bigoperator integral">∳</span>',
        '\\smallint': '<span class="smallsymbol integral">∫</span>',
        '\\sqint': '<span class="bigoperator integral">⨖</span>',
        '\\varointclockwise': '<span class="bigoperator integral">∲</span>',
    }

    modified = {
        '\n': '', ' ': '', '$': '', '&': '	', '\'': '’', '+': '\u2009+\u2009',
        ',': ',\u2009', '-': '\u2009−\u2009', '/': '\u2009⁄\u2009', ':': ' : ', '<': '\u2009&lt;\u2009',
        '=': '\u2009=\u2009', '>': '\u2009&gt;\u2009', '@': '', '~': '\u00a0',
    }

    onefunctions = {
        '\\big': 'span class="bigdelimiter size1"',
        '\\bigl': 'span class="bigdelimiter size1"',
        '\\bigr': 'span class="bigdelimiter size1"',
        '\\Big': 'span class="bigdelimiter size2"',
        '\\Bigl': 'span class="bigdelimiter size2"',
        '\\Bigr': 'span class="bigdelimiter size2"',
        '\\bigg': 'span class="bigdelimiter size3"',
        '\\biggl': 'span class="bigdelimiter size3"',
        '\\biggr': 'span class="bigdelimiter size3"',
        '\\Bigg': 'span class="bigdelimiter size4"',
        '\\Biggl': 'span class="bigdelimiter size4"',
        '\\Biggr': 'span class="bigdelimiter size4"',
        # '\\bar': 'span class="bar"',
        '\\begin{array}': 'span class="arraydef"',
        '\\centering': 'span class="align-center"',
        '\\ensuremath': 'span class="ensuremath"',
        '\\hphantom': 'span class="phantom"',
        '\\noindent': 'span class="noindent"',
        '\\overbrace': 'span class="overbrace"',
        '\\overline': 'span class="overline"',
        '\\phantom': 'span class="phantom"',
        '\\underbrace': 'span class="underbrace"',
        '\\underline': '',
        '\\vphantom': 'span class="phantom"',
    }

    # relations (put additional space before and after the symbol)
    spacedcommands = {
        # negated symbols without pre-composed Unicode character
        '\\nleqq':      '\u2266\u0338',  # ≦̸
        '\\ngeqq':      '\u2267\u0338',  # ≧̸
        '\\nleqslant':  '\u2a7d\u0338',  # ⩽̸
        '\\ngeqslant':  '\u2a7e\u0338',  # ⩾̸
        '\\nsubseteqq': '\u2AC5\u0338',  # ⫅̸
        '\\nsupseteqq': '\u2AC6\u0338',  # ⫆̸
        '\\nsqsubset':  '\u2276\u228F',  # ⊏̸
        # modified glyphs
        '\\shortmid': '<span class="smallsymbol">∣</span>',
        '\\shortparallel': '<span class="smallsymbol">∥</span>',
        '\\nshortmid': '<span class="smallsymbol">∤</span>',
        '\\nshortparallel': '<span class="smallsymbol">∦</span>',
        '\\smallfrown': '<span class="smallsymbol">⌢</span>',
        '\\smallsmile': '<span class="smallsymbol">⌣</span>',
        '\\thickapprox': '<span class="boldsymbol">≈</span>',
        '\\thicksim': '<span class="boldsymbol">∼</span>',
        '\\varpropto': '<span class="mathsf">\u221d</span>',  # ∝ PROPORTIONAL TO
    }
    for key, value in tex2unichar.mathrel.items():
        spacedcommands['\\'+key] = value
    starts = {
        'beginafter': '}', 'beginbefore': '\\begin{', 'bracket': '{',
        'command': '\\', 'comment': '%', 'complex': '\\[', 'simple': '$',
        'squarebracket': '[', 'unnumbered': '*',
    }

    symbolfunctions = {
        '^': 'sup', '_': 'sub',
    }

    textfunctions = {
        '\\mbox': 'span class="mbox"',
        '\\text': 'span class="text"',
        '\\textbf': 'span class="textbf"',
        '\\textit': 'span class="textit"',
        '\\textnormal': 'span class="textnormal"',
        '\\textrm': 'span class="textrm"',
        '\\textsc': 'span class="textsc"',
        '\\textsf': 'span class="textsf"',
        '\\textsl': 'span class="textsl"',
        '\\texttt': 'span class="texttt"',
        '\\textup': 'span class="normal"',
    }

    unmodified = {
        'characters': ['.', '*', '€', '(', ')', '[', ']',
                       '·', '!', ';', '|', '§', '"', '?'],
        }


class CommandLineParser:
    "A parser for runtime options"

    def __init__(self, options):
        self.options = options

    def parseoptions(self, args):
        "Parse command line options"
        if len(args) == 0:
            return None
        while len(args) > 0 and args[0].startswith('--'):
            key, value = self.readoption(args)
            if not key:
                return 'Option ' + value + ' not recognized'
            if not value:
                return 'Option ' + key + ' needs a value'
            setattr(self.options, key, value)
        return None

    def readoption(self, args):
        "Read the key and value for an option"
        arg = args[0][2:]
        del args[0]
        if '=' in arg:
            key = self.readequalskey(arg, args)
        else:
            key = arg.replace('-', '')
        if not hasattr(self.options, key):
            return None, key
        current = getattr(self.options, key)
        if isinstance(current, bool):
            return key, True
        # read value
        if len(args) == 0:
            return key, None
        if args[0].startswith('"'):
            initial = args[0]
            del args[0]
            return key, self.readquoted(args, initial)
        value = args[0].decode('utf-8')
        del args[0]
        if isinstance(current, list):
            current.append(value)
            return key, current
        return key, value

    def readquoted(self, args, initial):
        "Read a value between quotes"
        Trace.error('Oops')
        value = initial[1:]
        while len(args) > 0 and not args[0].endswith('"') and not args[0].startswith('--'):
            Trace.error('Appending ' + args[0])
            value += ' ' + args[0]
            del args[0]
        if len(args) == 0 or args[0].startswith('--'):
            return None
        value += ' ' + args[0:-1]
        return value

    def readequalskey(self, arg, args):
        "Read a key using equals"
        split = arg.split('=', 1)
        key = split[0]
        value = split[1]
        args.insert(0, value)
        return key


class Options:
    "A set of runtime options"

    location = None

    debug = False
    quiet = False
    version = False
    help = False
    simplemath = False
    showlines = True

    branches = {}

    def parseoptions(self, args):
        "Parse command line options"
        Options.location = args[0]
        del args[0]
        parser = CommandLineParser(Options)
        result = parser.parseoptions(args)
        if result:
            Trace.error(result)
            self.usage()
        self.processoptions()

    def processoptions(self):
        "Process all options parsed."
        if Options.help:
            self.usage()
        if Options.version:
            self.showversion()
        # set in Trace if necessary
        for param in dir(Trace):
            if param.endswith('mode'):
                setattr(Trace, param, getattr(self, param[:-4]))

    def usage(self):
        "Show correct usage"
        Trace.error(f'Usage: {pathlib.Path(Options.location).parent}'
                    ' [options] "input string"')
        Trace.error('Convert input string with LaTeX math to MathML')
        self.showoptions()

    def showoptions(self):
        "Show all possible options"
        Trace.error('    --help:                 show this online help')
        Trace.error('    --quiet:                disables all runtime messages')
        Trace.error('    --debug:                enable debugging messages (for developers)')
        Trace.error('    --version:              show version number and release date')
        Trace.error('    --simplemath:           do not generate fancy math constructions')
        sys.exit()

    def showversion(self):
        "Return the current eLyXer version string"
        Trace.error('math2html '+__version__)
        sys.exit()


class Cloner:
    "An object used to clone other objects."

    def clone(cls, original):
        "Return an exact copy of an object."
        "The original object must have an empty constructor."
        return cls.create(original.__class__)

    def create(cls, type):
        "Create an object of a given class."
        clone = type.__new__(type)
        clone.__init__()
        return clone

    clone = classmethod(clone)
    create = classmethod(create)


class ContainerExtractor:
    """A class to extract certain containers.

    The config parameter is a map containing three lists:
    allowed, copied and extracted.
    Each of the three is a list of class names for containers.
    Allowed containers are included as is into the result.
    Cloned containers are cloned and placed into the result.
    Extracted containers are looked into.
    All other containers are silently ignored.
    """

    def __init__(self, config):
        self.allowed = config['allowed']
        self.extracted = config['extracted']

    def extract(self, container):
        "Extract a group of selected containers from a container."
        list = []
        locate = lambda c: c.__class__.__name__ in self.allowed
        recursive = lambda c: c.__class__.__name__ in self.extracted
        process = lambda c: self.process(c, list)
        container.recursivesearch(locate, recursive, process)
        return list

    def process(self, container, list):
        "Add allowed containers."
        name = container.__class__.__name__
        if name in self.allowed:
            list.append(container)
        else:
            Trace.error('Unknown container class ' + name)

    def safeclone(self, container):
        "Return a new container with contents only in a safe list, recursively."
        clone = Cloner.clone(container)
        clone.output = container.output
        clone.contents = self.extract(container)
        return clone


class Parser:
    "A generic parser"

    def __init__(self):
        self.begin = 0
        self.parameters = {}

    def parseheader(self, reader):
        "Parse the header"
        header = reader.currentline().split()
        reader.nextline()
        self.begin = reader.linenumber
        return header

    def parseparameter(self, reader):
        "Parse a parameter"
        split = reader.currentline().strip().split(' ', 1)
        reader.nextline()
        if len(split) == 0:
            return
        key = split[0]
        if len(split) == 1:
            self.parameters[key] = True
            return
        if '"' not in split[1]:
            self.parameters[key] = split[1].strip()
            return
        doublesplit = split[1].split('"')
        self.parameters[key] = doublesplit[1]

    def parseending(self, reader, process):
        "Parse until the current ending is found"
        if not self.ending:
            Trace.error('No ending for ' + str(self))
            return
        while not reader.currentline().startswith(self.ending):
            process()

    def parsecontainer(self, reader, contents):
        container = self.factory.createcontainer(reader)
        if container:
            container.parent = self.parent
            contents.append(container)

    def __str__(self):
        "Return a description"
        return self.__class__.__name__ + ' (' + str(self.begin) + ')'


class LoneCommand(Parser):
    "A parser for just one command line"

    def parse(self, reader):
        "Read nothing"
        return []


class TextParser(Parser):
    "A parser for a command and a bit of text"

    stack = []

    def __init__(self, container):
        Parser.__init__(self)
        self.ending = None
        if container.__class__.__name__ in ContainerConfig.endings:
            self.ending = ContainerConfig.endings[container.__class__.__name__]
        self.endings = []

    def parse(self, reader):
        "Parse lines as long as they are text"
        TextParser.stack.append(self.ending)
        self.endings = TextParser.stack + [ContainerConfig.endings['Layout'],
                                           ContainerConfig.endings['Inset'],
                                           self.ending]
        contents = []
        while not self.isending(reader):
            self.parsecontainer(reader, contents)
        return contents

    def isending(self, reader):
        "Check if text is ending"
        current = reader.currentline().split()
        if len(current) == 0:
            return False
        if current[0] in self.endings:
            if current[0] in TextParser.stack:
                TextParser.stack.remove(current[0])
            else:
                TextParser.stack = []
            return True
        return False


class ExcludingParser(Parser):
    "A parser that excludes the final line"

    def parse(self, reader):
        "Parse everything up to (and excluding) the final line"
        contents = []
        self.parseending(reader, lambda: self.parsecontainer(reader, contents))
        return contents


class BoundedParser(ExcludingParser):
    "A parser bound by a final line"

    def parse(self, reader):
        "Parse everything, including the final line"
        contents = ExcludingParser.parse(self, reader)
        # skip last line
        reader.nextline()
        return contents


class BoundedDummy(Parser):
    "A bound parser that ignores everything"

    def parse(self, reader):
        "Parse the contents of the container"
        self.parseending(reader, lambda: reader.nextline())
        # skip last line
        reader.nextline()
        return []


class StringParser(Parser):
    "Parses just a string"

    def parseheader(self, reader):
        "Do nothing, just take note"
        self.begin = reader.linenumber + 1
        return []

    def parse(self, reader):
        "Parse a single line"
        contents = reader.currentline()
        reader.nextline()
        return contents


class ContainerOutput:
    "The generic HTML output for a container."

    def gethtml(self, container):
        "Show an error."
        Trace.error('gethtml() not implemented for ' + str(self))

    def isempty(self):
        "Decide if the output is empty: by default, not empty."
        return False


class EmptyOutput(ContainerOutput):

    def gethtml(self, container):
        "Return empty HTML code."
        return []

    def isempty(self):
        "This output is particularly empty."
        return True


class FixedOutput(ContainerOutput):
    "Fixed output"

    def gethtml(self, container):
        "Return constant HTML code"
        return container.html


class ContentsOutput(ContainerOutput):
    "Outputs the contents converted to HTML"

    def gethtml(self, container):
        "Return the HTML code"
        html = []
        if container.contents is None:
            return html
        for element in container.contents:
            if not hasattr(element, 'gethtml'):
                Trace.error('No html in ' + element.__class__.__name__ + ': ' + str(element))
                return html
            html += element.gethtml()
        return html


class TaggedOutput(ContentsOutput):
    "Outputs an HTML tag surrounding the contents."

    tag = None
    breaklines = False
    empty = False

    def settag(self, tag, breaklines=False, empty=False):
        "Set the value for the tag and other attributes."
        self.tag = tag
        if breaklines:
            self.breaklines = breaklines
        if empty:
            self.empty = empty
        return self

    def setbreaklines(self, breaklines):
        "Set the value for breaklines."
        self.breaklines = breaklines
        return self

    def gethtml(self, container):
        "Return the HTML code."
        if self.empty:
            return [self.selfclosing(container)]
        html = [self.open(container)]
        html += ContentsOutput.gethtml(self, container)
        html.append(self.close(container))
        return html

    def open(self, container):
        "Get opening line."
        if not self.checktag(container):
            return ''
        open = '<' + self.tag + '>'
        if self.breaklines:
            return open + '\n'
        return open

    def close(self, container):
        "Get closing line."
        if not self.checktag(container):
            return ''
        close = '</' + self.tag.split()[0] + '>'
        if self.breaklines:
            return '\n' + close + '\n'
        return close

    def selfclosing(self, container):
        "Get self-closing line."
        if not self.checktag(container):
            return ''
        selfclosing = '<' + self.tag + '/>'
        if self.breaklines:
            return selfclosing + '\n'
        return selfclosing

    def checktag(self, container):
        "Check that the tag is valid."
        if not self.tag:
            Trace.error('No tag in ' + str(container))
            return False
        if self.tag == '':
            return False
        return True


class FilteredOutput(ContentsOutput):
    "Returns the output in the contents, but filtered:"
    "some strings are replaced by others."

    def __init__(self):
        "Initialize the filters."
        self.filters = []

    def addfilter(self, original, replacement):
        "Add a new filter: replace the original by the replacement."
        self.filters.append((original, replacement))

    def gethtml(self, container):
        "Return the HTML code"
        result = []
        html = ContentsOutput.gethtml(self, container)
        for line in html:
            result.append(self.filter(line))
        return result

    def filter(self, line):
        "Filter a single line with all available filters."
        for original, replacement in self.filters:
            if original in line:
                line = line.replace(original, replacement)
        return line


class StringOutput(ContainerOutput):
    "Returns a bare string as output"

    def gethtml(self, container):
        "Return a bare string"
        return [container.string]


class Globable:
    """A bit of text which can be globbed (lumped together in bits).
    Methods current(), skipcurrent(), checkfor() and isout() have to be
    implemented by subclasses."""

    leavepending = False

    def __init__(self):
        self.endinglist = EndingList()

    def checkbytemark(self):
        "Check for a Unicode byte mark and skip it."
        if self.finished():
            return
        if ord(self.current()) == 0xfeff:
            self.skipcurrent()

    def isout(self):
        "Find out if we are out of the position yet."
        Trace.error('Unimplemented isout()')
        return True

    def current(self):
        "Return the current character."
        Trace.error('Unimplemented current()')
        return ''

    def checkfor(self, string):
        "Check for the given string in the current position."
        Trace.error('Unimplemented checkfor()')
        return False

    def finished(self):
        "Find out if the current text has finished."
        if self.isout():
            if not self.leavepending:
                self.endinglist.checkpending()
            return True
        return self.endinglist.checkin(self)

    def skipcurrent(self):
        "Return the current character and skip it."
        Trace.error('Unimplemented skipcurrent()')
        return ''

    def glob(self, currentcheck):
        "Glob a bit of text that satisfies a check on the current char."
        glob = ''
        while not self.finished() and currentcheck():
            glob += self.skipcurrent()
        return glob

    def globalpha(self):
        "Glob a bit of alpha text"
        return self.glob(lambda: self.current().isalpha())

    def globnumber(self):
        "Glob a row of digits."
        return self.glob(lambda: self.current().isdigit())

    def isidentifier(self):
        "Return if the current character is alphanumeric or _."
        if self.current().isalnum() or self.current() == '_':
            return True
        return False

    def globidentifier(self):
        "Glob alphanumeric and _ symbols."
        return self.glob(self.isidentifier)

    def isvalue(self):
        "Return if the current character is a value character:"
        "not a bracket or a space."
        if self.current().isspace():
            return False
        if self.current() in '{}()':
            return False
        return True

    def globvalue(self):
        "Glob a value: any symbols but brackets."
        return self.glob(self.isvalue)

    def skipspace(self):
        "Skip all whitespace at current position."
        return self.glob(lambda: self.current().isspace())

    def globincluding(self, magicchar):
        "Glob a bit of text up to (including) the magic char."
        glob = self.glob(lambda: self.current() != magicchar) + magicchar
        self.skip(magicchar)
        return glob

    def globexcluding(self, excluded):
        "Glob a bit of text up until (excluding) any excluded character."
        return self.glob(lambda: self.current() not in excluded)

    def pushending(self, ending, optional=False):
        "Push a new ending to the bottom"
        self.endinglist.add(ending, optional)

    def popending(self, expected=None):
        "Pop the ending found at the current position"
        if self.isout() and self.leavepending:
            return expected
        ending = self.endinglist.pop(self)
        if expected and expected != ending:
            Trace.error('Expected ending ' + expected + ', got ' + ending)
        self.skip(ending)
        return ending

    def nextending(self):
        "Return the next ending in the queue."
        nextending = self.endinglist.findending(self)
        if not nextending:
            return None
        return nextending.ending


class EndingList:
    "A list of position endings"

    def __init__(self):
        self.endings = []

    def add(self, ending, optional=False):
        "Add a new ending to the list"
        self.endings.append(PositionEnding(ending, optional))

    def pickpending(self, pos):
        "Pick any pending endings from a parse position."
        self.endings += pos.endinglist.endings

    def checkin(self, pos):
        "Search for an ending"
        if self.findending(pos):
            return True
        return False

    def pop(self, pos):
        "Remove the ending at the current position"
        if pos.isout():
            Trace.error('No ending out of bounds')
            return ''
        ending = self.findending(pos)
        if not ending:
            Trace.error('No ending at ' + pos.current())
            return ''
        for each in reversed(self.endings):
            self.endings.remove(each)
            if each == ending:
                return each.ending
            elif not each.optional:
                Trace.error('Removed non-optional ending ' + each)
        Trace.error('No endings left')
        return ''

    def findending(self, pos):
        "Find the ending at the current position"
        if len(self.endings) == 0:
            return None
        for index, ending in enumerate(reversed(self.endings)):
            if ending.checkin(pos):
                return ending
            if not ending.optional:
                return None
        return None

    def checkpending(self):
        "Check if there are any pending endings"
        if len(self.endings) != 0:
            Trace.error('Pending ' + str(self) + ' left open')

    def __str__(self):
        "Printable representation"
        string = 'endings ['
        for ending in self.endings:
            string += str(ending) + ','
        if len(self.endings) > 0:
            string = string[:-1]
        return string + ']'


class PositionEnding:
    "An ending for a parsing position"

    def __init__(self, ending, optional):
        self.ending = ending
        self.optional = optional

    def checkin(self, pos):
        "Check for the ending"
        return pos.checkfor(self.ending)

    def __str__(self):
        "Printable representation"
        string = 'Ending ' + self.ending
        if self.optional:
            string += ' (optional)'
        return string


class Position(Globable):
    """A position in a text to parse.
    Including those in Globable, functions to implement by subclasses are:
    skip(), identifier(), extract(), isout() and current()."""

    def __init__(self):
        Globable.__init__(self)

    def skip(self, string):
        "Skip a string"
        Trace.error('Unimplemented skip()')

    def identifier(self):
        "Return an identifier for the current position."
        Trace.error('Unimplemented identifier()')
        return 'Error'

    def extract(self, length):
        "Extract the next string of the given length, or None if not enough text,"
        "without advancing the parse position."
        Trace.error('Unimplemented extract()')
        return None

    def checkfor(self, string):
        "Check for a string at the given position."
        return string == self.extract(len(string))

    def checkforlower(self, string):
        "Check for a string in lower case."
        extracted = self.extract(len(string))
        if not extracted:
            return False
        return string.lower() == self.extract(len(string)).lower()

    def skipcurrent(self):
        "Return the current character and skip it."
        current = self.current()
        self.skip(current)
        return current

    def __next__(self):
        "Advance the position and return the next character."
        self.skipcurrent()
        return self.current()

    def checkskip(self, string):
        "Check for a string at the given position; if there, skip it"
        if not self.checkfor(string):
            return False
        self.skip(string)
        return True

    def error(self, message):
        "Show an error message and the position identifier."
        Trace.error(message + ': ' + self.identifier())


class TextPosition(Position):
    "A parse position based on a raw text."

    def __init__(self, text):
        "Create the position from some text."
        Position.__init__(self)
        self.pos = 0
        self.text = text
        self.checkbytemark()

    def skip(self, string):
        "Skip a string of characters."
        self.pos += len(string)

    def identifier(self):
        "Return a sample of the remaining text."
        length = 30
        if self.pos + length > len(self.text):
            length = len(self.text) - self.pos
        return '*' + self.text[self.pos:self.pos + length] + '*'

    def isout(self):
        "Find out if we are out of the text yet."
        return self.pos >= len(self.text)

    def current(self):
        "Return the current character, assuming we are not out."
        return self.text[self.pos]

    def extract(self, length):
        "Extract the next string of the given length, or None if not enough text."
        if self.pos + length > len(self.text):
            return None
        return self.text[self.pos : self.pos + length]                 # noqa: E203


class Container:
    "A container for text and objects in a lyx file"

    partkey = None
    parent = None
    begin = None

    def __init__(self):
        self.contents = list()

    def process(self):
        "Process contents"
        pass

    def gethtml(self):
        "Get the resulting HTML"
        html = self.output.gethtml(self)
        if isinstance(html, str):
            Trace.error('Raw string ' + html)
            html = [html]
        return html

    def escape(self, line, replacements=EscapeConfig.entities):
        "Escape a line with replacements from a map"
        pieces = sorted(replacements.keys())
        # do them in order
        for piece in pieces:
            if piece in line:
                line = line.replace(piece, replacements[piece])
        return line

    def escapeentities(self, line):
        "Escape all Unicode characters to HTML entities."
        result = ''
        pos = TextPosition(line)
        while not pos.finished():
            if ord(pos.current()) > 128:
                codepoint = hex(ord(pos.current()))
                if codepoint == '0xd835':
                    codepoint = hex(ord(next(pos)) + 0xf800)
                result += '&#' + codepoint[1:] + ';'
            else:
                result += pos.current()
            pos.skipcurrent()
        return result

    def searchall(self, type):
        "Search for all embedded containers of a given type"
        list = []
        self.searchprocess(type, lambda container: list.append(container))
        return list

    def searchremove(self, type):
        "Search for all containers of a type and remove them"
        list = self.searchall(type)
        for container in list:
            container.parent.contents.remove(container)
        return list

    def searchprocess(self, type, process):
        "Search for elements of a given type and process them"
        self.locateprocess(lambda container: isinstance(container, type), process)

    def locateprocess(self, locate, process):
        "Search for all embedded containers and process them"
        for container in self.contents:
            container.locateprocess(locate, process)
            if locate(container):
                process(container)

    def recursivesearch(self, locate, recursive, process):
        "Perform a recursive search in the container."
        for container in self.contents:
            if recursive(container):
                container.recursivesearch(locate, recursive, process)
            if locate(container):
                process(container)

    def extracttext(self):
        "Extract all text from allowed containers."
        constants = ContainerExtractor(ContainerConfig.extracttext).extract(self)
        return ''.join(constant.string for constant in constants)

    def group(self, index, group, isingroup):
        "Group some adjoining elements into a group"
        if index >= len(self.contents):
            return
        if hasattr(self.contents[index], 'grouped'):
            return
        while index < len(self.contents) and isingroup(self.contents[index]):
            self.contents[index].grouped = True
            group.contents.append(self.contents[index])
            self.contents.pop(index)
        self.contents.insert(index, group)

    def remove(self, index):
        "Remove a container but leave its contents"
        container = self.contents[index]
        self.contents.pop(index)
        while len(container.contents) > 0:
            self.contents.insert(index, container.contents.pop())

    def tree(self, level=0):
        "Show in a tree"
        Trace.debug("  " * level + str(self))
        for container in self.contents:
            container.tree(level + 1)

    def getparameter(self, name):
        "Get the value of a parameter, if present."
        if name not in self.parameters:
            return None
        return self.parameters[name]

    def getparameterlist(self, name):
        "Get the value of a comma-separated parameter as a list."
        paramtext = self.getparameter(name)
        if not paramtext:
            return []
        return paramtext.split(',')

    def hasemptyoutput(self):
        "Check if the parent's output is empty."
        current = self.parent
        while current:
            if current.output.isempty():
                return True
            current = current.parent
        return False

    def __str__(self):
        "Get a description"
        if not self.begin:
            return self.__class__.__name__
        return self.__class__.__name__ + '@' + str(self.begin)


class BlackBox(Container):
    "A container that does not output anything"

    def __init__(self):
        self.parser = LoneCommand()
        self.output = EmptyOutput()
        self.contents = []


class StringContainer(Container):
    "A container for a single string"

    parsed = None

    def __init__(self):
        self.parser = StringParser()
        self.output = StringOutput()
        self.string = ''

    def process(self):
        "Replace special chars from the contents."
        if self.parsed:
            self.string = self.replacespecial(self.parsed)
            self.parsed = None

    def replacespecial(self, line):
        "Replace all special chars from a line"
        replaced = self.escape(line, EscapeConfig.entities)
        replaced = self.changeline(replaced)
        if ContainerConfig.string['startcommand'] in replaced and len(replaced) > 1:
            # unprocessed commands
            if self.begin:
                message = 'Unknown command at ' + str(self.begin) + ': '
            else:
                message = 'Unknown command: '
            Trace.error(message + replaced.strip())
        return replaced

    def changeline(self, line):
        return self.escape(line, EscapeConfig.chars)

    def extracttext(self):
        "Return all text."
        return self.string

    def __str__(self):
        "Return a printable representation."
        result = 'StringContainer'
        if self.begin:
            result += '@' + str(self.begin)
        ellipsis = '...'
        if len(self.string.strip()) <= 15:
            ellipsis = ''
        return result + ' (' + self.string.strip()[:15] + ellipsis + ')'


class Constant(StringContainer):
    "A constant string"

    def __init__(self, text):
        self.contents = []
        self.string = text
        self.output = StringOutput()

    def __str__(self):
        return 'Constant: ' + self.string


class DocumentParameters:
    "Global parameters for the document."

    displaymode = False


class FormulaParser(Parser):
    "Parses a formula"

    def parseheader(self, reader):
        "See if the formula is inlined"
        self.begin = reader.linenumber + 1
        type = self.parsetype(reader)
        if not type:
            reader.nextline()
            type = self.parsetype(reader)
            if not type:
                Trace.error('Unknown formula type in ' + reader.currentline().strip())
                return ['unknown']
        return [type]

    def parsetype(self, reader):
        "Get the formula type from the first line."
        if reader.currentline().find(FormulaConfig.starts['simple']) >= 0:
            return 'inline'
        if reader.currentline().find(FormulaConfig.starts['complex']) >= 0:
            return 'block'
        if reader.currentline().find(FormulaConfig.starts['unnumbered']) >= 0:
            return 'block'
        if reader.currentline().find(FormulaConfig.starts['beginbefore']) >= 0:
            return 'numbered'
        return None

    def parse(self, reader):
        "Parse the formula until the end"
        formula = self.parseformula(reader)
        while not reader.currentline().startswith(self.ending):
            stripped = reader.currentline().strip()
            if len(stripped) > 0:
                Trace.error('Unparsed formula line ' + stripped)
            reader.nextline()
        reader.nextline()
        return formula

    def parseformula(self, reader):
        "Parse the formula contents"
        simple = FormulaConfig.starts['simple']
        if simple in reader.currentline():
            rest = reader.currentline().split(simple, 1)[1]
            if simple in rest:
                # formula is $...$
                return self.parsesingleliner(reader, simple, simple)
            # formula is multiline $...$
            return self.parsemultiliner(reader, simple, simple)
        if FormulaConfig.starts['complex'] in reader.currentline():
            # formula of the form \[...\]
            return self.parsemultiliner(reader, FormulaConfig.starts['complex'],
                                        FormulaConfig.endings['complex'])
        beginbefore = FormulaConfig.starts['beginbefore']
        beginafter = FormulaConfig.starts['beginafter']
        if beginbefore in reader.currentline():
            if reader.currentline().strip().endswith(beginafter):
                current = reader.currentline().strip()
                endsplit = current.split(beginbefore)[1].split(beginafter)
                startpiece = beginbefore + endsplit[0] + beginafter
                endbefore = FormulaConfig.endings['endbefore']
                endafter = FormulaConfig.endings['endafter']
                endpiece = endbefore + endsplit[0] + endafter
                return startpiece + self.parsemultiliner(reader, startpiece, endpiece) + endpiece
            Trace.error('Missing ' + beginafter + ' in ' + reader.currentline())
            return ''
        begincommand = FormulaConfig.starts['command']
        beginbracket = FormulaConfig.starts['bracket']
        if begincommand in reader.currentline() and beginbracket in reader.currentline():
            endbracket = FormulaConfig.endings['bracket']
            return self.parsemultiliner(reader, beginbracket, endbracket)
        Trace.error('Formula beginning ' + reader.currentline() + ' is unknown')
        return ''

    def parsesingleliner(self, reader, start, ending):
        "Parse a formula in one line"
        line = reader.currentline().strip()
        if start not in line:
            Trace.error('Line ' + line + ' does not contain formula start ' + start)
            return ''
        if not line.endswith(ending):
            Trace.error('Formula ' + line + ' does not end with ' + ending)
            return ''
        index = line.index(start)
        rest = line[index + len(start):-len(ending)]
        reader.nextline()
        return rest

    def parsemultiliner(self, reader, start, ending):
        "Parse a formula in multiple lines"
        formula = ''
        line = reader.currentline()
        if start not in line:
            Trace.error('Line ' + line.strip() + ' does not contain formula start ' + start)
            return ''
        index = line.index(start)
        line = line[index + len(start):].strip()
        while not line.endswith(ending):
            formula += line + '\n'
            reader.nextline()
            line = reader.currentline()
        formula += line[:-len(ending)]
        reader.nextline()
        return formula


class FormulaBit(Container):
    "A bit of a formula"

    type = None
    size = 1
    original = ''

    def __init__(self):
        "The formula bit type can be 'alpha', 'number', 'font'."
        self.contents = []
        self.output = ContentsOutput()

    def setfactory(self, factory):
        "Set the internal formula factory."
        self.factory = factory
        return self

    def add(self, bit):
        "Add any kind of formula bit already processed"
        self.contents.append(bit)
        self.original += bit.original
        bit.parent = self

    def skiporiginal(self, string, pos):
        "Skip a string and add it to the original formula"
        self.original += string
        if not pos.checkskip(string):
            Trace.error('String ' + string + ' not at ' + pos.identifier())

    def computesize(self):
        "Compute the size of the bit as the max of the sizes of all contents."
        if len(self.contents) == 0:
            return 1
        self.size = max(element.size for element in self.contents)
        return self.size

    def clone(self):
        "Return a copy of itself."
        return self.factory.parseformula(self.original)

    def __str__(self):
        "Get a string representation"
        return self.__class__.__name__ + ' read in ' + self.original


class TaggedBit(FormulaBit):
    "A tagged string in a formula"

    def constant(self, constant, tag):
        "Set the constant and the tag"
        self.output = TaggedOutput().settag(tag)
        self.add(FormulaConstant(constant))
        return self

    def complete(self, contents, tag, breaklines=False):
        "Set the constant and the tag"
        self.contents = contents
        self.output = TaggedOutput().settag(tag, breaklines)
        return self

    def selfcomplete(self, tag):
        "Set the self-closing tag, no contents (as in <hr/>)."
        self.output = TaggedOutput().settag(tag, empty=True)
        return self


class FormulaConstant(Constant):
    "A constant string in a formula"

    def __init__(self, string):
        "Set the constant string"
        Constant.__init__(self, string)
        self.original = string
        self.size = 1
        self.type = None

    def computesize(self):
        "Compute the size of the constant: always 1."
        return self.size

    def clone(self):
        "Return a copy of itself."
        return FormulaConstant(self.original)

    def __str__(self):
        "Return a printable representation."
        return 'Formula constant: ' + self.string


class RawText(FormulaBit):
    "A bit of text inside a formula"

    def detect(self, pos):
        "Detect a bit of raw text"
        return pos.current().isalpha()

    def parsebit(self, pos):
        "Parse alphabetic text"
        alpha = pos.globalpha()
        self.add(FormulaConstant(alpha))
        self.type = 'alpha'


class FormulaSymbol(FormulaBit):
    "A symbol inside a formula"

    modified = FormulaConfig.modified
    unmodified = FormulaConfig.unmodified['characters']

    def detect(self, pos):
        "Detect a symbol"
        if pos.current() in FormulaSymbol.unmodified:
            return True
        if pos.current() in FormulaSymbol.modified:
            return True
        return False

    def parsebit(self, pos):
        "Parse the symbol"
        if pos.current() in FormulaSymbol.unmodified:
            self.addsymbol(pos.current(), pos)
            return
        if pos.current() in FormulaSymbol.modified:
            self.addsymbol(FormulaSymbol.modified[pos.current()], pos)
            return
        Trace.error('Symbol ' + pos.current() + ' not found')

    def addsymbol(self, symbol, pos):
        "Add a symbol"
        self.skiporiginal(pos.current(), pos)
        self.contents.append(FormulaConstant(symbol))


class FormulaNumber(FormulaBit):
    "A string of digits in a formula"

    def detect(self, pos):
        "Detect a digit"
        return pos.current().isdigit()

    def parsebit(self, pos):
        "Parse a bunch of digits"
        digits = pos.glob(lambda: pos.current().isdigit())
        self.add(FormulaConstant(digits))
        self.type = 'number'


class Comment(FormulaBit):
    "A LaTeX comment: % to the end of the line."

    start = FormulaConfig.starts['comment']

    def detect(self, pos):
        "Detect the %."
        return pos.current() == self.start

    def parsebit(self, pos):
        "Parse to the end of the line."
        self.original += pos.globincluding('\n')


class WhiteSpace(FormulaBit):
    "Some white space inside a formula."

    def detect(self, pos):
        "Detect the white space."
        return pos.current().isspace()

    def parsebit(self, pos):
        "Parse all whitespace."
        self.original += pos.skipspace()

    def __str__(self):
        "Return a printable representation."
        return 'Whitespace: *' + self.original + '*'


class Bracket(FormulaBit):
    "A {} bracket inside a formula"

    start = FormulaConfig.starts['bracket']
    ending = FormulaConfig.endings['bracket']

    def __init__(self):
        "Create a (possibly literal) new bracket"
        FormulaBit.__init__(self)
        self.inner = None

    def detect(self, pos):
        "Detect the start of a bracket"
        return pos.checkfor(self.start)

    def parsebit(self, pos):
        "Parse the bracket"
        self.parsecomplete(pos, self.innerformula)
        return self

    def parsetext(self, pos):
        "Parse a text bracket"
        self.parsecomplete(pos, self.innertext)
        return self

    def parseliteral(self, pos):
        "Parse a literal bracket"
        self.parsecomplete(pos, self.innerliteral)
        return self

    def parsecomplete(self, pos, innerparser):
        "Parse the start and end marks"
        if not pos.checkfor(self.start):
            Trace.error('Bracket should start with ' + self.start + ' at ' + pos.identifier())
            return None
        self.skiporiginal(self.start, pos)
        pos.pushending(self.ending)
        innerparser(pos)
        self.original += pos.popending(self.ending)
        self.computesize()

    def innerformula(self, pos):
        "Parse a whole formula inside the bracket"
        while not pos.finished():
            self.add(self.factory.parseany(pos))

    def innertext(self, pos):
        "Parse some text inside the bracket, following textual rules."
        specialchars = list(FormulaConfig.symbolfunctions.keys())
        specialchars.append(FormulaConfig.starts['command'])
        specialchars.append(FormulaConfig.starts['bracket'])
        specialchars.append(Comment.start)
        while not pos.finished():
            if pos.current() in specialchars:
                self.add(self.factory.parseany(pos))
                if pos.checkskip(' '):
                    self.original += ' '
            else:
                self.add(FormulaConstant(pos.skipcurrent()))

    def innerliteral(self, pos):
        "Parse a literal inside the bracket, which does not generate HTML."
        self.literal = ''
        while not pos.finished() and not pos.current() == self.ending:
            if pos.current() == self.start:
                self.parseliteral(pos)
            else:
                self.literal += pos.skipcurrent()
        self.original += self.literal


class SquareBracket(Bracket):
    "A [] bracket inside a formula"

    start = FormulaConfig.starts['squarebracket']
    ending = FormulaConfig.endings['squarebracket']

    def clone(self):
        "Return a new square bracket with the same contents."
        bracket = SquareBracket()
        bracket.contents = self.contents
        return bracket


class MathsProcessor:
    "A processor for a maths construction inside the FormulaProcessor."

    def process(self, contents, index):
        "Process an element inside a formula."
        Trace.error('Unimplemented process() in ' + str(self))

    def __str__(self):
        "Return a printable description."
        return 'Maths processor ' + self.__class__.__name__


class FormulaProcessor:
    "A processor specifically for formulas."

    processors = []

    def process(self, bit):
        "Process the contents of every formula bit, recursively."
        self.processcontents(bit)
        self.processinsides(bit)
        self.traversewhole(bit)

    def processcontents(self, bit):
        "Process the contents of a formula bit."
        if not isinstance(bit, FormulaBit):
            return
        bit.process()
        for element in bit.contents:
            self.processcontents(element)

    def processinsides(self, bit):
        "Process the insides (limits, brackets) in a formula bit."
        if not isinstance(bit, FormulaBit):
            return
        for index, element in enumerate(bit.contents):
            for processor in self.processors:
                processor.process(bit.contents, index)
            # continue with recursive processing
            self.processinsides(element)

    def traversewhole(self, formula):
        "Traverse over the contents to alter variables and space units."
        last = None
        for bit, contents in self.traverse(formula):
            if bit.type == 'alpha':
                self.italicize(bit, contents)
            elif bit.type == 'font' and last and last.type == 'number':
                bit.contents.insert(0, FormulaConstant('\u2009'))
            last = bit

    def traverse(self, bit):
        "Traverse a formula and yield a flattened structure of (bit, list) pairs."
        for element in bit.contents:
            if hasattr(element, 'type') and element.type:
                yield element, bit.contents
            elif isinstance(element, FormulaBit):
                yield from self.traverse(element)

    def italicize(self, bit, contents):
        "Italicize the given bit of text."
        index = contents.index(bit)
        contents[index] = TaggedBit().complete([bit], 'i')


class Formula(Container):
    "A LaTeX formula"

    def __init__(self):
        self.parser = FormulaParser()
        self.output = TaggedOutput().settag('span class="formula"')

    def process(self):
        "Convert the formula to tags"
        if self.header[0] == 'inline':
            DocumentParameters.displaymode = False
        else:
            DocumentParameters.displaymode = True
            self.output.settag('div class="formula"', True)
        self.classic()

    def classic(self):
        "Make the contents using classic output generation with XHTML and CSS."
        whole = FormulaFactory().parseformula(self.parsed)
        FormulaProcessor().process(whole)
        whole.parent = self
        self.contents = [whole]

    def parse(self, pos):
        "Parse using a parse position instead of self.parser."
        if pos.checkskip('$$'):
            self.parsedollarblock(pos)
        elif pos.checkskip('$'):
            self.parsedollarinline(pos)
        elif pos.checkskip('\\('):
            self.parseinlineto(pos, '\\)')
        elif pos.checkskip('\\['):
            self.parseblockto(pos, '\\]')
        else:
            pos.error('Unparseable formula')
        self.process()
        return self

    def parsedollarinline(self, pos):
        "Parse a $...$ formula."
        self.header = ['inline']
        self.parsedollar(pos)

    def parsedollarblock(self, pos):
        "Parse a $$...$$ formula."
        self.header = ['block']
        self.parsedollar(pos)
        if not pos.checkskip('$'):
            pos.error('Formula should be $$...$$, but last $ is missing.')

    def parsedollar(self, pos):
        "Parse to the next $."
        pos.pushending('$')
        self.parsed = pos.globexcluding('$')
        pos.popending('$')

    def parseinlineto(self, pos, limit):
        "Parse a \\(...\\) formula."
        self.header = ['inline']
        self.parseupto(pos, limit)

    def parseblockto(self, pos, limit):
        "Parse a \\[...\\] formula."
        self.header = ['block']
        self.parseupto(pos, limit)

    def parseupto(self, pos, limit):
        "Parse a formula that ends with the given command."
        pos.pushending(limit)
        self.parsed = pos.glob(lambda: True)
        pos.popending(limit)

    def __str__(self):
        "Return a printable representation."
        if self.partkey and self.partkey.number:
            return 'Formula (' + self.partkey.number + ')'
        return 'Unnumbered formula'


class WholeFormula(FormulaBit):
    "Parse a whole formula"

    def detect(self, pos):
        "Not outside the formula is enough."
        return not pos.finished()

    def parsebit(self, pos):
        "Parse with any formula bit"
        while not pos.finished():
            self.add(self.factory.parseany(pos))


class FormulaFactory:
    "Construct bits of formula"

    # bit types will be appended later
    types = [FormulaSymbol, RawText, FormulaNumber, Bracket, Comment, WhiteSpace]
    skippedtypes = [Comment, WhiteSpace]
    defining = False

    def __init__(self):
        "Initialize the map of instances."
        self.instances = {}

    def detecttype(self, type, pos):
        "Detect a bit of a given type."
        if pos.finished():
            return False
        return self.instance(type).detect(pos)

    def instance(self, type):
        "Get an instance of the given type."
        if type not in self.instances or not self.instances[type]:
            self.instances[type] = self.create(type)
        return self.instances[type]

    def create(self, type):
        "Create a new formula bit of the given type."
        return Cloner.create(type).setfactory(self)

    def clearskipped(self, pos):
        "Clear any skipped types."
        while not pos.finished():
            if not self.skipany(pos):
                return
        return

    def skipany(self, pos):
        "Skip any skipped types."
        for type in self.skippedtypes:
            if self.instance(type).detect(pos):
                return self.parsetype(type, pos)
        return None

    def parseany(self, pos):
        "Parse any formula bit at the current location."
        for type in self.types + self.skippedtypes:
            if self.detecttype(type, pos):
                return self.parsetype(type, pos)
        Trace.error('Unrecognized formula at ' + pos.identifier())
        return FormulaConstant(pos.skipcurrent())

    def parsetype(self, type, pos):
        "Parse the given type and return it."
        bit = self.instance(type)
        self.instances[type] = None
        returnedbit = bit.parsebit(pos)
        if returnedbit:
            return returnedbit.setfactory(self)
        return bit

    def parseformula(self, formula):
        "Parse a string of text that contains a whole formula."
        pos = TextPosition(formula)
        whole = self.create(WholeFormula)
        if whole.detect(pos):
            whole.parsebit(pos)
            return whole
        # no formula found
        if not pos.finished():
            Trace.error('Unknown formula at: ' + pos.identifier())
            whole.add(TaggedBit().constant(formula, 'span class="unknown"'))
        return whole


class FormulaCommand(FormulaBit):
    "A LaTeX command inside a formula"

    types = []
    start = FormulaConfig.starts['command']
    commandmap = None

    def detect(self, pos):
        "Find the current command."
        return pos.checkfor(FormulaCommand.start)

    def parsebit(self, pos):
        "Parse the command."
        command = self.extractcommand(pos)
        bit = self.parsewithcommand(command, pos)
        if bit:
            return bit
        if command.startswith('\\up') or command.startswith('\\Up'):
            upgreek = self.parseupgreek(command, pos)
            if upgreek:
                return upgreek
        if not self.factory.defining:
            Trace.error('Unknown command ' + command)
        self.output = TaggedOutput().settag('span class="unknown"')
        self.add(FormulaConstant(command))
        return None

    def parsewithcommand(self, command, pos):
        "Parse the command type once we have the command."
        for type in FormulaCommand.types:
            if command in type.commandmap:
                return self.parsecommandtype(command, type, pos)
        return None

    def parsecommandtype(self, command, type, pos):
        "Parse a given command type."
        bit = self.factory.create(type)
        bit.setcommand(command)
        returned = bit.parsebit(pos)
        if returned:
            return returned
        return bit

    def extractcommand(self, pos):
        "Extract the command from the current position."
        if not pos.checkskip(FormulaCommand.start):
            pos.error('Missing command start ' + FormulaCommand.start)
            return
        if pos.finished():
            return self.emptycommand(pos)
        if pos.current().isalpha():
            # alpha command
            command = FormulaCommand.start + pos.globalpha()
            # skip mark of short command
            pos.checkskip('*')
            return command
        # symbol command
        return FormulaCommand.start + pos.skipcurrent()

    def emptycommand(self, pos):
        """Check for an empty command: look for command disguised as ending.
        Special case against '{ \\{ \\} }' situation."""
        command = ''
        if not pos.isout():
            ending = pos.nextending()
            if ending and pos.checkskip(ending):
                command = ending
        return FormulaCommand.start + command

    def parseupgreek(self, command, pos):
        "Parse the Greek \\up command.."
        if len(command) < 4:
            return None
        if command.startswith('\\up'):
            upcommand = '\\' + command[3:]
        elif pos.checkskip('\\Up'):
            upcommand = '\\' + command[3:4].upper() + command[4:]
        else:
            Trace.error('Impossible upgreek command: ' + command)
            return
        upgreek = self.parsewithcommand(upcommand, pos)
        if upgreek:
            upgreek.type = 'font'
        return upgreek


class CommandBit(FormulaCommand):
    "A formula bit that includes a command"

    def setcommand(self, command):
        "Set the command in the bit"
        self.command = command
        if self.commandmap:
            self.original += command
            self.translated = self.commandmap[self.command]

    def parseparameter(self, pos):
        "Parse a parameter at the current position"
        self.factory.clearskipped(pos)
        if pos.finished():
            return None
        parameter = self.factory.parseany(pos)
        self.add(parameter)
        return parameter

    def parsesquare(self, pos):
        "Parse a square bracket"
        self.factory.clearskipped(pos)
        if not self.factory.detecttype(SquareBracket, pos):
            return None
        bracket = self.factory.parsetype(SquareBracket, pos)
        self.add(bracket)
        return bracket

    def parseliteral(self, pos):
        "Parse a literal bracket."
        self.factory.clearskipped(pos)
        if not self.factory.detecttype(Bracket, pos):
            if not pos.isvalue():
                Trace.error('No literal parameter found at: ' + pos.identifier())
                return None
            return pos.globvalue()
        bracket = Bracket().setfactory(self.factory)
        self.add(bracket.parseliteral(pos))
        return bracket.literal

    def parsesquareliteral(self, pos):
        "Parse a square bracket literally."
        self.factory.clearskipped(pos)
        if not self.factory.detecttype(SquareBracket, pos):
            return None
        bracket = SquareBracket().setfactory(self.factory)
        self.add(bracket.parseliteral(pos))
        return bracket.literal

    def parsetext(self, pos):
        "Parse a text parameter."
        self.factory.clearskipped(pos)
        if not self.factory.detecttype(Bracket, pos):
            Trace.error('No text parameter for ' + self.command)
            return None
        bracket = Bracket().setfactory(self.factory).parsetext(pos)
        self.add(bracket)
        return bracket


class EmptyCommand(CommandBit):
    "An empty command (without parameters)"

    commandmap = FormulaConfig.commands

    def parsebit(self, pos):
        "Parse a command without parameters"
        self.contents = [FormulaConstant(self.translated)]


class SpacedCommand(CommandBit):
    """An empty command which should have math spacing in formulas."""

    commandmap = FormulaConfig.spacedcommands

    def parsebit(self, pos):
        "Place as contents the command translated and spaced."
        # pad with MEDIUM MATHEMATICAL SPACE (4/18 em): too wide in STIX fonts :(
        # self.contents = [FormulaConstant('\u205f' + self.translated + '\u205f')]
        # pad with THIN SPACE (1/5 em)
        self.contents = [FormulaConstant('\u2009' + self.translated + '\u2009')]


class AlphaCommand(EmptyCommand):
    """A command without parameters whose result is alphabetical."""

    commandmap = FormulaConfig.alphacommands
    greek_capitals = ('\\Xi', '\\Theta', '\\Pi', '\\Sigma', '\\Gamma',
                      '\\Lambda', '\\Phi', '\\Psi', '\\Delta',
                      '\\Upsilon', '\\Omega')

    def parsebit(self, pos):
        "Parse the command and set type to alpha"
        EmptyCommand.parsebit(self, pos)
        if self.command not in self.greek_capitals:
            # Greek Capital letters are upright in LaTeX default math-style.
            # TODO: use italic, like in MathML and "iso" math-style?
            self.type = 'alpha'


class OneParamFunction(CommandBit):
    "A function of one parameter"

    commandmap = FormulaConfig.onefunctions
    simplified = False

    def parsebit(self, pos):
        "Parse a function with one parameter"
        self.output = TaggedOutput().settag(self.translated)
        self.parseparameter(pos)
        self.simplifyifpossible()

    def simplifyifpossible(self):
        "Try to simplify to a single character."
        if self.original in self.commandmap:
            self.output = FixedOutput()
            self.html = [self.commandmap[self.original]]
            self.simplified = True


class SymbolFunction(CommandBit):
    "Find a function which is represented by a symbol (like _ or ^)"

    commandmap = FormulaConfig.symbolfunctions

    def detect(self, pos):
        "Find the symbol"
        return pos.current() in SymbolFunction.commandmap

    def parsebit(self, pos):
        "Parse the symbol"
        self.setcommand(pos.current())
        pos.skip(self.command)
        self.output = TaggedOutput().settag(self.translated)
        self.parseparameter(pos)


class TextFunction(CommandBit):
    "A function where parameters are read as text."

    commandmap = FormulaConfig.textfunctions

    def parsebit(self, pos):
        "Parse a text parameter"
        self.output = TaggedOutput().settag(self.translated)
        self.parsetext(pos)

    def process(self):
        "Set the type to font"
        self.type = 'font'


class FontFunction(OneParamFunction):
    """A function of one parameter that changes the font."""
    # TODO: keep letters italic with \boldsymbol.

    commandmap = FormulaConfig.fontfunctions

    def process(self):
        "Simplify if possible using a single character."
        self.type = 'font'
        self.simplifyifpossible()


FormulaFactory.types += [FormulaCommand, SymbolFunction]
FormulaCommand.types = [
    AlphaCommand, EmptyCommand, OneParamFunction, FontFunction,
    TextFunction, SpacedCommand]


class BigBracket:
    "A big bracket generator."

    def __init__(self, size, bracket, alignment='l'):
        "Set the size and symbol for the bracket."
        self.size = size
        self.original = bracket
        self.alignment = alignment
        self.pieces = None
        if bracket in FormulaConfig.bigbrackets:
            self.pieces = FormulaConfig.bigbrackets[bracket]

    def getpiece(self, index):
        "Return the nth piece for the bracket."
        function = getattr(self, 'getpiece' + str(len(self.pieces)))
        return function(index)

    def getpiece1(self, index):
        "Return the only piece for a single-piece bracket."
        return self.pieces[0]

    def getpiece3(self, index):
        "Get the nth piece for a 3-piece bracket: parenthesis or square bracket."
        if index == 0:
            return self.pieces[0]
        if index == self.size - 1:
            return self.pieces[-1]
        return self.pieces[1]

    def getpiece4(self, index):
        "Get the nth piece for a 4-piece bracket: curly bracket."
        if index == 0:
            return self.pieces[0]
        if index == self.size - 1:
            return self.pieces[3]
        if index == (self.size - 1)/2:
            return self.pieces[2]
        return self.pieces[1]

    def getcell(self, index):
        "Get the bracket piece as an array cell."
        piece = self.getpiece(index)
        span = 'span class="bracket align-' + self.alignment + '"'
        return TaggedBit().constant(piece, span)

    def getcontents(self):
        "Get the bracket as an array or as a single bracket."
        if self.size == 1 or not self.pieces:
            return self.getsinglebracket()
        rows = []
        for index in range(self.size):
            cell = self.getcell(index)
            rows.append(TaggedBit().complete([cell], 'span class="arrayrow"'))
        return [TaggedBit().complete(rows, 'span class="array"')]

    def getsinglebracket(self):
        "Return the bracket as a single sign."
        if self.original == '.':
            return [TaggedBit().constant('', 'span class="emptydot"')]
        return [TaggedBit().constant(self.original, 'span class="stretchy"')]


class FormulaEquation(CommandBit):
    "A simple numbered equation."

    piece = 'equation'

    def parsebit(self, pos):
        "Parse the array"
        self.output = ContentsOutput()
        self.add(self.factory.parsetype(WholeFormula, pos))


class FormulaCell(FormulaCommand):
    "An array cell inside a row"

    def setalignment(self, alignment):
        self.alignment = alignment
        self.output = TaggedOutput().settag('span class="arraycell align-'
                                            + alignment + '"', True)
        return self

    def parsebit(self, pos):
        self.factory.clearskipped(pos)
        if pos.finished():
            return
        self.add(self.factory.parsetype(WholeFormula, pos))


class FormulaRow(FormulaCommand):
    "An array row inside an array"

    cellseparator = FormulaConfig.array['cellseparator']

    def setalignments(self, alignments):
        self.alignments = alignments
        self.output = TaggedOutput().settag('span class="arrayrow"', True)
        return self

    def parsebit(self, pos):
        "Parse a whole row"
        index = 0
        pos.pushending(self.cellseparator, optional=True)
        while not pos.finished():
            cell = self.createcell(index)
            cell.parsebit(pos)
            self.add(cell)
            index += 1
            pos.checkskip(self.cellseparator)
        if len(self.contents) == 0:
            self.output = EmptyOutput()

    def createcell(self, index):
        "Create the cell that corresponds to the given index."
        alignment = self.alignments[index % len(self.alignments)]
        return self.factory.create(FormulaCell).setalignment(alignment)


class MultiRowFormula(CommandBit):
    "A formula with multiple rows."

    def parserows(self, pos):
        "Parse all rows, finish when no more row ends"
        self.rows = []
        first = True
        for row in self.iteraterows(pos):
            if first:
                first = False
            else:
                # intersparse empty rows
                self.addempty()
            row.parsebit(pos)
            self.addrow(row)
        self.size = len(self.rows)

    def iteraterows(self, pos):
        "Iterate over all rows, end when no more row ends"
        rowseparator = FormulaConfig.array['rowseparator']
        while True:
            pos.pushending(rowseparator, True)
            row = self.factory.create(FormulaRow)
            yield row.setalignments(self.alignments)
            if pos.checkfor(rowseparator):
                self.original += pos.popending(rowseparator)
            else:
                return

    def addempty(self):
        "Add an empty row."
        row = self.factory.create(FormulaRow).setalignments(self.alignments)
        for index, originalcell in enumerate(self.rows[-1].contents):
            cell = row.createcell(index)
            cell.add(FormulaConstant(' '))
            row.add(cell)
        self.addrow(row)

    def addrow(self, row):
        "Add a row to the contents and to the list of rows."
        self.rows.append(row)
        self.add(row)


class FormulaArray(MultiRowFormula):
    "An array within a formula"

    piece = 'array'

    def parsebit(self, pos):
        "Parse the array"
        self.output = TaggedOutput().settag('span class="array"', False)
        self.parsealignments(pos)
        self.parserows(pos)

    def parsealignments(self, pos):
        "Parse the different alignments"
        # vertical
        self.valign = 'c'
        literal = self.parsesquareliteral(pos)
        if literal:
            self.valign = literal
        # horizontal
        literal = self.parseliteral(pos)
        self.alignments = []
        for s in literal:
            self.alignments.append(s)


class FormulaMatrix(MultiRowFormula):
    "A matrix (array with center alignment)."

    piece = 'matrix'

    def parsebit(self, pos):
        "Parse the matrix, set alignments to 'c'."
        self.output = TaggedOutput().settag('span class="array"', False)
        self.valign = 'c'
        self.alignments = ['c']
        self.parserows(pos)


class FormulaCases(MultiRowFormula):
    "A cases statement"

    piece = 'cases'

    def parsebit(self, pos):
        "Parse the cases"
        self.output = ContentsOutput()
        self.alignments = ['l', 'l']
        self.parserows(pos)
        for row in self.contents:
            for cell in row.contents:
                cell.output.settag('span class="case align-l"', True)
                cell.contents.append(FormulaConstant(' '))
        array = TaggedBit().complete(self.contents, 'span class="bracketcases"', True)
        brace = BigBracket(len(self.contents), '{', 'l')
        self.contents = brace.getcontents() + [array]


class EquationEnvironment(MultiRowFormula):
    "A \\begin{}...\\end equation environment with rows and cells."

    def parsebit(self, pos):
        "Parse the whole environment."
        environment = self.piece.replace('*', '')
        self.output = TaggedOutput().settag(
                        'span class="environment %s"'%environment, False)
        if environment in FormulaConfig.environments:
            self.alignments = FormulaConfig.environments[environment]
        else:
            Trace.error('Unknown equation environment ' + self.piece)
            # print in red
            self.output = TaggedOutput().settag('span class="unknown"')
            self.add(FormulaConstant('\\begin{%s} '%environment))

            self.alignments = ['l']
        self.parserows(pos)


class BeginCommand(CommandBit):
    "A \\begin{}...\\end command and what it entails (array, cases, aligned)"

    commandmap = {FormulaConfig.array['begin']: ''}

    types = [FormulaEquation, FormulaArray, FormulaCases, FormulaMatrix]

    def parsebit(self, pos):
        "Parse the begin command"
        command = self.parseliteral(pos)
        bit = self.findbit(command)
        ending = FormulaConfig.array['end'] + '{' + command + '}'
        pos.pushending(ending)
        bit.parsebit(pos)
        self.add(bit)
        self.original += pos.popending(ending)
        self.size = bit.size

    def findbit(self, piece):
        "Find the command bit corresponding to the \\begin{piece}"
        for type in BeginCommand.types:
            if piece.replace('*', '') == type.piece:
                return self.factory.create(type)
        bit = self.factory.create(EquationEnvironment)
        bit.piece = piece
        return bit


FormulaCommand.types += [BeginCommand]


class CombiningFunction(OneParamFunction):

    commandmap = FormulaConfig.combiningfunctions

    def parsebit(self, pos):
        "Parse a combining function."
        combining = self.translated
        parameter = self.parsesingleparameter(pos)
        if not parameter:
            Trace.error('Missing parameter for combining function ' + self.command)
            return
        # Trace.message('apply %s to %r'%(self.command, parameter.extracttext()))
        # parameter.tree()
        if not isinstance(parameter, FormulaConstant):
            try:
                extractor = ContainerExtractor(ContainerConfig.extracttext)
                parameter = extractor.extract(parameter)[0]
            except IndexError:
                Trace.error('No base character found for "%s".' % self.command)
                return
        # Trace.message('  basechar: %r' % parameter.string)
        # Insert combining character after the first character:
        if parameter.string.startswith('\u2009'):
            i = 2  # skip padding by SpacedCommand and FormulaConfig.modified
        else:
            i = 1
        parameter.string = parameter.string[:i] + combining + parameter.string[i:]
        # Use pre-composed characters if possible: \not{=} -> ≠, say.
        parameter.string = unicodedata.normalize('NFC', parameter.string)

    def parsesingleparameter(self, pos):
        "Parse a parameter, or a single letter."
        self.factory.clearskipped(pos)
        if pos.finished():
            return None
        return self.parseparameter(pos)


class OversetFunction(OneParamFunction):
    "A function that decorates some bit of text with an overset."

    commandmap = FormulaConfig.oversetfunctions

    def parsebit(self, pos):
        "Parse an overset-function"
        symbol = self.translated
        self.symbol = TaggedBit().constant(symbol, 'sup')
        self.parameter = self.parseparameter(pos)
        self.output = TaggedOutput().settag('span class="embellished"')
        self.contents.insert(0, self.symbol)
        self.parameter.output = TaggedOutput().settag('span class="base"')
        self.simplifyifpossible()


class UndersetFunction(OneParamFunction):
    "A function that decorates some bit of text with an underset."

    commandmap = FormulaConfig.undersetfunctions

    def parsebit(self, pos):
        "Parse an underset-function"
        symbol = self.translated
        self.symbol = TaggedBit().constant(symbol, 'sub')
        self.parameter = self.parseparameter(pos)
        self.output = TaggedOutput().settag('span class="embellished"')
        self.contents.insert(0, self.symbol)
        self.parameter.output = TaggedOutput().settag('span class="base"')
        self.simplifyifpossible()


class LimitCommand(EmptyCommand):
    "A command which accepts limits above and below, in display mode."

    commandmap = FormulaConfig.limitcommands

    def parsebit(self, pos):
        "Parse a limit command."
        self.output = TaggedOutput().settag('span class="limits"')
        symbol = self.translated
        self.contents.append(TaggedBit().constant(symbol, 'span class="limit"'))


class LimitPreviousCommand(LimitCommand):
    "A command to limit the previous command."

    commandmap = None

    def parsebit(self, pos):
        "Do nothing."
        self.output = TaggedOutput().settag('span class="limits"')
        self.factory.clearskipped(pos)

    def __str__(self):
        "Return a printable representation."
        return 'Limit previous command'


class LimitsProcessor(MathsProcessor):
    "A processor for limits inside an element."

    def process(self, contents, index):
        "Process the limits for an element."
        if Options.simplemath:
            return
        if self.checklimits(contents, index):
            self.modifylimits(contents, index)
        if self.checkscript(contents, index) and self.checkscript(contents, index + 1):
            self.modifyscripts(contents, index)

    def checklimits(self, contents, index):
        "Check if the current position has a limits command."
        # TODO: check for \limits macro
        if not DocumentParameters.displaymode:
            return False
        if self.checkcommand(contents, index + 1, LimitPreviousCommand):
            self.limitsahead(contents, index)
            return False
        if not isinstance(contents[index], LimitCommand):
            return False
        return self.checkscript(contents, index + 1)

    def limitsahead(self, contents, index):
        "Limit the current element based on the next."
        contents[index + 1].add(contents[index].clone())
        contents[index].output = EmptyOutput()

    def modifylimits(self, contents, index):
        "Modify a limits commands so that the limits appear above and below."
        limited = contents[index]
        subscript = self.getlimit(contents, index + 1)
        if self.checkscript(contents, index + 1):
            superscript = self.getlimit(contents, index + 1)
        else:
            superscript = TaggedBit().constant('\u2009', 'sup class="limit"')
        # fix order if source is x^i
        if subscript.command == '^':
            superscript, subscript = subscript, superscript
        limited.contents.append(subscript)
        limited.contents.insert(0, superscript)

    def getlimit(self, contents, index):
        "Get the limit for a limits command."
        limit = self.getscript(contents, index)
        limit.output.tag = limit.output.tag.replace('script', 'limit')
        return limit

    def modifyscripts(self, contents, index):
        "Modify the super- and subscript to appear vertically aligned."
        subscript = self.getscript(contents, index)
        # subscript removed so instead of index + 1 we get index again
        superscript = self.getscript(contents, index)
        # super-/subscript are reversed if source is x^i_j
        if subscript.command == '^':
            superscript, subscript = subscript, superscript
        scripts = TaggedBit().complete([superscript, subscript], 'span class="scripts"')
        contents.insert(index, scripts)

    def checkscript(self, contents, index):
        "Check if the current element is a sub- or superscript."
        return self.checkcommand(contents, index, SymbolFunction)

    def checkcommand(self, contents, index, type):
        "Check for the given type as the current element."
        if len(contents) <= index:
            return False
        return isinstance(contents[index], type)

    def getscript(self, contents, index):
        "Get the sub- or superscript."
        bit = contents[index]
        bit.output.tag += ' class="script"'
        del contents[index]
        return bit


class BracketCommand(OneParamFunction):
    "A command which defines a bracket."

    commandmap = FormulaConfig.bracketcommands

    def parsebit(self, pos):
        "Parse the bracket."
        OneParamFunction.parsebit(self, pos)

    def create(self, direction, character):
        "Create the bracket for the given character."
        self.original = character
        self.command = '\\' + direction
        self.contents = [FormulaConstant(character)]
        return self


class BracketProcessor(MathsProcessor):
    "A processor for bracket commands."

    def process(self, contents, index):
        "Convert the bracket using Unicode pieces, if possible."
        if Options.simplemath:
            return
        if self.checkleft(contents, index):
            return self.processleft(contents, index)

    def processleft(self, contents, index):
        "Process a left bracket."
        rightindex = self.findright(contents, index + 1)
        if not rightindex:
            return
        size = self.findmax(contents, index, rightindex)
        self.resize(contents[index], size)
        self.resize(contents[rightindex], size)

    def checkleft(self, contents, index):
        "Check if the command at the given index is left."
        return self.checkdirection(contents[index], '\\left')

    def checkright(self, contents, index):
        "Check if the command at the given index is right."
        return self.checkdirection(contents[index], '\\right')

    def checkdirection(self, bit, command):
        "Check if the given bit is the desired bracket command."
        if not isinstance(bit, BracketCommand):
            return False
        return bit.command == command

    def findright(self, contents, index):
        "Find the right bracket starting at the given index, or 0."
        depth = 1
        while index < len(contents):
            if self.checkleft(contents, index):
                depth += 1
            if self.checkright(contents, index):
                depth -= 1
            if depth == 0:
                return index
            index += 1
        return None

    def findmax(self, contents, leftindex, rightindex):
        "Find the max size of the contents between the two given indices."
        sliced = contents[leftindex:rightindex]
        return max(element.size for element in sliced)

    def resize(self, command, size):
        "Resize a bracket command to the given size."
        character = command.extracttext()
        alignment = command.command.replace('\\', '')
        bracket = BigBracket(size, character, alignment)
        command.output = ContentsOutput()
        command.contents = bracket.getcontents()


FormulaCommand.types += [OversetFunction, UndersetFunction,
                         CombiningFunction, LimitCommand, BracketCommand]

FormulaProcessor.processors += [
    LimitsProcessor(), BracketProcessor(),
]


class ParameterDefinition:
    "The definition of a parameter in a hybrid function."
    "[] parameters are optional, {} parameters are mandatory."
    "Each parameter has a one-character name, like {$1} or {$p}."
    "A parameter that ends in ! like {$p!} is a literal."
    "Example: [$1]{$p!} reads an optional parameter $1 and a literal mandatory parameter p."

    parambrackets = [('[', ']'), ('{', '}')]

    def __init__(self):
        self.name = None
        self.literal = False
        self.optional = False
        self.value = None
        self.literalvalue = None

    def parse(self, pos):
        "Parse a parameter definition: [$0], {$x}, {$1!}..."
        for (opening, closing) in ParameterDefinition.parambrackets:
            if pos.checkskip(opening):
                if opening == '[':
                    self.optional = True
                if not pos.checkskip('$'):
                    Trace.error('Wrong parameter name, did you mean $' + pos.current() + '?')
                    return None
                self.name = pos.skipcurrent()
                if pos.checkskip('!'):
                    self.literal = True
                if not pos.checkskip(closing):
                    Trace.error('Wrong parameter closing ' + pos.skipcurrent())
                    return None
                return self
        Trace.error('Wrong character in parameter template: ' + pos.skipcurrent())
        return None

    def read(self, pos, function):
        "Read the parameter itself using the definition."
        if self.literal:
            if self.optional:
                self.literalvalue = function.parsesquareliteral(pos)
            else:
                self.literalvalue = function.parseliteral(pos)
            if self.literalvalue:
                self.value = FormulaConstant(self.literalvalue)
        elif self.optional:
            self.value = function.parsesquare(pos)
        else:
            self.value = function.parseparameter(pos)

    def __str__(self):
        "Return a printable representation."
        result = 'param ' + self.name
        if self.value:
            result += ': ' + str(self.value)
        else:
            result += ' (empty)'
        return result


class ParameterFunction(CommandBit):
    "A function with a variable number of parameters defined in a template."
    "The parameters are defined as a parameter definition."

    def readparams(self, readtemplate, pos):
        "Read the params according to the template."
        self.params = {}
        for paramdef in self.paramdefs(readtemplate):
            paramdef.read(pos, self)
            self.params['$' + paramdef.name] = paramdef

    def paramdefs(self, readtemplate):
        "Read each param definition in the template"
        pos = TextPosition(readtemplate)
        while not pos.finished():
            paramdef = ParameterDefinition().parse(pos)
            if paramdef:
                yield paramdef

    def getparam(self, name):
        "Get a parameter as parsed."
        if name not in self.params:
            return None
        return self.params[name]

    def getvalue(self, name):
        "Get the value of a parameter."
        return self.getparam(name).value

    def getliteralvalue(self, name):
        "Get the literal value of a parameter."
        param = self.getparam(name)
        if not param or not param.literalvalue:
            return None
        return param.literalvalue


class HybridFunction(ParameterFunction):
    """
    A parameter function where the output is also defined using a template.
    The template can use a number of functions; each function has an associated
    tag.
    Example: [f0{$1},span class="fbox"] defines a function f0 which corresponds
    to a span of class fbox, yielding <span class="fbox">$1</span>.
    Literal parameters can be used in tags definitions:
      [f0{$1},span style="color: $p;"]
    yields <span style="color: $p;">$1</span>, where $p is a literal parameter.
    Sizes can be specified in hybridsizes, e.g. adding parameter sizes. By
    default the resulting size is the max of all arguments. Sizes are used
    to generate the right parameters.
    A function followed by a single / is output as a self-closing XHTML tag:
      [f0/,hr]
    will generate <hr/>.
    """

    commandmap = FormulaConfig.hybridfunctions

    def parsebit(self, pos):
        "Parse a function with [] and {} parameters"
        readtemplate = self.translated[0]
        writetemplate = self.translated[1]
        self.readparams(readtemplate, pos)
        self.contents = self.writeparams(writetemplate)
        self.computehybridsize()

    def writeparams(self, writetemplate):
        "Write all params according to the template"
        return self.writepos(TextPosition(writetemplate))

    def writepos(self, pos):
        "Write all params as read in the parse position."
        result = []
        while not pos.finished():
            if pos.checkskip('$'):
                param = self.writeparam(pos)
                if param:
                    result.append(param)
            elif pos.checkskip('f'):
                function = self.writefunction(pos)
                if function:
                    function.type = None
                    result.append(function)
            elif pos.checkskip('('):
                result.append(self.writebracket('left', '('))
            elif pos.checkskip(')'):
                result.append(self.writebracket('right', ')'))
            else:
                result.append(FormulaConstant(pos.skipcurrent()))
        return result

    def writeparam(self, pos):
        "Write a single param of the form $0, $x..."
        name = '$' + pos.skipcurrent()
        if name not in self.params:
            Trace.error('Unknown parameter ' + name)
            return None
        if not self.params[name]:
            return None
        if pos.checkskip('.'):
            self.params[name].value.type = pos.globalpha()
        return self.params[name].value

    def writefunction(self, pos):
        "Write a single function f0,...,fn."
        tag = self.readtag(pos)
        if not tag:
            return None
        if pos.checkskip('/'):
            # self-closing XHTML tag, such as <hr/>
            return TaggedBit().selfcomplete(tag)
        if not pos.checkskip('{'):
            Trace.error('Function should be defined in {}')
            return None
        pos.pushending('}')
        contents = self.writepos(pos)
        pos.popending()
        if len(contents) == 0:
            return None
        return TaggedBit().complete(contents, tag)

    def readtag(self, pos):
        "Get the tag corresponding to the given index. Does parameter substitution."
        if not pos.current().isdigit():
            Trace.error('Function should be f0,...,f9: f' + pos.current())
            return None
        index = int(pos.skipcurrent())
        if 2 + index > len(self.translated):
            Trace.error('Function f' + str(index) + ' is not defined')
            return None
        tag = self.translated[2 + index]
        if '$' not in tag:
            return tag
        for variable in self.params:
            if variable in tag:
                param = self.params[variable]
                if not param.literal:
                    Trace.error('Parameters in tag ' + tag + ' should be literal: {' + variable + '!}')
                    continue
                if param.literalvalue:
                    value = param.literalvalue
                else:
                    value = ''
                tag = tag.replace(variable, value)
        return tag

    def writebracket(self, direction, character):
        "Return a new bracket looking at the given direction."
        return self.factory.create(BracketCommand).create(direction, character)

    def computehybridsize(self):
        "Compute the size of the hybrid function."
        if self.command not in HybridSize.configsizes:
            self.computesize()
            return
        self.size = HybridSize().getsize(self)
        # set the size in all elements at first level
        for element in self.contents:
            element.size = self.size


class HybridSize:
    "The size associated with a hybrid function."

    configsizes = FormulaConfig.hybridsizes

    def getsize(self, function):
        "Read the size for a function and parse it."
        sizestring = self.configsizes[function.command]
        for name in function.params:
            if name in sizestring:
                size = function.params[name].value.computesize()
                sizestring = sizestring.replace(name, str(size))
        if '$' in sizestring:
            Trace.error('Unconverted variable in hybrid size: ' + sizestring)
            return 1
        return eval(sizestring)


FormulaCommand.types += [HybridFunction]


def math2html(formula):
    "Convert some TeX math to HTML."
    factory = FormulaFactory()
    whole = factory.parseformula(formula)
    FormulaProcessor().process(whole)
    whole.process()
    return ''.join(whole.gethtml())


def main():
    "Main function, called if invoked from the command line"
    args = sys.argv
    Options().parseoptions(args)
    if len(args) != 1:
        Trace.error('Usage: math2html.py escaped_string')
        exit()
    result = math2html(args[0])
    Trace.message(result)


if __name__ == '__main__':
    main()
