#Copyright ReportLab Europe Ltd. 2000-2016

#see license.txt for license details

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

__version__='3.3.0'

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

import string

import re

import sys

import os

import copy

import base64

from pprint import pprint as pp

import unicodedata

import reportlab.lib.sequencer

from reportlab.lib.abag import ABag

from reportlab.lib.utils import ImageReader, isPy3, annotateException, encode_label, asUnicode, asBytes, uniChr, isStr

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

if isPy3:

    from html.parser import HTMLParser

    from html.entities import name2codepoint

else:

    from HTMLParser import HTMLParser

    from htmlentitydefs import name2codepoint

_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

supFraction = 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 _int(s):

    try:

        return int(s)

    except:

        raise ValueError('cannot convert %r to int' % s)

def _bool(s):

    s = s.lower()

    if s in ('true','1','yes'):

        return True

    if s in ('false','0','no'):

        return False

    raise ValueError('cannot convert %r to bool value' % s)

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 fontSizeNormalize(frag,attr,default):

    if not hasattr(frag,attr): return default

    v = _numpct(getattr(frag,attr),allowRelative=True)

    return (v[1]+frag.fontSize) if isinstance(v,tuple) else v.normalizedValue(frag.fontSize) if isinstance(v,_PCT) else v

class _CheckSup:

    '''class for syntax checking <sup> attributes

    if the check succeeds then we always return the string for later evaluation

    '''

    def __init__(self,kind):

        self.kind = kind

        self.fontSize = 10

    def __call__(self,s):

        setattr(self,self.kind,s)

        try:

            fontSizeNormalize(self,self.kind,None)

            return s

        except:

            raise ValueError('<sup> invalid value %r for attribute %s' % (s,self.kind))

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('illegal alignment %r' % s)

def _bAnchor(s):

    s = s.lower()

    if not s in ('start','middle','end','numeric'):

        raise ValueError('illegal bullet anchor %r' % s)

    return s

def _wordWrapConv(s):

    s = s.upper().strip()

    if not s: return None

    if s not in ('CJK','RTL','LTR'):

        raise ValueError('cannot convert wordWrap=%r' % s)

    return s

def _textTransformConv(s):

    s = s.lower().strip()

    if not s: return None

    if s not in ('uppercase','lowercase','capitalize','none'):

        raise ValueError('cannot convert wordWrap=%r' % s)

    return s

_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),

                'banchor': ('bulletAnchor',_bAnchor),

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

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

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

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

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

                'justifybreaks': ('justifyBreaks',_bool),

                'justifylastline': ('justifyLastLine',_int),

                'wordwrap': ('wordWrap',_wordWrapConv),

                'allowwidows': ('allowWidows',_bool),

                'alloworphans': ('allowOrphans',_bool),

                'splitlongwords': ('splitLongWords',_bool),

                'borderwidth': ('borderWidth',_num),

                'borderpadding': ('borderpadding',_num),

                'bordercolor': ('borderColor',toColor),

                'borderradius': ('borderRadius',_num),

                'texttransform':('textTransform',_textTransformConv),

                'enddots':('endDots',None),

                'underlineproportion':('underlineProportion',_num),

                }

_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),

                'anchor': ('bulletAnchor',_bAnchor),

                }

#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),

                }

_supAttrMap = {

                'rise': ('supr', _CheckSup('rise')),

                'size': ('sups', _CheckSup('size')),

                }

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': u'\xc1',

    'aacute': u'\xe1',

    'Acirc': u'\xc2',

    'acirc': u'\xe2',

    'acute': u'\xb4',

    'AElig': u'\xc6',

    'aelig': u'\xe6',

    'Agrave': u'\xc0',

    'agrave': u'\xe0',

    'alefsym': u'\u2135',

    'Alpha': u'\u0391',

    'alpha': u'\u03b1',

    'and': u'\u2227',

    'ang': u'\u2220',

    'Aring': u'\xc5',

    'aring': u'\xe5',

    'asymp': u'\u2248',

    'Atilde': u'\xc3',

    'atilde': u'\xe3',

    'Auml': u'\xc4',

    'auml': u'\xe4',

    'bdquo': u'\u201e',

    'Beta': u'\u0392',

    'beta': u'\u03b2',

    'brvbar': u'\xa6',

    'bull': u'\u2022',

    'cap': u'\u2229',

    'Ccedil': u'\xc7',

    'ccedil': u'\xe7',

    'cedil': u'\xb8',

    'cent': u'\xa2',

    'Chi': u'\u03a7',

    'chi': u'\u03c7',

    'circ': u'\u02c6',

    'clubs': u'\u2663',

    'cong': u'\u2245',

    'copy': u'\xa9',

    'crarr': u'\u21b5',

    'cup': u'\u222a',

    'curren': u'\xa4',

    'dagger': u'\u2020',

    'Dagger': u'\u2021',

    'darr': u'\u2193',

    'dArr': u'\u21d3',

    'deg': u'\xb0',

    'delta': u'\u03b4',

    'Delta': u'\u2206',

    'diams': u'\u2666',

    'divide': u'\xf7',

    'Eacute': u'\xc9',

    'eacute': u'\xe9',

    'Ecirc': u'\xca',

    'ecirc': u'\xea',

    'Egrave': u'\xc8',

    'egrave': u'\xe8',

    'empty': u'\u2205',

    'emsp': u'\u2003',

    'ensp': u'\u2002',

    'Epsilon': u'\u0395',

    'epsilon': u'\u03b5',

    'epsiv': u'\u03b5',

    'equiv': u'\u2261',

    'Eta': u'\u0397',

    'eta': u'\u03b7',

    'ETH': u'\xd0',

    'eth': u'\xf0',

    'Euml': u'\xcb',

    'euml': u'\xeb',

    'euro': u'\u20ac',

    'exist': u'\u2203',

    'fnof': u'\u0192',

    'forall': u'\u2200',

    'frac12': u'\xbd',

    'frac14': u'\xbc',

    'frac34': u'\xbe',

    'frasl': u'\u2044',

    'Gamma': u'\u0393',

    'gamma': u'\u03b3',

    'ge': u'\u2265',

    'harr': u'\u2194',

    'hArr': u'\u21d4',

    'hearts': u'\u2665',

    'hellip': u'\u2026',

    'Iacute': u'\xcd',

    'iacute': u'\xed',

    'Icirc': u'\xce',

    'icirc': u'\xee',

    'iexcl': u'\xa1',

    'Igrave': u'\xcc',

    'igrave': u'\xec',

    'image': u'\u2111',

    'infin': u'\u221e',

    'int': u'\u222b',

    'Iota': u'\u0399',

    'iota': u'\u03b9',

    'iquest': u'\xbf',

    'isin': u'\u2208',

    'Iuml': u'\xcf',

    'iuml': u'\xef',

    'Kappa': u'\u039a',

    'kappa': u'\u03ba',

    'Lambda': u'\u039b',

    'lambda': u'\u03bb',

    'lang': u'\u2329',

    'laquo': u'\xab',

    'larr': u'\u2190',

    'lArr': u'\u21d0',

    'lceil': u'\uf8ee',

    'ldquo': u'\u201c',

    'le': u'\u2264',

    'lfloor': u'\uf8f0',

    'lowast': u'\u2217',

    'loz': u'\u25ca',

    'lrm': u'\u200e',

    'lsaquo': u'\u2039',

    'lsquo': u'\u2018',

    'macr': u'\xaf',

    'mdash': u'\u2014',

    'micro': u'\xb5',

    'middot': u'\xb7',

    'minus': u'\u2212',

    'mu': u'\xb5',

    'Mu': u'\u039c',

    'nabla': u'\u2207',

    'nbsp': u'\xa0',

    'ndash': u'\u2013',

    'ne': u'\u2260',

    'ni': u'\u220b',

    'notin': u'\u2209',

    'not': u'\xac',

    'nsub': u'\u2284',

    'Ntilde': u'\xd1',

    'ntilde': u'\xf1',

    'Nu': u'\u039d',

    'nu': u'\u03bd',

    'Oacute': u'\xd3',

    'oacute': u'\xf3',

    'Ocirc': u'\xd4',

    'ocirc': u'\xf4',

    'OElig': u'\u0152',

    'oelig': u'\u0153',

    'Ograve': u'\xd2',

    'ograve': u'\xf2',

    'oline': u'\uf8e5',

    'omega': u'\u03c9',

    'Omega': u'\u2126',

    'Omicron': u'\u039f',

    'omicron': u'\u03bf',

    'oplus': u'\u2295',

    'ordf': u'\xaa',

    'ordm': u'\xba',

    'or': u'\u2228',

    'Oslash': u'\xd8',

    'oslash': u'\xf8',

    'Otilde': u'\xd5',

    'otilde': u'\xf5',

    'otimes': u'\u2297',

    'Ouml': u'\xd6',

    'ouml': u'\xf6',

    'para': u'\xb6',

    'part': u'\u2202',

    'permil': u'\u2030',

    'perp': u'\u22a5',

    'phis': u'\u03c6',

    'Phi': u'\u03a6',

    'phi': u'\u03d5',

    'piv': u'\u03d6',

    'Pi': u'\u03a0',

    'pi': u'\u03c0',

    'plusmn': u'\xb1',

    'pound': u'\xa3',

    'prime': u'\u2032',

    'Prime': u'\u2033',

    'prod': u'\u220f',

    'prop': u'\u221d',

    'Psi': u'\u03a8',

    'psi': u'\u03c8',

    'radic': u'\u221a',

    'rang': u'\u232a',

    'raquo': u'\xbb',

    'rarr': u'\u2192',