address@hidden@ # vim: set noexpandtab: # TODO: # * Figure out clean set of options. # * add support for .lilyrc # * %\def\preMudelaExample should be ignored by mudela-book because # it is commented out # * if you run mudela-book once with --no-pictures, and then again # without the option, then the pngs will not be created. You have # to delete the generated .ly files and rerun mudela-book. # * kontroller hvordan det skannes etter preMudelaExample i preamble # det ser ut til at \usepackage{graphics} legges til bare hvis # preMudelaExample ikke finnes. # * add suppoert for @c comments. Check that preamble scanning works after this. # * in LaTeX, commenting out blocks like this # %\begin{mudela} # %c d e # %\end{mudela} works as expected. # * \usepackage{landscape} is gone. Convince me it is really neede to get it back. # * We are calculating more of the linewidths, for example 2 col from 1 col. import os import stat import string import re import getopt import sys import __main__ import operator program_version = '@TOPLEVEL_VERSION@' if program_version == '@' + 'TOPLEVEL_VERSION' + '@': program_version = '1.3.85' include_path = [os.getcwd()] g_dep_prefix = '' g_outdir = '' g_force_mudela_fontsize = 0 g_read_lys = 0 g_do_pictures = 1 g_num_cols = 1 format = '' g_run_lilypond = 1 no_match = 'a\ba' default_music_fontsize = 16 default_text_fontsize = 12 class LatexPaper: def __init__(self): self.m_paperdef = { # the dimentions are from geometry.sty 'a0paper': (mm2pt(841), mm2pt(1189)), 'a1paper': (mm2pt(595), mm2pt(841)), 'a2paper': (mm2pt(420), mm2pt(595)), 'a3paper': (mm2pt(297), mm2pt(420)), 'a4paper': (mm2pt(210), mm2pt(297)), 'a5paper': (mm2pt(149), mm2pt(210)), 'b0paper': (mm2pt(1000), mm2pt(1414)), 'b1paper': (mm2pt(707), mm2pt(1000)), 'b2paper': (mm2pt(500), mm2pt(707)), 'b3paper': (mm2pt(353), mm2pt(500)), 'b4paper': (mm2pt(250), mm2pt(353)), 'b5paper': (mm2pt(176), mm2pt(250)), 'letterpaper': (in2pt(8.5), in2pt(11)), 'legalpaper': (in2pt(8.5), in2pt(14)), 'executivepaper': (in2pt(7.25), in2pt(10.5))} self.m_use_geometry = None self.m_papersize = 'letterpaper' self.m_fontsize = 10 self.m_num_cols = 1 self.m_landscape = 0 self.m_geo_landscape = 0 self.m_geo_width = None self.m_geo_textwidth = None self.m_geo_lmargin = None self.m_geo_rmargin = None self.m_geo_includemp = None self.m_geo_marginparwidth = {10: 57, 11: 50, 12: 35} self.m_geo_marginparsep = {10: 11, 11: 10, 12: 10} self.m_geo_x_marginparwidth = None self.m_geo_x_marginparsep = None self.__body = None def set_geo_option(self, name, value): if name == 'body' or name == 'text': if type(value) == type(""): self._set_dimen('m_geo_textwidth', value) else: self._set_dimen('m_geo_textwidth', value[0]) self.__body = 1 elif name == 'portrait': self.m_geo_landscape = 0 elif name == 'reversemp' or name == 'reversemarginpar': if self.m_geo_includemp == None: self.m_geo_includemp = 1 elif name == 'marginparwidth' or name == 'marginpar': self._set_dimen('m_geo_x_marginparwidth', value) self.m_geo_includemp = 1 elif name == 'marginparsep': self._set_dimen('m_geo_x_marginparsep', value) self.m_geo_includemp = 1 elif name == 'scale': if type(value) == type(""): self.m_geo_width = self.get_paperwidth() * float(value) else: self.m_geo_width = self.get_paperwidth() * float(value[0]) elif name == 'hscale': self.m_geo_width = self.get_paperwidth() * float(value) elif name == 'left' or name == 'lmargin': self._set_dimen('m_geo_lmargin', value) elif name == 'right' or name == 'rmargin': self._set_dimen('m_geo_rmargin', value) elif name == 'hdivide' or name == 'divide': if value[0] not in ('*', ''): self._set_dimen('m_geo_lmargin', value[0]) if value[1] not in ('*', ''): self._set_dimen('m_geo_width', value[1]) if value[2] not in ('*', ''): self._set_dimen('m_geo_rmargin', value[2]) elif name == 'hmargin': if type(value) == type(""): self._set_dimen('m_geo_lmargin', value) self._set_dimen('m_geo_rmargin', value) else: self._set_dimen('m_geo_lmargin', value[0]) self._set_dimen('m_geo_rmargin', value[1]) elif name == 'margin':#ugh there is a bug about this option in # the geometry documentation if type(value) == type(""): self._set_dimen('m_geo_lmargin', value) self._set_dimen('m_geo_rmargin', value) else: self._set_dimen('m_geo_lmargin', value[0]) self._set_dimen('m_geo_rmargin', value[0]) elif name == 'total': if type(value) == type(""): self._set_dimen('m_geo_width', value) else: self._set_dimen('m_geo_width', value[0]) elif name == 'width' or name == 'totalwidth': self._set_dimen('m_geo_width', value) elif name == 'paper' or name == 'papername': self.m_papersize = value elif name[-5:] == 'paper': self.m_papersize = name else: self._set_dimen('m_geo_'+name, value) def _set_dimen(self, name, value): if type(value) == type("") and value[-2:] == 'pt': self.__dict__[name] = int(value[:-2]) elif type(value) == type("") and value[-2:] == 'mm': self.__dict__[name] = mm2pt(int(value[:-2])) elif type(value) == type("") and value[-2:] == 'cm': self.__dict__[name] = 10 * mm2pt(int(value[:-2])) elif type(value) == type("") and value[-2:] == 'in': self.__dict__[name] = in2pt(int(value[:-2])) else: self.__dict__[name] = value def display(self): print "LatexPaper:\n-----------" for v in self.__dict__.keys(): if v[:2] == 'm_': print v, self.__dict__[v] print "-----------" def get_linewidth(self): w = self._calc_linewidth() if self.m_num_cols == 2: return (w - 10) / 2 else: return w def get_paperwidth(self): if self.m_use_geometry: if self.m_landscape and self.m_geo_landscape: return self.m_paperdef[self.m_papersize][0] return self.m_paperdef[self.m_papersize][self.m_landscape or self.m_geo_landscape] #return self.m_paperdef[self.m_papersize][self.m_geo_landscape] def _calc_linewidth(self): # since geometry sometimes ignores 'includemp', this is # more complicated than it should be mp = 0 if self.m_geo_includemp: if self.m_geo_x_marginparsep is not None: mp = mp + self.m_geo_x_marginparsep else: mp = mp + self.m_geo_marginparsep[self.m_fontsize] if self.m_geo_x_marginparwidth is not None: mp = mp + self.m_geo_x_marginparwidth else: mp = mp + self.m_geo_marginparwidth[self.m_fontsize] if self.__body:#ugh test if this is necessary mp = 0 def tNone(a, b, c): return a == None, b == None, c == None if not self.m_use_geometry: return latex_linewidths[self.m_papersize][self.m_fontsize] else: if tNone(self.m_geo_lmargin, self.m_geo_width, self.m_geo_rmargin) == (1, 1, 1): if self.m_geo_textwidth: return self.m_geo_textwidth w = self.get_paperwidth() * 0.8 return w - mp elif tNone(self.m_geo_lmargin, self.m_geo_width, self.m_geo_rmargin) == (0, 1, 1): if self.m_geo_textwidth: return self.m_geo_textwidth return self.f1(self.m_geo_lmargin, mp) elif tNone(self.m_geo_lmargin, self.m_geo_width, self.m_geo_rmargin) == (1, 1, 0): if self.m_geo_textwidth: return self.m_geo_textwidth return self.f1(self.m_geo_rmargin, mp) elif tNone(self.m_geo_lmargin, self.m_geo_width, self.m_geo_rmargin) \ in ((0, 0, 1), (1, 0, 0), (1, 0, 1)): if self.m_geo_textwidth: return self.m_geo_textwidth return self.m_geo_width - mp elif tNone(self.m_geo_lmargin, self.m_geo_width, self.m_geo_rmargin) in ((0, 1, 0), (0, 0, 0)): w = self.get_paperwidth() - self.m_geo_lmargin - self.m_geo_rmargin - mp if w < 0: w = 0 return w raise "Never do this!" def f1(self, m, mp): tmp = self.get_paperwidth() - m * 2 - mp if tmp < 0: tmp = 0 return tmp def f2(self): tmp = self.get_paperwidth() - self.m_geo_lmargin \ - self.m_geo_rmargin if tmp < 0: return 0 return tmp class TexiPaper: def __init__(self): self.m_papersize = 'a4' self.m_fontsize = 12 def get_linewidth(self): return texi_linewidths[self.m_papersize][self.m_fontsize] def mm2pt(x): return x * 2.8452756 def in2pt(x): return x * 72.26999 def em2pt(x, fontsize): return {10: 10.00002, 11: 10.8448, 12: 11.74988}[fontsize] * x def ex2pt(x, fontsize): return {10: 4.30554, 11: 4.7146, 12: 5.16667}[fontsize] * x # latex linewidths: # indices are no. of columns, papersize, fontsize # Why can't this be calculated? latex_linewidths = { 'a4paper':{10: 345, 11: 360, 12: 390}, 'a4paper-landscape': {10: 598, 11: 596, 12:592}, 'a5paper':{10: 276, 11: 276, 12: 276}, 'b5paper':{10: 345, 11: 356, 12: 356}, 'letterpaper':{10: 345, 11: 360, 12: 390}, 'letterpaper-landscape':{10: 598, 11: 596, 12:596}, 'legalpaper': {10: 345, 11: 360, 12: 390}, 'executivepaper':{10: 345, 11: 360, 12: 379}} texi_linewidths = { 'a4': {12: 455}, 'a4wide': {12: 470}, 'smallbook': {12: 361}, 'texidefault': {12: 433}} option_definitions = [ ('EXT', 'f', 'format', 'set format. EXT is one of texi and latex.'), ('DIM', '', 'default-music-fontsize', 'default fontsize for music. DIM is assumed to be in points'), ('DIM', '', 'default-mudela-fontsize', 'deprecated, use --default-music-fontsize'), ('DIM', '', 'force-music-fontsize', 'force fontsize for all inline mudela. DIM is assumed be to in points'), ('DIM', '', 'force-mudela-fontsize', 'deprecated, use --force-music-fontsize'), ('DIR', 'I', 'include', 'include path'), ('', 'M', 'dependencies', 'write dependencies'), ('PREF', '', 'dep-prefix', 'prepend PREF before each -M dependency'), ('', 'n', 'no-lily', 'don\'t run lilypond'), ('', '', 'no-pictures', "don\'t generate pictures"), ('', '', 'read-lys', "don't write ly files."), ('FILE', 'o', 'outname', 'filename main output file'), ('FILE', '', 'outdir', "where to place generated files"), ('', 'v', 'version', 'print version information' ), ('', 'h', 'help', 'print help'), ] # format specific strings, ie. regex-es for input, and % strings for output output_dict= { 'latex': { 'output-mudela-fragment' : r"""\begin[eps,singleline,%s]{mudela} \context Staff < \context Voice{ %s } > \end{mudela}""", 'output-mudela':r"""\begin[%s]{mudela} %s \end{mudela}""", 'output-verbatim': "\\begin{verbatim}%s\\end{verbatim}", 'output-default-post': r"""\def\postMudelaExample{}""", 'output-default-pre': r"""\def\preMudelaExample{}""", 'output-eps': '\\noindent\\parbox{\\mudelaepswidth{%(fn)s.eps}}{\includegraphics{%(fn)s.eps}}', 'output-tex': '\\preMudelaExample \\input %(fn)s.tex \\postMudelaExample\n', 'pagebreak': r'\pagebreak', }, 'texi' : {'output-mudela': """@mudela[%s] %s @end mudela """, 'output-mudela-fragment': """@mudela[%s] \context Staff\context Voice{ %s } @end mudela """, 'pagebreak': None, 'output-verbatim': r"""@example %s @end example """, # do some tweaking: @ is needed in some ps stuff. # override EndLilyPondOutput, since @tex is done # in a sandbox, you can't do \input lilyponddefs at the # top of the document. # should also support fragment in 'output-all': r"""@tex address@hidden \input lilyponddefs \def\EndLilyPondOutput{} \input %(fn)s.tex address@hidden @end tex @html
@end html
""",
}
}
def output_verbatim (body):#ugh .format
if __main__.format == 'texi':
body = re.sub ('(address@hidden)', '@\\1', body)
return get_output ('output-verbatim') % body
def output_mbverbatim (body):#ugh .format
if __main__.format == 'texi':
body = re.sub ('(address@hidden)', '@\\1', body)
return get_output ('output-verbatim') % body
re_dict = {
'latex': {'input': '\\\\mbinput{?([^}\t \n}]*)',
'include': '\\\\mbinclude{(?P\\\\begin{document}))',
'verbatim': r"""(?s)(?P
\\begin{verbatim}.*?\\end{verbatim})""",
'verb': r"""(?P
\\verb(?P
.).*?(?P=del))""",
'mudela-file': r'(?m)^[^%\n]*?(?P.*?)})',
'mudela-block': r"""(?sm)^[^%\n]*?(?P
.*?)\\end{mudela})""",
'def-post-re': r"""\\def\\postMudelaExample""",
'def-pre-re': r"""\\def\\preMudelaExample""",
'intertext': r',?\s*intertext=\".*?\"',
'ignore': r"(?m)(?P
^%.*$\n+)",
'numcols': r"(?P
\\(?P
@address@hidden example\s)""",
'verb': r"""(?P
@code{.*?})""",
'mudela-file': '(?P
.*?)})',
#ugh add check for @c
'mudela-block': r"""(?P
.*?)@end mudela\s))""",
'option-sep' : ', *',
'intertext': r',?\s*intertext=\".*?\"',
'ignore': r"(?s)(?P
@address@hidden ignore)\s",
'numcols': no_match,
}
}
for r in re_dict.keys ():
olddict = re_dict[r]
newdict = {}
for k in olddict.keys ():
newdict[k] = re.compile (olddict[k])
re_dict[r] = newdict
def uniq (list):
list.sort ()
s = list
list = []
for x in s:
if x not in list:
list.append (x)
return list
def get_output (name):
return output_dict[format][name]
def get_re (name):
return re_dict[format][name]
def bounding_box_dimensions(fname):
try:
fd = open(fname)
except IOError:
error ("Error opening `%s'" % fname)
str = fd.read ()
s = re.search('%%BoundingBox: ([0-9]+) ([0-9]+) ([0-9]+) ([0-9]+)', str)
if s:
return (int(s.group(3))-int(s.group(1)),
int(s.group(4))-int(s.group(2)))
else:
return (0,0)
def error (str):
sys.stderr.write (str + "\n Exiting ... \n\n")
raise 'Exiting.'
def compose_full_body (body, opts):
"""Construct the mudela code to send to Lilypond.
Add stuff to BODY using OPTS as options."""
music_size = default_music_fontsize
latex_size = default_text_fontsize
for o in opts:
if g_force_mudela_fontsize:
music_size = g_force_mudela_fontsize
else:
m = re.match ('([0-9]+)pt', o)
if m:
music_size = string.atoi(m.group (1))
m = re.match ('latexfontsize=([0-9]+)pt', o)
if m:
latex_size = string.atoi (m.group (1))
if re.search ('\\\\score', body):
is_fragment = 0
else:
is_fragment = 1
if 'fragment' in opts:
is_fragment = 1
if 'nonfragment' in opts:
is_fragment = 0
if is_fragment and not 'multiline' in opts:
opts.append('singleline')
if 'singleline' in opts:
l = -1.0;
else:
l = paperguru.get_linewidth()
if 'relative' in opts:#ugh only when is_fragment
body = '\\relative c { %s }' % body
if is_fragment:
body = r"""\score {
\notes { %s }
\paper { }
}""" % body
opts = uniq (opts)
optstring = string.join (opts, ' ')
optstring = re.sub ('\n', ' ', optstring)
body = r"""
%% Generated by mudela-book.py; options are %s %%ughUGH not original options
\include "paper%d.ly"
\paper { linewidth = %f \pt; }
""" % (optstring, music_size, l) + body
return body
def parse_options_string(s):
d = {}
r1 = re.compile("((\w+)={(.*?)})((,\s*)|$)")
r2 = re.compile("((\w+)=(.*?))((,\s*)|$)")
r3 = re.compile("(\w+?)((,\s*)|$)")
while s:
m = r1.match(s)
if m:
s = s[m.end():]
d[m.group(2)] = re.split(",\s*", m.group(3))
continue
m = r2.match(s)
if m:
s = s[m.end():]
d[m.group(2)] = m.group(3)
continue
m = r3.match(s)
if m:
s = s[m.end():]
d[m.group(1)] = 1
continue
print "trøbbel:%s:" % s
return d
def scan_latex_preamble(chunks):
# first we want to scan the \documentclass line
# it should be the first non-comment line
idx = 0
while 1:
if chunks[idx][0] == 'ignore':
idx = idx + 1
continue
m = get_re ('header').match(chunks[idx][1])
options = re.split (',[\n \t]*', m.group(1)[1:-1])
for o in options:
if o == 'landscape':
paperguru.m_landscape = 1
m = re.match("(.*?)paper", o)
if m:
paperguru.m_papersize = m.group()
else:
m = re.match("(\d\d)pt", o)
if m:
paperguru.m_fontsize = int(m.group(1))
break
while chunks[idx][0] != 'preamble-end':
if chunks[idx] == 'ignore':
idx = idx + 1
continue
m = get_re ('geometry').search(chunks[idx][1])
if m:
paperguru.m_use_geometry = 1
o = parse_options_string(m.group('options'))
for k in o.keys():
paperguru.set_geo_option(k, o[k])
idx = idx + 1
def scan_preamble (chunks):
if __main__.format == 'texi':
#ugh has to be fixed when @c comments are implemented
# also the searching here is far from bullet proof.
if string.find(chunks[0][1], "@afourpaper") != -1:
paperguru.m_papersize = 'a4'
elif string.find(chunks[0][1], "@afourwide") != -1:
paperguru.m_papersize = 'a4wide'
elif string.find(chunks[0][1], "@smallbook") != -1:
paperguru.m_papersize = 'smallbook'
else:
assert __main__.format == 'latex'
scan_latex_preamble(chunks)
def completize_preamble (str):
m = get_re ('preamble-end').search( str)
if not m:
return str
preamble = str [:m.start (0)]
str = str [m.start(0):]
if not get_re('def-post-re').search (preamble):
preamble = preamble + get_output('output-default-post')
if not get_re ('def-pre-re').search( preamble):
preamble = preamble + get_output ('output-default-pre')
# UGH ! BUG!
#if re.search ('\\\\includegraphics', str) and not re.search ('usepackage{graphics}',str):
preamble = preamble + '\\usepackage{graphics}\n'
return preamble + str
read_files = []
def find_file (name):
f = None
for a in include_path:
try:
nm = os.path.join (a, name)
f = open (nm)
__main__.read_files.append (nm)
break
except IOError:
pass
if f:
return f.read ()
else:
error ("File not found `%s'\n" % name)
return ''
def do_ignore(match_object):
return [('ignore', match_object.group('code'))]
def do_preamble_end(match_object):
return [('preamble-end', match_object.group('code'))]
def make_verbatim(match_object):
return [('verbatim', match_object.group('code'))]
def make_verb(match_object):
return [('verb', match_object.group('code'))]
def do_include_file(m):
"m: MatchObject"
return [('input', get_output ('pagebreak'))] \
+ read_doc_file(m.group('filename')) \
+ [('input', get_output ('pagebreak'))]
def do_input_file(m):
return read_doc_file(m.group('filename'))
def make_mudela(m):
if m.group('options'):
options = m.group('options')
else:
options = ''
return [('input', get_output('output-mudela-fragment') %
(options, m.group('code')))]
def make_mudela_file(m):
if m.group('options'):
options = m.group('options')
else:
options = ''
return [('input', get_output('output-mudela') %
(options, find_file(m.group('filename'))))]
def make_mudela_block(m):
if m.group('options'):
options = get_re('option-sep').split (m.group('options'))
else:
options = []
options = filter(lambda s: s != '', options)
if 'mbverbatim' in options:#ugh this is ugly and only for texi format
s = m.group()
im = get_re('intertext').search(s)
if im:
s = s[:im.start()] + s[im.end():]
im = re.search('mbverbatim', s)
if im:
s = s[:im.start()] + s[im.end():]
if s[:9] == "@mudela[]":
s = "@mudela" + s[9:]
return [('mudela', m.group('code'), options, s)]
return [('mudela', m.group('code'), options)]
def do_columns(m):
if __main__.format != 'latex':
return []
if m.group('num') == 'one':
return [('numcols', m.group('code'), 1)]
if m.group('num') == 'two':
return [('numcols', m.group('code'), 2)]
def new_chop_chunks(chunks, re_name, func):
newchunks = []
for c in chunks:
if c[0] == 'input':
str = c[1]
while str:
m = get_re (re_name).search (str)
if m == None:
newchunks.append (('input', str))
str = ''
else:
print "REDICT", re_name
print m.groupdict()
newchunks.append (('input', str[:m.start ('match')]))
#newchunks.extend(func(m))
# python 1.5 compatible:
newchunks = newchunks + func(m)
str = str [m.end(0):]
else:
newchunks.append(c)
return newchunks
def chop_chunks(chunks, re_name, func):
newchunks = []
for c in chunks:
if c[0] == 'input':
str = c[1]
while str:
m = get_re (re_name).search (str)
if m == None:
newchunks.append (('input', str))
str = ''
else:
newchunks.append (('input', str[:m.start (0)]))
#newchunks.extend(func(m))
# python 1.5 compatible:
newchunks = newchunks + func(m)
str = str [m.end(0):]
else:
newchunks.append(c)
return newchunks
def read_doc_file (filename):
"""Read the input file, find verbatim chunks and do \input and \include
"""
str = ''
str = find_file(filename)
if __main__.format == '':
latex = re.search ('\\\\document', str[:200])
texinfo = re.search ('@node|@setfilename', str[:200])
if (texinfo and latex) or not (texinfo or latex):
error("error: can't determine format, please specify")
if texinfo:
__main__.format = 'texi'
__main__.paperguru = TexiPaper()
else:
__main__.format = 'latex'
__main__.paperguru = LatexPaper()
chunks = [('input', str)]
# we have to check for verbatim before doing include,
# because we don't want to include files that are mentioned
# inside a verbatim environment
chunks = chop_chunks(chunks, 'verbatim', make_verbatim)
chunks = chop_chunks(chunks, 'verb', make_verb)
#ugh fix input
chunks = chop_chunks(chunks, 'include', do_include_file)
chunks = chop_chunks(chunks, 'input', do_input_file)
return chunks
taken_file_names = {}
def schedule_mudela_block (chunk):
"""Take the body and options from CHUNK, figure out how the
real .ly should look, and what should be left MAIN_STR (meant
for the main file). The .ly is written, and scheduled in
TODO.
Return: a chunk (TYPE_STR, MAIN_STR, OPTIONS, TODO, BASE)
TODO has format [basename, extension, extension, ... ]
"""
if len(chunk) == 3:
(type, body, opts) = chunk
complete_body = None
else:# mbverbatim
(type, body, opts, complete_body) = chunk
assert type == 'mudela'
file_body = compose_full_body (body, opts)
basename = `abs(hash (file_body))`
for o in opts:
m = re.search ('filename="(.*?)"', o)
if m:
basename = m.group (1)
if not taken_file_names.has_key(basename):
taken_file_names[basename] = 0
else:
taken_file_names[basename] = taken_file_names[basename] + 1
basename = basename + "-%i" % taken_file_names[basename]
# writes the file if necessary, returns true if it was written
if not g_read_lys:
update_file(file_body, os.path.join(g_outdir, basename) + '.ly')
needed_filetypes = ['tex']
if format == 'texi':
needed_filetypes.append('eps')
needed_filetypes.append('png')
if 'eps' in opts and not ('eps' in needed_filetypes):
needed_filetypes.append('eps')
outname = os.path.join(g_outdir, basename)
if not os.path.isfile(outname + '.tex') \
or os.stat(outname+'.ly')[stat.ST_MTIME] > \
os.stat(outname+'.tex')[stat.ST_MTIME]:
todo = needed_filetypes
else:
todo = []
newbody = ''
if 'verbatim' in opts:
newbody = output_verbatim (body)
elif 'mbverbatim' in opts:
newbody = output_mbverbatim (complete_body)
for o in opts:
m = re.search ('intertext="(.*?)"', o)
if m:
newbody = newbody + m.group (1) + "\n\n"
if format == 'latex':
if 'eps' in opts:
s = 'output-eps'
else:
s = 'output-tex'
else: # format == 'texi'
s = 'output-all'
newbody = newbody + get_output(s) % {'fn': basename }
return ('mudela', newbody, opts, todo, basename)
def process_mudela_blocks(outname, chunks):#ugh rename
newchunks = []
# Count sections/chapters.
for c in chunks:
if c[0] == 'mudela':
c = schedule_mudela_block (c)
elif c[0] == 'numcols':
paperguru.m_num_cols = c[2]
newchunks.append (c)
return newchunks
def find_eps_dims (match):
"Fill in dimensions of EPS files."
fn =match.group (1)
dims = bounding_box_dimensions (fn)
return '%ipt' % dims[0]
def system (cmd):
sys.stderr.write ("invoking `%s'\n" % cmd)
st = os.system (cmd)
if st:
error ('Error command exited with value %d\n' % st)
return st
def compile_all_files (chunks):
eps = []
tex = []
png = []
for c in chunks:
if c[0] <> 'mudela':
continue
base = c[4]
exts = c[3]
for e in exts:
if e == 'eps':
eps.append (base)
elif e == 'tex':
#ugh
if base + '.ly' not in tex:
tex.append (base + '.ly')
elif e == 'png' and g_do_pictures:
png.append (base)
d = os.getcwd()
if g_outdir:
os.chdir(g_outdir)
if tex:
lilyopts = map (lambda x: '-I ' + x, include_path)
lilyopts = string.join (lilyopts, ' ' )
texfiles = string.join (tex, ' ')
system ('lilypond %s %s' % (lilyopts, texfiles))
for e in eps:
system(r"tex '\nonstopmode \input %s'" % e)
system(r"dvips -E -o %s %s" % (e + '.eps', e))
for g in png:
cmd = r"""gs -sDEVICE=pgm -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -q -sOutputFile=- -r90 -dNOPAUSE %s -c quit | pnmcrop | pnmtopng > %s"""
cmd = cmd % (g + '.eps', g + '.png')
system (cmd)
if g_outdir:
os.chdir(d)
def update_file (body, name):
"""
write the body if it has changed
"""
same = 0
try:
f = open (name)
fs = f.read (-1)
same = (fs == body)
except:
pass
if not same:
f = open (name , 'w')
f.write (body)
f.close ()
return not same
def getopt_args (opts):
"Construct arguments (LONG, SHORT) for getopt from list of options."
short = ''
long = []
for o in opts:
if o[1]:
short = short + o[1]
if o[0]:
short = short + ':'
if o[2]:
l = o[2]
if o[0]:
l = l + '='
long.append (l)
return (short, long)
def option_help_str (o):
"Transform one option description (4-tuple ) into neatly formatted string"
sh = ' '
if o[1]:
sh = '-%s' % o[1]
sep = ' '
if o[1] and o[2]:
sep = ','
long = ''
if o[2]:
long= '--%s' % o[2]
arg = ''
if o[0]:
if o[2]:
arg = '='
arg = arg + o[0]
return ' ' + sh + sep + long + arg
def options_help_str (opts):
"Convert a list of options into a neatly formatted string"
w = 0
strs =[]
helps = []
for o in opts:
s = option_help_str (o)
strs.append ((s, o[3]))
if len (s) > w:
w = len (s)
str = ''
for s in strs:
str = str + '%s%s%s\n' % (s[0], ' ' * (w - len(s[0]) + 3), s[1])
return str
def help():
sys.stdout.write("""Usage: mudela-book [options] FILE\n
Generate hybrid LaTeX input from Latex + mudela
Options:
""")
sys.stdout.write (options_help_str (option_definitions))
sys.stdout.write (r"""Warning all output is written in the CURRENT directory
Report bugs to address@hidden
Written by Tom Cato Amundsen and
Han-Wen Nienhuys
""")
sys.exit (0)
def write_deps (fn, target):
sys.stdout.write('writing `%s\'\n' % os.path.join(g_outdir, fn))
f = open (os.path.join(g_outdir, fn), 'w')
f.write ('%s%s: ' % (g_dep_prefix, target))
for d in __main__.read_files:
f.write ('%s ' % d)
f.write ('\n')
f.close ()
__main__.read_files = []
def identify():
sys.stdout.write ('mudela-book (GNU LilyPond) %s\n' % program_version)
def print_version ():
identify()
sys.stdout.write (r"""Copyright 1998--1999
Distributed under terms of the GNU General Public License. It comes with
NO WARRANTY.
""")
def do_file(input_filename):
file_settings = {}
if outname:
my_outname = outname
else:
my_outname = os.path.basename(os.path.splitext(input_filename)[0])
my_depname = my_outname + '.dep'
chunks = read_doc_file(input_filename)
chunks = new_chop_chunks(chunks, 'mudela', make_mudela)
chunks = new_chop_chunks(chunks, 'mudela-file', make_mudela_file)
chunks = new_chop_chunks(chunks, 'mudela-block', make_mudela_block)
chunks = chop_chunks(chunks, 'ignore', do_ignore)
chunks = new_chop_chunks(chunks, 'preamble-end', do_preamble_end)
chunks = chop_chunks(chunks, 'numcols', do_columns)
#print "-" * 50
#for c in chunks: print "c:", c;
#sys.exit()
scan_preamble(chunks)
chunks = process_mudela_blocks(my_outname, chunks)
# Do It.
if __main__.g_run_lilypond:
compile_all_files (chunks)
newchunks = []
# finishing touch.
for c in chunks:
if c[0] == 'mudela' and 'eps' in c[2]:
body = re.sub (r"""\\mudelaepswidth{(.*?)}""", find_eps_dims, c[1])
newchunks.append (('mudela', body))
else:
newchunks.append (c)
chunks = newchunks
if chunks and chunks[0][0] == 'input':
chunks[0] = ('input', completize_preamble (chunks[0][1]))
foutn = os.path.join(g_outdir, my_outname + '.' + format)
sys.stderr.write ("Writing `%s'\n" % foutn)
fout = open (foutn, 'w')
for c in chunks:
fout.write (c[1])
fout.close ()
if do_deps:
write_deps (my_depname, foutn)
outname = ''
try:
(sh, long) = getopt_args (__main__.option_definitions)
(options, files) = getopt.getopt(sys.argv[1:], sh, long)
except getopt.error, msg:
sys.stderr.write("error: %s" % msg)
sys.exit(1)
do_deps = 0
for opt in options:
o = opt[0]
a = opt[1]
if o == '--include' or o == '-I':
include_path.append (a)
elif o == '--version' or o == '-v':
print_version ()
sys.exit (0)
elif o == '--format' or o == '-f':
__main__.format = a
elif o == '--outname' or o == '-o':
if len(files) > 1:
#HACK
sys.stderr.write("Mudela-book is confused by --outname on multiple files")
sys.exit(1)
outname = a
elif o == '--help' or o == '-h':
help ()
elif o == '--no-lily' or o == '-n':
__main__.g_run_lilypond = 0
elif o == '--dependencies' or o == '-M':
do_deps = 1
elif o == '--default-music-fontsize':
default_music_fontsize = string.atoi (a)
elif o == '--default-mudela-fontsize':
print "--default-mudela-fontsize is deprecated, use --default-music-fontsize"
default_music_fontsize = string.atoi (a)
elif o == '--force-music-fontsize':
g_force_mudela_fontsize = string.atoi(a)
elif o == '--force-mudela-fontsize':
print "--force-mudela-fontsize is deprecated, use --default-mudela-fontsize"
g_force_mudela_fontsize = string.atoi(a)
elif o == '--dep-prefix':
g_dep_prefix = a
elif o == '--no-pictures':
g_do_pictures = 0
elif o == '--read-lys':
g_read_lys = 1
elif o == '--outdir':
g_outdir = a
identify()
if g_outdir:
if os.path.isfile(g_outdir):
error ("outdir is a file: %s" % g_outdir)
if not os.path.exists(g_outdir):
os.mkdir(g_outdir)
for input_filename in files:
do_file(input_filename)
#
# Petr, ik zou willen dat ik iets zinvoller deed,
# maar wat ik kan ik doen, het verandert toch niets?
# --hwn 20/aug/99