File: fontextract.py

package info (click to toggle)
lilypond 2.19.81+really-2.18.2-13
  • links: PTS, VCS
  • area: main
  • in suites: buster, sid
  • size: 68,528 kB
  • sloc: cpp: 76,619; ansic: 75,407; lisp: 56,140; xml: 31,046; python: 20,799; sh: 7,946; yacc: 3,266; perl: 3,045; asm: 1,587; lex: 1,405; makefile: 1,048; tcl: 457; awk: 199; php: 53; csh: 50
file content (115 lines) | stat: -rw-r--r-- 3,271 bytes parent folder | download | duplicates (4)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
import re

import getopt
import sys
import os

dsr_font_regex = re.compile ('%%DocumentSuppliedResources: font (.*)')
begin_font_regex = re.compile ('%%BeginFont: (.*)')
end_font_regex = re.compile ('%%EndFont')
verbose = 0

try:
    import gettext
    gettext.bindtextdomain ('lilypond', localedir)
    gettext.textdomain ('lilypond')
    _ = gettext.gettext
except:
    def _ (s):
        return s

def scan_files (files):
    file_of_font_dict = {}
    for f in files:
        if verbose:
            sys.stderr.write (_('Scanning %s') % f + '\n')

        header = open (f, 'r').read ()
        idx = 0

        extract_from_this = []
        while idx < len (header):
            match = dsr_font_regex.search (header[idx:])
            if not match:
                break
            name = match.group (1)
            idx += match.end (1)
            if file_of_font_dict.has_key (name):
                continue

            file_of_font_dict[name] = f

    return file_of_font_dict

def get_file_fonts_dict (file_of_font_dict):
    dict = {}
    for (n, f) in file_of_font_dict.items ():
        if not dict.has_key (f):
            dict[f] = []

        dict[f].append (n)

    return dict

def extract_fonts_from_file (extract_from_this, font_dict, filename):
    if extract_from_this:
        curr_font = []
        curr_font_name = []
        in_font = 0
        for l in open (filename).readlines ():
            if not in_font and begin_font_regex.match (l):
                in_font = 1
                curr_font_name = begin_font_regex.match (l).group (1)
                curr_font = []
            elif in_font and end_font_regex.match (l):
                in_font = 0

                if curr_font_name in extract_from_this:
                    font_dict[curr_font_name] = ''.join (curr_font)
                    if verbose:
                        sys.stderr.write (_('Extracted %s')
                                          % curr_font_name + '\n')

                    extract_from_this.remove (curr_font_name)
            elif in_font:
                curr_font.append (l)
            if not extract_from_this:
                break

        if extract_from_this:
            sys.stderr.write ("Failed to extract %s from %s\n"
                              % (', '.join (extract_from_this), filename))

def write_extracted_fonts (output_file_name, font_dict):
    if verbose:
        sys.stderr.write( _('Writing fonts to %s') % output_file_name + '\n')
    output = open (output_file_name, 'w')
    output.write ('''%!PS-Adobe-3.0
%%VMusage: 0 0 
%%Creator: lilypond-extract-fonts
''')

    for x in font_dict.keys ():
        output.write ('%%%%DocumentSuppliedResources: font %s\n' % x)

    output.write ('''%%EndComments\n''')

    for (k,v) in font_dict.items ():
        output.write ('\n%%%%BeginFont: %s\n' % k)
        output.write (v)
        output.write ('\n%%EndFont')


def extract_fonts (output_file_name, input_files):
    d = scan_files (input_files)
    ff = get_file_fonts_dict (d)

    font_dict = {}
    for (file, fonts) in ff.items ():
        extract_fonts_from_file (fonts, font_dict, file)

    write_extracted_fonts (output_file_name, font_dict)


if __name__ == '__main__':
    extract_fonts ('fonts.ps', sys.argv[1:])