#!/usr/bin/python3
"""Parse the glyphs in IMLAC PDS-1 display list disassembly.

Specifically,
https://github.com/PDP-10/its/blob/f6408e16cb1aaf7f2583c02cdca506f2fe24b993/src/imsrc/ssvchr.22

This is a barely-working kludge.

The display processor’s instruction set is documented in
<http://bitsavers.org/pdf/imlac/PDS-1D_ProgrammingGuide.pdf>.

"""
import sys, re


comment = re.compile(r';.*')
blank = re.compile(r'\s*$')
label = re.compile(r'^(?P<label>.*):')
inc = re.compile(r'\s+INC (E|X|[BD]M?[0-3]M?[0-3]),'
                      + r'(E|X|[BD]M?[0-3]M?[0-3])\s*$')
vecpat = re.compile(r'[BD](?P<xs>M?)(?P<xa>[0-3])(?P<ys>M?)(?P<ya>[0-3])$')

def read(infile):
    current_glyph = None

    def vector(vec):
        if vec == 'E' or vec == 'X':
            return
        mo = vecpat.match(vec)
        if not mo:
            sys.stderr.write("Couldn’t grok vec %r" % vec)
            return
        Δx = int(mo.group('xa'))
        if mo.group('xs'):
            Δx = -Δx

        Δy = int(mo.group('ya'))
        if mo.group('ys'):
            Δy = -Δy

        current_glyph.append((vec[0], Δx, Δy))
    
    for line in infile:
        line = comment.sub('', line)
        if blank.match(line):
            continue
        if mo := label.match(line):
            line = label.sub('', line)
            if current_glyph is not None:
                yield current_label, current_glyph
            current_label = mo.group('label')
            current_glyph = []

        if mo := inc.match(line):
            vector(mo.group(1))
            vector(mo.group(2))
        else:
            sys.stderr.write("Couldn’t understand %r\n" % line)
        
    if current_glyph is not None:
        yield current_label, current_glyph

def jhfify(glyph):
    "Translate parsed IMLAC PDS-1 glyph to James Hurt JHF Hershey file format."
    label, vecs = glyph
    x = y = 0
    lit = False
    paths = []
    for beam, Δx, Δy in vecs:
        if beam == 'B':         # bright, i.e., not blank
            if not lit:         # start a new path
                lit = True
                paths.append([(x, y)])

            xo, yo = x, y       # x old, y old
            x += Δx
            y += Δy
            # Check to see if most recent point is collinear or
            # duplicate, removing it if so.
            if (xo, yo) == (x, y):
                paths[-1].pop()
            elif len(paths[-1]) > 1:
                # Collinear check.
                xo2, yo2 = paths[-1][-2]
                Δxo, Δyo = xo - xo2, yo - yo2
                # Cross product.
                if (Δx * Δyo - Δy * Δxo == 0 and # consider 3 * 8 - 4 * 6, e.g.
                    Δx * Δxo >= 0 and            # ensure they’re the same sign
                    Δy * Δyo >= 0):
                    paths[-1].pop()

            paths[-1].append((x, y))
        else:                   # dim, i.e., blank
            lit = False
            x += Δx
            y += Δy

    left, right = 0, x
    if paths:
        left  = min(left,  min(xi for path in paths for xi, yi in path))
        right = max(right, max(xi for path in paths for xi, yi in path))

    vecs = []
    for i, path in enumerate(paths):
        if i > 0:
            vecs.append((-50, 0)) # ' R', new path
        vecs.extend(path)
        # The IMLAC font contains single-point paths for the dots in
        # !, i, j, and ?.  But the other things I’m using can’t handle
        # that, and the traditional Hershey fonts don’t contain them.
        # So this is a dirty hack to make such single-point paths
        # visible.
        if len(path) == 1:
            vecs.append((path[0][0], path[0][1] + 1))

    print('#', paths, vecs)
    return '%5d%3d%s%s%s\n' % (int(label[1:], 8), len(vecs) + 1,
                               chr(ord('R') + left),
                               chr(ord('R') + right),
                               ''.join(chr(ord('R') + x) +
                                       chr(ord('R') - y) for x, y in vecs))

if __name__ == '__main__':
    for glyph in read(sys.stdin):
        print('#', glyph)       # Grep these out for a hopefully valid JHF file.
        print(jhfify(glyph), end='')