scripts/lilypond-book.py

   1 #!@PYTHON@
   2 # vim: set noexpandtab:
   3 # TODO:
   4 # * junk --outdir for --output
   5 # * Figure out clean set of options.
   6 # *
   7 # * EndLilyPondOutput is def'd as vfil. Causes large white gaps.
   8 # * texinfo: add support for @pagesize
   9
  10 # todo: dimension handling (all the x2y) is clumsy. (tca: Thats
  11 #       because the values are taken directly from texinfo.tex,
  12 #       geometry.sty and article.cls. Give me a hint, and I'll
  13 #       fix it.)
  14
  15 # This is was the idea for handling of comments:
  16 #       Multiline comments, @ignore .. @end ignore is scanned for
  17 #       in read_doc_file, and the chunks are marked as 'ignore', so
  18 #       lilypond-book will not touch them any more. The content of the
  19 #       chunks are written to the output file. Also 'include' and 'input'
  20 #       regex has to check if they are commented out.
  21 #
  22 #       Then it is scanned for 'lilypond', 'lilypond-file' and 'lilypond-block'.
  23 #       These three regex's has to check if they are on a commented line,
  24 #       % for latex, @c for texinfo.
  25 #
  26 #       Then lines that are commented out with % (latex) and @c (Texinfo)
  27 #       are put into chunks marked 'ignore'. This cannot be done before
  28 #       searching for the lilypond-blocks because % is also the comment character
  29 #       for lilypond.
  30 #
  31 #       The the rest of the rexeces are searched for. They don't have to test
  32 #       if they are on a commented out line.
  33
  34 import os
  35 import stat
  36 import string
  37 import re
  38 import getopt
  39 import sys
  40 import __main__
  41 import operator
  42
  43
  44 program_version = '@TOPLEVEL_VERSION@'
  45 if program_version == '@' + 'TOPLEVEL_VERSION' + '@':
  46         program_version = '1.5.18'
  47
  48 #
  49 # Try to cater for bad installations of LilyPond, that have
  50 # broken TeX setup.  Just hope this doesn't hurt good TeX
  51 # setups.  Maybe we should check if kpsewhich can find
  52 # feta16.{afm,mf,tex,tfm}, and only set env upon failure.
  53 #
  54 datadir = '@datadir@'
  55 environment = {
  56         'MFINPUTS' : datadir + '/mf:',
  57         'TEXINPUTS': datadir + '/tex:' + datadir + '/ps:.:',
  58         'TFMFONTS' : datadir + '/tfm:',
  59         'GS_FONTPATH' : datadir + '/afm:' + datadir + '/pfa',
  60         'GS_LIB' : datadir + '/ps',
  61 }
  62
  63 def setup_environment ():
  64         for key in environment.keys ():
  65                 val = environment[key]
  66                 if os.environ.has_key (key):
  67                         val = val + os.pathsep + os.environ[key]
  68                 os.environ[key] = val
  69
  70
  71
  72 include_path = [os.getcwd()]
  73
  74
  75 # g_ is for global (?)
  76
  77 g_here_dir = os.getcwd ()
  78 g_dep_prefix = ''
  79 g_outdir = ''
  80 g_force_lilypond_fontsize = 0
  81 g_read_lys = 0
  82 g_do_pictures = 1
  83 g_num_cols = 1
  84 format = ''
  85 g_run_lilypond = 1
  86 no_match = 'a\ba'
  87
  88 default_music_fontsize = 16
  89 default_text_fontsize = 12
  90 paperguru = None
  91
  92 # this code is ugly. It should be cleaned
  93 class LatexPaper:
  94         def __init__(self):
  95                 self.m_paperdef =  {
  96                         # the dimensions are from geometry.sty
  97                         'a0paper': (mm2pt(841), mm2pt(1189)),
  98                         'a1paper': (mm2pt(595), mm2pt(841)),
  99                         'a2paper': (mm2pt(420), mm2pt(595)),
 100                         'a3paper': (mm2pt(297), mm2pt(420)),
 101                         'a4paper': (mm2pt(210), mm2pt(297)),
 102                         'a5paper': (mm2pt(149), mm2pt(210)),
 103                         'b0paper': (mm2pt(1000), mm2pt(1414)),
 104                         'b1paper': (mm2pt(707), mm2pt(1000)),
 105                         'b2paper': (mm2pt(500), mm2pt(707)),
 106                         'b3paper': (mm2pt(353), mm2pt(500)),
 107                         'b4paper': (mm2pt(250), mm2pt(353)),
 108                         'b5paper': (mm2pt(176), mm2pt(250)),
 109                         'letterpaper': (in2pt(8.5), in2pt(11)),
 110                         'legalpaper': (in2pt(8.5), in2pt(14)),
 111                         'executivepaper': (in2pt(7.25), in2pt(10.5))}
 112                 self.m_use_geometry = None
 113                 self.m_papersize = 'letterpaper'
 114                 self.m_fontsize = 10
 115                 self.m_num_cols = 1
 116                 self.m_landscape = 0
 117                 self.m_geo_landscape = 0
 118                 self.m_geo_width = None
 119                 self.m_geo_textwidth = None
 120                 self.m_geo_lmargin = None
 121                 self.m_geo_rmargin = None
 122                 self.m_geo_includemp = None
 123                 self.m_geo_marginparwidth = {10: 57, 11: 50, 12: 35}
 124                 self.m_geo_marginparsep = {10: 11, 11: 10, 12: 10}
 125                 self.m_geo_x_marginparwidth = None
 126                 self.m_geo_x_marginparsep = None
 127                 self.__body = None
 128         def set_geo_option(self, name, value):
 129                 if name == 'body' or name == 'text':
 130                         if type(value) == type(""):
 131                                 self.m_geo_textwidth =  value
 132                         else:
 133                                 self.m_geo_textwidth =  value[0]
 134                         self.__body = 1
 135                 elif name == 'portrait':
 136                         self.m_geo_landscape = 0
 137                 elif name == 'reversemp' or name == 'reversemarginpar':
 138                         if self.m_geo_includemp == None:
 139                                 self.m_geo_includemp = 1
 140                 elif name == 'marginparwidth' or name == 'marginpar':
 141                         self.m_geo_x_marginparwidth =  value
 142                         self.m_geo_includemp = 1
 143                 elif name == 'marginparsep':
 144                         self.m_geo_x_marginparsep =  value
 145                         self.m_geo_includemp = 1
 146                 elif name == 'scale':
 147                         if type(value) == type(""):
 148                                 self.m_geo_width = self.get_paperwidth() * float(value)
 149                         else:
 150                                 self.m_geo_width = self.get_paperwidth() * float(value[0])
 151                 elif name == 'hscale':
 152                         self.m_geo_width = self.get_paperwidth() * float(value)
 153                 elif name == 'left' or name == 'lmargin':
 154                         self.m_geo_lmargin =  value
 155                 elif name == 'right' or name == 'rmargin':
 156                         self.m_geo_rmargin =  value
 157                 elif name == 'hdivide' or name == 'divide':
 158                         if value[0] not in ('*', ''):
 159                                 self.m_geo_lmargin =  value[0]
 160                         if value[1] not in ('*', ''):
 161                                 self.m_geo_width =  value[1]
 162                         if value[2] not in ('*', ''):
 163                                 self.m_geo_rmargin =  value[2]
 164                 elif name == 'hmargin':
 165                         if type(value) == type(""):
 166                                 self.m_geo_lmargin =  value
 167                                 self.m_geo_rmargin =  value
 168                         else:
 169                                 self.m_geo_lmargin =  value[0]
 170                                 self.m_geo_rmargin =  value[1]
 171                 elif name == 'margin':#ugh there is a bug about this option in
 172                                         # the geometry documentation
 173                         if type(value) == type(""):
 174                                 self.m_geo_lmargin =  value
 175                                 self.m_geo_rmargin =  value
 176                         else:
 177                                 self.m_geo_lmargin =  value[0]
 178                                 self.m_geo_rmargin =  value[0]
 179                 elif name == 'total':
 180                         if type(value) == type(""):
 181                                 self.m_geo_width =  value
 182                         else:
 183                                 self.m_geo_width =  value[0]
 184                 elif name == 'width' or name == 'totalwidth':
 185                         self.m_geo_width =  value
 186                 elif name == 'paper' or name == 'papername':
 187                         self.m_papersize = value
 188                 elif name[-5:] == 'paper':
 189                         self.m_papersize = name
 190                 else:
 191                         pass
 192                         # what is _set_dimen ?? /MB
 193                         #self._set_dimen('m_geo_'+name, value)
 194         def __setattr__(self, name, value):
 195                 if type(value) == type("") and \
 196                    dimension_conversion_dict.has_key (value[-2:]):
 197                         f = dimension_conversion_dict[value[-2:]]
 198                         self.__dict__[name] = f(float(value[:-2]))
 199                 else:
 200                         self.__dict__[name] = value
 201
 202         def __str__(self):
 203                 s =  "LatexPaper:\n-----------"
 204                 for v in self.__dict__.keys():
 205                         if v[:2] == 'm_':
 206                                 s = s +  str (v) + ' ' + str (self.__dict__[v])
 207                 s = s +  "-----------"
 208                 return s
 209
 210         def get_linewidth(self):
 211                 w = self._calc_linewidth()
 212                 if self.m_num_cols == 2:
 213                         return (w - 10) / 2
 214                 else:
 215                         return w
 216         def get_paperwidth(self):
 217                 #if self.m_use_geometry:
 218                         return self.m_paperdef[self.m_papersize][self.m_landscape or self.m_geo_landscape]
 219                 #return self.m_paperdef[self.m_papersize][self.m_landscape]
 220
 221         def _calc_linewidth(self):
 222                 # since geometry sometimes ignores 'includemp', this is
 223                 # more complicated than it should be
 224                 mp = 0
 225                 if self.m_geo_includemp:
 226                         if self.m_geo_x_marginparsep is not None:
 227                                 mp = mp + self.m_geo_x_marginparsep
 228                         else:
 229                                 mp = mp + self.m_geo_marginparsep[self.m_fontsize]
 230                         if self.m_geo_x_marginparwidth is not None:
 231                                 mp = mp + self.m_geo_x_marginparwidth
 232                         else:
 233                                 mp = mp + self.m_geo_marginparwidth[self.m_fontsize]
 234
 235                 #ugh test if this is necessary
 236                 if self.__body:
 237                         mp = 0
 238
 239                 if not self.m_use_geometry:
 240                         return latex_linewidths[self.m_papersize][self.m_fontsize]
 241                 else:
 242                         geo_opts = (self.m_geo_lmargin == None,
 243                                     self.m_geo_width == None,
 244                                     self.m_geo_rmargin == None)
 245
 246                         if geo_opts == (1, 1, 1):
 247                                 if self.m_geo_textwidth:
 248                                         return self.m_geo_textwidth
 249                                 w = self.get_paperwidth() * 0.8
 250                                 return w - mp
 251                         elif geo_opts == (0, 1, 1):
 252                                  if self.m_geo_textwidth:
 253                                         return self.m_geo_textwidth
 254                                  return self.f1(self.m_geo_lmargin, mp)
 255                         elif geo_opts == (1, 1, 0):
 256                                  if self.m_geo_textwidth:
 257                                         return self.m_geo_textwidth
 258                                  return self.f1(self.m_geo_rmargin, mp)
 259                         elif geo_opts \
 260                                         in ((0, 0, 1), (1, 0, 0), (1, 0, 1)):
 261                                 if self.m_geo_textwidth:
 262                                         return self.m_geo_textwidth
 263                                 return self.m_geo_width - mp
 264                         elif geo_opts in ((0, 1, 0), (0, 0, 0)):
 265                                 w = self.get_paperwidth() \
 266                                   - self.m_geo_lmargin - self.m_geo_rmargin - mp
 267                                 if w < 0:
 268                                         w = 0
 269                                 return w
 270                         raise "Never do this!"
 271         def f1(self, m, mp):
 272                 tmp = self.get_paperwidth() - m * 2 - mp
 273                 if tmp < 0:
 274                         tmp = 0
 275                 return tmp
 276         def f2(self):
 277                 tmp = self.get_paperwidth() - self.m_geo_lmargin \
 278                         - self.m_geo_rmargin
 279                 if tmp < 0:
 280                         return 0
 281                 return tmp
 282
 283 class TexiPaper:
 284         def __init__(self):
 285                 self.m_papersize = 'letterpaper'
 286                 self.m_fontsize = 12
 287         def get_linewidth(self):
 288                 return texi_linewidths[self.m_papersize][self.m_fontsize]
 289
 290 def mm2pt(x):
 291         return x * 2.8452756
 292 def in2pt(x):
 293         return x * 72.26999
 294 def em2pt(x, fontsize = 10):
 295         return {10: 10.00002, 11: 10.8448, 12: 11.74988}[fontsize] * x
 296 def ex2pt(x, fontsize = 10):
 297         return {10: 4.30554, 11: 4.7146, 12: 5.16667}[fontsize] * x
 298
 299 def pt2pt(x):
 300         return x
 301
 302 dimension_conversion_dict ={
 303         'mm': mm2pt,
 304         'in': in2pt,
 305         'em': em2pt,
 306         'ex': ex2pt,
 307         'pt': pt2pt
 308         }
 309
 310
 311 # latex linewidths:
 312 # indices are no. of columns, papersize,  fontsize
 313 # Why can't this be calculated?
 314 latex_linewidths = {
 315         'a4paper':{10: 345, 11: 360, 12: 390},
 316         'a4paper-landscape': {10: 598, 11: 596, 12:592},
 317         'a5paper':{10: 276, 11: 276, 12: 276},
 318         'b5paper':{10: 345, 11: 356, 12: 356},
 319         'letterpaper':{10: 345, 11: 360, 12: 390},
 320         'letterpaper-landscape':{10: 598, 11: 596, 12:596},
 321         'legalpaper': {10: 345, 11: 360, 12: 390},
 322         'executivepaper':{10: 345, 11: 360, 12: 379}}
 323
 324 texi_linewidths = {
 325         'afourpaper': {12: mm2pt(160)},
 326         'afourwide': {12: in2pt(6.5)},
 327         'afourlatex': {12: mm2pt(150)},
 328         'smallbook': {12: in2pt(5)},
 329         'letterpaper': {12: in2pt(6)}}
 330
 331 option_definitions = [
 332   ('EXT', 'f', 'format', 'set format.  EXT is one of texi and latex.'),
 333   ('DIM',  '', 'default-music-fontsize', 'default fontsize for music.  DIM is assumed to be in points'),
 334   ('DIM',  '', 'default-lilypond-fontsize', 'deprecated, use --default-music-fontsize'),
 335   ('DIM', '', 'force-music-fontsize', 'force fontsize for all inline lilypond. DIM is assumed be to in points'),
 336   ('DIM', '', 'force-lilypond-fontsize', 'deprecated, use --force-music-fontsize'),
 337   ('DIR', 'I', 'include', 'include path'),
 338   ('', 'M', 'dependencies', 'write dependencies'),
 339   ('PREF', '',  'dep-prefix', 'prepend PREF before each -M dependency'),
 340   ('', 'n', 'no-lily', 'don\'t run lilypond'),
 341   ('', '', 'no-pictures', "don\'t generate pictures"),
 342   ('', '', 'read-lys', "don't write ly files."),
 343   ('FILE', 'o', 'outname', 'filename main output file'),
 344   ('FILE', '', 'outdir', "where to place generated files"),
 345   ('', 'v', 'version', 'print version information' ),
 346   ('', 'h', 'help', 'print help'),
 347   ]
 348
 349 # format specific strings, ie. regex-es for input, and % strings for output
 350 output_dict= {
 351         'latex': {
 352                 'output-lilypond-fragment' : r"""\begin[eps,singleline,%s]{lilypond}
 353   \context Staff <
 354     \context Voice{
 355       %s
 356     }
 357   >
 358 \end{lilypond}""",
 359                 'output-filename' : r'''
 360
 361 \verb+%s+:''',
 362                 'output-lilypond': r"""\begin[%s]{lilypond}
 363 %s
 364 \end{lilypond}""",
 365                 'output-verbatim': "\\begin{verbatim}%s\\end{verbatim}",
 366                 'output-default-post': "\\def\postLilypondExample{}\n",
 367                 'output-default-pre': "\\def\preLilypondExample{}\n",
 368                 'usepackage-graphics': '\\usepackage{graphics}\n',
 369                 'output-eps': '\\noindent\\parbox{\\lilypondepswidth{%(fn)s.eps}}{\includegraphics{%(fn)s.eps}}',
 370                 'output-tex': '{\\preLilypondExample \\input %(fn)s.tex \\postLilypondExample\n}',
 371                 'pagebreak': r'\pagebreak',
 372                 },
 373         'texi' : {'output-lilypond': """@lilypond[%s]
 374 %s
 375 @end lilypond
 376 """,
 377                 'output-filename' : r'''
 378
 379 @file{%s}:''',
 380                   'output-lilypond-fragment': """@lilypond[%s]
 381 \context Staff\context Voice{ %s }
 382 @end lilypond """,
 383                   'pagebreak': None,
 384                   'output-verbatim': r"""@example
 385 %s
 386 @end example
 387 """,
 388
 389 # do some tweaking: @ is needed in some ps stuff.
 390 # override EndLilyPondOutput, since @tex is done
 391 # in a sandbox, you can't do \input lilyponddefs at the
 392 # top of the document.
 393
 394 # should also support fragment in
 395
 396                   'output-all': r"""
 397 @tex
 398 \catcode`\@=12
 399 \input lilyponddefs
 400 \def\EndLilyPondOutput{}
 401 \input %(fn)s.tex
 402 \catcode`\@=0
 403 @end tex
 404 @html
 405 <p>
 406 <a href="%(fn)s.png">
 407 <img border=0 src="%(fn)s.png" alt="[picture of music]">
 408 </a>
 409 @end html
 410 """,
 411                 }
 412         }
 413
 414 def output_verbatim (body):
 415         if __main__.format == 'texi':
 416                 body = re.sub ('([@{}])', '@\\1', body)
 417         return get_output ('output-verbatim') % body
 418
 419
 420 re_dict = {
 421         'latex': {'input': r'(?m)^[^%\n]*?(?P<match>\\mbinput{?([^}\t \n}]*))',
 422                   'include': r'(?m)^[^%\n]*?(?P<match>\\mbinclude{(?P<filename>[^}]+)})',
 423                   'option-sep' : ',\s*',
 424                   'header': r"\\documentclass\s*(\[.*?\])?",
 425                   'geometry': r"^(?m)[^%\n]*?\\usepackage\s*(\[(?P<options>.*)\])?\s*{geometry}",
 426                   'preamble-end': r'(?P<code>\\begin{document})',
 427                   'verbatim': r"(?s)(?P<code>\\begin{verbatim}.*?\\end{verbatim})",
 428                   'verb': r"(?P<code>\\verb(?P<del>.).*?(?P=del))",
 429                   'lilypond-file': r'(?m)^[^%\n]*?(?P<match>\\lilypondfile\s*(\[(?P<options>.*?)\])?\s*\{(?P<filename>.+)})',
 430                   'lilypond' : r'(?m)^[^%\n]*?(?P<match>\\lilypond\s*(\[(?P<options>.*?)\])?\s*{(?P<code>.*?)})',
 431                   'lilypond-block': r"(?sm)^[^%\n]*?(?P<match>\\begin\s*(\[(?P<options>.*?)\])?\s*{lilypond}(?P<code>.*?)\\end{lilypond})",
 432                   'def-post-re': r"\\def\\postLilypondExample",
 433                   'def-pre-re': r"\\def\\preLilypondExample",
 434                   'usepackage-graphics': r"\usepackage{graphics}",
 435                   'intertext': r',?\s*intertext=\".*?\"',
 436                   'multiline-comment': no_match,
 437                   'singleline-comment': r"(?m)^.*?(?P<match>(?P<code>^%.*$\n+))",
 438                   'numcols': r"(?P<code>\\(?P<num>one|two)column)",
 439                   },
 440
 441
 442         # why do we have distinction between @mbinclude and @include?
 443         'texi': {
 444                  'include':  '(?m)^[^%\n]*?(?P<match>@mbinclude[ \n\t]+(?P<filename>[^\t \n]*))',
 445                  'input': no_match,
 446                  'header': no_match,
 447                  'preamble-end': no_match,
 448                  'landscape': no_match,
 449                  'verbatim': r"""(?s)(?P<code>@example\s.*?@end example\s)""",
 450                  'verb': r"""(?P<code>@code{.*?})""",
 451                  'lilypond-file': '(?m)^(?!@c)(?P<match>@lilypondfile(\[(?P<options>.*?)\])?{(?P<filename>[^}]+)})',
 452                  'lilypond' : '(?m)^(?!@c)(?P<match>@lilypond(\[(?P<options>.*?)\])?{(?P<code>.*?)})',
 453                  'lilypond-block': r"""(?m)^(?!@c)(?P<match>(?s)(?P<match>@lilypond(\[(?P<options>.*?)\])?\s(?P<code>.*?)@end lilypond\s))""",
 454                   'option-sep' : ',\s*',
 455                   'intertext': r',?\s*intertext=\".*?\"',
 456                   'multiline-comment': r"(?sm)^\s*(?!@c\s+)(?P<code>@ignore\s.*?@end ignore)\s",
 457                   'singleline-comment': r"(?m)^.*?(?P<match>(?P<code>@c.*$\n+))",
 458                   'numcols': no_match,
 459                  }
 460         }
 461
 462
 463 for r in re_dict.keys ():
 464         olddict = re_dict[r]
 465         newdict = {}
 466         for k in olddict.keys ():
 467                 newdict[k] = re.compile (olddict[k])
 468         re_dict[r] = newdict
 469
 470
 471 def uniq (list):
 472         list.sort ()
 473         s = list
 474         list = []
 475         for x in s:
 476                 if x not in list:
 477                         list.append (x)
 478         return list
 479
 480
 481 def get_output (name):
 482         return  output_dict[format][name]
 483
 484 def get_re (name):
 485         return  re_dict[format][name]
 486
 487 def bounding_box_dimensions(fname):
 488         if g_outdir:
 489                 fname = os.path.join(g_outdir, fname)
 490         try:
 491                 fd = open(fname)
 492         except IOError:
 493                 error ("Error opening `%s'" % fname)
 494         str = fd.read ()
 495         s = re.search('%%BoundingBox: ([0-9]+) ([0-9]+) ([0-9]+) ([0-9]+)', str)
 496         if s:
 497                 return (int(s.group(3))-int(s.group(1)),
 498                         int(s.group(4))-int(s.group(2)))
 499         else:
 500                 return (0,0)
 501
 502 def error (str):
 503         sys.stderr.write (str + "\n  Exiting ... \n\n")
 504         raise 'Exiting.'
 505
 506
 507 def compose_full_body (body, opts):
 508         """Construct the lilypond code to send to Lilypond.
 509         Add stuff to BODY using OPTS as options."""
 510         music_size = default_music_fontsize
 511         latex_size = default_text_fontsize
 512         for o in opts:
 513                 if g_force_lilypond_fontsize:
 514                         music_size = g_force_lilypond_fontsize
 515                 else:
 516                         m = re.match ('([0-9]+)pt', o)
 517                         if m:
 518                                 music_size = string.atoi(m.group (1))
 519
 520                 m = re.match ('latexfontsize=([0-9]+)pt', o)
 521                 if m:
 522                         latex_size = string.atoi (m.group (1))
 523
 524         if re.search ('\\\\score', body):
 525                 is_fragment = 0
 526         else:
 527                 is_fragment = 1
 528         if 'fragment' in opts:
 529                 is_fragment = 1
 530         if 'nofragment' in opts:
 531                 is_fragment = 0
 532
 533         if is_fragment and not 'multiline' in opts:
 534                 opts.append('singleline')
 535         if 'singleline' in opts:
 536                 l = -1.0;
 537         else:
 538                 l = __main__.paperguru.get_linewidth()
 539
 540         for o in opts:
 541                 m= re.search ('relative(.*)', o)
 542                 v = 0
 543                 if m:
 544                         try:
 545                                 v = string.atoi (m.group (1))
 546                         except ValueError:
 547                                 pass
 548
 549                         v = v + 1
 550                         pitch = 'c'
 551                         if v < 0:
 552                                 pitch = pitch + '\,' * v
 553                         elif v > 0:
 554                                 pitch = pitch + '\'' * v
 555
 556                         body = '\\relative %s { %s }' %(pitch, body)
 557
 558         if is_fragment:
 559                 body = r"""\score {
 560  \notes { %s }
 561   \paper { }
 562 }""" % body
 563
 564         opts = uniq (opts)
 565         optstring = string.join (opts, ' ')
 566         optstring = re.sub ('\n', ' ', optstring)
 567         body = r"""
 568 %% Generated automatically by: lilypond-book.py
 569 %% options are %s
 570 \include "paper%d.ly"
 571 \paper  { linewidth = %f \pt }
 572 """ % (optstring, music_size, l) + body
 573
 574         # ughUGH not original options
 575         return body
 576
 577 def parse_options_string(s):
 578         d = {}
 579         r1 = re.compile("((\w+)={(.*?)})((,\s*)|$)")
 580         r2 = re.compile("((\w+)=(.*?))((,\s*)|$)")
 581         r3 = re.compile("(\w+?)((,\s*)|$)")
 582         while s:
 583                 m = r1.match(s)
 584                 if m:
 585                         s = s[m.end():]
 586                         d[m.group(2)] = re.split(",\s*", m.group(3))
 587                         continue
 588                 m = r2.match(s)
 589                 if m:
 590                         s = s[m.end():]
 591                         d[m.group(2)] = m.group(3)
 592                         continue
 593                 m = r3.match(s)
 594                 if m:
 595                         s = s[m.end():]
 596                         d[m.group(1)] = 1
 597                         continue
 598
 599                 error ("format of option string invalid (was `%')" % s)
 600         return d
 601
 602 def scan_latex_preamble(chunks):
 603         # first we want to scan the \documentclass line
 604         # it should be the first non-comment line
 605         idx = 0
 606         while 1:
 607                 if chunks[idx][0] == 'ignore':
 608                         idx = idx + 1
 609                         continue
 610                 m = get_re ('header').match(chunks[idx][1])
 611                 if m.group (1):
 612                         options = re.split (',[\n \t]*', m.group(1)[1:-1])
 613                 else:
 614                         options = []
 615                 for o in options:
 616                         if o == 'landscape':
 617                                 paperguru.m_landscape = 1
 618                         m = re.match("(.*?)paper", o)
 619                         if m:
 620                                 paperguru.m_papersize = m.group()
 621                         else:
 622                                 m = re.match("(\d\d)pt", o)
 623                                 if m:
 624                                         paperguru.m_fontsize = int(m.group(1))
 625
 626                 break
 627         while chunks[idx][0] != 'preamble-end':
 628                 if chunks[idx] == 'ignore':
 629                         idx = idx + 1
 630                         continue
 631                 m = get_re ('geometry').search(chunks[idx][1])
 632                 if m:
 633                         paperguru.m_use_geometry = 1
 634                         o = parse_options_string(m.group('options'))
 635                         for k in o.keys():
 636                                 paperguru.set_geo_option(k, o[k])
 637                 idx = idx + 1
 638
 639 def scan_texi_preamble (chunks):
 640         # this is not bulletproof..., it checks the first 10 chunks
 641         for c in chunks[:10]:
 642                 if c[0] == 'input':
 643                         for s in ('afourpaper', 'afourwide', 'letterpaper',
 644                                   'afourlatex', 'smallbook'):
 645                                 if string.find(c[1], "@%s" % s) != -1:
 646                                         paperguru.m_papersize = s
 647
 648 def scan_preamble (chunks):
 649         if __main__.format == 'texi':
 650                 scan_texi_preamble(chunks)
 651         else:
 652                 assert __main__.format == 'latex'
 653                 scan_latex_preamble(chunks)
 654
 655
 656 def completize_preamble (chunks):
 657         if __main__.format == 'texi':
 658                 return chunks
 659         pre_b = post_b = graphics_b = None
 660         for chunk in chunks:
 661                 if chunk[0] == 'preamble-end':
 662                         break
 663                 if chunk[0] == 'input':
 664                         m = get_re('def-pre-re').search(chunk[1])
 665                         if m:
 666                                 pre_b = 1
 667                 if chunk[0] == 'input':
 668                         m = get_re('def-post-re').search(chunk[1])
 669                         if m:
 670                                 post_b = 1
 671                 if chunk[0] == 'input':
 672                         m = get_re('usepackage-graphics').search(chunk[1])
 673                         if m:
 674                                 graphics_b = 1
 675         x = 0
 676         while chunks[x][0] != 'preamble-end':
 677                 x = x + 1
 678         if not pre_b:
 679                 chunks.insert(x, ('input', get_output ('output-default-pre')))
 680         if not post_b:
 681                 chunks.insert(x, ('input', get_output ('output-default-post')))
 682         if not graphics_b:
 683                 chunks.insert(x, ('input', get_output ('usepackage-graphics')))
 684         return chunks
 685
 686
 687 read_files = []
 688 def find_file (name):
 689         """
 690         Search the include path for NAME. If found, return the (CONTENTS, PATH) of the file.
 691         """
 692
 693         f = None
 694         nm = ''
 695         for a in include_path:
 696                 try:
 697                         nm = os.path.join (a, name)
 698                         f = open (nm)
 699                         __main__.read_files.append (nm)
 700                         break
 701                 except IOError:
 702                         pass
 703         if f:
 704                 sys.stderr.write ("Reading `%s'\n" % nm)
 705                 return (f.read (), nm)
 706         else:
 707                 error ("File not found `%s'\n" % name)
 708                 return ('', '')
 709
 710 def do_ignore(match_object):
 711         return [('ignore', match_object.group('code'))]
 712 def do_preamble_end(match_object):
 713         return [('preamble-end', match_object.group('code'))]
 714
 715 def make_verbatim(match_object):
 716         return [('verbatim', match_object.group('code'))]
 717
 718 def make_verb(match_object):
 719         return [('verb', match_object.group('code'))]
 720
 721 def do_include_file(m):
 722         "m: MatchObject"
 723         return [('input', get_output ('pagebreak'))] \
 724              + read_doc_file(m.group('filename')) \
 725              + [('input', get_output ('pagebreak'))]
 726
 727 def do_input_file(m):
 728         return read_doc_file(m.group('filename'))
 729
 730 def make_lilypond(m):
 731         if m.group('options'):
 732                 options = m.group('options')
 733         else:
 734                 options = ''
 735         return [('input', get_output('output-lilypond-fragment') %
 736                         (options, m.group('code')))]
 737
 738 def make_lilypond_file(m):
 739         """
 740
 741         Find @lilypondfile{bla.ly} occurences and substitute bla.ly
 742         into a @lilypond .. @end lilypond block.
 743
 744         """
 745
 746         if m.group('options'):
 747                 options = m.group('options')
 748         else:
 749                 options = ''
 750         (content, nm) = find_file(m.group('filename'))
 751         options = "filename=%s," % nm + options
 752
 753         return [('input', get_output('output-lilypond') %
 754                         (options, content))]
 755
 756 def make_lilypond_block(m):
 757         if m.group('options'):
 758                 options = get_re('option-sep').split (m.group('options'))
 759         else:
 760             options = []
 761         options = filter(lambda s: s != '', options)
 762         return [('lilypond', m.group('code'), options)]
 763
 764 def do_columns(m):
 765         if __main__.format != 'latex':
 766                 return []
 767         if m.group('num') == 'one':
 768                 return [('numcols', m.group('code'), 1)]
 769         if m.group('num') == 'two':
 770                 return [('numcols', m.group('code'), 2)]
 771
 772 def chop_chunks(chunks, re_name, func, use_match=0):
 773     newchunks = []
 774     for c in chunks:
 775         if c[0] == 'input':
 776             str = c[1]
 777             while str:
 778                 m = get_re (re_name).search (str)
 779                 if m == None:
 780                     newchunks.append (('input', str))
 781                     str = ''
 782                 else:
 783                     if use_match:
 784                         newchunks.append (('input', str[:m.start ('match')]))
 785                     else:
 786                         newchunks.append (('input', str[:m.start (0)]))
 787                     #newchunks.extend(func(m))
 788                     # python 1.5 compatible:
 789                     newchunks = newchunks + func(m)
 790                     str = str [m.end(0):]
 791         else:
 792             newchunks.append(c)
 793     return newchunks
 794
 795 def determine_format (str):
 796         if __main__.format == '':
 797
 798                 latex =  re.search ('\\\\document', str[:200])
 799                 texinfo =  re.search ('@node|@setfilename', str[:200])
 800
 801                 f = ''
 802                 g = None
 803
 804                 if texinfo and latex == None:
 805                         f = 'texi'
 806                 elif latex and texinfo == None:
 807                         f = 'latex'
 808                 else:
 809                         error("error: can't determine format, please specify")
 810                 __main__.format = f
 811
 812         if __main__.paperguru == None:
 813                 if __main__.format == 'texi':
 814                         g = TexiPaper()
 815                 else:
 816                         g = LatexPaper()
 817
 818                 __main__.paperguru = g
 819
 820
 821 def read_doc_file (filename):
 822         """Read the input file, find verbatim chunks and do \input and \include
 823         """
 824         (str, path) = find_file(filename)
 825         determine_format (str)
 826
 827         chunks = [('input', str)]
 828
 829         # we have to check for verbatim before doing include,
 830         # because we don't want to include files that are mentioned
 831         # inside a verbatim environment
 832         chunks = chop_chunks(chunks, 'verbatim', make_verbatim)
 833         chunks = chop_chunks(chunks, 'verb', make_verb)
 834         chunks = chop_chunks(chunks, 'multiline-comment', do_ignore)
 835         #ugh fix input
 836         chunks = chop_chunks(chunks, 'include', do_include_file, 1)
 837         chunks = chop_chunks(chunks, 'input', do_input_file, 1)
 838         return chunks
 839
 840
 841 taken_file_names = {}
 842 def schedule_lilypond_block (chunk):
 843         """Take the body and options from CHUNK, figure out how the
 844         real .ly should look, and what should be left MAIN_STR (meant
 845         for the main file).  The .ly is written, and scheduled in
 846         TODO.
 847
 848         Return: a chunk (TYPE_STR, MAIN_STR, OPTIONS, TODO, BASE)
 849
 850         TODO has format [basename, extension, extension, ... ]
 851
 852         """
 853         (type, body, opts) = chunk
 854         assert type == 'lilypond'
 855         file_body = compose_full_body (body, opts)
 856         basename = 'lily-' + `abs(hash (file_body))`
 857         for o in opts:
 858                 m = re.search ('filename="(.*?)"', o)
 859                 if m:
 860                         basename = m.group (1)
 861                         if not taken_file_names.has_key(basename):
 862                             taken_file_names[basename] = 0
 863                         else:
 864                             taken_file_names[basename] = taken_file_names[basename] + 1
 865                             basename = basename + "-%i" % taken_file_names[basename]
 866         if not g_read_lys:
 867                 update_file(file_body, os.path.join(g_outdir, basename) + '.ly')
 868         needed_filetypes = ['tex']
 869
 870         if format  == 'texi':
 871                 needed_filetypes.append('eps')
 872                 needed_filetypes.append('png')
 873         if 'eps' in opts and not ('eps' in needed_filetypes):
 874                 needed_filetypes.append('eps')
 875         pathbase = os.path.join (g_outdir, basename)
 876         def f(base, ext1, ext2):
 877                 a = os.path.isfile(base + ext2)
 878                 if (os.path.isfile(base + ext1) and
 879                     os.path.isfile(base + ext2) and
 880                                 os.stat(base+ext1)[stat.ST_MTIME] >
 881                                 os.stat(base+ext2)[stat.ST_MTIME]) or \
 882                                 not os.path.isfile(base + ext2):
 883                         return 1
 884         todo = []
 885         if 'tex' in needed_filetypes and f(pathbase, '.ly', '.tex'):
 886                 todo.append('tex')
 887         if 'eps' in needed_filetypes and f(pathbase, '.tex', '.eps'):
 888                 todo.append('eps')
 889         if 'png' in needed_filetypes and f(pathbase, '.eps', '.png'):
 890                 todo.append('png')
 891         newbody = ''
 892
 893         if 'printfilename' in opts:
 894                 for o in opts:
 895                         m= re.match ("filename=(.*)", o)
 896                         if m:
 897                                 newbody = newbody + get_output ("output-filename") % m.group(1)
 898                                 break
 899
 900
 901         if 'verbatim' in opts:
 902                 newbody = output_verbatim (body)
 903
 904         for o in opts:
 905                 m = re.search ('intertext="(.*?)"', o)
 906                 if m:
 907                         newbody = newbody  + m.group (1) + "\n\n"
 908         if format == 'latex':
 909                 if 'eps' in opts:
 910                         s = 'output-eps'
 911                 else:
 912                         s = 'output-tex'
 913         else: # format == 'texi'
 914                 s = 'output-all'
 915         newbody = newbody + get_output (s) % {'fn': basename }
 916         return ('lilypond', newbody, opts, todo, basename)
 917
 918 def process_lilypond_blocks(outname, chunks):#ugh rename
 919         newchunks = []
 920         # Count sections/chapters.
 921         for c in chunks:
 922                 if c[0] == 'lilypond':
 923                         c = schedule_lilypond_block (c)
 924                 elif c[0] == 'numcols':
 925                         paperguru.m_num_cols = c[2]
 926                 newchunks.append (c)
 927         return newchunks
 928
 929
 930 def find_eps_dims (match):
 931         "Fill in dimensions of EPS files."
 932
 933         fn =match.group (1)
 934         dims = bounding_box_dimensions (fn)
 935         if g_outdir:
 936                 fn = os.path.join(g_outdir, fn)
 937
 938         return '%ipt' % dims[0]
 939
 940
 941 def system (cmd):
 942         sys.stderr.write ("invoking `%s'\n" % cmd)
 943         st = os.system (cmd)
 944         if st:
 945                 error ('Error command exited with value %d\n' % st)
 946         return st
 947
 948 def compile_all_files (chunks):
 949         global foutn
 950         eps = []
 951         tex = []
 952         png = []
 953
 954         for c in chunks:
 955                 if c[0] <> 'lilypond':
 956                         continue
 957                 base  = c[4]
 958                 exts = c[3]
 959                 for e in exts:
 960                         if e == 'eps':
 961                                 eps.append (base)
 962                         elif e == 'tex':
 963                                 #ugh
 964                                 if base + '.ly' not in tex:
 965                                         tex.append (base + '.ly')
 966                         elif e == 'png' and g_do_pictures:
 967                                 png.append (base)
 968         d = os.getcwd()
 969         if g_outdir:
 970                 os.chdir(g_outdir)
 971         if tex:
 972                 # fixme: be sys-independent.
 973                 def incl_opt (x):
 974                         if g_outdir and x[0] <> '/' :
 975                                 x = os.path.join (g_here_dir, x)
 976                         return ' -I %s' % x
 977
 978                 incs = map (incl_opt, include_path)
 979                 lilyopts = string.join (incs, ' ' )
 980                 if do_deps:
 981                         lilyopts = lilyopts + ' --dependencies '
 982                         if g_outdir:
 983                                 lilyopts = lilyopts + '--dep-prefix=' + g_outdir + '/'
 984                 texfiles = string.join (tex, ' ')
 985                 system ('lilypond --header=texidoc %s %s' % (lilyopts, texfiles))
 986
 987                 #
 988                 # Ugh, fixing up dependencies for .tex generation
 989                 #
 990                 if do_deps:
 991                         depfiles=map (lambda x: re.sub ('(.*)\.ly', '\\1.dep', x), tex)
 992                         for i in depfiles:
 993                                 f =open (i)
 994                                 text=f.read ()
 995                                 f.close ()
 996                                 text=re.sub ('\n([^:\n]*):', '\n' + foutn + ':', text)
 997                                 f = open (i, 'w')
 998                                 f.write (text)
 999                                 f.close ()
1000
1001         for e in eps:
1002                 system(r"tex '\nonstopmode \input %s'" % e)
1003                 system(r"dvips -E -o %s %s" % (e + '.eps', e))
1004         for g in png:
1005                 cmd = r"""gs -sDEVICE=pgm  -dTextAlphaBits=4 -dGraphicsAlphaBits=4  -q -sOutputFile=- -r90 -dNOPAUSE %s -c quit | pnmcrop | pnmtopng > %s"""
1006                 cmd = cmd % (g + '.eps', g + '.png')
1007                 try:
1008                         status = system (cmd)
1009                 except:
1010                         os.unlink (g + '.png')
1011                         error ("Removing output file")
1012
1013         os.chdir (d)
1014
1015
1016 def update_file (body, name):
1017         """
1018         write the body if it has changed
1019         """
1020         same = 0
1021         try:
1022                 f = open (name)
1023                 fs = f.read (-1)
1024                 same = (fs == body)
1025         except:
1026                 pass
1027
1028         if not same:
1029                 f = open (name , 'w')
1030                 f.write (body)
1031                 f.close ()
1032
1033         return not same
1034
1035
1036 def getopt_args (opts):
1037         "Construct arguments (LONG, SHORT) for getopt from  list of options."
1038         short = ''
1039         long = []
1040         for o in opts:
1041                 if o[1]:
1042                         short = short + o[1]
1043                         if o[0]:
1044                                 short = short + ':'
1045                 if o[2]:
1046                         l = o[2]
1047                         if o[0]:
1048                                 l = l + '='
1049                         long.append (l)
1050         return (short, long)
1051
1052 def option_help_str (o):
1053         "Transform one option description (4-tuple ) into neatly formatted string"
1054         sh = '  '
1055         if o[1]:
1056                 sh = '-%s' % o[1]
1057
1058         sep = ' '
1059         if o[1] and o[2]:
1060                 sep = ','
1061
1062         long = ''
1063         if o[2]:
1064                 long= '--%s' % o[2]
1065
1066         arg = ''
1067         if o[0]:
1068                 if o[2]:
1069                         arg = '='
1070                 arg = arg + o[0]
1071         return '  ' + sh + sep + long + arg
1072
1073
1074 def options_help_str (opts):
1075         "Convert a list of options into a neatly formatted string"
1076         w = 0
1077         strs =[]
1078         helps = []
1079
1080         for o in opts:
1081                 s = option_help_str (o)
1082                 strs.append ((s, o[3]))
1083                 if len (s) > w:
1084                         w = len (s)
1085
1086         str = ''
1087         for s in strs:
1088                 str = str + '%s%s%s\n' % (s[0], ' ' * (w - len(s[0])  + 3), s[1])
1089         return str
1090
1091 def help():
1092         sys.stdout.write("""Usage: lilypond-book [options] FILE\n
1093 Generate hybrid LaTeX input from Latex + lilypond
1094 Options:
1095 """)
1096         sys.stdout.write (options_help_str (option_definitions))
1097         sys.stdout.write (r"""Warning all output is written in the CURRENT directory
1098
1099
1100
1101 Report bugs to bug-gnu-music@gnu.org.
1102
1103 Written by Tom Cato Amundsen <tca@gnu.org> and
1104 Han-Wen Nienhuys <hanwen@cs.uu.nl>
1105 """)
1106
1107         sys.exit (0)
1108
1109
1110 def write_deps (fn, target, chunks):
1111         global read_files
1112         sys.stdout.write('Writing `%s\'\n' % os.path.join(g_outdir, fn))
1113         f = open (os.path.join(g_outdir, fn), 'w')
1114         f.write ('%s%s: ' % (g_dep_prefix, target))
1115         for d in read_files:
1116                 f.write ('%s ' %  d)
1117         basenames=[]
1118         for c in chunks:
1119                 if c[0] == 'lilypond':
1120                         (type, body, opts, todo, basename) = c;
1121                         basenames.append (basename)
1122         for d in basenames:
1123                 if g_outdir:
1124                         d=g_outdir + '/' + d
1125                 if g_dep_prefix:
1126                         #if not os.isfile (d): # thinko?
1127                         if not re.search ('/', d):
1128                                 d = g_dep_prefix + d
1129                 f.write ('%s.tex ' %  d)
1130         f.write ('\n')
1131         #if len (basenames):
1132         #       for d in basenames:
1133         #               f.write ('%s.ly ' %  d)
1134         #       f.write (' : %s' % target)
1135         f.write ('\n')
1136         f.close ()
1137         read_files = []
1138
1139 def identify():
1140         sys.stdout.write ('lilypond-book (GNU LilyPond) %s\n' % program_version)
1141
1142 def print_version ():
1143         identify()
1144         sys.stdout.write (r"""Copyright 1998--1999
1145 Distributed under terms of the GNU General Public License. It comes with
1146 NO WARRANTY.
1147 """)
1148
1149
1150 def check_texidoc (chunks):
1151         n = []
1152         for c in chunks:
1153                 if c[0] == 'lilypond':
1154                         (type, body, opts, todo, basename) = c;
1155                         pathbase = os.path.join (g_outdir, basename)
1156                         if os.path.isfile (pathbase + '.texidoc'):
1157                                 body = '\n@include %s.texidoc\n' % basename + body
1158                                 c = (type, body, opts, todo, basename)
1159                 n.append (c)
1160         return n
1161
1162 def fix_epswidth (chunks):
1163         newchunks = []
1164         for c in chunks:
1165                 if c[0] == 'lilypond' and 'eps' in c[2]:
1166                         body = re.sub (r"""\\lilypondepswidth{(.*?)}""", find_eps_dims, c[1])
1167                         newchunks.append(('lilypond', body, c[2], c[3], c[4]))
1168                 else:
1169                         newchunks.append (c)
1170         return newchunks
1171
1172
1173 foutn=""
1174 def do_file(input_filename):
1175         global foutn
1176         file_settings = {}
1177         if outname:
1178                 my_outname = outname
1179         else:
1180                 my_outname = os.path.basename(os.path.splitext(input_filename)[0])
1181         my_depname = my_outname + '.dep'
1182
1183         chunks = read_doc_file(input_filename)
1184         chunks = chop_chunks(chunks, 'lilypond', make_lilypond, 1)
1185         chunks = chop_chunks(chunks, 'lilypond-file', make_lilypond_file, 1)
1186         chunks = chop_chunks(chunks, 'lilypond-block', make_lilypond_block, 1)
1187         chunks = chop_chunks(chunks, 'singleline-comment', do_ignore, 1)
1188         chunks = chop_chunks(chunks, 'preamble-end', do_preamble_end)
1189         chunks = chop_chunks(chunks, 'numcols', do_columns)
1190         #print "-" * 50
1191         #for c in chunks: print "c:", c;
1192         #sys.exit()
1193         scan_preamble(chunks)
1194         chunks = process_lilypond_blocks(my_outname, chunks)
1195
1196         foutn = os.path.join (g_outdir, my_outname + '.' + format)
1197
1198         # Do It.
1199         if __main__.g_run_lilypond:
1200                 compile_all_files (chunks)
1201                 chunks = fix_epswidth (chunks)
1202
1203         if __main__.format == 'texi':
1204                 chunks = check_texidoc (chunks)
1205
1206         x = 0
1207         chunks = completize_preamble (chunks)
1208         sys.stderr.write ("Writing `%s'\n" % foutn)
1209         fout = open (foutn, 'w')
1210         for c in chunks:
1211                 fout.write (c[1])
1212         fout.close ()
1213         # should chmod -w
1214
1215         if do_deps:
1216                 write_deps (my_depname, foutn, chunks)
1217
1218
1219 outname = ''
1220 try:
1221         (sh, long) = getopt_args (__main__.option_definitions)
1222         (options, files) = getopt.getopt(sys.argv[1:], sh, long)
1223 except getopt.error, msg:
1224         sys.stderr.write("error: %s" % msg)
1225         sys.exit(1)
1226
1227 do_deps = 0
1228 for opt in options:
1229         o = opt[0]
1230         a = opt[1]
1231
1232         if o == '--include' or o == '-I':
1233                 include_path.append (a)
1234         elif o == '--version' or o == '-v':
1235                 print_version ()
1236                 sys.exit  (0)
1237         elif o == '--format' or o == '-f':
1238                 __main__.format = a
1239         elif o == '--outname' or o == '-o':
1240                 if len(files) > 1:
1241                         #HACK
1242                         sys.stderr.write("Lilypond-book is confused by --outname on multiple files")
1243                         sys.exit(1)
1244                 outname = a
1245         elif o == '--help' or o == '-h':
1246                 help ()
1247         elif o == '--no-lily' or o == '-n':
1248                 __main__.g_run_lilypond = 0
1249         elif o == '--dependencies' or o == '-M':
1250                 do_deps = 1
1251         elif o == '--default-music-fontsize':
1252                 default_music_fontsize = string.atoi (a)
1253         elif o == '--default-lilypond-fontsize':
1254                 print "--default-lilypond-fontsize is deprecated, use --default-music-fontsize"
1255                 default_music_fontsize = string.atoi (a)
1256         elif o == '--force-music-fontsize':
1257                 g_force_lilypond_fontsize = string.atoi(a)
1258         elif o == '--force-lilypond-fontsize':
1259                 print "--force-lilypond-fontsize is deprecated, use --default-lilypond-fontsize"
1260                 g_force_lilypond_fontsize = string.atoi(a)
1261         elif o == '--dep-prefix':
1262                 g_dep_prefix = a
1263         elif o == '--no-pictures':
1264                 g_do_pictures = 0
1265         elif o == '--read-lys':
1266                 g_read_lys = 1
1267         elif o == '--outdir':
1268                 g_outdir = a
1269
1270 identify()
1271 if g_outdir:
1272         if os.path.isfile(g_outdir):
1273                 error ("outdir is a file: %s" % g_outdir)
1274         if not os.path.exists(g_outdir):
1275                 os.mkdir(g_outdir)
1276 setup_environment ()
1277 for input_filename in files:
1278         do_file(input_filename)
1279
1280 #
1281 # Petr, ik zou willen dat ik iets zinvoller deed,
1282 # maar wat ik kan ik doen, het verandert toch niets?
1283 #   --hwn 20/aug/99