#!@PYTHON@
-#
-# The bugs you find are made by Tom Cato Amundsen <tomcato@xoommail.com>
-# Send patches/questions/bugreports to a mailinglist:
-# gnu-music-discuss@gnu.org
-# bug-gnu-music@gnu.org
-# help-gnu-music@gnu.org
-#
-# All non-english comments are NOT in swedish, they are norwegian!
-# TODO:
-# * output various stuff either via sys.stderr or sys.stdout, not using print.
-# * center option (??)
-# * make mudela-book understand usepackage{geometry}
-# * check that linewidth set in \paper is not wider than actual linewidth?
-# * the following fails because mudelabook doesn't care that the
-# last } after \end{mudela} finishes the marginpar:
-# \marginpar{
-# \begin{mudela}
-# c d e f g
-# \end{mudela}}
-# * force-verbatim is maybe not that useful since latex fails with footnotes,
-# marginpars and others
-# log:
-# 0.3:
-# rewrite in Python.
-# 0.4:
-# much rewritten by new author. I think the work has been split more
-# logical between different classes.
-# 0.4.1:
-# - cleanup
-# - speedup, do all mudela parsing at the same time to avoid multiple
-# guile startup that takes some seconds on my computer
-# 0.4.2:
-# - fixed default latex fontsize, it should be 10pt not 11pt
-# - verbatim option no longer visible
-# - mudela-book produces .dvi output
-# - change to use castingalgorithm = \Gourlay instead of \Wordwrap. It gives
-# better result on small linewidths.
-# - mudela-book-doc.doc rewritten
-# 0.5:
-# - junked floating and fragment options, added eps option
-# - mudela-book will scan the mudela code to find out if it has to add
-# paper-definition and \score{\notes{...}}
-# - possible to define commands that look like this: \mudela{ c d e }
-# - don't produce .dvi output, it was a silly idea...
-# 0.5.1:
-# - removed init/mudela-book-defs.py, \mudela is defined inside mudela-book
-# - fragment and nonfragment options will override autodetection of type of
-# in mudela-block (voice contents or complete code)
-# 0.5.2:
-# - fixed verbatim option behaviour: don't show \begin{mudela} \end{mudela}
-# and show both mudela code and music
-# - veryverbatim option, same as verbatim but show \begin{mudela}
-# and \end{mudela}. (saves keystrokes in mudela-book-doc.doc)
-# - intertext="bla bla bla" option
-# - mudela-book now understand latex \begin{verbatim}
-# 0.5.3:
-# - bf: \mudela{ \times 2/3{...} }
-# * \t in \times is not tab character and
-# * dont treat the first '}' as command ending
import os
import string
import re
import getopt
import sys
+import __main__
+
-outdir = 'out'
initfile = ''
-program_version = '0.5.3'
-include_path = ['.']
-
-out_files = []
-
-fontsize_i2a = {11:'eleven', 13:'thirteen', 16:'sixteen',
- 20:'twenty', 26:'twentysix'}
-fontsize_pt2i = {'11pt':11, '13pt':13, '16pt':16, '20pt':20, '26pt':26}
-
-begin_mudela_re = re.compile ('^ *\\\\begin{mudela}')
-begin_verbatim_re = re.compile ('^ *\\\\begin{verbatim}')
-end_verbatim_re = re.compile ('^ *\\\\end{verbatim}')
-extract_papersize_re = re.compile('\\\\documentclass[\[, ]*(\w*)paper[\w ,]*\]\{\w*\}')
-extract_fontsize_re = re.compile('[ ,\[]*([0-9]*)pt')
-begin_mudela_opts_re = re.compile('\[[^\]]*\]')
-end_mudela_re = re.compile ('^ *\\\\end{mudela}')
-section_re = re.compile ('\\\\section')
-chapter_re = re.compile ('\\\\chapter')
-input_re = re.compile ('^\\\\input{([^}]*)')
-include_re = re.compile ('^\\\\include{([^}]*)')
-begin_document_re = re.compile ('^ *\\\\begin{document}')
-documentclass_re = re.compile('\\\\documentclass')
-twocolumn_re = re.compile('\\\\twocolumn')
-onecolumn_re = re.compile('\\\\onecolumn')
-mudela_file_re = re.compile('\\\\mudelafile{([^}]+)}')
-preMudelaExample_re = re.compile('\\\\def\\\\preMudelaExample')
-postMudelaExample_re = re.compile('\\\\def\\\\postMudelaExample')
-boundingBox_re = re.compile('%%BoundingBox: ([0-9]+) ([0-9]+) ([0-9]+) ([0-9]+)')
-intertext_re = re.compile("intertext=\"([^\"]*)\"")
-
-def file_exist_b(name):
- try:
- f = open(name)
- except IOError:
- return 0
- f.close ()
- return 1
-
-def ps_dimention(fname):
- fd = open(fname)
- lines = fd.readlines()
- for line in lines:
- s = boundingBox_re.search(line)
- if s:
- break
- return (int(s.groups()[2])-int(s.groups()[0]),
- int(s.groups()[3])-int(s.groups()[1]))
+program_version = '@TOPLEVEL_VERSION@'
+cwd = os.getcwd ()
+include_path = [cwd]
+dep_prefix = ''
-def find_file (name):
- for a in include_path:
+# TODO: Figure out clean set of options.
+
+# BUG: does not handle \verb|\begin{verbatim}\end{verbatim}| correctly.
+# Should make a joint RE for \verb and \begin, \end{verbatim}
+#
+
+default_music_fontsize = 16
+default_text_fontsize = 12
+
+# latex linewidths:
+# indices are no. of columns, papersize, fontsize
+# Why can't this be calculated?
+latex_linewidths = {
+ 1: {'a4':{10: 345, 11: 360, 12: 390},
+ 'a5':{10: 276, 11: 276, 12: 276},
+ 'b5':{10: 345, 11: 356, 12: 356},
+ 'letter':{10: 345, 11: 360, 12: 390},
+ 'legal': {10: 345, 11: 360, 12: 390},
+ 'executive':{10: 345, 11: 360, 12: 379}},
+ 2: {'a4':{10: 167, 11: 175, 12: 190},
+ 'a5':{10: 133, 11: 133, 12: 133},
+ 'b5':{10: 167, 11: 173, 12: 173},
+ 'letter':{10: 167, 11: 175, 12: 190},
+ 'legal':{10: 167, 11: 175, 12: 190},
+ 'executive':{10: 167, 11: 175, 12: 184}}}
+
+
+options = [
+ ('DIM', '', 'default-mudela-fontsize', 'default fontsize for music. DIM is assumed to in points'),
+ ('EXT', 'f', 'format', 'set format. EXT is one of texi and latex.'),
+ ('', 'h', 'help', 'print help'),
+ ('DIR', 'I', 'include', 'include path'),
+ ('', '', 'init', 'mudela-book initfile'),
+# ('DIM', '', 'force-mudela-fontsize', 'force fontsize for all inline mudela. DIM is assumed to in points'),
+ ('', '', 'force-verbatim', 'make all mudela verbatim'),
+ ('', 'M', 'dependencies', 'write dependencies'),
+ ('', 'n', 'no-lily', 'don\'t run lilypond'),
+ ('FILE', 'o', 'outname', 'prefix for filenames'),
+ ('', 'v', 'version', 'print version information' ),
+ ('PREF', '', 'dep-prefix', 'prepend PREF before each -M dependency')
+ ]
+
+format = ''
+run_lilypond = 1
+use_hash = 1
+no_match = 'a\ba'
+
+# format specific strings, ie. regex-es for input, and % strings for output
+output_dict= {
+ 'latex': {
+ 'output-mudela-fragment' : r"""\begin[eps,fragment%s]{mudela}
+ \context Staff <
+ \context Voice{
+ %s
+ }
+ >
+\end{mudela}""",
+ 'output-mudela':r"""\begin[%s]{mudela}
+%s
+\end{mudela}""",
+ 'output-verbatim': r"""\begin{verbatim}%s\end{verbatim}""",
+ 'output-default-post': r"""\def\postMudelaExample{}""",
+ 'output-default-pre': r"""\def\preMudelaExample{}""",
+ 'output-eps': '\\noindent\\parbox{\\mudelaepswidth{%s.eps}}{\includegraphics{%s.eps}}',
+ 'output-tex': '\\preMudelaExample \\input %s.tex \\postMudelaExample\n'
+ },
+ 'texi' : {'output-mudela': """@mudela[%s]
+%s
+@end mudela
+""",
+ '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.
+ 'output-all': r"""@tex
+\catcode`\@=12
+\input lilyponddefs
+\def\EndLilyPondOutput{}
+\input %s.tex
+\catcode`\@=0
+@end tex
+@html
+<img src=%s.png>
+@end html
+""",
+ }
+ }
+
+def output_verbatim (body):
+ if __main__.format == 'texi':
+ body = re.sub ('([@{}])', '@\\1', body)
+ return get_output ('output-verbatim') % body
+
+re_dict = {
+ 'latex': {'input': '\\\\mbinput{?([^}\t \n}]*)',
+ 'include': '\\\\mbinclude{([^}]+)}',
+
+ 'comma-sep' : ', *',
+ 'header': r"""\\documentclass(\[.*?\])?""",
+ 'preamble-end': '\\\\begin{document}',
+ 'verbatim': r"""(?s)\\begin{verbatim}(.*?)\\end{verbatim}""",
+ 'verb': r"""\\verb(.)(.*?)\1""",
+ 'mudela-file': '\\\\mudelafile(\[[^\\]]+\])?{([^}]+)}',
+ 'mudela' : '\\\\mudela(\[.*?\])?{(.*?)}',
+ 'mudela-block': r"""(?s)\\begin(\[.*?\])?{mudela}(.*?)\\end{mudela}""",
+ 'interesting-cs': '\\\\(chapter|section|twocolumn|onecolumn)',
+ 'def-post-re': r"""\\def\\postMudelaExample""",
+ 'def-pre-re': r"""\\def\\preMudelaExample""",
+ },
+
+ 'texi': {
+ 'input': '@mbinclude[ \n\t]+([^\t \n]*)',# disabled
+ 'include': no_match,
+ 'header': no_match,
+ 'preamble-end': no_match,
+ 'verbatim': r"""(?s)@example(.*?)@end example$""",
+ 'verb': r"""@code{(.*?)}""",
+ 'mudela-file': '@mudelafile(\[[^\\]]+\])?{([^}]+)}',
+ 'mudela' : '@mudela(\[.*?\])?{(.*?)}',
+ 'mudela-block': r"""(?s)@mudela(\[.*?\])?(.*?)@end mudela""",
+ 'interesting-cs': r"""[\\@](chapter|section)""",
+ 'comma-sep' : ', *',
+ }
+ }
+
+
+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:
- nm = os.path.join (a, name)
- f = open (nm)
- return nm
+ fd = open(fname)
except IOError:
- pass
- return ''
+ 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)
+
+
+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 error (str):
+ sys.stderr.write (str + "\n Exiting ... \n\n")
+ raise 'Exiting.'
+
+
+def compose_full_body (body, opts):
+ "Construct the text of an input file: add stuff to BODY using OPTS as options."
+ paper = 'a4'
+ music_size = default_music_fontsize
+ latex_size = default_text_fontsize
+
+ cols = 1
+ for o in opts:
+ m = re.search ('^(.*)paper$', o)
+ if m:
+ paper = m.group (1)
+
-class CompileStatus:
- pass
-class SomethingIsSeriouslyBroken:
- pass
+ m = re.match ('([0-9]+)pt', o)
+ if m:
+ music_size = string.atoi(m.group (1))
-def file_mtime (name):
- return os.stat (name)[8] #mod time
+ m = re.match ('latexfontsize=([0-9]+)pt', o)
+ if m:
+ latex_size = string.atoi (m.group (1))
-def need_recompile_b(infile, outfile):
- indate = file_mtime (infile)
- try:
- outdate = file_mtime (outfile)
- return indate > outdate
- except os.error:
- return 1
-#
-# executes os.system(command) if infile is newer than
-# outfile or outfile don't exist
-#
-def compile (command, workingdir, infile, outfile):
- "Test if infile is newer than outfile. If so, cd to workingdir"
- "and execute command"
- indate = file_mtime (workingdir+infile)
- try:
- outdate = file_mtime (workingdir+outfile)
- recompile = indate > outdate
-
- except os.error:
- recompile = 1
-
- if recompile:
- sys.stderr.write ('invoking `%s\'\n' % command)
- if workingdir == '':
- status = os.system (command)
- else:
- status = os.system ('cd %s; %s' %(workingdir, command))
- if status:
- raise CompileStatus
-
-class Properties:
- #
- # init
- #
- def __init__(self):
- self.__linewidth = {
- 1: {'a4':{10: 345, 11: 360, 12: 390},
- 'a5':{10: 276, 11: 276, 12: 276},
- 'b5':{10: 345, 11: 356, 12: 356},
- 'letter':{10: 345, 11: 360, 12: 390},
- 'legal': {10: 345, 11: 360, 12: 390},
- 'executive':{10: 345, 11: 360, 12: 379}},
- 2: {'a4':{10: 167, 11: 175, 12: 190},
- 'a5':{10: 133, 11: 133, 12: 133},
- 'b5':{10: 167, 11: 173, 12: 173},
- 'letter':{10: 167, 11: 175, 12: 190},
- 'legal':{10: 167, 11: 175, 12: 190},
- 'executive':{10: 167, 11: 175, 12: 184}}}
- # >0 --> force all mudela to this pt size
- self.force_mudela_fontsize = 0
- self.force_verbatim_b = 0
- self.__data = {
- 'mudela-fontsize' : {'init': 16},
- 'papersize' : {'init': 'a4'},
- 'num-column' : {'init': 1},
- 'tex-fontsize' : {'init': 10}
- }
- def clear_for_new_file(self):
- for var in self.__data.keys():
- self.__data[var] = {'init': self.__data[var]['init']}
- def clear_for_new_block(self):
- for var in self.__data.keys():
- if self.__data[var].has_key('block'):
- del self.__data[var]['block']
- def __get_variable(self, var):
- if self.__data[var].has_key('block'):
- return self.__data[var]['block']
- elif self.__data[var].has_key('file'):
- return self.__data[var]['file']
- else:
- return self.__data[var]['init']
- def setPapersize(self, size, requester):
- self.__data['papersize'][requester] = size
- def getPapersize(self):
- return self.__get_variable('papersize')
- def setMudelaFontsize(self, size, requester):
- self.__data['mudela-fontsize'][requester] = size
- def getMudelaFontsize(self):
- if self.force_mudela_fontsize:
- return self.force_mudela_fontsize
- return self.__get_variable('mudela-fontsize')
- def setTexFontsize(self, size, requester):
- self.__data['tex-fontsize'][requester] = size
- def getTexFontsize(self):
- return self.__get_variable('tex-fontsize')
- def setNumColumn(self, num, requester):
- self.__data['num-column'][requester] = num
- def getNumColumn(self):
- return self.__get_variable('num-column')
- def getLineWidth(self):
- return self.__linewidth[self.getNumColumn()][self.getPapersize()][self.getTexFontsize()]
-
-
-class Mudela_output:
- def __init__ (self, basename):
- self.basename = basename
- self.temp_filename = "%s/%s" %(outdir, 'mudela-temp.ly')
- self.file = open (self.temp_filename, 'w')
- self.__lines = []
- # 'tex' or 'eps'
- self.graphic_type = 'tex'
- self.code_type = 'unknown'
- self.code_type_override = None
- def write (self, line):
- # match only if there is nothing but whitespace before \begin HACK
- if re.search('^\s*\\\\begin{mudela}', line):
- self.scan_begin_statement(line)
- else:
- if self.code_type == 'unknown':
- if re.search('^\s*\\\\score', line) or \
- re.search('^\s*\\\\paper', line) or \
- re.search('^\s*\\\\header', line) or \
- re.search('^\s*[A-Za-z]*\s*=', line):
- self.code_type = 'ly'
- self.__lines.append(line)
- def scan_begin_statement(self, line):
- r = begin_mudela_opts_re.search(line)
- if r:
- o = r.group()[1:-1]
- optlist = re.compile('[\s,]*').split(o)
- else:
- optlist = []
- if 'fragment' in optlist:
- self.code_type_override = 'fly'
- if 'nonfragment' in optlist:
- self.code_type_override = 'ly'
- if 'eps' in optlist:
- self.graphic_type = 'eps'
- for pt in fontsize_pt2i.keys():
- if pt in optlist:
- Props.setMudelaFontsize(fontsize_pt2i[pt], 'block')
- def write_red_tape(self):
- self.file.write ('\\include \"paper%d.ly\"\n' \
- % Props.getMudelaFontsize())
-
- s = fontsize_i2a[Props.getMudelaFontsize()]
- if self.code_type == 'fly':
- linewidth_str = 'linewidth = -1.\cm;'
- else:
- linewidth_str = 'linewidth = %i.\\pt;' % Props.getLineWidth()
- self.file.write("\\paper {"
- + "\\paper_%s " % s
- + linewidth_str
- + "castingalgorithm = \Gourlay; \n}")
- #+ "castingalgorithm = \Wordwrap; indent = 2.\cm; \n}")
- if self.code_type == 'fly':
- self.file.write('\\score{\n\\notes{')
- def close (self):
- if self.code_type == 'unknown':
- self.code_type = 'fly'
- if self.code_type_override:
- self.code_type = self.code_type_override
- self.write_red_tape()
- for l in self.__lines:
- self.file.write(l)
- if self.code_type == 'fly':
- self.file.write('}}')
-
- self.file.close()
-
- inf = outdir + self.basename + '.ly'
- outf = outdir + self.basename + '.tex'
- if not os.path.isfile(inf):
- status = 1
- else:
- status = os.system ('diff -q %s %s' % (self.temp_filename, inf))
- if status:
- os.rename (self.temp_filename, inf)
-
- recompile_b = need_recompile_b(inf, outf)
- if recompile_b:
- out_files.append((self.graphic_type, inf))
- return recompile_b
-
- def insert_me_string(self):
- "Returns a string that can be used directly in latex."
- if self.graphic_type == 'tex':
- return ['tex', self.basename]
- elif self.graphic_type == 'eps':
- return ['eps', self.basename]
- else:
- raise SomethingIsSeriouslyBroken
-
-class Tex_output:
- def __init__ (self, name):
- self.output_fn = '%s/%s' % (outdir, name)
- self.__lines = []
- def open_verbatim (self, line, level):
- self.__lines.append('\\begin{verbatim}\n')
- if level == 2:
- s = re.sub('veryverbatim[\s,]*', '', line)
- s = re.sub('intertext=\"([^\"]*)\"[\s,]*', '', s)
- s = re.sub(',\s*\]', ']', s)
- s = re.sub('\[\]', '', s)
- self.__lines.append(s);
- def close_verbatim (self):
- self.__lines.append('\\end{verbatim}\n')
- def write (self, s):
- self.__lines.append(s)
- def create_graphics(self):
- s = ''
- g_vec = []
- for line in self.__lines:
- if type(line)==type([]):
- g_vec.append(line)
- for g in g_vec:
- if need_recompile_b(outdir+g[1]+'.ly', outdir+g[1]+'.tex'):
- s = s + ' ' + g[1]+'.ly'
- if s != '':
- e = os.system('cd %s; lilypond %s' %(outdir, s))
- if e:
- print "error: lilypond exited with value", e
- sys.exit(e)
- for g in g_vec:
- if g[0] == 'eps':
- compile('tex %s' % g[1]+'.tex', outdir, g[1]+'.tex', g[1]+'.dvi')
- compile('dvips -E -o %s %s' %(g[1]+'.eps', g[1]+'.dvi'), outdir,
- g[1]+'.dvi', g[1]+'.eps')
- def write_outfile(self):
- file = open(self.output_fn+'.latex', 'w')
- file.write('% Created by mudela-book\n')
- for line in self.__lines:
- if type(line)==type([]):
- if line[0] == 'tex':
- file.write('\\preMudelaExample\\input %s\n\postMudelaExample '\
- # TeX applies the prefix of the main source automatically.
- % (line[1]+'.tex'))
-# % (outdir+line[1]+'.tex'))
- if line[0] == 'eps':
- ps_dim = ps_dimention(outdir+line[1]+'.eps')
- file.write('\\parbox{%ipt}{\includegraphics{%s}}\n' \
- % (ps_dim[0], line[1]+'.eps'))
-# % (ps_dim[0], outdir+line[1]+'.eps'))
- else:
- file.write(line)
- file.close()
-
-# given parameter s="\mudela[some options]{CODE} some text and commands"
-# it returns a tuple:
-# (CODE, integer)
-# where the last number is the index of the ending '}'
-def extract_command(s):
- start_found_b = 0
- count = 0
- start = 0
- for idx in range(len(s)):
- if s[idx] == '{':
- if not start_found_b:
- start = idx
- start_found_b = 1
- count = count + 1
- if s[idx] == '}':
- count = count - 1
- if (start_found_b == 1) and (count == 0):
- break
- return s[start+1:idx], idx
-
-class Tex_input:
- def __init__ (self, filename):
- for fn in [filename, filename+'.tex', filename+'.doc']:
- try:
- self.infile = open (fn)
- self.filename = fn
- return
- except:
- continue
- raise IOError
-
- def get_lines (self):
- lines = self.infile.readlines ()
- (retlines, retdeps) = ([],[self.filename])
- for line in lines:
- r_inp = input_re.search (line)
- r_inc = include_re.search (line)
-
- # Filename rules for \input :
- # input: no .tex ext
- # 1. will search for file with exact that name (tex-input.my will be found)
- # 2. will search for file with .tex ext, (tex-input.my
- # will find tex-input.my.tex)
- # input: with .tex ext
- # 1. will find exact match
-
- # Filename rules for \include :
- # 1. will only find files with name given to \include + .tex ext
- if r_inp:
- try:
- t = Tex_input (r_inp.groups()[0])
- ls = t.get_lines ()
- retlines = retlines + ls[0]
- retdeps = retdeps + ls[1]
- except:
- print "warning: can't find %s, let's hope latex will" \
- % r_inp.groups()[0]
- retlines.append (line)
- elif r_inc:
- try:
- t = Tex_input (r_inc.groups()[0]+'.tex')
- ls =t.get_lines ()
- ls[0].insert(0, '\\newpage\n')
- ls[0].append('\\newpage\n')
- retlines = retlines + ls[0]
- retdeps = retdeps + ls[1]
- except:
- print "warning: can't find %s, let's hope latex will" \
- % r_inc.groups()[0]
- retlines.append (line)
- else:
- # This code should be rewritten, it looks terrible
- r_mud = defined_mudela_cmd_re.search(line)
- if r_mud:
- # TODO document this
- ss = "\\\\verb(?P<xx>[^a-zA-Z])\s*\\\\%s\s*(?P=xx)" \
- % re.escape(r_mud.group()[1:])
- # just append the line if the command is inside \verb|..|
- if re.search(ss, line):
- retlines.append(line)
- continue
- while 1:
- opts = r_mud.groups()[2]
- cmd_start_idx = r_mud.span()[0]
- if cmd_start_idx > 0:
- retlines.append(line[:cmd_start_idx])
-
- cmd_data, rest_idx = extract_command(line[cmd_start_idx:])
- rest_idx = rest_idx + cmd_start_idx + 1
- if opts == None:
- opts = ''
- else:
- opts = ', '+opts
-
- v = string.split(defined_mudela_cmd[r_mud.groups()[0]], '\n')
- for l in v[1:-1]:
- l = string.replace(l, '\\fontoptions', opts)
- l = string.replace(l, '\\maininput', cmd_data)
- retlines.append(l)
- r_mud = defined_mudela_cmd_re.search(line[rest_idx:])
- if not r_mud:
- rs = line[rest_idx:]
- while rs[0] == " ":
- rs = rs[1:]
- if rs != "\n":
- retlines.append(line[rest_idx:])
- break;
- line = line[rest_idx:]
- else:
- retlines.append (line)
- return (retlines, retdeps)
-
-
-class Main_tex_input(Tex_input):
- def __init__ (self, name, outname):
-
- Tex_input.__init__ (self, name) # ugh
- self.outname = outname
- self.chapter = 0
- self.section = 0
- self.fine_count =0
- self.mudtex = Tex_output (self.outname)
- self.mudela = None
- self.deps = []
- self.verbatim = 0
- # set to 'mudela' when we are processing mudela code,
- # both verbatim and graphic-to-be
- self.mode = 'latex'
- def set_sections (self, l):
- if section_re.search (l):
- self.section = self.section + 1
- if chapter_re.search (l):
- self.section = 0
- self.chapter = self.chapter + 1
-
- def gen_basename (self):
- return '%s-%d.%d.%d' % (self.outname, self.chapter,
- self.section, self.fine_count)
- def extract_papersize_from_documentclass(self, line):
- pre = extract_papersize_re.search(line)
- if not pre:
- return None
- return pre.groups()[0]
- def extract_fontsize_from_documentclass(self, line):
- r = extract_fontsize_re.search(line)
- if r:
- return int(r.groups()[0])
- def do_it(self):
- preMudelaDef = postMudelaDef = 0
- (lines, self.deps) = self.get_lines ()
- #HACK
- latex_verbatim = 0
- for line in lines:
- if documentclass_re.search (line):
- p = self.extract_papersize_from_documentclass (line)
- if p:
- Props.setPapersize(p, 'file')
- f = self.extract_fontsize_from_documentclass (line)
- if f:
- Props.setTexFontsize (f, 'file')
- elif twocolumn_re.search (line):
- Props.setNumColumn (2, 'file')
- elif onecolumn_re.search (line):
- Props.setNumColumn (1, 'file')
- elif preMudelaExample_re.search (line):
- preMudelaDef = 1
- elif postMudelaExample_re.search (line):
- postMudelaDef = 1
- elif begin_verbatim_re.search (line):
- latex_verbatim = 1
- elif end_verbatim_re.search (line):
- latex_verbatim = 0
- elif begin_document_re.search (line):
- if not preMudelaDef:
- self.mudtex.write ('\\def\\preMudelaExample{}\n')
- if not postMudelaDef:
- self.mudtex.write ('\\def\\postMudelaExample{}\n')
-
- elif mudela_file_re.search(line):
- r = mudela_file_re.search(line)
-
- self.mudela = Mudela_output(self.gen_basename())
- fn = r.groups ()[0]
- full_path = find_file (fn)
- if not full_path:
- print 'error: can\'t find file `%s\'.' % fn
- sys.exit (1)
+
+ if 'twocolumn' in opts:
+ cols = 2
- f = open (full_path, 'r')
- lines =f.readlines ()
- for x in lines:
- self.mudela.write (x)
- stat =self.mudela.close ()
- if stat:
- print "(File %s needs recompiling)\n" % full_path
- self.mudtex.write (self.mudela.insert_me_string())
- self.deps.append (full_path)
- del self.mudela
- self.mudela = None
- self.fine_count = self.fine_count + 1
- continue
- elif begin_mudela_re.search (line) and not latex_verbatim:
- Props.clear_for_new_block()
- if __debug__:
- if self.mode == 'mudela':
- raise AssertionError
- self.mode = 'mudela'
- r = begin_mudela_opts_re.search (line)
- if r:
- o = r.group()[1:][:-1]
- optlist = re.compile('[ ,]*').split(o)
- m = intertext_re.search(r.group())
- if m:
- self.intertext = m.groups()[0]
- else:
- self.intertext = None
- else:
- optlist = []
- if ('veryverbatim' in optlist):
- self.verbatim = 2
- elif ('verbatim' in optlist) or (Props.force_verbatim_b):
- self.verbatim = 1
- else:
- self.verbatim = 0
- if self.verbatim:
- self.mudtex.open_verbatim (line, self.verbatim)
- self.mudela = Mudela_output (self.gen_basename ())
- self.mudela.write (line)
- continue
- elif end_mudela_re.search (line) and not latex_verbatim:
- if __debug__:
- if self.mode != 'mudela':
- raise AssertionError
-
- if self.verbatim:
- if self.verbatim == 2:
- self.mudtex.write (line)
- self.mudtex.close_verbatim ()
- self.mudela.close ()
- if self.verbatim and self.intertext:
- self.mudtex.write(self.intertext)
- self.mudtex.write (self.mudela.insert_me_string())
- del self.mudela
- self.mudela = None
- self.fine_count = self.fine_count + 1
- self.mode = 'latex'
- continue
-
-
- if self.mode == 'mudela':
- self.mudela.write (line)
- if self.verbatim:
- self.mudtex.write (line)
- else:
- self.mudtex.write (line)
- self.set_sections(line)
- self.mudtex.create_graphics()
- self.mudtex.write_outfile()
- del self.mudtex
+
+ # urg: breaks on \include of full score
+ # Use nofly option if you want to \include full score.
+ if 'nofly' not in opts and not re.search ('\\\\score', body):
+ opts.append ('fragment')
+
+ if 'fragment' in opts and 'nosingleline' not in opts:
+ opts.append ('singleline')
+
+ if 'singleline' in opts:
+ l = -1.0;
+ else:
+ l = latex_linewidths[cols][paper][latex_size]
+
+
+ if 'relative' in opts:
+ body = '\\relative c { %s }' % body
+
+
+ if 'fragment' in opts:
+ 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
+\include "paper%d.ly"
+\paper { linewidth = %f \pt; }
+""" % (optstring, music_size, l) + body
+
+ return body
+
+def find_inclusion_chunks (regex, surround, str):
+ chunks = []
+ while str:
+ m = regex.search (str)
+
+ if m == None:
+ chunks.append (('input', str))
+ str = ''
+ break
+
+ chunks.append (('input', str[: m.start (0)]))
+ chunks.append (('input', surround))
+ chunks = chunks + read_doc_file (m.group (1))
+
+ chunks.append (('input', surround))
+
+ str = str [m.end (0):]
+ return chunks
+
+def find_include_chunks (str):
+ return find_inclusion_chunks (get_re ('include'), '\\newpage', str)
+
+def find_input_chunks (str):
+ return find_inclusion_chunks (get_re ('input'), '', str)
+
+def read_doc_file (filename):
+ """Read the input file, substituting for \input, \include, \mudela{} and \mudelafile"""
+ str = ''
+ str = find_file(filename)
+
+ if __main__.format == '':
+ latex = re.search ('\\\\document', str[:200])
+ texinfo = re.search ('@node', str[:200])
+ if (texinfo and latex) or not (texinfo or latex):
+ error("error: can't determine format, please specify")
+ if texinfo:
+ __main__.format = 'texi'
+ else:
+ __main__.format = 'latex'
+
+ chunks = [('input', str)]
+
+ for func in (find_verbatim_chunks, find_verb_chunks, find_include_chunks, find_input_chunks):
+ newchunks = []
+ for c in chunks:
+ if c[0] == 'input':
+ newchunks = newchunks + func (c[1])
+ else:
+ newchunks.append (c)
+ chunks = newchunks
+
+ return chunks
+
+
+
+def scan_preamble (str):
+ options = []
+ m = get_re ('header').search( str)
+
+ # should extract paper & fontsz.
+ if m and m.group (1):
+ options = options + re.split (',[\n \t]*', m.group(1)[1:-1])
+
+ def verbose_fontsize ( x):
+ # o ??
+ #if o.match('[0-9]+pt'):
+ if re.match('[0-9]+pt', x):
+ return 'latexfontsize=' + x
+ else:
+ return x
+
+ options = map (verbose_fontsize, options)
+
+ return options
+
+
+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
+
+def find_verbatim_chunks (str):
+ """Chop STR into a list of tagged chunks, ie. tuples of form
+ (TYPE_STR, CONTENT_STR), where TYPE_STR is one of 'input' and 'verbatim'
+
+ """
+
+ chunks = []
+ while str:
+ m = get_re ('verbatim').search( str)
+ if m == None:
+ chunks.append( ('input', str))
+ str = ''
+ else:
+ chunks.append (('input', str[:m.start (0)]))
+ chunks.append (('verbatim', m.group (0)))
+ str = str [m.end(0):]
+
+ return chunks
+
+def find_verb_chunks (str):
+
+ chunks = []
+ while str:
+ m = get_re ("verb").search(str)
+ if m == None:
+ chunks.append (('input', str))
+ str = ''
+ else:
+ chunks.append (('input', str[:m.start (0)]))
+ chunks.append (('verbatim', m.group (0)))
+ str = str [m.end(0):]
+
+ return chunks
+
+
+
+def find_mudela_shorthand_chunks (str):
+ return [('input', find_mudela_shorthands(str))]
+
+def find_mudela_shorthands (b):
+ def mudela_short (match):
+ "Find \mudela{}, and substitute appropriate \begin / \end blocks."
+ opts = match.group (1)
+ if opts:
+ opts = ',' + opts[1:-1]
+ else:
+ opts = ''
+ return get_output ('output-mudela-fragment') % (opts, match.group (2))
+
+ def mudela_file (match):
+ "Find \mudelafile, and substitute appropriate \begin / \end blocks."
+ fn = match.group (2)
+ str = find_file (fn)
+ opts = match.group (1)
+ if opts:
+ opts = opts[1:-1]
+ opts = re.split (',[ \n\t]*', opts)
+ else:
+ opts = []
+
+ if re.search ('.fly$', fn):
+ opts.append ('fly')
+ elif re.search ('.sly$', fn):
+ opts = opts + [ 'fly','fragment']
+ elif re.search ('.ly$', fn):
+ opts .append ('nofly')
+
+ str_opts = string.join (opts, ',')
+
+ str = ("%% copied from file `%s'\n" % fn) + str
+ return get_output ('output-mudela') % (str_opts, str)
+
+ b = get_re('mudela-file').sub (mudela_file, b)
+ b = get_re('mudela').sub (mudela_short, b)
+ return b
+
+def find_mudela_chunks (str):
+ """Find mudela blocks, while watching for verbatim. Returns
+ (STR,MUDS) with substituted for the blocks in STR,
+ and the blocks themselves MUDS"""
+
+ chunks = []
+ while str:
+ m = get_re ("mudela-block").search( str)
+ if not m:
+ chunks.append (('input', str))
+ str = ''
+ break
+
+ chunks.append (('input', str[:m.start (0)]))
+
+ opts = m.group (1)
+ if opts:
+ opts = opts[1:-1]
+ else:
+ opts = ''
+ optlist = get_re('comma-sep').split (opts)
+
+ body = m.group (2)
+ chunks.append (('mudela', body, optlist))
+
+ str = str [m.end (0):]
+
+ return chunks
+
+
+
+def advance_counters (counter, opts, str):
+ """Advance chap/sect counters,
+ revise OPTS. Return the new counter tuple"""
+
+ (chapter, section, count) = counter
+ done = ''
+ while str:
+ m = get_re ('interesting-cs').search(str)
+ if not m:
+ done = done + str
+ str = ''
+ break
+
+ done = done + str[:m.end (0)]
+ str = str[m.end(0):]
+ g = m.group (1)
+
+ if g == 'twocolumn':
+ opts.append ('twocolumn')
+ elif g == 'onecolumn':
+ try:
+ opts.remove ('twocolumn')
+ except IndexError:
+ pass
+ elif g == 'chapter':
+ (chapter, section, count) = (chapter + 1, 0, 0)
+ elif g == 'section':
+ (section, count) = (section + 1, 0)
+
+
+ return (chapter, section, count)
+
+
+def schedule_mudela_block (base, chunk, extra_opts):
+ """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, ... ]
+
+ """
+
+ (type, body, opts) = chunk
+ assert type == 'mudela'
+ opts = opts + extra_opts
+
+ newbody = ''
+ if 'verbatim' in opts:
+ newbody = output_verbatim (body)
+
+ file_body = compose_full_body (body, opts)
+ basename = base
+ if __main__.use_hash:
+ basename = `abs(hash (file_body))`
+ updated = update_file (file_body, basename + '.ly')
+ todo = [basename] # UGH.
+
+ if not os.path.isfile (basename + '.tex') or updated:
+ todo.append ('tex')
+ updated = 1
+
+ for o in opts:
+ m = re.search ('intertext="(.*?)"', o)
+ if m:
+ newbody = newbody + m.group (1)
+
+ if format == 'texi':
+ opts.append ('png')
+
+ if 'png' in opts:
+ opts.append ('eps')
+
+ if 'eps' in opts and ('tex' in todo or
+ not os.path.isfile (basename + '.eps')):
+ todo.append ('eps')
+
+ if 'png' in opts and ('eps' in todo or
+ not os.path.isfile (basename + '.png')):
+ todo.append ('png')
+
+ if format == 'latex':
+ if 'eps' in opts :
+ newbody = newbody + get_output ('output-eps') % (basename, basename)
+ else:
+ newbody = newbody + get_output ('output-tex') % basename
+
+ elif format == 'texi':
+ newbody = newbody + get_output ('output-all') % (basename, basename)
+
+ return ('mudela', newbody, opts, todo, base)
+
+
+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 print_chunks (ch):
+ for c in ch:
+ print '-->%s\n%s' % (c[0], c[1])
+ if len (c) > 2:
+ print '==>%s' % list (c[2:])
+ print foo
+
+
+def transform_input_file (in_filename, out_filename):
+ """Read the input, and deliver a list of chunks
+ ready for writing.
+
+ """
+
+ chunks = read_doc_file (in_filename)
+
+ #. Process \mudela and \mudelafile.
+ for func in [find_mudela_shorthand_chunks,
+ find_mudela_chunks]:
+ newchunks = []
+ for c in chunks:
+ if c[0] == 'input':
+ newchunks = newchunks + func (c[1])
+ else:
+ newchunks.append (c)
+ chunks = newchunks
+
+ opts = []
+ if chunks:
+ opts = scan_preamble (chunks[0][1])
+
+ (chap,sect,count) = (0,0,0)
+ newchunks = []
+ # Count sections/chapters.
+ for c in chunks:
+ if c[0] == 'input':
+ (chap,sect,count) = advance_counters((chap,sect,count), opts, c[1])
+ elif c[0] == 'mudela':
+ base = '%s-%d.%d.%d' % (out_filename, chap, sect, count)
+ count = count + 1
+ c = schedule_mudela_block (base, c, opts)
+
+ newchunks.append (c)
+
+ chunks = newchunks
+ newchunks = []
+
+ # Do It.
+ if __main__.run_lilypond:
+ compile_all_files (chunks)
+
+ # 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]))
+
+ return chunks
+
+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 = []
+ hash_dict = {}
+
+ for c in chunks:
+ if c[0] <> 'mudela':
+ continue
+ base = c[3][0]
+ exts = c[3][1:]
+ for e in exts:
+ if e == 'eps':
+ eps.append (base)
+ elif e == 'tex':
+ tex.append (base + '.ly')
+ elif e == 'png':
+ png.append (base)
+
+ if __main__.use_hash:
+ hash_dict[c[4]] = c[3][0]
+
+ 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:
+ cmd = r"""tex '\nonstopmode \input %s'; dvips -E -o %s %s""" % \
+ (e, e + '.eps', e)
+ system (cmd)
+
+ 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 __main__.use_hash:
+ name = ''
+ last_name = ''
+ f = 0
+ ks = hash_dict.keys ()
+ ks.sort ()
+ for i in ks:
+ name = re.sub ("(.*)-[0-9]+\.[0-9]+\.[0-9]+", "\\1", i)
+ name = name + '.mix'
+ if name != last_name:
+ if last_name:
+ f.close ()
+ f = open (name, 'w')
+ last_name = name
+ f.write ("%s:%s\n" % (i, hash_dict[i]))
+
+
+def update_file (body, name):
+ 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
+ sys.stdout.write("""Usage: mudela-book [options] FILE\n
Generate hybrid LaTeX input from Latex + mudela
-Options:\n
- -h, --help print this help
- -d, --outdir=DIR directory to put generated files
- -o, --outname=FILE prefix for filenames
- --default-mudela-fontsize=??pt default fontsize for music
- --force-mudela-fontsize=??pt force fontsize for all inline mudela
- --force-verbatim make all mudela verbatim\n
- --dependencies write dependencies
- --include include path
- --init mudela-book initfile
- """
- )
- sys.exit (0)
-
-
-def write_deps (fn, out, deps):
- out_fn = os.path.join (outdir, fn)
-
- print 'writing `%s\'\n' % out_fn
+Options:
+""")
+ sys.stdout.write (options_help_str (options))
+ sys.stdout.write (r"""Warning all output is written in the CURRENT directory
+
+
+
+Report bugs to bug-gnu-music@gnu.org.
+
+Written by Tom Cato Amundsen <tomcato@xoommail.com> and
+Han-Wen Nienhuys <hanwen@cs.uu.nl>
+""")
+
+ sys.exit (0)
+
+
+def write_deps (fn, target):
+ sys.stdout.write('writing `%s\'\n' % fn)
+
+ f = open (fn, 'w')
- f = open (out_fn, 'w')
- target = re.sub (os.sep + os.sep, os.sep, os.path.join (outdir, out + '.latex'))
- f.write ('%s: %s\n'% (target,
- reduce (lambda x,y: x + ' '+ y, deps)))
+ f.write ('%s%s: ' % (dep_prefix, target))
+ for d in __main__.read_files:
+ f.write ('%s ' % d)
+ f.write ('\n')
f.close ()
+ __main__.read_files = []
def identify():
- sys.stderr.write ('This is %s version %s\n' % ('mudela-book', program_version))
-
-def main():
- global outdir, initfile, defined_mudela_cmd, defined_mudela_cmd_re
- outname = ''
- try:
- (options, files) = getopt.getopt(
- sys.argv[1:], 'hd:o:I:', ['outdir=', 'outname=',
- 'default-mudela-fontsize=',
- 'force-mudela-fontsize=',
- 'help', 'dependencies', 'include=',
- 'force-verbatim', 'init='])
- except getopt.error, msg:
- print "error:", msg
- sys.exit(1)
-
- do_deps = 0
- for opt in options:
+ 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.
+""")
+
+
+outname = ''
+try:
+ (sh, long) = getopt_args (__main__.options)
+ (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)
+ include_path.append (a)
+ elif o == '--version':
+ print_version ()
+ sys.exit (0)
+
+ elif o == '--format' or o == '-o':
+ __main__.format = a
elif o == '--outname' or o == '-o':
- if len(files) > 1:
- #HACK
- print "Mudela-book is confused by --outname on multiple files"
- sys.exit(1)
- outname = a
- elif o == '--outdir' or o == '-d':
- outdir = a
- elif o == '--help' or o == '-h':
- help ()
+ 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__.run_lilypond = 0
elif o == '--dependencies':
- do_deps = 1
- elif o == '--default-mudela-fontsize':
- if not fontsize_pt2i.has_key(a):
- print "Error: illegal fontsize:", a
- print " accepted fontsizes are: 11pt, 13pt, 16pt, 20pt, 26pt"
- sys.exit()
- Props.setMudelaFontsize(fontsize_pt2i[a], 'init')
- elif o == '--force-mudela-fontsize':
- if not fontsize_pt2i.has_key(a):
- print "Error: illegal fontsize:", a
- print " accepted fontsizes are: 11pt, 13pt, 16pt, 20pt, 26pt"
- sys.exit()
- Props.force_mudela_fontsize = fontsize_pt2i[a]
- elif o == '--force-verbatim':
- Props.force_verbatim_b = 1
- elif o == '--init':
- initfile = a
- if outdir[-1:] != '/':
- outdir = outdir + '/'
-
- # r""" ... """ means: leave escape seqs alone.
- defined_mudela_cmd = {'mudela': r"""
-\begin{mudela}[eps \fontoptions]
- \type Staff <
- \type Voice{
- \maininput
- }
- >
-\end{mudela}
-"""}
- if initfile != '':
- f = open(initfile)
- s = f.read()
- f.close()
- d = eval(s)
- for i in d.keys():
- defined_mudela_cmd[i] = d[i]
- del d
-
- c = string.join (defined_mudela_cmd.keys(), '|')
-
- defined_mudela_cmd_re = re.compile("\\\\(%s)(\[(\d*pt)\])*{([^}]*)}" %c)
-
- if not os.path.isdir(outdir):
- os.system('mkdir %s' % outdir)
-
- for input_filename in files:
- Props.clear_for_new_file()
- if outname:
- my_outname = outname
- else:
- my_outname = os.path.basename(os.path.splitext(input_filename)[0])
- my_depname = my_outname + '.dep'
- inp = Main_tex_input (input_filename, my_outname)
- inp.do_it ()
- if do_deps:
- write_deps (my_depname, my_outname, inp.deps)
+ do_deps = 1
+ elif o == '--default-mudela-fontsize':
+ default_music_fontsize = string.atoi (a)
+ elif o == '--init':
+ initfile = a
+ elif o == '--dep-prefix':
+ dep_prefix = a
identify()
-Props = Properties()
-main()
+
+for input_filename in files:
+ 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 = transform_input_file (input_filename, my_outname)
+
+ foutn = 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)
+
+
+
+#
+# Petr, ik zou willen dat ik iets zinvoller deed,
+# maar wat ik kan ik doen, het verandert toch niets?
+# --hwn 20/aug/99
projects / lilypond.git / blobdiff