#!@PYTHON@
# vim: set noexpandtab:
# TODO:
-# * Figure out clean set of options. Hmm, isn't it pretty ok now?
-# * add support for .lilyrc
+# * junk --outdir for --output
+# * Figure out clean set of options.
+# *
# * EndLilyPondOutput is def'd as vfil. Causes large white gaps.
# * texinfo: add support for @pagesize
# geometry.sty and article.cls. Give me a hint, and I'll
# fix it.)
+#
+# TODO: magnification support should also work for texinfo -> html: eg. add as option to dvips.
+#
+
# This is was the idea for handling of comments:
# Multiline comments, @ignore .. @end ignore is scanned for
# in read_doc_file, and the chunks are marked as 'ignore', so
# The the rest of the rexeces are searched for. They don't have to test
# if they are on a commented out line.
+
+
import os
import stat
import string
-import re
import getopt
import sys
import __main__
import operator
+# Handle bug in Python 1.6-2.1
+#
+# there are recursion limits for some patterns in Python 1.6 til 2.1.
+# fix this by importing the 1.5.2 implementation pre instead. Fix by Mats.
+
+if float (sys.version[0:3]) < 2.2:
+ try:
+ import pre
+ re = pre
+ del pre
+ except ImportError:
+ import re
+else:
+ import re
+
+# Attempt to fix problems with limited stack size set by Python!
+# Sets unlimited stack size. Note that the resource module only
+# is available on UNIX.
+try:
+ import resource
+ resource.setrlimit (resource.RLIMIT_STACK, (-1, -1))
+except:
+ pass
+
+errorport = sys.stderr
+verbose_p = 0
+
+
+
+try:
+ import gettext
+ gettext.bindtextdomain ('lilypond', localedir)
+ gettext.textdomain ('lilypond')
+ _ = gettext.gettext
+except:
+ def _ (s):
+ return s
+
+def progress (s):
+ errorport.write (s + '\n')
+
program_version = '@TOPLEVEL_VERSION@'
if program_version == '@' + 'TOPLEVEL_VERSION' + '@':
- program_version = '1.3.113'
+ program_version = '1.5.53'
+
+# if set, LILYPONDPREFIX must take prevalence
+# if datadir is not set, we're doing a build and LILYPONDPREFIX
+datadir = '@datadir@'
+
+if os.environ.has_key ('LILYPONDPREFIX') :
+ datadir = os.environ['LILYPONDPREFIX']
+else:
+ datadir = '@datadir@'
+
+while datadir[-1] == os.sep:
+ datadir= datadir[:-1]
+
+kpse = os.popen ('kpsexpand \$TEXMF').read()
+kpse = re.sub('[ \t\n]+$','', kpse)
+type1_paths = os.popen ('kpsewhich -expand-path=\$T1FONTS').read ()
+
+environment = {
+ # TODO: * prevent multiple addition.
+ # * clean TEXINPUTS, MFINPUTS, TFMFONTS,
+ # as these take prevalence over $TEXMF
+ # and thus may break tex run?
+ 'TEXMF' : "{%s,%s}" % (datadir, kpse) ,
+ 'GS_FONTPATH' : type1_paths,
+ 'GS_LIB' : datadir + '/ps',
+}
+
+# tex needs lots of memory, more than it gets by default on Debian
+non_path_environment = {
+ 'extra_mem_top' : '1000000',
+ 'extra_mem_bottom' : '1000000',
+ 'pool_size' : '250000',
+}
+
+def setup_environment ():
+ # $TEXMF is special, previous value is already taken care of
+ if os.environ.has_key ('TEXMF'):
+ del os.environ['TEXMF']
+
+ for key in environment.keys ():
+ val = environment[key]
+ if os.environ.has_key (key):
+ val = val + os.pathsep + os.environ[key]
+ os.environ[key] = val
+
+ for key in non_path_environment.keys ():
+ val = non_path_environment[key]
+ os.environ[key] = val
include_path = [os.getcwd()]
# g_ is for global (?)
-
+g_extra_opts = ''
g_here_dir = os.getcwd ()
g_dep_prefix = ''
g_outdir = ''
g_read_lys = 0
g_do_pictures = 1
g_num_cols = 1
+g_do_music = 1
+
format = ''
g_run_lilypond = 1
no_match = 'a\ba'
self.m_geo_x_marginparsep = None
self.__body = None
def set_geo_option(self, name, value):
+
+ if type(value) == type([]):
+ value = map(conv_dimen_to_float, value)
+ else:
+ value = conv_dimen_to_float(value)
+
if name == 'body' or name == 'text':
- if type(value) == type(""):
- self.m_geo_textwidth = value
- else:
+ if type(value) == type([]):
self.m_geo_textwidth = value[0]
+ else:
+ self.m_geo_textwidth = value
self.__body = 1
elif name == 'portrait':
self.m_geo_landscape = 0
self.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)
+ if type(value) == type([]):
+ self.m_geo_width = self.get_paperwidth() * value[0]
else:
- self.m_geo_width = self.get_paperwidth() * float(value[0])
+ self.m_geo_width = self.get_paperwidth() * value
elif name == 'hscale':
- self.m_geo_width = self.get_paperwidth() * float(value)
+ self.m_geo_width = self.get_paperwidth() * value
elif name == 'left' or name == 'lmargin':
self.m_geo_lmargin = value
elif name == 'right' or name == 'rmargin':
if value[2] not in ('*', ''):
self.m_geo_rmargin = value[2]
elif name == 'hmargin':
- if type(value) == type(""):
- self.m_geo_lmargin = value
- self.m_geo_rmargin = value
- else:
+ if type(value) == type([]):
self.m_geo_lmargin = value[0]
self.m_geo_rmargin = value[1]
- elif name == 'margin':#ugh there is a bug about this option in
- # the geometry documentation
- if type(value) == type(""):
+ else:
self.m_geo_lmargin = value
self.m_geo_rmargin = value
- else:
+ elif name == 'margin':#ugh there is a bug about this option in
+ # the geometry documentation
+ if type(value) == type([]):
self.m_geo_lmargin = value[0]
self.m_geo_rmargin = value[0]
- elif name == 'total':
- if type(value) == type(""):
- self.m_geo_width = value
else:
+ self.m_geo_lmargin = value
+ self.m_geo_rmargin = value
+ elif name == 'total':
+ if type(value) == type([]):
self.m_geo_width = value[0]
+ else:
+ self.m_geo_width = value
elif name == 'width' or name == 'totalwidth':
self.m_geo_width = value
elif name == 'paper' or name == 'papername':
elif name[-5:] == 'paper':
self.m_papersize = name
else:
- self._set_dimen('m_geo_'+name, value)
+ pass
+
def __setattr__(self, name, value):
if type(value) == type("") and \
dimension_conversion_dict.has_key (value[-2:]):
- f = dimension_conversion_dict[dim]
+ f = dimension_conversion_dict[value[-2:]]
self.__dict__[name] = f(float(value[:-2]))
else:
self.__dict__[name] = value
if not self.m_use_geometry:
return latex_linewidths[self.m_papersize][self.m_fontsize]
else:
- geo_opts = (a == None, b == None, c == None)
-
+ geo_opts = (self.m_geo_lmargin == None,
+ self.m_geo_width == None,
+ self.m_geo_rmargin == None)
+
if geo_opts == (1, 1, 1):
if self.m_geo_textwidth:
return self.m_geo_textwidth
return 0
return tmp
+class HtmlPaper:
+ def __init__(self):
+ self.m_papersize = 'letterpaper'
+ self.m_fontsize = 12
+ def get_linewidth(self):
+ return html_linewidths[self.m_papersize][self.m_fontsize]
+
class TexiPaper:
def __init__(self):
self.m_papersize = 'letterpaper'
dimension_conversion_dict ={
'mm': mm2pt,
+ 'cm': lambda x: mm2pt(10*x),
'in': in2pt,
'em': em2pt,
'ex': ex2pt,
'pt': pt2pt
}
+# Convert numeric values, with or without specific dimension, to floats.
+# Keep other strings
+def conv_dimen_to_float(value):
+ if type(value) == type(""):
+ m = re.match ("([0-9.]+)(cm|in|pt|mm|em|ex)",value)
+ if m:
+ unit = m.group (2)
+ num = string.atof(m.group (1))
+ conv = dimension_conversion_dict[m.group(2)]
+
+ value = conv(num)
+
+ elif re.match ("^[0-9.]+$",value):
+ value = float(value)
+
+ return value
+
# latex linewidths:
# indices are no. of columns, papersize, fontsize
'smallbook': {12: in2pt(5)},
'letterpaper': {12: in2pt(6)}}
+html_linewidths = {
+ 'afourpaper': {12: mm2pt(160)},
+ 'afourwide': {12: in2pt(6.5)},
+ 'afourlatex': {12: mm2pt(150)},
+ 'smallbook': {12: in2pt(5)},
+ 'letterpaper': {12: in2pt(6)}}
+
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-lilypond-fontsize', 'deprecated, use --default-music-fontsize'),
- ('DIM', '', 'force-music-fontsize', 'force fontsize for all inline lilypond. DIM is assumed be to in points'),
- ('DIM', '', 'force-lilypond-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'),
- ]
+ ('EXT', 'f', 'format', 'use output format EXT (texi [default], latex, html)'),
+ ('DIM', '', 'default-music-fontsize', 'default fontsize for music. DIM is assumed to be in points'),
+ ('DIM', '', 'default-lilypond-fontsize', 'deprecated, use --default-music-fontsize'),
+ ('OPT', '', 'extra-options' , 'Pass OPT quoted to the lilypond command line'),
+ ('DIM', '', 'force-music-fontsize', 'force fontsize for all inline lilypond. DIM is assumed be to in points'),
+ ('DIM', '', 'force-lilypond-fontsize', 'deprecated, use --force-music-fontsize'),
+ ('', 'h', 'help', 'this help'),
+ ('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"),
+ ('', '', 'no-music', "strip all lilypond blocks from output"),
+ ('', '', 'read-lys', "don't write ly files."),
+ ('FILE', 'o', 'outname', 'filename main output file'),
+ ('FILE', '', 'outdir', "where to place generated files"),
+ ('', 'V', 'verbose', 'verbose' ),
+ ('', 'v', 'version', 'print version information' ),
+ ]
# format specific strings, ie. regex-es for input, and % strings for output
output_dict= {
+ 'html' : {'output-lilypond': '''<lilypond%s>
+%s
+</lilypond>''',
+ 'output-filename' : r'''
+
+<pre>%s</pre>:''',
+ 'output-lilypond-fragment': '''<lilypond%s>
+\context Staff\context Voice{ %s }
+</lilypond>''',
+ 'output-noinline': r'''
+<!-- generated: %(fn)s.png !-->
+''',
+ ## maybe <hr> ?
+ 'pagebreak': None,
+ 'output-verbatim': r'''<pre>
+%s
+</pre>''',
+ ## Ugh we need to differentiate on origin:
+ ## lilypond-block origin wants an extra <p>, but
+ ## inline music doesn't.
+ ## possibly other center options?
+ 'output-all': r'''
+<a href="%(fn)s.png">
+<img align="center" valign="center" border="0" src="%(fn)s.png" alt="[picture of music]"></a>
+''',
+ },
'latex': {
- 'output-lilypond-fragment' : r"""\begin[eps,singleline,%s]{lilypond}
+ 'output-lilypond-fragment' : r'''\begin[eps,singleline,%s]{lilypond}
\context Staff <
\context Voice{
%s
}
>
-\end{lilypond}""",
+\end{lilypond}''',
'output-filename' : r'''
\verb+%s+:''',
- 'output-lilypond': r"""\begin[%s]{lilypond}
+ 'output-lilypond': r'''\begin[%s]{lilypond}
%s
-\end{lilypond}""",
- 'output-verbatim': "\\begin{verbatim}%s\\end{verbatim}",
+\end{lilypond}
+''',
+ 'output-verbatim': r'''\begin{verbatim}%s\end{verbatim}%%
+''',
'output-default-post': "\\def\postLilypondExample{}\n",
'output-default-pre': "\\def\preLilypondExample{}\n",
'usepackage-graphics': '\\usepackage{graphics}\n',
'output-eps': '\\noindent\\parbox{\\lilypondepswidth{%(fn)s.eps}}{\includegraphics{%(fn)s.eps}}',
- 'output-tex': '\\preLilypondExample \\input %(fn)s.tex \\postLilypondExample\n',
+ 'output-noinline': r'''
+%% generated: %(fn)s.eps
+''',
+ 'output-tex': '{\\preLilypondExample \\input %(fn)s.tex \\postLilypondExample\n}',
'pagebreak': r'\pagebreak',
},
- 'texi' : {'output-lilypond': """@lilypond[%s]
+
+ 'texi' : {'output-lilypond': '''@lilypond[%s]
%s
@end lilypond
-""",
+''',
'output-filename' : r'''
@file{%s}:''',
- 'output-lilypond-fragment': """@lilypond[%s]
+ 'output-lilypond-fragment': '''@lilypond[%s]
\context Staff\context Voice{ %s }
-@end lilypond """,
+@end lilypond ''',
+ 'output-noinline': r'''
+@c generated: %(fn)s.png
+''',
'pagebreak': None,
- 'output-verbatim': r"""@example
+ 'output-verbatim': r'''@example
%s
@end example
-""",
+''',
# do some tweaking: @ is needed in some ps stuff.
# override EndLilyPondOutput, since @tex is done
# top of the document.
# should also support fragment in
+
+# ugh, the <p> below breaks inline images...
- 'output-all': r"""
+ 'output-all': r'''
@tex
\catcode`\@=12
\input lilyponddefs
@end tex
@html
<p>
-<img src=%(fn)s.png>
+<a href="%(fn)s.png">
+<img border=0 src="%(fn)s.png" alt="[picture of music]">
+</a>
@end html
-""",
+''',
}
+
}
def output_verbatim (body):
- if __main__.format == 'texi':
+ if __main__.format == 'html':
+ body = re.sub ('&', '&', body)
+ body = re.sub ('>', '>', body)
+ body = re.sub ('<', '<', body)
+ elif __main__.format == 'texi':
body = re.sub ('([@{}])', '@\\1', body)
return get_output ('output-verbatim') % body
+#warning: this uses extended regular expressions. Tread with care.
+
+# legenda
+
+# (?P -- name parameter
+# *? -- match non-greedily.
+# (?m) -- ?
re_dict = {
+ 'html': {
+ 'include': no_match,
+ 'input': no_match,
+ 'header': no_match,
+ 'preamble-end': no_match,
+ 'landscape': no_match,
+ 'verbatim': r'''(?s)(?P<code><pre>\s.*?</pre>\s)''',
+ 'verb': r'''(?P<code><pre>.*?</pre>)''',
+ 'lilypond-file': r'(?m)(?P<match><lilypondfile(?P<options>[^>]+)?>\s*(?P<filename>[^<]+)\s*</lilypondfile>)',
+ 'lilypond' : '(?m)(?P<match><lilypond((?P<options>[^:]*):)(?P<code>.*?)/>)',
+ 'lilypond-block': r'''(?ms)(?P<match><lilypond(?P<options>[^>]+)?>(?P<code>.*?)</lilypond>)''',
+ 'option-sep' : '\s*',
+ 'intertext': r',?\s*intertext=\".*?\"',
+ 'multiline-comment': r"(?sm)\s*(?!@c\s+)(?P<code><!--\s.*?!-->)\s",
+ 'singleline-comment': no_match,
+ 'numcols': no_match,
+ },
+
'latex': {'input': r'(?m)^[^%\n]*?(?P<match>\\mbinput{?([^}\t \n}]*))',
'include': r'(?m)^[^%\n]*?(?P<match>\\mbinclude{(?P<filename>[^}]+)})',
- 'option-sep' : ', *',
+ 'option-sep' : ',\s*',
'header': r"\\documentclass\s*(\[.*?\])?",
'geometry': r"^(?m)[^%\n]*?\\usepackage\s*(\[(?P<options>.*)\])?\s*{geometry}",
'preamble-end': r'(?P<code>\\begin{document})',
'verbatim': r"(?s)(?P<code>\\begin{verbatim}.*?\\end{verbatim})",
'verb': r"(?P<code>\\verb(?P<del>.).*?(?P=del))",
- 'lilypond-file': r'(?m)^[^%\n]*?(?P<match>\\lilypondfile(\[(?P<options>.*?)\])?\{(?P<filename>.+)})',
- 'lilypond' : r'(?m)^[^%\n]*?(?P<match>\\lilypond(\[(?P<options>.*?)\])?{(?P<code>.*?)})',
- 'lilypond-block': r"(?sm)^[^%\n]*?(?P<match>\\begin(\[(?P<options>.*?)\])?{lilypond}(?P<code>.*?)\\end{lilypond})",
+ 'lilypond-file': r'(?m)^[^%\n]*?(?P<match>\\lilypondfile\s*(\[(?P<options>.*?)\])?\s*\{(?P<filename>.+)})',
+ 'lilypond' : r'(?m)^[^%\n]*?(?P<match>\\lilypond\s*(\[(?P<options>.*?)\])?\s*{(?P<code>.*?)})',
+ 'lilypond-block': r"(?sm)^[^%\n]*?(?P<match>\\begin\s*(\[(?P<options>.*?)\])?\s*{lilypond}(?P<code>.*?)\\end{lilypond})",
'def-post-re': r"\\def\\postLilypondExample",
'def-pre-re': r"\\def\\preLilypondExample",
'usepackage-graphics': r"\usepackage{graphics}",
},
- # why do we have distinction between @mbinclude and @include?
+ # why do we have distinction between @mbinclude and @include?
+
+
'texi': {
'include': '(?m)^[^%\n]*?(?P<match>@mbinclude[ \n\t]+(?P<filename>[^\t \n]*))',
'input': no_match,
'header': no_match,
'preamble-end': no_match,
'landscape': no_match,
- 'verbatim': r"""(?s)(?P<code>@example\s.*?@end example\s)""",
- 'verb': r"""(?P<code>@code{.*?})""",
- 'lilypond-file': '(?m)^(?!@c)(?P<match>@lilypondfile(\[(?P<options>.*?)\])?{(?P<filename>[^}]+)})',
- 'lilypond' : '(?m)^(?!@c)(?P<match>@lilypond(\[(?P<options>.*?)\])?{(?P<code>.*?)})',
- 'lilypond-block': r"""(?m)^(?!@c)(?P<match>(?s)(?P<match>@lilypond(\[(?P<options>.*?)\])?\s(?P<code>.*?)@end lilypond\s))""",
- 'option-sep' : ', *',
- 'intertext': r',?\s*intertext=\".*?\"',
- 'multiline-comment': r"(?sm)^\s*(?!@c\s+)(?P<code>@ignore\s.*?@end ignore)\s",
- 'singleline-comment': r"(?m)^.*?(?P<match>(?P<code>@c.*$\n+))",
- 'numcols': no_match,
+ 'verbatim': r'''(?s)(?P<code>@example\s.*?@end example\s)''',
+ 'verb': r'''(?P<code>@code{.*?})''',
+ 'lilypond-file': '(?m)^(?P<match>@lilypondfile(\[(?P<options>[^]]*)\])?{(?P<filename>[^}]+)})',
+ 'lilypond' : '(?m)^(?P<match>@lilypond(\[(?P<options>[^]]*)\])?{(?P<code>.*?)})',
+ 'lilypond-block': r'''(?ms)^(?P<match>@lilypond(\[(?P<options>[^]]*)\])?\s(?P<code>.*?)@end +lilypond)\s''',
+ 'option-sep' : ',\s*',
+ 'intertext': r',?\s*intertext=\".*?\"',
+ 'multiline-comment': r"(?sm)^\s*(?!@c\s+)(?P<code>@ignore\s.*?@end ignore)\s",
+ 'singleline-comment': r"(?m)^.*?(?P<match>(?P<code>@c.*$\n+))",
+ 'numcols': no_match,
}
}
olddict = re_dict[r]
newdict = {}
for k in olddict.keys ():
- newdict[k] = re.compile (olddict[k])
+ try:
+ newdict[k] = re.compile (olddict[k])
+ except:
+ print 'invalid regexp: %s' % olddict[k]
+
+ # we'd like to catch and reraise a more detailed error, but
+ # alas, the exceptions changed across the 1.5/2.1 boundary.
+ raise "Invalid re"
re_dict[r] = newdict
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)))
+
+ gs = map (lambda x: string.atoi (x), s.groups ())
+ return (int (gs[2] - gs[0] + 0.5),
+ int (gs[3] - gs[1] + 0.5))
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 lilypond code to send to Lilypond.
- Add stuff to BODY using OPTS as options."""
+ '''Construct the lilypond code to send to Lilypond.
+ Add stuff to BODY using OPTS as options.'''
music_size = default_music_fontsize
latex_size = default_text_fontsize
+ indent = ''
+ linewidth = ''
for o in opts:
if g_force_lilypond_fontsize:
music_size = g_force_lilypond_fontsize
m = re.match ('latexfontsize=([0-9]+)pt', o)
if m:
latex_size = string.atoi (m.group (1))
+
+ m = re.match ('indent=([-.0-9]+)(cm|in|mm|pt)', o)
+ if m:
+ f = float (m.group (1))
+ indent = 'indent = %f\\%s' % (f, m.group (2))
+
+ m = re.match ('linewidth=([-.0-9]+)(cm|in|mm|pt)', o)
+ if m:
+ f = float (m.group (1))
+ linewidth = 'linewidth = %f\\%s' % (f, m.group (2))
if re.search ('\\\\score', body):
is_fragment = 0
is_fragment = 1
if 'fragment' in opts:
is_fragment = 1
- if 'nonfragment' in opts:
+ if 'nofragment' 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 = __main__.paperguru.get_linewidth()
-
- if 'relative' in opts:#ugh only when is_fragment
- body = '\\relative c { %s }' % body
+ linewidth = 'linewidth = -1.0'
+ elif not linewidth:
+ l = __main__.paperguru.get_linewidth ()
+ linewidth = 'linewidth = %f\pt' % l
+
+ if 'noindent' in opts:
+ indent = 'indent = 0.0\mm'
+
+ for o in opts:
+ m= re.search ('relative(.*)', o)
+ v = 0
+ if m:
+ try:
+ v = string.atoi (m.group (1))
+ except ValueError:
+ pass
+
+ v = v + 1
+ pitch = 'c'
+ if v < 0:
+ pitch = pitch + '\,' * v
+ elif v > 0:
+ pitch = pitch + '\'' * v
+
+ body = '\\relative %s { %s }' %(pitch, body)
if is_fragment:
- body = r"""\score {
+ body = r'''\score {
\notes { %s }
\paper { }
-}""" % body
+}''' % body
opts = uniq (opts)
optstring = string.join (opts, ' ')
optstring = re.sub ('\n', ' ', optstring)
- body = r"""
+ body = r'''
%% Generated automatically by: lilypond-book.py
-%% options are %s %%ughUGH not original options
+%% options are %s
\include "paper%d.ly"
-\paper { linewidth = %f \pt; }
-""" % (optstring, music_size, l) + body
+\paper {
+ %s
+ %s
+}
+''' % (optstring, music_size, linewidth, indent) + body
+
+ # ughUGH not original options
return body
def parse_options_string(s):
error ("format of option string invalid (was `%')" % s)
return d
+def scan_html_preamble (chunks):
+ return
+
def scan_latex_preamble(chunks):
# first we want to scan the \documentclass line
# it should be the first non-comment line
idx = idx + 1
continue
m = get_re ('header').match(chunks[idx][1])
- options = re.split (',[\n \t]*', m.group(1)[1:-1])
+ if m <> None and m.group (1):
+ options = re.split (',[\n \t]*', m.group(1)[1:-1])
+ else:
+ options = []
for o in options:
if o == 'landscape':
paperguru.m_landscape = 1
m = re.match("(\d\d)pt", o)
if m:
paperguru.m_fontsize = int(m.group(1))
-
break
- while chunks[idx][0] != 'preamble-end':
+
+ while idx < len(chunks) and chunks[idx][0] != 'preamble-end':
if chunks[idx] == 'ignore':
idx = idx + 1
continue
if string.find(c[1], "@%s" % s) != -1:
paperguru.m_papersize = s
+
def scan_preamble (chunks):
- if __main__.format == 'texi':
- scan_texi_preamble(chunks)
- else:
- assert __main__.format == 'latex'
- scan_latex_preamble(chunks)
+ if __main__.format == 'html':
+ scan_html_preamble (chunks)
+ elif __main__.format == 'latex':
+ scan_latex_preamble (chunks)
+ elif __main__.format == 'texi':
+ scan_texi_preamble (chunks)
def completize_preamble (chunks):
- if __main__.format == 'texi':
+ if __main__.format != 'latex':
return chunks
pre_b = post_b = graphics_b = None
for chunk in chunks:
m = get_re('def-post-re').search(chunk[1])
if m:
post_b = 1
+
if chunk[0] == 'input':
m = get_re('usepackage-graphics').search(chunk[1])
if m:
graphics_b = 1
x = 0
- while chunks[x][0] != 'preamble-end':
+ while x < len (chunks) and chunks[x][0] != 'preamble-end':
x = x + 1
+
+ if x == len(chunks):
+ return chunks
+
if not pre_b:
chunks.insert(x, ('input', get_output ('output-default-pre')))
if not post_b:
chunks.insert(x, ('input', get_output ('output-default-post')))
if not graphics_b:
chunks.insert(x, ('input', get_output ('usepackage-graphics')))
+
return chunks
read_files = []
def find_file (name):
- """
+ '''
Search the include path for NAME. If found, return the (CONTENTS, PATH) of the file.
- """
-
+ '''
+
+ if name == '-':
+ return (sys.stdin.read (), '<stdin>')
f = None
nm = ''
for a in include_path:
(options, m.group('code')))]
def make_lilypond_file(m):
- """
+ '''
Find @lilypondfile{bla.ly} occurences and substitute bla.ly
into a @lilypond .. @end lilypond block.
- """
+ '''
if m.group('options'):
options = m.group('options')
(options, content))]
def make_lilypond_block(m):
+ if not g_do_music:
+ return []
+
if m.group('options'):
options = get_re('option-sep').split (m.group('options'))
else:
return [('numcols', m.group('code'), 2)]
def chop_chunks(chunks, re_name, func, use_match=0):
- 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:
- if use_match:
- newchunks.append (('input', str[:m.start ('match')]))
- 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
+ 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:
+ if use_match:
+ newchunks.append (('input', str[:m.start ('match')]))
+ 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 determine_format (str):
if __main__.format == '':
- latex = re.search ('\\\\document', str[:200])
- texinfo = re.search ('@node|@setfilename', str[:200])
+ html = re.search ('(?i)<[dh]tml', str[:200])
+ latex = re.search (r'''\\document''', str[:200])
+ texi = re.search ('@node|@setfilename', str[:200])
f = ''
g = None
- if texinfo and latex == None:
- f = 'texi'
- elif latex and texinfo == None:
+ if html and not latex and not texi:
+ f = 'html'
+ elif latex and not html and not texi:
f = 'latex'
+ elif texi and not html and not latex:
+ f = 'texi'
else:
- error("error: can't determine format, please specify")
+ error ("can't determine format, please specify")
__main__.format = f
if __main__.paperguru == None:
- if __main__.format == 'texi':
- g = TexiPaper()
- else:
- g = LatexPaper()
+ if __main__.format == 'html':
+ g = HtmlPaper ()
+ elif __main__.format == 'latex':
+ g = LatexPaper ()
+ elif __main__.format == 'texi':
+ g = TexiPaper ()
__main__.paperguru = g
def read_doc_file (filename):
- """Read the input file, find verbatim chunks and do \input and \include
- """
+ '''Read the input file, find verbatim chunks and do \input and \include
+ '''
(str, path) = find_file(filename)
determine_format (str)
taken_file_names = {}
def schedule_lilypond_block (chunk):
- """Take the body and options from CHUNK, figure out how the
+ '''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.
TODO has format [basename, extension, extension, ... ]
- """
+ '''
(type, body, opts) = chunk
assert type == 'lilypond'
file_body = compose_full_body (body, opts)
+ ## Hmm, we should hash only lilypond source, and skip the
+ ## %options are ...
+ ## comment line
basename = 'lily-' + `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
+ taken_file_names[basename] = 0
else:
- taken_file_names[basename] = taken_file_names[basename] + 1
- basename = basename + "-%i" % taken_file_names[basename]
+ taken_file_names[basename] = taken_file_names[basename] + 1
+ basename = basename + "-%i" % taken_file_names[basename]
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 format == 'html' or format == 'texi':
+ needed_filetypes.append ('eps')
+ needed_filetypes.append ('png')
if 'eps' in opts and not ('eps' in needed_filetypes):
needed_filetypes.append('eps')
pathbase = os.path.join (g_outdir, basename)
- def f(base, ext1, ext2):
+ def f (base, ext1, ext2):
a = os.path.isfile(base + ext2)
if (os.path.isfile(base + ext1) and
os.path.isfile(base + ext2) and
m = re.search ('intertext="(.*?)"', o)
if m:
newbody = newbody + m.group (1) + "\n\n"
- if format == 'latex':
+
+ if 'noinline' in opts:
+ s = 'output-noinline'
+ elif format == 'latex':
if 'eps' in opts:
s = 'output-eps'
else:
s = 'output-tex'
- else: # format == 'texi'
+ else: # format == 'html' or format == 'texi':
s = 'output-all'
newbody = newbody + get_output (s) % {'fn': basename }
return ('lilypond', newbody, opts, todo, basename)
-def process_lilypond_blocks(outname, chunks):#ugh rename
+def process_lilypond_blocks(chunks):#ugh rename
newchunks = []
# Count sections/chapters.
for c in chunks:
return newchunks
-def find_eps_dims (match):
- "Fill in dimensions of EPS files."
-
- fn =match.group (1)
- dims = bounding_box_dimensions (fn)
- if g_outdir:
- fn = os.path.join(g_outdir, fn)
-
- return '%ipt' % dims[0]
-
def system (cmd):
sys.stderr.write ("invoking `%s'\n" % cmd)
error ('Error command exited with value %d\n' % st)
return st
+def quiet_system (cmd, name):
+ if not verbose_p:
+ progress ( _("Running %s...") % name)
+ cmd = cmd + ' 1> /dev/null 2> /dev/null'
+
+ return system (cmd)
+
+def get_bbox (filename):
+ system ('gs -sDEVICE=bbox -q -sOutputFile=- -dNOPAUSE %s -c quit > %s.bbox 2>&1 ' % (filename, filename))
+
+ box = open (filename + '.bbox').read()
+ m = re.match ('^%%BoundingBox: ([0-9]+) ([0-9]+) ([0-9]+) ([0-9]+)', box)
+ gr = []
+ if m:
+ gr = map (string.atoi, m.groups ())
+
+ return gr
+
+def make_pixmap (name):
+ bbox = get_bbox (name + '.eps')
+ margin = 0
+ fo = open (name + '.trans.eps' , 'w')
+ fo.write ('%d %d translate\n' % (-bbox[0]+margin, -bbox[1]+margin))
+ fo.close ()
+
+ res = 90
+
+ x = (2* margin + bbox[2] - bbox[0]) * res / 72.
+ y = (2* margin + bbox[3] - bbox[1]) * res / 72.
+
+ cmd = r'''gs -g%dx%d -sDEVICE=pnggray -dTextAlphaBits=4 -dGraphicsAlphaBits=4 -q -sOutputFile=- -r%d -dNOPAUSE %s %s -c quit > %s'''
+
+ cmd = cmd % (x, y, res, name + '.trans.eps', name + '.eps',name + '.png')
+ quiet_system (cmd, 'gs')
+
+ try:
+ status = system (cmd)
+ except:
+ os.unlink (name + '.png')
+ error ("Removing output file")
+
def compile_all_files (chunks):
global foutn
eps = []
if g_outdir:
lilyopts = lilyopts + '--dep-prefix=' + g_outdir + '/'
texfiles = string.join (tex, ' ')
- system ('lilypond --header=texidoc %s %s' % (lilyopts, texfiles))
+ cmd = 'lilypond --header=texidoc %s %s %s' \
+ % (lilyopts, g_extra_opts, texfiles)
+
+ system (cmd)
#
# Ugh, fixing up dependencies for .tex generation
if do_deps:
depfiles=map (lambda x: re.sub ('(.*)\.ly', '\\1.dep', x), tex)
for i in depfiles:
- text=open (i).read ()
+ f =open (i)
+ text=f.read ()
+ f.close ()
text=re.sub ('\n([^:\n]*):', '\n' + foutn + ':', text)
- open (i, 'w').write (text)
+ f = open (i, 'w')
+ f.write (text)
+ f.close ()
for e in eps:
- system(r"tex '\nonstopmode \input %s'" % e)
- system(r"dvips -E -o %s %s" % (e + '.eps', e))
+ cmd = r"echo $TEXMF; tex '\nonstopmode \input %s'" % e
+ quiet_system (cmd, 'TeX')
+
+ cmd = r"dvips -E -o %s %s" % (e + '.eps', e)
+ quiet_system (cmd, 'dvips')
+
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)
+ make_pixmap (g)
+
os.chdir (d)
def update_file (body, name):
- """
+ '''
write the body if it has changed
- """
+ '''
same = 0
try:
f = open (name)
return str
def help():
- sys.stdout.write("""Usage: lilypond-book [options] FILE\n
+ sys.stdout.write('''Usage: lilypond-book [options] FILE\n
Generate hybrid LaTeX input from Latex + lilypond
Options:
-""")
+''')
sys.stdout.write (options_help_str (option_definitions))
- sys.stdout.write (r"""Warning all output is written in the CURRENT directory
+ sys.stdout.write (r'''Warning all output is written in the CURRENT directory
-Report bugs to bug-gnu-music@gnu.org.
+Report bugs to bug-lilypond@gnu.org.
Written by Tom Cato Amundsen <tca@gnu.org> and
Han-Wen Nienhuys <hanwen@cs.uu.nl>
-""")
+''')
sys.exit (0)
def write_deps (fn, target, chunks):
global read_files
- sys.stdout.write('Writing `%s\'\n' % os.path.join(g_outdir, fn))
+ sys.stderr.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 read_files:
f.close ()
read_files = []
-def identify():
- sys.stdout.write ('lilypond-book (GNU LilyPond) %s\n' % program_version)
+def identify (stream):
+ stream.write ('lilypond-book (GNU LilyPond) %s\n' % program_version)
def print_version ():
- identify()
- sys.stdout.write (r"""Copyright 1998--1999
+ identify (sys.stdout)
+ sys.stdout.write (r'''Copyright 1998--1999
Distributed under terms of the GNU General Public License. It comes with
NO WARRANTY.
-""")
+''')
def check_texidoc (chunks):
n.append (c)
return n
+
+## what's this? Docme --hwn
+##
def fix_epswidth (chunks):
newchunks = []
for c in chunks:
- if c[0] == 'lilypond' and 'eps' in c[2]:
- body = re.sub (r"""\\lilypondepswidth{(.*?)}""", find_eps_dims, c[1])
- newchunks.append(('lilypond', body, c[2], c[3], c[4]))
- else:
+ if c[0] <> 'lilypond' or 'eps' not in c[2]:
newchunks.append (c)
+ continue
+
+ mag = 1.0
+ for o in c[2]:
+ m = re.match ('magnification=([0-9.]+)', o)
+ if m:
+ mag = string.atof (m.group (1))
+
+ def replace_eps_dim (match, lmag = mag):
+ filename = match.group (1)
+ dims = bounding_box_dimensions (filename)
+
+ return '%fpt' % (dims[0] *lmag)
+
+ body = re.sub (r'''\\lilypondepswidth{(.*?)}''', replace_eps_dim, c[1])
+ newchunks.append(('lilypond', body, c[2], c[3], c[4]))
+
return newchunks
+##docme: why global?
foutn=""
def do_file(input_filename):
- global foutn
- 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 = chop_chunks(chunks, 'lilypond', make_lilypond, 1)
#for c in chunks: print "c:", c;
#sys.exit()
scan_preamble(chunks)
- chunks = process_lilypond_blocks(my_outname, chunks)
-
- foutn = os.path.join (g_outdir, my_outname + '.' + format)
+ chunks = process_lilypond_blocks(chunks)
# Do It.
if __main__.g_run_lilypond:
x = 0
chunks = completize_preamble (chunks)
- sys.stderr.write ("Writing `%s'\n" % foutn)
- fout = open (foutn, 'w')
+
+
+ global foutn
+
+ if outname:
+ my_outname = outname
+ elif input_filename == '-' or input_filename == "/dev/stdin":
+ my_outname = '-'
+ else:
+ my_outname = os.path.basename (os.path.splitext(input_filename)[0]) + '.' + format
+ my_depname = my_outname + '.dep'
+
+ if my_outname == '-' or my_outname == '/dev/stdout':
+ fout = sys.stdout
+ foutn = "<stdout>"
+ __main__.do_deps = 0
+ else:
+ foutn = os.path.join (g_outdir, my_outname)
+ sys.stderr.write ("Writing `%s'\n" % foutn)
+ fout = open (foutn, 'w')
for c in chunks:
fout.write (c[1])
fout.close ()
elif o == '--version' or o == '-v':
print_version ()
sys.exit (0)
+ elif o == '--verbose' or o == '-V':
+ __main__.verbose_p = 1
elif o == '--format' or o == '-f':
__main__.format = a
elif o == '--outname' or o == '-o':
elif o == '--default-lilypond-fontsize':
print "--default-lilypond-fontsize is deprecated, use --default-music-fontsize"
default_music_fontsize = string.atoi (a)
+ elif o == '--extra-options':
+ g_extra_opts = a
elif o == '--force-music-fontsize':
g_force_lilypond_fontsize = string.atoi(a)
elif o == '--force-lilypond-fontsize':
g_dep_prefix = a
elif o == '--no-pictures':
g_do_pictures = 0
+ elif o == '--no-music':
+ g_do_music = 0
elif o == '--read-lys':
g_read_lys = 1
elif o == '--outdir':
g_outdir = a
-identify()
+identify (sys.stderr)
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)
+setup_environment ()
for input_filename in files:
do_file(input_filename)
projects / lilypond.git / blobdiff