1

def read_block (fh) :

     2

    """

     3

        Yield a series of non-empty lines from the given file, ignoring any leading empty lines, and stopping after the first empty line

     4

    """

     5

     6

    leading = True

     7

     8

    for line in fh :

     9

        if line.strip() :

    10

            leading = False

    11

    12

            # yield non-empty

    13

            yield line

    14

    15

        elif leading :

    16

            # skip leading empty

    17

            continue

    18

    19

        else :

    20

            # stop on empty

    21

            return

    22

    23

    else :

    24

        # EOF

    25

        return

    26

    27

def read_charblock (lines) :

    28

    """

    29

        Read in a char from the given lines, returning an

    30

            (ascii, rows)

    31

    32

        tuple, or None, if there weren't any more blocks

    33

    """

    34

    35

    # the ascii code as a char

    36

    ascii = ''

    37

    38

    # row data as ints

    39

    rows = []

    40

    41

    for line in lines :

    42

        line = line.strip()

    43

    44

        if line.startswith(';') :

    45

            # set ascii code

    46

            ascii = line.replace(';', '').strip()

    47

    48

            if not ascii :

    49

                print 'read_charblock', 'empty'

    50

    51

                # skip

    52

                return None

    53

    54

            elif len(ascii) == 1 :

    55

                print 'read_charblock', 'simplechar', ascii

    56

    57

            else :

    58

                ascii = ascii.decode('string_escape')

    59

    60

                print 'read_charblock', 'decodechar', ascii

    61

    62

            assert len(ascii) == 1

    63

    64

        else :

    65

            # convert

    66

            row = line.replace('#', '1').replace('-', '0')

    67

    68

            print 'read_charblock', 'row', row

    69

    70

            # 6 columns

    71

            assert len(row) == 6

    72

    73

            # from binary

    74

            row = int(row, 2)

    75

    76

            rows.append(row)

    77

    78

    # got data?

    79

    if ascii and rows :

    80

        # 8 rows

    81

        assert len(rows) == 8

    82

    83

        return ascii, rows

    84

    85

    else :

    86

        # nope, empty block, EOF

    87

        return None

    88

    89

def read_charblocks (fh) :

    90

    """

    91

        Read in all char blocks as (ascii, rows) tuples from given file

    92

    """

    93

    94

    while True :

    95

        out = read_charblock(read_block(fh))

    96

    97

        if out :

    98

            yield out

    99

   100

        else :

   101

            break

   102

   103

def decode_rows (inrows) :

   104

    """

   105

        Decode char def data from its 6x8 row format into the format we need (6x8 col format)

   106

    """

   107

   108

    outcols = [0x00] * 6

   109

   110

    for rowidx, row in enumerate(inrows) :

   111

   112

        for colidx, col in enumerate(outcols) :

   113

            # get bit from row

   114

            bit = (row >> (5 - colidx)) & 1

   115

   116

            # set bit into column

   117

            outcols[colidx] |= (bit << rowidx)

   118

   119

    # ok...

   120

    return outcols

   121

   122

def write_chardef (fh, ascii, cols) :

   123

    """

   124

        Write out character definition block to given .def file, using given char code and column data

   125

    """

   126

   127

    fh.write(

   128

            ("; %r\n" % ascii)

   129

        +   (".db %s\n" % (', '.join(bin(col) for col in cols)))

   130

        +   ("\n")

   131

    )

   132

   133

def compile_fonts (infh, outf) :

   134

    """

   135

        Compile char blocks from infh, writing out definitions to outf

   136

    """

   137

   138

    charmap = dict()

   139

   140

    # decode in

   141

    for charblock in read_charblocks(infh) :

   142

        # unpack

   143

        ascii, rows = charblock

   144

   145

        # convert

   146

        cols = decode_rows(rows)

   147

   148

        # map

   149

        charmap[ascii] = cols

   150

   151

        print 'compile_fonts', 'read', ascii

   152

   153

    # detect min/max syms

   154

    syms = charmap.keys()

   155

    font_start = min(syms)

   156

    font_end = max(syms)

   157

   158

    assert(ord(font_start) < ord(font_end))

   159

   160

    # write out

   161

    outf.write(

   162

            ";; AUTOMATICALLY GENERATED - Do not edit!\n"

   163

            ";; 8x6 font, '0' - '1', rows-by-col format\n"

   164

        +  (".equ FONT_8x6_START = %d ; %r\n" % (ord(font_start), font_start))

   165

        +  (".equ FONT_8x6_END = %d ; %r\n" % (ord(font_end), font_end))

   166

        +  (".equ FONT_8x6_COLS = %d\n" % (6, ))

   167

        +  (".equ FONT_8x6_ROWS = %d\n" % (8, ))

   168

        +   "FONT_8x6:\n"

   169

            "\n"

   170

    )

   171

   172

    # default symbol for unknown chars

   173

    defsym = charmap['\0']

   174

   175

    for char in xrange(ord(font_start), ord(font_end) + 1) :

   176

        ascii = chr(char)

   177

        cols = charmap.get(ascii, defsym)

   178

   179

        write_chardef(outf, ascii, cols)

   180

   181

def main () :

   182

    import sys, getopt

   183

   184

    opts, args = getopt.getopt(sys.argv[1:], '')

   185

   186

    inpath, outpath = args

   187

   188

    # run

   189

    compile_fonts(open(inpath, 'r'), open(outpath, 'w'))

   190

   191

if __name__ == '__main__' :

   192

    main()

   193