#Copyright ReportLab Europe Ltd. 2000-2012

#see license.txt for license details

#history http://www.reportlab.co.uk/cgi-bin/viewcvs.cgi/public/reportlab/trunk/reportlab/platypus/paraparser.py

__version__=''' $Id$ '''

__doc__='''The parser used to process markup within paragraphs'''

import string

import re

import sys

import os

import copy

import base64

try:

    import pickle as pickle

except:

    import pickle

import unicodedata

import reportlab.lib.sequencer

from reportlab.lib.abag import ABag

from reportlab.lib.utils import ImageReader, isPy3, annotateException

from reportlab.lib.colors import toColor, white, black, red, Color

from reportlab.lib.fonts import tt2ps, ps2tt

from reportlab.lib.enums import TA_LEFT, TA_RIGHT, TA_CENTER, TA_JUSTIFY

from reportlab.lib.units import inch,mm,cm,pica

_re_para = re.compile(r'^\s*<\s*para(?:\s+|>|/>)')

sizeDelta = 2       # amount to reduce font size by for super and sub script

subFraction = 0.5   # fraction of font size that a sub script should be lowered

superFraction = 0.5 # fraction of font size that a super script should be raised

DEFAULT_INDEX_NAME='_indexAdd'

def _convnum(s, unit=1, allowRelative=True):

    if s[0] in ('+','-') and allowRelative:

        try:

            return ('relative',int(s)*unit)

        except ValueError:

            return ('relative',float(s)*unit)

    else:

        try:

            return int(s)*unit

        except ValueError:

            return float(s)*unit

def _num(s, unit=1, allowRelative=True):

    """Convert a string like '10cm' to an int or float (in points).

       The default unit is point, but optionally you can use other

       default units like mm.

    """

    if s.endswith('cm'):

        unit=cm

        s = s[:-2]

    if s.endswith('in'):

        unit=inch

        s = s[:-2]

    if s.endswith('pt'):

        unit=1

        s = s[:-2]

    if s.endswith('i'):

        unit=inch

        s = s[:-1]

    if s.endswith('mm'):

        unit=mm

        s = s[:-2]

    if s.endswith('pica'):

        unit=pica

        s = s[:-4]

    return _convnum(s,unit,allowRelative)

def _numpct(s,unit=1,allowRelative=False):

    if s.endswith('%'):

        return _PCT(_convnum(s[:-1],allowRelative=allowRelative))

    else:

        return _num(s,unit,allowRelative)

class _PCT:

    def __init__(self,v):

        self._value = v*0.01

    def normalizedValue(self,normalizer):

        normalizer = normalizer or getattr(self,'_normalizer')

        return normalizer*self._value

def _valignpc(s):

    s = s.lower()

    if s in ('baseline','sub','super','top','text-top','middle','bottom','text-bottom'):

        return s

    if s.endswith('%'):

        n = _convnum(s[:-1])

        if isinstance(n,tuple):

            n = n[1]

        return _PCT(n)

    n = _num(s)

    if isinstance(n,tuple):

        n = n[1]

    return n

def _autoLeading(x):

    x = x.lower()

    if x in ('','min','max','off'):

        return x

    raise ValueError('Invalid autoLeading=%r' % x )

def _align(s):

    s = s.lower()

    if s=='left': return TA_LEFT

    elif s=='right': return TA_RIGHT

    elif s=='justify': return TA_JUSTIFY

    elif s in ('centre','center'): return TA_CENTER

    else: raise ValueError

_paraAttrMap = {'font': ('fontName', None),

                'face': ('fontName', None),

                'fontsize': ('fontSize', _num),

                'size': ('fontSize', _num),

                'leading': ('leading', _num),

                'autoleading': ('autoLeading', _autoLeading),

                'lindent': ('leftIndent', _num),

                'rindent': ('rightIndent', _num),

                'findent': ('firstLineIndent', _num),

                'align': ('alignment', _align),

                'spaceb': ('spaceBefore', _num),

                'spacea': ('spaceAfter', _num),

                'bfont': ('bulletFontName', None),

                'bfontsize': ('bulletFontSize',_num),

                'boffsety': ('bulletOffsetY',_num),

                'bindent': ('bulletIndent',_num),

                'bcolor': ('bulletColor',toColor),

                'color':('textColor',toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                'bg':('backColor',toColor),

                'fg': ('textColor',toColor),

                }

_bulletAttrMap = {

                'font': ('bulletFontName', None),

                'face': ('bulletFontName', None),

                'size': ('bulletFontSize',_num),

                'fontsize': ('bulletFontSize',_num),

                'offsety': ('bulletOffsetY',_num),

                'indent': ('bulletIndent',_num),

                'color': ('bulletColor',toColor),

                'fg': ('bulletColor',toColor),

                }

#things which are valid font attributes

_fontAttrMap = {'size': ('fontSize', _num),

                'face': ('fontName', None),

                'name': ('fontName', None),

                'fg':   ('textColor', toColor),

                'color':('textColor', toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                }

#things which are valid span attributes

_spanAttrMap = {'size': ('fontSize', _num),

                'face': ('fontName', None),

                'name': ('fontName', None),

                'fg':   ('textColor', toColor),

                'color':('textColor', toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                'style': ('style',None),

                }

#things which are valid font attributes

_linkAttrMap = {'size': ('fontSize', _num),

                'face': ('fontName', None),

                'name': ('fontName', None),

                'fg':   ('textColor', toColor),

                'color':('textColor', toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                'dest': ('link', None),

                'destination': ('link', None),

                'target': ('link', None),

                'href': ('link', None),

                }

_anchorAttrMap = {'fontSize': ('fontSize', _num),

                'fontName': ('fontName', None),

                'name': ('name', None),

                'fg':   ('textColor', toColor),

                'color':('textColor', toColor),

                'backcolor':('backColor',toColor),

                'bgcolor':('backColor',toColor),

                'href': ('href', None),

                }

_imgAttrMap = {

                'src': ('src', None),

                'width': ('width',_numpct),

                'height':('height',_numpct),

                'valign':('valign',_valignpc),

                }

_indexAttrMap = {

                'name': ('name',None),

                'item': ('item',None),

                'offset': ('offset',None),

                'format': ('format',None),

                }

def _addAttributeNames(m):

    K = list(m.keys())

    for k in K:

        n = m[k][0]

        if n not in m: m[n] = m[k]

        n = n.lower()

        if n not in m: m[n] = m[k]

_addAttributeNames(_paraAttrMap)

_addAttributeNames(_fontAttrMap)

_addAttributeNames(_spanAttrMap)

_addAttributeNames(_bulletAttrMap)

_addAttributeNames(_anchorAttrMap)

_addAttributeNames(_linkAttrMap)

def _applyAttributes(obj, attr):

    for k, v in attr.items():

        if isinstance(v,(list,tuple)) and v[0]=='relative':

            if hasattr(obj, k):

                v = v[1]+getattr(obj,k)

            else:

                v = v[1]

        setattr(obj,k,v)

#Named character entities intended to be supported from the special font

#with additions suggested by Christoph Zwerschke who also suggested the

#numeric entity names that follow.

greeks = {

    'Aacute': b'\xc3\x81',

    'aacute': b'\xc3\xa1',

    'Acirc': b'\xc3\x82',

    'acirc': b'\xc3\xa2',

    'acute': b'\xc2\xb4',

    'AElig': b'\xc3\x86',

    'aelig': b'\xc3\xa6',

    'Agrave': b'\xc3\x80',

    'agrave': b'\xc3\xa0',

    'alefsym': b'\xe2\x84\xb5',

    'Alpha': b'\xce\x91',

    'alpha': b'\xce\xb1',

    'and': b'\xe2\x88\xa7',

    'ang': b'\xe2\x88\xa0',

    'Aring': b'\xc3\x85',

    'aring': b'\xc3\xa5',

    'asymp': b'\xe2\x89\x88',

    'Atilde': b'\xc3\x83',

    'atilde': b'\xc3\xa3',

    'Auml': b'\xc3\x84',

    'auml': b'\xc3\xa4',

    'bdquo': b'\xe2\x80\x9e',

    'Beta': b'\xce\x92',

    'beta': b'\xce\xb2',

    'brvbar': b'\xc2\xa6',

    'bull': b'\xe2\x80\xa2',

    'cap': b'\xe2\x88\xa9',

    'Ccedil': b'\xc3\x87',

    'ccedil': b'\xc3\xa7',

    'cedil': b'\xc2\xb8',

    'cent': b'\xc2\xa2',

    'Chi': b'\xce\xa7',

    'chi': b'\xcf\x87',

    'circ': b'\xcb\x86',

    'clubs': b'\xe2\x99\xa3',

    'cong': b'\xe2\x89\x85',

    'copy': b'\xc2\xa9',

    'crarr': b'\xe2\x86\xb5',

    'cup': b'\xe2\x88\xaa',

    'curren': b'\xc2\xa4',

    'dagger': b'\xe2\x80\xa0',

    'Dagger': b'\xe2\x80\xa1',

    'darr': b'\xe2\x86\x93',

    'dArr': b'\xe2\x87\x93',

    'deg': b'\xc2\xb0',

    'delta': b'\xce\xb4',

    'Delta': b'\xe2\x88\x86',

    'diams': b'\xe2\x99\xa6',

    'divide': b'\xc3\xb7',

    'Eacute': b'\xc3\x89',

    'eacute': b'\xc3\xa9',

    'Ecirc': b'\xc3\x8a',

    'ecirc': b'\xc3\xaa',

    'Egrave': b'\xc3\x88',

    'egrave': b'\xc3\xa8',

    'empty': b'\xe2\x88\x85',

    'emsp': b'\xe2\x80\x83',

    'ensp': b'\xe2\x80\x82',

    'Epsilon': b'\xce\x95',

    'epsilon': b'\xce\xb5',

    'epsiv': b'\xce\xb5',

    'equiv': b'\xe2\x89\xa1',

    'Eta': b'\xce\x97',

    'eta': b'\xce\xb7',

    'ETH': b'\xc3\x90',

    'eth': b'\xc3\xb0',

    'Euml': b'\xc3\x8b',

    'euml': b'\xc3\xab',

    'euro': b'\xe2\x82\xac',

    'exist': b'\xe2\x88\x83',

    'fnof': b'\xc6\x92',

    'forall': b'\xe2\x88\x80',

    'frac12': b'\xc2\xbd',

    'frac14': b'\xc2\xbc',

    'frac34': b'\xc2\xbe',

    'frasl': b'\xe2\x81\x84',

    'Gamma': b'\xce\x93',

    'gamma': b'\xce\xb3',

    'ge': b'\xe2\x89\xa5',

    'harr': b'\xe2\x86\x94',

    'hArr': b'\xe2\x87\x94',

    'hearts': b'\xe2\x99\xa5',

    'hellip': b'\xe2\x80\xa6',

    'Iacute': b'\xc3\x8d',

    'iacute': b'\xc3\xad',

    'Icirc': b'\xc3\x8e',

    'icirc': b'\xc3\xae',

    'iexcl': b'\xc2\xa1',

    'Igrave': b'\xc3\x8c',

    'igrave': b'\xc3\xac',

    'image': b'\xe2\x84\x91',

    'infin': b'\xe2\x88\x9e',

    'int': b'\xe2\x88\xab',

    'Iota': b'\xce\x99',

    'iota': b'\xce\xb9',

    'iquest': b'\xc2\xbf',

    'isin': b'\xe2\x88\x88',

    'Iuml': b'\xc3\x8f',

    'iuml': b'\xc3\xaf',

    'Kappa': b'\xce\x9a',

    'kappa': b'\xce\xba',

    'Lambda': b'\xce\x9b',

    'lambda': b'\xce\xbb',

    'lang': b'\xe2\x8c\xa9',

    'laquo': b'\xc2\xab',

    'larr': b'\xe2\x86\x90',

    'lArr': b'\xe2\x87\x90',

    'lceil': b'\xef\xa3\xae',

    'ldquo': b'\xe2\x80\x9c',

    'le': b'\xe2\x89\xa4',

    'lfloor': b'\xef\xa3\xb0',

    'lowast': b'\xe2\x88\x97',

    'loz': b'\xe2\x97\x8a',

    'lrm': b'\xe2\x80\x8e',

    'lsaquo': b'\xe2\x80\xb9',

    'lsquo': b'\xe2\x80\x98',

    'macr': b'\xc2\xaf',

    'mdash': b'\xe2\x80\x94',

    'micro': b'\xc2\xb5',

    'middot': b'\xc2\xb7',

    'minus': b'\xe2\x88\x92',

    'mu': b'\xc2\xb5',

    'Mu': b'\xce\x9c',

    'nabla': b'\xe2\x88\x87',

    'nbsp': b'\xc2\xa0',

    'ndash': b'\xe2\x80\x93',

    'ne': b'\xe2\x89\xa0',

    'ni': b'\xe2\x88\x8b',

    'notin': b'\xe2\x88\x89',

    'not': b'\xc2\xac',

    'nsub': b'\xe2\x8a\x84',

    'Ntilde': b'\xc3\x91',

    'ntilde': b'\xc3\xb1',

    'Nu': b'\xce\x9d',

    'nu': b'\xce\xbd',

    'Oacute': b'\xc3\x93',

    'oacute': b'\xc3\xb3',

    'Ocirc': b'\xc3\x94',

    'ocirc': b'\xc3\xb4',

    'OElig': b'\xc5\x92',

    'oelig': b'\xc5\x93',

    'Ograve': b'\xc3\x92',

    'ograve': b'\xc3\xb2',

    'oline': b'\xef\xa3\xa5',

    'omega': b'\xcf\x89',

    'Omega': b'\xe2\x84\xa6',

    'Omicron': b'\xce\x9f',

    'omicron': b'\xce\xbf',

    'oplus': b'\xe2\x8a\x95',

    'ordf': b'\xc2\xaa',

    'ordm': b'\xc2\xba',

    'or': b'\xe2\x88\xa8',

    'Oslash': b'\xc3\x98',

    'oslash': b'\xc3\xb8',

    'Otilde': b'\xc3\x95',

    'otilde': b'\xc3\xb5',

    'otimes': b'\xe2\x8a\x97',

    'Ouml': b'\xc3\x96',

    'ouml': b'\xc3\xb6',

    'para': b'\xc2\xb6',

    'part': b'\xe2\x88\x82',

    'permil': b'\xe2\x80\xb0',

    'perp': b'\xe2\x8a\xa5',

    'phis': b'\xcf\x86',

    'Phi': b'\xce\xa6',

    'phi': b'\xcf\x95',

    'piv': b'\xcf\x96',

    'Pi': b'\xce\xa0',

    'pi': b'\xcf\x80',

    'plusmn': b'\xc2\xb1',

    'pound': b'\xc2\xa3',

    'prime': b'\xe2\x80\xb2',

    'Prime': b'\xe2\x80\xb3',

    'prod': b'\xe2\x88\x8f',

    'prop': b'\xe2\x88\x9d',

    'Psi': b'\xce\xa8',

    'psi': b'\xcf\x88',

    'radic': b'\xe2\x88\x9a',

    'rang': b'\xe2\x8c\xaa',

    'raquo': b'\xc2\xbb',

    'rarr': b'\xe2\x86\x92',

    'rArr': b'\xe2\x87\x92',

    'rceil': b'\xef\xa3\xb9',

    'rdquo': b'\xe2\x80\x9d',

    'real': b'\xe2\x84\x9c',

    'reg': b'\xc2\xae',

    'rfloor': b'\xef\xa3\xbb',

    'Rho': b'\xce\xa1',

    'rho': b'\xcf\x81',

    'rlm': b'\xe2\x80\x8f',

    'rsaquo': b'\xe2\x80\xba',

    'rsquo': b'\xe2\x80\x99',

    'sbquo': b'\xe2\x80\x9a',

    'Scaron': b'\xc5\xa0',

    'scaron': b'\xc5\xa1',

    'sdot': b'\xe2\x8b\x85',

    'sect': b'\xc2\xa7',

    'shy': b'\xc2\xad',

    'sigmaf': b'\xcf\x82',

    'sigmav': b'\xcf\x82',

    'Sigma': b'\xce\xa3',

    'sigma': b'\xcf\x83',

    'sim': b'\xe2\x88\xbc',

    'spades': b'\xe2\x99\xa0',

    'sube': b'\xe2\x8a\x86',

    'sub': b'\xe2\x8a\x82',

    'sum': b'\xe2\x88\x91',

    'sup1': b'\xc2\xb9',

    'sup2': b'\xc2\xb2',

    'sup3': b'\xc2\xb3',

    'supe': b'\xe2\x8a\x87',

    'sup': b'\xe2\x8a\x83',

    'szlig': b'\xc3\x9f',

    'Tau': b'\xce\xa4',

    'tau': b'\xcf\x84',

    'there4': b'\xe2\x88\xb4',

    'thetasym': b'\xcf\x91',

    'thetav': b'\xcf\x91',

    'Theta': b'\xce\x98',

    'theta': b'\xce\xb8',

    'thinsp': b'\xe2\x80\x89',

    'THORN': b'\xc3\x9e',

    'thorn': b'\xc3\xbe',

    'tilde': b'\xcb\x9c',

    'times': b'\xc3\x97',

    'trade': b'\xef\xa3\xaa',

    'Uacute': b'\xc3\x9a',

    'uacute': b'\xc3\xba',

    'uarr': b'\xe2\x86\x91',

    'uArr': b'\xe2\x87\x91',

    'Ucirc': b'\xc3\x9b',

    'ucirc': b'\xc3\xbb',

    'Ugrave': b'\xc3\x99',

    'ugrave': b'\xc3\xb9',

    'uml': b'\xc2\xa8',

    'upsih': b'\xcf\x92',

    'Upsilon': b'\xce\xa5',

    'upsilon': b'\xcf\x85',

    'Uuml': b'\xc3\x9c',

    'uuml': b'\xc3\xbc',

    'weierp': b'\xe2\x84\x98',

    'Xi': b'\xce\x9e',

    'xi': b'\xce\xbe',

    'Yacute': b'\xc3\x9d',

    'yacute': b'\xc3\xbd',

    'yen': b'\xc2\xa5',

    'yuml': b'\xc3\xbf',

    'Yuml': b'\xc5\xb8',

    'Zeta': b'\xce\x96',

    'zeta': b'\xce\xb6',

    'zwj': b'\xe2\x80\x8d',

    'zwnj': b'\xe2\x80\x8c',

    }

#------------------------------------------------------------------------

class ParaFrag(ABag):

    """class ParaFrag contains the intermediate representation of string

    segments as they are being parsed by the XMLParser.

    fontname, fontSize, rise, textColor, cbDefn

    """