scripts/ly2dvi.py

   1 #!@PYTHON@
   2 # Run lilypond, latex, dvips.
   3 #
   4 # This is the third incarnation of ly2dvi.
   5 #
   6 # Earlier incarnations of ly2dvi were written by
   7 # Jeffrey B. Reed<daboys@austin.rr.com> (Python version)
   8 # Jan Arne Fagertun <Jan.A.Fagertun@@energy.sintef.no> (Bourne shell script)
   9 #
  10
  11
  12 # Note: gettext work best if we use ' for docstrings and "
  13 # for gettextable strings
  14
  15 '''
  16 TODO:
  17
  18   * figure out which set of command line options should make ly2dvi:
  19
  20       na: create tex only?
  21       na: create latex only?
  22       na: create tex and latex
  23       default: create dvi only
  24       na: create tex, latex and dvi
  25       -P: create dvi and ps
  26       na: * create ps only
  27
  28      etc.
  29
  30      for foo.ly, rename ly2dvi.dir to out-ly2dvi, foo.ly2dvi, foo.dir ?
  31
  32   * move versatile taglines,
  33
  34      \header {
  35         beginfooter=\mutopiaPD
  36         endfooter=\tagline  -> 'lily was here <version>'
  37      }
  38
  39      lilytagline (->lily was here), usertagline, copyright etc.
  40
  41   * head/header tagline/endfooter
  42
  43   * dvi from lilypond .tex output?  This is hairy, because we create dvi
  44     from lilypond .tex *and* header output.
  45
  46   * multiple \score blocks?
  47
  48   * windows-sans-cygwin compatibility?  rm -rf, cp file... dir
  49
  50 '''
  51
  52
  53 import os
  54 import stat
  55 import string
  56 import re
  57 import getopt
  58 import sys
  59 import __main__
  60 import operator
  61 import tempfile
  62
  63 datadir = '@datadir@'
  64 sys.path.append (datadir + '/python')
  65 try:
  66         import gettext
  67         gettext.bindtextdomain ('lilypond', '@localedir@')
  68         gettext.textdomain('lilypond')
  69         _ = gettext.gettext
  70 except:
  71         def _ (s):
  72                 return s
  73
  74
  75 layout_fields = ['title', 'subtitle', 'subsubtitle', 'footer', 'head',
  76           'composer', 'arranger', 'instrument', 'opus', 'piece', 'metre',
  77           'meter', 'poet']
  78
  79
  80 # init to empty; values here take precedence over values in the file
  81 extra_init = {
  82         'language' : [],
  83         'latexheaders' : [],
  84         'latexpackages' :  ['geometry'],
  85         'papersize' : [],
  86         'pagenumber' : [1],
  87         'textheight' : [],
  88         'linewidth' : [],
  89         'orientation' : []
  90 }
  91
  92 extra_fields = extra_init.keys ()
  93
  94 fields = layout_fields + extra_fields
  95 program_name = 'ly2dvi'
  96 help_summary = _ ("Generate .dvi with LaTeX for LilyPond")
  97
  98 include_path = ['.']
  99 lily_p = 1
 100 paper_p = 1
 101
 102 output = 0
 103 targets = {
 104         'DVI' : 0,
 105         'LATEX' : 0,
 106         'MIDI' : 0,
 107         'TEX' : 0,
 108         }
 109
 110 track_dependencies_p = 0
 111 dependency_files = []
 112
 113 # be verbose?
 114 verbose_p = 0
 115
 116
 117 # lily_py.py -- options and stuff
 118 #
 119 # source file of the GNU LilyPond music typesetter
 120
 121 # BEGIN Library for these?
 122 # cut-n-paste from ly2dvi
 123
 124 program_version = '@TOPLEVEL_VERSION@'
 125 if program_version == '@' + 'TOPLEVEL_VERSION' + '@':
 126         program_version = '1.3.142'
 127
 128
 129 original_dir = os.getcwd ()
 130 temp_dir = '%s.dir' % program_name
 131 keep_temp_dir_p = 0
 132 verbose_p = 0
 133
 134 #
 135 # Try to cater for bad installations of LilyPond, that have
 136 # broken TeX setup.  Just hope this doesn't hurt good TeX
 137 # setups.  Maybe we should check if kpsewhich can find
 138 # feta16.{afm,mf,tex,tfm}, and only set env upon failure.
 139 #
 140 environment = {
 141         'MFINPUTS' : datadir + '/mf:',
 142         'TEXINPUTS': datadir + '/tex:' + datadir + '/ps:.:',
 143         'TFMFONTS' : datadir + '/tfm:',
 144         'GS_FONTPATH' : datadir + '/afm:' + datadir + '/pfa',
 145         'GS_LIB' : datadir + '/ps',
 146 }
 147
 148 def setup_environment ():
 149         for key in environment.keys ():
 150                 val = environment[key]
 151                 if os.environ.has_key (key):
 152                         val = val + os.pathsep + os.environ[key]
 153                 os.environ[key] = val
 154
 155 def identify ():
 156         sys.stdout.write ('%s (GNU LilyPond) %s\n' % (program_name, program_version))
 157
 158 def warranty ():
 159         identify ()
 160         sys.stdout.write ('\n')
 161         sys.stdout.write (_ ('Copyright (c) %s by' % ' 2001'))
 162         sys.stdout.write ('\n')
 163         sys.stdout.write ('  Han-Wen Nienhuys')
 164         sys.stdout.write ('  Jan Nieuwenhuizen')
 165         sys.stdout.write ('\n')
 166         sys.stdout.write (_ (r'''
 167 Distributed under terms of the GNU General Public License. It comes with
 168 NO WARRANTY.'''))
 169         sys.stdout.write ('\n')
 170
 171 def progress (s):
 172         sys.stderr.write (s + '\n')
 173
 174 def warning (s):
 175         sys.stderr.write (_ ("warning: ") + s)
 176         sys.stderr.write ('\n')
 177
 178
 179 def error (s):
 180         sys.stderr.write (_ ("error: ") + s)
 181         sys.stderr.write ('\n')
 182         raise _ ("Exiting ... ")
 183
 184 def getopt_args (opts):
 185         '''Construct arguments (LONG, SHORT) for getopt from  list of options.'''
 186         short = ''
 187         long = []
 188         for o in opts:
 189                 if o[1]:
 190                         short = short + o[1]
 191                         if o[0]:
 192                                 short = short + ':'
 193                 if o[2]:
 194                         l = o[2]
 195                         if o[0]:
 196                                 l = l + '='
 197                         long.append (l)
 198         return (short, long)
 199
 200 def option_help_str (o):
 201         '''Transform one option description (4-tuple ) into neatly formatted string'''
 202         sh = '  '
 203         if o[1]:
 204                 sh = '-%s' % o[1]
 205
 206         sep = ' '
 207         if o[1] and o[2]:
 208                 sep = ','
 209
 210         long = ''
 211         if o[2]:
 212                 long= '--%s' % o[2]
 213
 214         arg = ''
 215         if o[0]:
 216                 if o[2]:
 217                         arg = '='
 218                 arg = arg + o[0]
 219         return '  ' + sh + sep + long + arg
 220
 221
 222 def options_help_str (opts):
 223         '''Convert a list of options into a neatly formatted string'''
 224         w = 0
 225         strs =[]
 226         helps = []
 227
 228         for o in opts:
 229                 s = option_help_str (o)
 230                 strs.append ((s, o[3]))
 231                 if len (s) > w:
 232                         w = len (s)
 233
 234         str = ''
 235         for s in strs:
 236                 str = str + '%s%s%s\n' % (s[0], ' ' * (w - len(s[0])  + 3), s[1])
 237         return str
 238
 239 def help ():
 240         sys.stdout.write (_ ("Usage: %s [OPTION]... FILE") % program_name)
 241         sys.stdout.write ('\n\n')
 242         sys.stdout.write (help_summary)
 243         sys.stdout.write ('\n\n')
 244         sys.stdout.write (_ ("Options:"))
 245         sys.stdout.write ('\n')
 246         sys.stdout.write (options_help_str (option_definitions))
 247         sys.stdout.write ('\n\n')
 248         sys.stdout.write (_ ("Report bugs to %s") % 'bug-gnu-music@gnu.org')
 249         sys.stdout.write ('\n')
 250
 251 def setup_temp ():
 252         global temp_dir
 253         if not keep_temp_dir_p:
 254                 temp_dir = tempfile.mktemp (program_name)
 255         try:
 256                 os.mkdir (temp_dir, 0777)
 257         except OSError:
 258                 pass
 259         os.chdir (temp_dir)
 260
 261
 262 def system (cmd, ignore_error = 0):
 263         if verbose_p:
 264                 progress (_ ("Invoking `%s\'") % cmd)
 265         st = os.system (cmd) >> 8
 266         if st:
 267                 name = re.match ('[ \t]*([^ \t]*)', cmd).group (1)
 268                 msg = name + ': ' + _ ("command exited with value %d") % st
 269                 if ignore_error:
 270                         warning (msg + ' ' + _ ("(ignored)") + ' ')
 271                 else:
 272                         error (msg)
 273
 274         return st
 275
 276
 277 def cleanup_temp ():
 278         if not keep_temp_dir_p:
 279                 if verbose_p:
 280                         progress (_ ("Cleaning %s...") % temp_dir)
 281                 system ('rm -rf %s' % temp_dir)
 282
 283
 284 def set_setting (dict, key, val):
 285         try:
 286                 val = string.atof (val)
 287         except ValueError:
 288                 #warning (_ ("invalid value: %s") % `val`)
 289                 pass
 290
 291         try:
 292                 dict[key].append (val)
 293         except KeyError:
 294                 warning (_ ("no such setting: %s") % `key`)
 295                 dict[key] = [val]
 296
 297 def strip_extension (f, ext):
 298         (p, e) = os.path.splitext (f)
 299         if e == ext:
 300                 e = ''
 301         return p + e
 302
 303 # END Library
 304
 305 option_definitions = [
 306         ('', 'd', 'dependencies', _ ("write Makefile dependencies for every input file")),
 307         ('', 'h', 'help', _ ("this help")),
 308         (_ ("DIR"), 'I', 'include', _ ("add DIR to LilyPond's search path")),
 309         ('', 'k', 'keep', _ ("keep all output, and name the directory %s.dir") % program_name),
 310         ('', '', 'no-lily', _ ("don't run LilyPond")),
 311         ('', 'm', 'no-paper', _ ("produce MIDI output only")),
 312         (_ ("FILE"), 'o', 'output', _ ("write ouput to FILE")),
 313         # why capital P?
 314         ('', 'P', 'postscript', _ ("generate PostScript output")),
 315         (_ ("KEY=VAL"), 's', 'set', _ ("change global setting KEY to VAL")),
 316         ('', 'V', 'verbose', _ ("verbose")),
 317         ('', 'v', 'version', _ ("print version number")),
 318         ('', 'w', 'warranty', _ ("show warranty and copyright")),
 319         ]
 320
 321 def run_lilypond (files, outbase, dep_prefix):
 322         opts = '--output=%s.tex' % outbase
 323         opts = opts + ' ' + string.join (map (lambda x : '-I ' + x, include_path))
 324         if paper_p:
 325                 opts = opts + ' ' + string.join (map (lambda x : '-H ' + x, fields))
 326         else:
 327                 opts = opts + ' --no-paper'
 328
 329         if track_dependencies_p:
 330                 opts = opts + " --dependencies"
 331                 if dep_prefix:
 332                         opts = opts + ' --dep-prefix=%s' % dep_prefix
 333
 334         fs = string.join (files)
 335
 336         if not verbose_p:
 337                 progress ( _("Running %s...") % 'LilyPond')
 338                 # cmd = cmd + ' 1> /dev/null 2> /dev/null'
 339         else:
 340                 opts = opts + ' --verbose'
 341
 342         system ('lilypond %s %s ' % (opts, fs))
 343
 344 def analyse_lilypond_output (filename, extra):
 345
 346         # urg
 347         '''Grep FILENAME for interesting stuff, and
 348         put relevant info into EXTRA.'''
 349         filename = filename+'.tex'
 350         progress (_ ("Analyzing %s...") % filename)
 351         s = open (filename).read ()
 352
 353         # search only the first 10k
 354         s = s[:10240]
 355         for x in ('textheight', 'linewidth', 'papersize', 'orientation'):
 356                 m = re.search (r'\\def\\lilypondpaper%s{([^}]*)}'%x, s)
 357                 if m:
 358                         set_setting (extra, x, m.group (1))
 359
 360 def find_tex_files_for_base (base, extra):
 361         headerfiles = {}
 362         for f in layout_fields:
 363                 if os.path.exists (base + '.' + f):
 364                         headerfiles[f] = base+'.'+f
 365
 366         if os.path.exists (base  +'.dep'):
 367                 dependency_files.append (base + '.dep')
 368
 369         for f in extra_fields:
 370                 if os.path.exists (base + '.' + f):
 371                         extra[f].append (open (base + '.' + f).read ())
 372
 373         return (base  +'.tex',headerfiles)
 374
 375
 376 def find_tex_files (files, extra):
 377         tfiles = []
 378
 379         for f in files:
 380                 x = 0
 381                 while 1:
 382                         fname = os.path.basename (f)
 383                         fname = strip_extension (fname, '.ly')
 384                         if x:
 385                                 fname = fname + '-%d' % x
 386
 387                         if os.path.exists (fname + '.tex'):
 388                                 tfiles.append (find_tex_files_for_base (fname, extra))
 389                                 analyse_lilypond_output (fname, extra)
 390                         else:
 391                                 break
 392
 393                         x = x + 1
 394         if not x:
 395                 warning (_ ("no lilypond output found for %s") % `files`)
 396         return tfiles
 397
 398 def one_latex_definition (defn, first):
 399         s = '\n'
 400         for (k,v) in defn[1].items ():
 401                 val = open (v).read ()
 402                 if (string.strip (val)):
 403                         s = s + r'''\def\lilypond%s{%s}''' % (k, val)
 404                 else:
 405                         s = s + r'''\let\lilypond%s\relax''' % k
 406                 s = s + '\n'
 407
 408         if first:
 409                 s = s + '\\def\\mustmakelilypondtitle{}\n'
 410         else:
 411                 s = s + '\\def\\mustmakelilypondpiecetitle{}\n'
 412
 413         s = s + '\\input %s' % defn[0]
 414         return s
 415
 416
 417 ly_paper_to_latexpaper =  {
 418         'a4' : 'a4paper',
 419         'letter' : 'letterpaper',
 420 }
 421
 422 def global_latex_definition (tfiles, extra):
 423         '''construct preamble from EXTRA,
 424         dump lily output files after that, and return result.
 425         '''
 426
 427
 428         s = ""
 429         s = s + '% generation tag\n'
 430
 431         paper = ''
 432
 433         if extra['papersize']:
 434                 try:
 435                         paper = '[%s]' % ly_paper_to_latexpaper[extra['papersize'][0]]
 436                 except:
 437                         warning (_ ("invalid value: %s") % `extra['papersize'][0]`)
 438                         pass
 439
 440         s = s + '\\documentclass%s{article}\n' % paper
 441
 442         if extra['language']:
 443                 s = s + r'\usepackage[%s]{babel}\n' % extra['language'][-1]
 444
 445
 446         s = s + '\\usepackage{%s}\n' \
 447                 % string.join (extra['latexpackages'], ',')
 448
 449         if extra['latexheaders']:
 450                 s = s + '\\include{%s}\n' \
 451                         % string.join (extra['latexheaders'], '}\n\\include{')
 452
 453         textheight = ''
 454         if extra['textheight']:
 455                 textheight = ',textheight=%fpt' % extra['textheight'][0]
 456
 457         orientation = 'portrait'
 458         if extra['orientation']:
 459                 orientation = extra['orientation'][0]
 460
 461         # set sane geometry width (a4-width) for linewidth = -1.
 462         if not extra['linewidth'] or extra['linewidth'][0] < 0:
 463                 linewidth = 597
 464         else:
 465                 linewidth = extra['linewidth'][0]
 466         s = s + '\geometry{width=%spt%s,headheight=2mm,headsep=0pt,footskip=2mm,%s}\n' % (linewidth, textheight, orientation)
 467
 468         s = s + r'''
 469 \usepackage[latin1]{inputenc}
 470 \input{titledefs}
 471 \makeatletter
 472 \renewcommand{\@oddfoot}{\parbox{\textwidth}{\mbox{}\thefooter}}%
 473 '''
 474
 475         if extra['pagenumber'] and extra['pagenumber'][-1] and extra['pagenumber'][-1] != 'no':
 476                 s = s + r'''
 477 \renewcommand{\@oddhead}{\parbox{\textwidth}%
 478     {\mbox{}\small\theheader\hfill\textbf{\thepage}}}
 479 '''
 480         else:
 481                 s = s + '\\pagestyle{empty}\n'
 482
 483         s = s + '\\makeatother\n'
 484         s = s + '\\begin{document}\n'
 485
 486
 487         first = 1
 488         for t in tfiles:
 489                 s = s + one_latex_definition (t, first)
 490                 first = 0
 491
 492         s = s + r'''
 493 \makeatletter
 494 \renewcommand{\@oddfoot}{\parbox{\textwidth}{\mbox{}\makelilypondtagline}}%
 495 \makeatother
 496 '''
 497         s = s + '\\end{document}'
 498
 499         return s
 500
 501 def run_latex (files, outbase, extra):
 502         wfs = find_tex_files ([outbase] + files[1:], extra)
 503         s = global_latex_definition (wfs, extra)
 504
 505         f = open (outbase + '.latex', 'w')
 506         f.write (s)
 507         f.close ()
 508
 509         cmd = 'latex \\\\nonstopmode \\\\input %s' % outbase + '.latex'
 510         if not verbose_p:
 511                 progress ( _("Running %s...") % 'LaTeX')
 512                 cmd = cmd + ' 1> /dev/null 2> /dev/null'
 513
 514         system (cmd)
 515
 516 def run_dvips (outbase, extra):
 517
 518         opts = ''
 519         if extra['papersize']:
 520                 opts = opts + ' -t %s' % extra['papersize'][0]
 521
 522         if extra['orientation'] and extra['orientation'][0] == 'landscape':
 523                 opts = opts + ' -t landscape'
 524
 525         cmd = 'dvips %s -o %s %s' % (opts, outbase + '.ps', outbase + '.dvi')
 526
 527         if not verbose_p:
 528                 progress ( _("Running %s...") % 'dvips')
 529                 cmd = cmd + ' 2> /dev/null'
 530
 531         system (cmd)
 532
 533 def generate_dependency_file (depfile, outname):
 534         df = open (depfile, 'w')
 535         df.write (outname + ':' )
 536
 537         for d in dependency_files:
 538                 s = open (d).read ()
 539                 s = re.sub ('#[^\n]*\n', '', s)
 540                 s = re.sub (r'\\\n', ' ', s)
 541                 m = re.search ('.*:(.*)\n', s)
 542
 543                 # ugh. Different targets?
 544                 if m:
 545                         df.write ( m.group (1)  + ' ' )
 546
 547         df.write ('\n')
 548         df.close ();
 549
 550 (sh, long) = getopt_args (__main__.option_definitions)
 551 try:
 552         (options, files) = getopt.getopt(sys.argv[1:], sh, long)
 553 except:
 554         help ()
 555         sys.exit (2)
 556
 557 for opt in options:
 558         o = opt[0]
 559         a = opt[1]
 560
 561         if 0:
 562                 pass
 563         elif o == '--help' or o == '-h':
 564                 help ()
 565                 sys.exit (0)
 566         elif o == '--include' or o == '-I':
 567                 include_path.append (a)
 568         elif o == '--postscript' or o == '-P':
 569                 targets['PS'] = 0
 570         elif o == '--keep' or o == '-k':
 571                 keep_temp_dir_p = 1
 572         elif o == '--no-lily':
 573                 lily_p = 0
 574         elif o == '--no-paper' or o == '-m':
 575                 targets = {}
 576                 targets['MIDI'] = 0
 577                 paper_p = 0
 578         elif o == '--output' or o == '-o':
 579                 output = a
 580         elif o == '--set' or o == '-s':
 581                 ss = string.split (a, '=')
 582                 set_setting (extra_init, ss[0], ss[1])
 583         elif o == '--dependencies' or o == '-d':
 584                 track_dependencies_p = 1
 585         elif o == '--verbose' or o == '-V':
 586                 verbose_p = 1
 587         elif o == '--version' or o == '-v':
 588                 identify ()
 589                 sys.exit (0)
 590         elif o == '--warranty' or o == '-w':
 591                 try:
 592                         system ('lilypond -w')
 593                 except:
 594                         warranty ()
 595                 sys.exit (0)
 596
 597 # On most platforms, this is equivalent to
 598 #`normpath(join(os.getcwd()), PATH)'.  *Added in Python version 1.5.2*
 599 def compat_abspath (path):
 600         return os.path.normpath (os.path.join (os.getcwd (), path))
 601
 602 include_path = map (compat_abspath, include_path)
 603
 604 original_output = output
 605
 606 if files and files[0] != '-':
 607
 608         files = map (lambda x: strip_extension (x, '.ly'), files)
 609
 610         if not output:
 611                 output = os.path.basename (files[0])
 612
 613         for i in ('.dvi', '.latex', '.ly', '.ps', '.tex'):
 614                 output = strip_extension (output, i)
 615
 616         files = map (compat_abspath, files)
 617
 618         if os.path.dirname (output) != '.':
 619                 dep_prefix = os.path.dirname (output)
 620         else:
 621                 dep_prefix = 0
 622
 623         reldir = os.path.dirname (output)
 624         (outdir, outbase) = os.path.split (compat_abspath (output))
 625
 626         setup_environment ()
 627         setup_temp ()
 628
 629         extra = extra_init
 630
 631         if lily_p:
 632                 try:
 633                         run_lilypond (files, outbase, dep_prefix)
 634                 except:
 635                         # TODO: friendly message about LilyPond setup/failing?
 636                         #
 637                         # TODO: lilypond should fail with different
 638                         # error codes for:
 639                         #   - guile setup/startup failure
 640                         #   - font setup failure
 641                         #   - init.ly setup failure
 642                         #   - parse error in .ly
 643                         #   - unexpected: assert/core dump
 644                         targets = {}
 645
 646         if targets.has_key ('DVI') or targets.has_key ('PS'):
 647                 try:
 648                         run_latex (files, outbase, extra)
 649                         # unless: add --tex, or --latex?
 650                         del targets['TEX']
 651                         del targets['LATEX']
 652                 except:
 653                         # TODO: friendly message about TeX/LaTeX setup,
 654                         # trying to run tex/latex by hand
 655                         if targets.has_key ('DVI'):
 656                                 del targets['DVI']
 657                         if targets.has_key ('PS'):
 658                                 del targets['PS']
 659
 660         # TODO: does dvips ever fail?
 661         if targets.has_key ('PS'):
 662                 run_dvips (outbase, extra)
 663
 664         if outdir != '.' and (track_dependencies_p or targets.keys ()):
 665                 system ('mkdir -p %s' % outdir)
 666
 667         # add DEP to targets?
 668         if track_dependencies_p:
 669                 depfile = os.path.join (outdir, outbase + '.dep')
 670                 generate_dependency_file (depfile, depfile)
 671                 if os.path.isfile (depfile):
 672                         progress (_ ("dependencies output to %s...") % depfile)
 673
 674         for i in targets.keys ():
 675                 ext = string.lower (i)
 676                 if re.match ('.*[.]%s' % ext, string.join (os.listdir ('.'))):
 677                         system ('cp *.%s %s' % (ext, outdir))
 678                 outname = outbase + '.' + string.lower (i)
 679                 abs = os.path.join (outdir, outname)
 680                 if reldir != '.':
 681                         outname = os.path.join (reldir, outname)
 682                 if os.path.isfile (abs):
 683                         progress (_ ("%s output to %s...") % (i, outname))
 684                 elif verbose_p:
 685                         warning (_ ("can't find file: `%s'") % outname)
 686
 687         os.chdir (original_dir)
 688         cleanup_temp ()
 689
 690 else:
 691         # FIXME
 692         help ()
 693         sys.stderr.write ('\n')
 694         try:
 695                 error (_ ("no FILEs specified, can't invoke as filter"))
 696         except:
 697                 pass
 698         sys.exit (2)
 699
 700
 701