"""Signed, length *delta*

if delta == 0:

return None

"""Signed, length *delta*+1

"""Unsigned length *delta*+1

"""Optionally signed, length *delta*+1

u1=partial(_arg, 1, False),

u4=partial(_arg, 4, False),

s4=partial(_arg, 4, True),

slen=_arg_slen,

olen1=_arg_olen1,

slen1=_arg_slen1,

"""Decorator for dispatch by opcode. Sets the values in *table*

def decorate(method):

get_args = [_arg_mapping[x] for x in args]

@wraps(method)

def wrapper(self, byte):

if state is not None and self.state != state:

raise ValueError("state precondition failed")

return method(self, *[f(self, byte-min) for f in get_args])

if max is None:

table[min] = wrapper

else:

for i in xrange(min, max+1):

assert table[i] is None

table[i] = wrapper

return wrapper

"""

# dispatch table

_dtable = [None for _ in xrange(256)]

dispatch = partial(_dispatch, _dtable)

def __init__(self, filename, dpi):

"""

matplotlib.verbose.report('Dvi: ' + filename, 'debug')

self.file = open(filename, 'rb')

self.dpi = dpi

self.fonts = {}

self.state = _dvistate.pre

self.baseline = self._get_baseline(filename)

def _get_baseline(self, filename):

if rcParams['text.latex.preview']:

base, ext = os.path.splitext(filename)

baseline_filename = base + ".baseline"

if os.path.exists(baseline_filename):

with open(baseline_filename, 'rb') as fd:

l = fd.read().split()

height, depth, width = l

return float(depth)

return None

def __enter__(self):

"""

return self

def __exit__(self, etype, evalue, etrace):

"""

self.close()

def __iter__(self):

"""

while True:

have_page = self._read()

if have_page:

yield self._output()

else:

break

def close(self):

"""

if not self.file.closed:

self.file.close()

def _output(self):

"""

minx, miny, maxx, maxy = np.inf, np.inf, -np.inf, -np.inf

maxy_pure = -np.inf

for elt in self.text + self.boxes:

if isinstance(elt, Box):

x, y, h, w = elt

e = 0 # zero depth

else: # glyph

x, y, font, g, w = elt

h, e = font._height_depth_of(g)

minx = min(minx, x)

miny = min(miny, y - h)

maxx = max(maxx, x + w)

maxy = max(maxy, y + e)

maxy_pure = max(maxy_pure, y)

if self.dpi is None:

# special case for ease of debugging: output raw dvi coordinates

return Page(text=self.text, boxes=self.boxes,

width=maxx-minx, height=maxy_pure-miny,

descent=maxy-maxy_pure)

# convert from TeX's "scaled points" to dpi units

d = self.dpi / (72.27 * 2**16)

if self.baseline is None:

descent = (maxy - maxy_pure) * d

else:

descent = self.baseline

text = [Text((x-minx)*d, (maxy-y)*d - descent, f, g, w*d)

for (x, y, f, g, w) in self.text]

boxes = [Box((x-minx)*d, (maxy-y)*d - descent, h*d, w*d)

for (x, y, h, w) in self.boxes]

return Page(text=text, boxes=boxes, width=(maxx-minx)*d,

height=(maxy_pure-miny)*d, descent=descent)

def _read(self):

"""

while True:

byte = ord(self.file.read(1)[0])

self._dtable[byte](self, byte)

if byte == 140: # end of page

return True

if self.state == _dvistate.post_post: # end of file

self.close()

return False

def _arg(self, nbytes, signed=False):

"""

str = self.file.read(nbytes)

value = ord(str[0])

if signed and value >= 0x80:

value = value - 0x100

for i in range(1, nbytes):

value = 0x100*value + ord(str[i])

return value

@dispatch(min=0, max=127, state=_dvistate.inpage)

def _set_char_immediate(self, char):

self._put_char_real(char)

self.h += self.fonts[self.f]._width_of(char)

@dispatch(min=128, max=131, state=_dvistate.inpage, args=('olen1',))

def _set_char(self, char):

self._put_char_real(char)

self.h += self.fonts[self.f]._width_of(char)

@dispatch(132, state=_dvistate.inpage, args=('s4', 's4'))

def _set_rule(self, a, b):

self._put_rule_real(a, b)

self.h += b

@dispatch(min=133, max=136, state=_dvistate.inpage, args=('olen1',))

def _put_char(self, char):

self._put_char_real(char)

def _put_char_real(self, char):

font = self.fonts[self.f]

if font._vf is None:

self.text.append(Text(self.h, self.v, font, char,

font._width_of(char)))

else:

scale = font._scale

for x, y, f, g, w in font._vf[char].text:

newf = DviFont(scale=_mul2012(scale, f._scale),

tfm=f._tfm, texname=f.texname, vf=f._vf)

self.text.append(Text(self.h + _mul2012(x, scale),

self.v + _mul2012(y, scale),

newf, g, newf._width_of(g)))

self.boxes.extend([Box(self.h + _mul2012(x, scale),

self.v + _mul2012(y, scale),

_mul2012(a, scale), _mul2012(b, scale))

for x, y, a, b in font._vf[char].boxes])

@dispatch(137, state=_dvistate.inpage, args=('s4', 's4'))

def _put_rule(self, a, b):

self._put_rule_real(a, b)

def _put_rule_real(self, a, b):

if a > 0 and b > 0:

self.boxes.append(Box(self.h, self.v, a, b))

@dispatch(138)

def _nop(self, _):

pass

@dispatch(139, state=_dvistate.outer, args=('s4',)*11)

def _bop(self, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, p):

self.state = _dvistate.inpage

self.h, self.v, self.w, self.x, self.y, self.z = 0, 0, 0, 0, 0, 0

self.stack = []

self.text = [] # list of Text objects

self.boxes = [] # list of Box objects

@dispatch(140, state=_dvistate.inpage)

def _eop(self, _):

self.state = _dvistate.outer

del self.h, self.v, self.w, self.x, self.y, self.z, self.stack

@dispatch(141, state=_dvistate.inpage)

def _push(self, _):

self.stack.append((self.h, self.v, self.w, self.x, self.y, self.z))

@dispatch(142, state=_dvistate.inpage)

def _pop(self, _):

self.h, self.v, self.w, self.x, self.y, self.z = self.stack.pop()

@dispatch(min=143, max=146, state=_dvistate.inpage, args=('slen1',))

def _right(self, b):

self.h += b

@dispatch(min=147, max=151, state=_dvistate.inpage, args=('slen',))

def _right_w(self, new_w):

if new_w is not None:

self.w = new_w

self.h += self.w

@dispatch(min=152, max=156, state=_dvistate.inpage, args=('slen',))

def _right_x(self, new_x):

if new_x is not None:

self.x = new_x

self.h += self.x

@dispatch(min=157, max=160, state=_dvistate.inpage, args=('slen1',))

def _down(self, a):

self.v += a

@dispatch(min=161, max=165, state=_dvistate.inpage, args=('slen',))

def _down_y(self, new_y):

if new_y is not None:

self.y = new_y

self.v += self.y

@dispatch(min=166, max=170, state=_dvistate.inpage, args=('slen',))

def _down_z(self, new_z):

if new_z is not None:

self.z = new_z

self.v += self.z

@dispatch(min=171, max=234, state=_dvistate.inpage)

def _fnt_num_immediate(self, k):

self.f = k

@dispatch(min=235, max=238, state=_dvistate.inpage, args=('olen1',))

def _fnt_num(self, new_f):

self.f = new_f

@dispatch(min=239, max=242, args=('ulen1',))

def _xxx(self, datalen):

special = self.file.read(datalen)

if six.PY3:

chr_ = chr

else:

def chr_(x):

return x

matplotlib.verbose.report(

'Dvi._xxx: encountered special: %s'

% ''.join([(32 <= ord(ch) < 127) and chr_(ch)

or '<%02x>' % ord(ch)

for ch in special]),

'debug')

@dispatch(min=243, max=246, args=('olen1', 'u4', 'u4', 'u4', 'u1', 'u1'))

def _fnt_def(self, k, c, s, d, a, l):

self._fnt_def_real(k, c, s, d, a, l)

def _fnt_def_real(self, k, c, s, d, a, l):

n = self.file.read(a + l)

fontname = n[-l:].decode('ascii')

tfm = _tfmfile(fontname)

if tfm is None:

if six.PY2:

error_class = OSError

else:

error_class = FileNotFoundError

raise error_class("missing font metrics file: %s" % fontname)

if c != 0 and tfm.checksum != 0 and c != tfm.checksum:

raise ValueError('tfm checksum mismatch: %s' % n)

vf = _vffile(fontname)

self.fonts[k] = DviFont(scale=s, tfm=tfm, texname=n, vf=vf)

@dispatch(247, state=_dvistate.pre, args=('u1', 'u4', 'u4', 'u4', 'u1'))

def _pre(self, i, num, den, mag, k):

comment = self.file.read(k)

if i != 2:

raise ValueError("Unknown dvi format %d" % i)

if num != 25400000 or den != 7227 * 2**16:

raise ValueError("nonstandard units in dvi file")

# meaning: TeX always uses those exact values, so it

# should be enough for us to support those

# (There are 72.27 pt to an inch so 7227 pt =

# 7227 * 2**16 sp to 100 in. The numerator is multiplied

# by 10^5 to get units of 10**-7 meters.)

if mag != 1000:

raise ValueError("nonstandard magnification in dvi file")

# meaning: LaTeX seems to frown on setting \mag, so

# I think we can assume this is constant

self.state = _dvistate.outer

@dispatch(248, state=_dvistate.outer)

def _post(self, _):

self.state = _dvistate.post_post

# TODO: actually read the postamble and finale?

# currently post_post just triggers closing the file

@dispatch(249)

def _post_post(self, _):

raise NotImplementedError

@dispatch(min=250, max=255)

def _malformed(self, offset):

"""

__slots__ = ('texname', 'size', 'widths', '_scale', '_vf', '_tfm')

def __init__(self, scale, tfm, texname, vf):

if not isinstance(texname, bytes):

raise ValueError("texname must be a bytestring, got %s"

% type(texname))

self._scale, self._tfm, self.texname, self._vf = \

scale, tfm, texname, vf

self.size = scale * (72.0 / (72.27 * 2**16))

try:

nchars = max(tfm.width) + 1

except ValueError:

nchars = 0

self.widths = [(1000*tfm.width.get(char, 0)) >> 20

for char in xrange(nchars)]

def __eq__(self, other):

return self.__class__ == other.__class__ and \

self.texname == other.texname and self.size == other.size

def __ne__(self, other):

return not self.__eq__(other)

def _width_of(self, char):

"""

width = self._tfm.width.get(char, None)

if width is not None:

return _mul2012(width, self._scale)

matplotlib.verbose.report(

'No width for char %d in font %s' % (char, self.texname),

'debug')

return 0

def _height_depth_of(self, char):

"""

result = []

for metric, name in ((self._tfm.height, "height"),

(self._tfm.depth, "depth")):

value = metric.get(char, None)

if value is None:

matplotlib.verbose.report(

'No %s for char %d in font %s' % (

name, char, self.texname),

'debug')

result.append(0)

else:

result.append(_mul2012(value, self._scale))

"""

def __init__(self, filename):

Dvi.__init__(self, filename, 0)

try:

self._first_font = None

self._chars = {}

self._read()

finally:

self.close()

def __getitem__(self, code):

return self._chars[code]

def _read(self):

"""

packet_len, packet_char, packet_width = None, None, None

while True:

byte = ord(self.file.read(1)[0])

# If we are in a packet, execute the dvi instructions

if self.state == _dvistate.inpage:

byte_at = self.file.tell()-1

if byte_at == packet_ends:

self._finalize_packet(packet_char, packet_width)

packet_len, packet_char, packet_width = None, None, None

# fall through to out-of-packet code

elif byte_at > packet_ends:

raise ValueError("Packet length mismatch in vf file")

else:

if byte in (139, 140) or byte >= 243:

raise ValueError(

"Inappropriate opcode %d in vf file" % byte)

Dvi._dtable[byte](self, byte)

continue

# We are outside a packet

if byte < 242: # a short packet (length given by byte)

packet_len = byte

packet_char, packet_width = self._arg(1), self._arg(3)

packet_ends = self._init_packet(byte)

self.state = _dvistate.inpage

elif byte == 242: # a long packet

packet_len, packet_char, packet_width = \

[self._arg(x) for x in (4, 4, 4)]

self._init_packet(packet_len)

elif 243 <= byte <= 246:

k = self._arg(byte - 242, byte == 246)

c, s, d, a, l = [self._arg(x) for x in (4, 4, 4, 1, 1)]

self._fnt_def_real(k, c, s, d, a, l)

if self._first_font is None:

self._first_font = k

elif byte == 247: # preamble

i, k = self._arg(1), self._arg(1)

x = self.file.read(k)

cs, ds = self._arg(4), self._arg(4)

self._pre(i, x, cs, ds)

elif byte == 248: # postamble (just some number of 248s)

break

else:

raise ValueError("unknown vf opcode %d" % byte)

def _init_packet(self, pl):

if self.state != _dvistate.outer:

raise ValueError("Misplaced packet in vf file")

self.h, self.v, self.w, self.x, self.y, self.z = 0, 0, 0, 0, 0, 0

self.stack, self.text, self.boxes = [], [], []

self.f = self._first_font

return self.file.tell() + pl

def _finalize_packet(self, packet_char, packet_width):

self._chars[packet_char] = Page(

text=self.text, boxes=self.boxes, width=packet_width,

height=None, descent=None)

self.state = _dvistate.outer

def _pre(self, i, x, cs, ds):

if self.state != _dvistate.pre:

raise ValueError("pre command in middle of vf file")

if i != 202:

raise ValueError("Unknown vf format %d" % i)

if len(x):

matplotlib.verbose.report('vf file comment: ' + x, 'debug')

self.state = _dvistate.outer

"""

assert 0 <= num < 2**32

if num & 2**31:

return num - 2**32

else:

"""

# Separated into a function because >> has surprising precedence

"""

__slots__ = ('checksum', 'design_size', 'width', 'height', 'depth')

def __init__(self, filename):

matplotlib.verbose.report('opening tfm file ' + filename, 'debug')

with open(filename, 'rb') as file:

header1 = file.read(24)

lh, bc, ec, nw, nh, nd = \

struct.unpack(str('!6H'), header1[2:14])

matplotlib.verbose.report(

'lh=%d, bc=%d, ec=%d, nw=%d, nh=%d, nd=%d' % (

lh, bc, ec, nw, nh, nd), 'debug')

header2 = file.read(4*lh)

self.checksum, self.design_size = \

struct.unpack(str('!2I'), header2[:8])

# there is also encoding information etc.

char_info = file.read(4*(ec-bc+1))

widths = file.read(4*nw)

heights = file.read(4*nh)

depths = file.read(4*nd)

self.width, self.height, self.depth = {}, {}, {}

widths, heights, depths = \

[struct.unpack(str('!%dI') % (len(x)/4), x)

for x in (widths, heights, depths)]

for idx, char in enumerate(xrange(bc, ec+1)):

byte0 = ord(char_info[4*idx])

byte1 = ord(char_info[4*idx+1])

self.width[char] = _fix2comp(widths[byte0])

self.height[char] = _fix2comp(heights[byte1 >> 4])

"""

__slots__ = ('_font', '_filename')

def __init__(self, filename):

self._font = {}

self._filename = filename

if six.PY3 and isinstance(filename, bytes):

encoding = sys.getfilesystemencoding() or 'utf-8'

self._filename = filename.decode(encoding, errors='replace')

with open(filename, 'rb') as file:

self._parse(file)

def __getitem__(self, texname):

assert isinstance(texname, bytes)

try:

result = self._font[texname]

except KeyError:

fmt = ('A PostScript file for the font whose TeX name is "{0}" '

'could not be found in the file "{1}". The dviread module '

'can only handle fonts that have an associated PostScript '

'font file. '

'This problem can often be solved by installing '

'a suitable PostScript font package in your (TeX) '

'package manager.')

msg = fmt.format(texname.decode('ascii'), self._filename)

msg = textwrap.fill(msg, break_on_hyphens=False,

break_long_words=False)

matplotlib.verbose.report(msg, 'helpful')

raise

fn, enc = result.filename, result.encoding

if fn is not None and not fn.startswith(b'/'):

fn = find_tex_file(fn)

if enc is not None and not enc.startswith(b'/'):

enc = find_tex_file(result.encoding)

return result._replace(filename=fn, encoding=enc)

def _parse(self, file):

"""

# If the map file specifies multiple encodings for a font, we

# follow pdfTeX in choosing the last one specified. Such

# entries are probably mistakes but they have occurred.

# http://tex.stackexchange.com/questions/10826/

# http://article.gmane.org/gmane.comp.tex.pdftex/4914

empty_re = re.compile(br'%|\s*$')

word_re = re.compile(

br'''(?x) (?:

)''')

effects_re = re.compile(

br'''(?x) (?P<slant> -?[0-9]*(?:\.[0-9]+)) \s* SlantFont

| (?P<extend>-?[0-9]*(?:\.[0-9]+)) \s* ExtendFont''')

lines = (line.strip()

for line in file

if not empty_re.match(line))

for line in lines:

effects, encoding, filename = b'', None, None

words = word_re.finditer(line)

# The named groups are mutually exclusive and are

# referenced below at an estimated order of probability of

# occurrence based on looking at my copy of pdftex.map.

# The font names are probably unquoted:

w = next(words)

texname = w.group('eff2') or w.group('eff1')

w = next(words)

psname = w.group('eff2') or w.group('eff1')

for w in words:

# Any effects are almost always quoted:

eff = w.group('eff1') or w.group('eff2')

if eff:

effects = eff

continue

# Encoding files usually have the .enc suffix

# and almost never need quoting:

enc = (w.group('enc4') or w.group('enc3') or

w.group('enc2') or w.group('enc1'))

if enc:

if encoding is not None:

matplotlib.verbose.report(

'Multiple encodings for %s = %s'

% (texname, psname),

'debug')

encoding = enc

continue

# File names are probably unquoted:

filename = w.group('file2') or w.group('file1')

effects_dict = {}

for match in effects_re.finditer(effects):

slant = match.group('slant')

if slant:

effects_dict['slant'] = float(slant)

else:

effects_dict['extend'] = float(match.group('extend'))

self._font[texname] = PsFont(

texname=texname, psname=psname, effects=effects_dict,

"""

__slots__ = ('encoding',)

def __init__(self, filename):

with open(filename, 'rb') as file:

matplotlib.verbose.report('Parsing TeX encoding ' + filename,

'debug-annoying')

self.encoding = self._parse(file)

matplotlib.verbose.report('Result: ' + repr(self.encoding),

'debug-annoying')

def __iter__(self):

for name in self.encoding:

yield name

def _parse(self, file):

result = []

lines = (line.split(b'%', 1)[0].strip() for line in file)

data = b''.join(lines)

beginning = data.find(b'[')

if beginning < 0:

raise ValueError("Cannot locate beginning of encoding in {}"

.format(file))

data = data[beginning:]