scripts/lilypond-book.py

   1 #!@PYTHON@
   2
   3 '''
   4 Example usage:
   5
   6 test:
   7      lilypond-book --filter="tr '[a-z]' '[A-Z]'" BOOK
   8
   9 convert-ly on book:
  10      lilypond-book --filter="convert-ly --no-version --from=1.6.11 -" BOOK
  11
  12 classic lilypond-book:
  13      lilypond-book --process="lilypond" BOOK.tely
  14
  15 TODO:
  16
  17     *  this script is too complex. Modularize.
  18
  19     *  ly-options: intertext?
  20     *  --linewidth?
  21     *  eps in latex / eps by lilypond -b ps?
  22     *  check latex parameters, twocolumn, multicolumn?
  23     *  use --png --ps --pdf for making images?
  24
  25     *  Converting from lilypond-book source, substitute:
  26        @mbinclude foo.itely -> @include foo.itely
  27        \mbinput -> \input
  28
  29 '''
  30
  31 import __main__
  32 import glob
  33 import stat
  34 import string
  35 import tempfile
  36 import commands
  37
  38 # Users of python modules should include this snippet
  39 # and customize variables below.
  40
  41 # We'll suffer this path initialization stuff as long as we don't install
  42 # our python packages in <prefix>/lib/pythonX.Y
  43
  44 # If set, LILYPONDPREFIX must take prevalence.
  45 # if datadir is not set, we're doing a build and LILYPONDPREFIX.
  46 import getopt, os, sys
  47 datadir = '@local_lilypond_datadir@'
  48 if not os.path.isdir (datadir):
  49         datadir = '@lilypond_datadir@'
  50 if os.environ.has_key ('LILYPONDPREFIX'):
  51         datadir = os.environ['LILYPONDPREFIX']
  52         while datadir[-1] == os.sep:
  53                 datadir= datadir[:-1]
  54
  55         datadir = os.path.join (datadir, "share/lilypond/current/")
  56
  57 sys.path.insert (0, os.path.join (datadir, 'python'))
  58
  59 # Customize these.
  60 #if __name__ == '__main__':
  61
  62 import lilylib as ly
  63 import fontextract
  64 global _;_=ly._
  65 global re;re = ly.re
  66
  67 # Lilylib globals.
  68 program_version = '@TOPLEVEL_VERSION@'
  69 program_name = os.path.basename (sys.argv[0])
  70 verbose_p = 0
  71 pseudo_filter_p = 0
  72 original_dir = os.getcwd ()
  73 backend = 'ps'
  74
  75 help_summary = _ (
  76 '''Process LilyPond snippets in hybrid HTML, LaTeX, or texinfo document.
  77 Example usage:
  78
  79    lilypond-book --filter="tr '[a-z]' '[A-Z]'" BOOK
  80    lilypond-book --filter="convert-ly --no-version --from=2.0.0 -" BOOK
  81    lilypond-book --process='lilypond -I include' BOOK
  82 ''')
  83
  84 copyright = ('Jan Nieuwenhuizen <janneke@gnu.org>',
  85              'Han-Wen Nienhuys <hanwen@cs.uu.nl>')
  86
  87 option_definitions = [
  88         (_ ("FMT"), 'f', 'format',
  89           _ ('''use output format FMT (texi [default], texi-html,
  90                 latex, html)''')),
  91         (_ ("FILTER"), 'F', 'filter',
  92           _ ("pipe snippets through FILTER [convert-ly -n -]")),
  93         ('', 'h', 'help',
  94           _ ("print this help")),
  95         (_ ("DIR"), 'I', 'include',
  96           _ ("add DIR to include path")),
  97         (_ ("DIR"), 'o', 'output',
  98           _ ("write output to DIR")),
  99         (_ ("COMMAND"), 'P', 'process',
 100           _ ("process ly_files using COMMAND FILE...")),
 101         ('', '', 'psfonts',
 102          _ ('''extract all PostScript fonts into INPUT.psfonts for LaTeX
 103          must use this with dvips -h INPUT.psfonts''')),
 104         ('', 'V', 'verbose',
 105           _ ("be verbose")),
 106         ('', 'v', 'version',
 107           _ ("print version information")),
 108         ('', 'w', 'warranty',
 109           _ ("show warranty and copyright")),
 110 ]
 111
 112 include_path = [os.path.abspath (os.getcwd ())]
 113 lilypond_binary = os.path.join ('@bindir@', 'lilypond')
 114
 115 # Only use installed binary when we are installed too.
 116 if '@bindir@' == ('@' + 'bindir@') or not os.path.exists (lilypond_binary):
 117         lilypond_binary = 'lilypond'
 118
 119 psfonts_p = 0
 120 use_hash_p = 1
 121 format = 0
 122 output_name = ''
 123 filter_cmd = 0
 124 process_cmd = ''
 125 default_ly_options = { 'alt': "[image of music]" }
 126
 127 #
 128 # Is this pythonic?  Personally, I find this rather #define-nesque. --hwn
 129 #
 130 AFTER = 'after'
 131 BEFORE = 'before'
 132 EXAMPLEINDENT = 'exampleindent'
 133 FILTER = 'filter'
 134 FRAGMENT = 'fragment'
 135 HTML = 'html'
 136 INDENT = 'indent'
 137 LATEX = 'latex'
 138 LAYOUT = 'layout'
 139 LINEWIDTH = 'linewidth'
 140 NOFRAGMENT = 'nofragment'
 141 NOINDENT = 'noindent'
 142 NOQUOTE = 'noquote'
 143 NOTES = 'body'
 144 NOTIME = 'notime'
 145 OUTPUT = 'output'
 146 OUTPUTIMAGE = 'outputimage'
 147 PACKED = 'packed'
 148 PAPER = 'paper'
 149 PREAMBLE = 'preamble'
 150 PRINTFILENAME = 'printfilename'
 151 QUOTE = 'quote'
 152 RAGGEDRIGHT = 'raggedright'
 153 RELATIVE = 'relative'
 154 STAFFSIZE = 'staffsize'
 155 TEXIDOC = 'texidoc'
 156 TEXINFO = 'texinfo'
 157 VERBATIM = 'verbatim'
 158 FONTLOAD = 'fontload'
 159 FILENAME = 'filename'
 160 ALT = 'alt'
 161
 162
 163 # NOTIME has no opposite so it isn't part of this dictionary.
 164 # NOQUOTE is used internally only.
 165 no_options = {
 166         NOFRAGMENT: FRAGMENT,
 167         NOINDENT: INDENT,
 168 }
 169
 170
 171 # Recognize special sequences in the input.
 172 #
 173 #   (?P<name>regex) -- Assign result of REGEX to NAME.
 174 #   *? -- Match non-greedily.
 175 #   (?m) -- Multiline regex: Make ^ and $ match at each line.
 176 #   (?s) -- Make the dot match all characters including newline.
 177 #   (?x) -- Ignore whitespace in patterns.
 178 no_match = 'a\ba'
 179 snippet_res = {
 180         ##
 181         HTML: {
 182                 'include':
 183                   no_match,
 184
 185                 'lilypond':
 186                   r'''(?mx)
 187                     (?P<match>
 188                     <lilypond
 189                       (\s*(?P<options>.*?)\s*:)?\s*
 190                       (?P<code>.*?)
 191                     />)''',
 192
 193                 'lilypond_block':
 194                   r'''(?msx)
 195                     (?P<match>
 196                     <lilypond
 197                       \s*(?P<options>.*?)\s*
 198                     >
 199                     (?P<code>.*?)
 200                     </lilypond>)''',
 201
 202                 'lilypond_file':
 203                   r'''(?mx)
 204                     (?P<match>
 205                     <lilypondfile
 206                       \s*(?P<options>.*?)\s*
 207                     >
 208                     \s*(?P<filename>.*?)\s*
 209                     </lilypondfile>)''',
 210
 211                 'multiline_comment':
 212                   r'''(?smx)
 213                     (?P<match>
 214                     \s*(?!@c\s+)
 215                     (?P<code><!--\s.*?!-->)
 216                     \s)''',
 217
 218                 'singleline_comment':
 219                   no_match,
 220
 221                 'verb':
 222                   r'''(?x)
 223                     (?P<match>
 224                       (?P<code><pre>.*?</pre>))''',
 225
 226                 'verbatim':
 227                   r'''(?x)
 228                     (?s)
 229                     (?P<match>
 230                       (?P<code><pre>\s.*?</pre>\s))''',
 231         },
 232
 233         ##
 234         LATEX: {
 235                 'include':
 236                   r'''(?smx)
 237                     ^[^%\n]*?
 238                     (?P<match>
 239                     \\input\s*{
 240                       (?P<filename>\S+?)
 241                     })''',
 242
 243                 'lilypond':
 244                   r'''(?smx)
 245                     ^[^%\n]*?
 246                     (?P<match>
 247                     \\lilypond\s*(
 248                     \[
 249                       \s*(?P<options>.*?)\s*
 250                     \])?\s*{
 251                       (?P<code>.*?)
 252                     })''',
 253
 254                 'lilypond_block':
 255                   r'''(?smx)
 256                     ^[^%\n]*?
 257                     (?P<match>
 258                     \\begin\s*(
 259                     \[
 260                       \s*(?P<options>.*?)\s*
 261                     \])?\s*{lilypond}
 262                       (?P<code>.*?)
 263                     ^[^%\n]*?
 264                     \\end\s*{lilypond})''',
 265
 266                 'lilypond_file':
 267                   r'''(?smx)
 268                     ^[^%\n]*?
 269                     (?P<match>
 270                     \\lilypondfile\s*(
 271                     \[
 272                       \s*(?P<options>.*?)\s*
 273                     \])?\s*\{
 274                       (?P<filename>\S+?)
 275                     })''',
 276
 277                 'multiline_comment':
 278                   no_match,
 279
 280                 'singleline_comment':
 281                   r'''(?mx)
 282                     ^.*?
 283                     (?P<match>
 284                       (?P<code>
 285                       %.*$\n+))''',
 286
 287                 'verb':
 288                   r'''(?mx)
 289                     ^[^%\n]*?
 290                     (?P<match>
 291                       (?P<code>
 292                       \\verb(?P<del>.)
 293                         .*?
 294                       (?P=del)))''',
 295
 296                 'verbatim':
 297                   r'''(?msx)
 298                     ^[^%\n]*?
 299                     (?P<match>
 300                       (?P<code>
 301                       \\begin\s*{verbatim}
 302                         .*?
 303                       \\end\s*{verbatim}))''',
 304         },
 305
 306         ##
 307         TEXINFO: {
 308                 'include':
 309                   r'''(?mx)
 310                     ^(?P<match>
 311                     @include\s+
 312                       (?P<filename>\S+))''',
 313
 314                 'lilypond':
 315                   r'''(?smx)
 316                     ^[^\n]*?(?!@c\s+)[^\n]*?
 317                     (?P<match>
 318                     @lilypond\s*(
 319                     \[
 320                       \s*(?P<options>.*?)\s*
 321                     \])?\s*{
 322                       (?P<code>.*?)
 323                     })''',
 324
 325                 'lilypond_block':
 326                   r'''(?msx)
 327                     ^(?P<match>
 328                     @lilypond\s*(
 329                     \[
 330                       \s*(?P<options>.*?)\s*
 331                     \])?\s+?
 332                     ^(?P<code>.*?)
 333                     ^@end\s+lilypond)\s''',
 334
 335                 'lilypond_file':
 336                   r'''(?mx)
 337                     ^(?P<match>
 338                     @lilypondfile\s*(
 339                     \[
 340                       \s*(?P<options>.*?)\s*
 341                     \])?\s*{
 342                       (?P<filename>\S+)
 343                     })''',
 344
 345                 'multiline_comment':
 346                   r'''(?smx)
 347                     ^(?P<match>
 348                       (?P<code>
 349                       @ignore\s
 350                         .*?
 351                       @end\s+ignore))\s''',
 352
 353                 'singleline_comment':
 354                   r'''(?mx)
 355                     ^.*
 356                     (?P<match>
 357                       (?P<code>
 358                       @c([ \t][^\n]*|)\n))''',
 359
 360         # Don't do this: It interferes with @code{@{}.
 361         #       'verb': r'''(?P<code>@code{.*?})''',
 362
 363                 'verbatim':
 364                   r'''(?sx)
 365                     (?P<match>
 366                       (?P<code>
 367                       @example
 368                         \s.*?
 369                       @end\s+example\s))''',
 370         },
 371 }
 372
 373 format_res = {
 374         HTML: {
 375                 'intertext': r',?\s*intertext=\".*?\"',
 376                 'option_sep': '\s*',
 377         },
 378
 379         LATEX: {
 380                 'intertext': r',?\s*intertext=\".*?\"',
 381                 'option_sep': '\s*,\s*',
 382         },
 383
 384         TEXINFO: {
 385                 'intertext': r',?\s*intertext=\".*?\"',
 386                 'option_sep': '\s*,\s*',
 387         },
 388 }
 389
 390 # Options without a pattern in ly_options.
 391 simple_options = [
 392         EXAMPLEINDENT,
 393         FRAGMENT,
 394         NOFRAGMENT,
 395         NOINDENT,
 396         PRINTFILENAME,
 397         TEXIDOC,
 398         VERBATIM,
 399         FONTLOAD,
 400         FILENAME,
 401         ALT
 402 ]
 403
 404 ly_options = {
 405         ##
 406         NOTES: {
 407                 RELATIVE: r'''\relative c%(relative_quotes)s''',
 408         },
 409
 410         ##
 411         PAPER: {
 412                 INDENT: r'''indent = %(indent)s''',
 413
 414                 LINEWIDTH: r'''linewidth = %(linewidth)s''',
 415
 416                 QUOTE: r'''linewidth = %(linewidth)s - 2.0 * %(exampleindent)s''',
 417
 418                 RAGGEDRIGHT: r'''raggedright = ##t''',
 419
 420                 PACKED: r'''packed = ##t''',
 421         },
 422
 423         ##
 424         LAYOUT: {
 425                 NOTIME: r'''
 426   \context {
 427     \Score
 428     timing = ##f
 429   }
 430   \context {
 431     \Staff
 432     \remove Time_signature_engraver
 433   }''',
 434         },
 435
 436         ##
 437         PREAMBLE: {
 438                 STAFFSIZE: r'''#(set-global-staff-size %(staffsize)s)''',
 439         },
 440 }
 441
 442 output = {
 443         ##
 444         HTML: {
 445                 FILTER: r'''<lilypond %(options)s>
 446 %(code)s
 447 </lilypond>
 448 ''',
 449
 450                 AFTER: r'''
 451   </a>
 452 </p>''',
 453
 454                 BEFORE: r'''<p>
 455   <a href="%(base)s.ly">''',
 456
 457                 OUTPUT: r'''
 458     <img align="center" valign="center"
 459          border="0" src="%(image)s" alt="%(alt)s">''',
 460
 461                 PRINTFILENAME: '<p><tt><a href="%(base)s.ly">%(filename)s</a></tt></p>',
 462
 463                 QUOTE: r'''<blockquote>
 464 %(str)s
 465 </blockquote>
 466 ''',
 467
 468                 VERBATIM: r'''<pre>
 469 %(verb)s</pre>''',
 470         },
 471
 472         ##
 473         LATEX: {
 474                 OUTPUT: r'''{%%
 475 \parindent 0pt
 476 \catcode`\@=12
 477 \ifx\preLilyPondExample \undefined
 478   \relax
 479 \else
 480   \preLilyPondExample
 481 \fi
 482 \def\lilypondbook{}%%
 483 \input %(base)s-systems.tex
 484 \ifx\postLilyPondExample \undefined
 485   \relax
 486 \else
 487   \postLilyPondExample
 488 \fi
 489 }''',
 490
 491                 PRINTFILENAME: '''\\texttt{%(filename)s}
 492         ''',
 493
 494                 QUOTE: r'''\begin{quotation}
 495 %(str)s
 496 \end{quotation}
 497 ''',
 498
 499                 VERBATIM: r'''\noindent
 500 \begin{verbatim}
 501 %(verb)s\end{verbatim}
 502 ''',
 503
 504                 FILTER: r'''\begin{lilypond}[%(options)s]
 505 %(code)s
 506 \end{lilypond}''',
 507         },
 508
 509         ##
 510         TEXINFO: {
 511                 FILTER: r'''@lilypond[%(options)s]
 512 %(code)s
 513 @lilypond''',
 514
 515                 OUTPUT: r'''
 516 @iftex
 517 @include %(base)s-systems.texi
 518 @end iftex
 519 ''',
 520
 521                 OUTPUTIMAGE: r'''@noindent
 522 @ifinfo
 523 @image{%(base)s,,,%(alt)s,%(ext)s}
 524 @end ifinfo
 525 @html
 526 <p>
 527   <a href="%(base)s.ly">
 528     <img align="center" valign="center"
 529          border="0" src="%(image)s" alt="%(alt)s">
 530   </a>
 531 </p>
 532 @end html
 533 ''',
 534
 535                 PRINTFILENAME: '''@file{%(filename)s}
 536         ''',
 537
 538                 QUOTE: r'''@quotation
 539 %(str)s@end quotation
 540 ''',
 541
 542                 NOQUOTE: r'''@format
 543 %(str)s@end format
 544 ''',
 545
 546                 VERBATIM: r'''@exampleindent 0
 547 @example
 548 %(verb)s@end example
 549 ''',
 550         },
 551 }
 552
 553 PREAMBLE_LY = r'''%%%% Generated by %(program_name)s
 554 %%%% Options: [%(option_string)s]
 555
 556 #(set! toplevel-score-handler print-score-with-defaults)
 557 #(set! toplevel-music-handler (lambda (p m)
 558                                (print-score-with-defaults
 559                                 p (scorify-music m p))))
 560
 561 #(ly:set-option (quote no-point-and-click))
 562 #(define inside-lilypond-book #t)
 563 #(define version-seen? #t)
 564 %(preamble_string)s
 565
 566
 567
 568
 569
 570
 571 %% ****************************************************************
 572 %% Start cut-&-pastable-section
 573 %% ****************************************************************
 574
 575 \paper {
 576   #(define dump-extents #t)
 577   %(font_dump_setting)s
 578   %(paper_string)s
 579 }
 580
 581 \layout {
 582   %(layout_string)s
 583 }
 584 '''
 585
 586 FRAGMENT_LY = r'''
 587 %(notes_string)s
 588 {
 589
 590
 591 %% ****************************************************************
 592 %% ly snippet contents follows:
 593 %% ****************************************************************
 594 %(code)s
 595
 596
 597 %% ****************************************************************
 598 %% end ly snippet
 599 %% ****************************************************************
 600 }
 601 '''
 602
 603 FULL_LY = '''
 604
 605
 606 %% ****************************************************************
 607 %% ly snippet:
 608 %% ****************************************************************
 609 %(code)s
 610
 611
 612 %% ****************************************************************
 613 %% end ly snippet
 614 %% ****************************************************************
 615 '''
 616
 617 texinfo_linewidths = {
 618         '@afourpaper': '160\\mm',
 619         '@afourwide': '6.5\\in',
 620         '@afourlatex': '150\\mm',
 621         '@smallbook': '5\\in',
 622         '@letterpaper': '6\\in',
 623 }
 624
 625 def classic_lilypond_book_compatibility (key, value):
 626         if key == 'singleline' and value == None:
 627                 return (RAGGEDRIGHT, None)
 628
 629         m = re.search ('relative\s*([-0-9])', key)
 630         if m:
 631                 return ('relative', m.group (1))
 632
 633         m = re.match ('([0-9]+)pt', key)
 634         if m:
 635                 return ('staffsize', m.group (1))
 636
 637         if key == 'indent' or key == 'linewidth':
 638                 m = re.match ('([-.0-9]+)(cm|in|mm|pt|staffspace)', value)
 639                 if m:
 640                         f = float (m.group (1))
 641                         return (key, '%f\\%s' % (f, m.group (2)))
 642
 643         return (None, None)
 644
 645 def find_file (name):
 646         for i in include_path:
 647                 full = os.path.join (i, name)
 648                 if os.path.exists (full):
 649                         return full
 650         ly.error (_ ("file not found: %s") % name + '\n')
 651         ly.exit (1)
 652         return ''
 653
 654 def verbatim_html (s):
 655         return re.sub ('>', '&gt;',
 656                        re.sub ('<', '&lt;',
 657                                re.sub ('&', '&amp;', s)))
 658
 659 def verbatim_texinfo (s):
 660         return re.sub ('{', '@{',
 661                        re.sub ('}', '@}',
 662                                re.sub ('@', '@@', s)))
 663
 664 def split_options (option_string):
 665         if option_string:
 666                 if format == HTML:
 667                         options = re.findall('[\w\.-:]+(?:\s*=\s*(?:"[^"]*"|\'[^\']*\'|\S+))?',option_string)
 668                         for i in range(len(options)):
 669                                 options[i] = re.sub('^([^=]+=\s*)(?P<q>["\'])(.*)(?P=q)','\g<1>\g<3>',options[i])
 670                         return options
 671                 else:
 672                         return re.split (format_res[format]['option_sep'],
 673                                          option_string)
 674         return []
 675
 676 def invokes_lilypond ():
 677         return re.search ('^[\'\"0-9A-Za-z/]*lilypond', process_cmd)
 678
 679 def set_default_options (source):
 680         global default_ly_options
 681         if not default_ly_options.has_key (LINEWIDTH):
 682                 if format == LATEX:
 683                         textwidth = get_latex_textwidth (source)
 684                         default_ly_options[LINEWIDTH] = \
 685                           '''%.0f\\pt''' % textwidth
 686                 elif format == TEXINFO:
 687                         for (k, v) in texinfo_linewidths.items ():
 688                                 # FIXME: @layout is usually not in
 689                                 # chunk #0:
 690                                 #
 691                                 #  \input texinfo @c -*-texinfo-*-
 692                                 #
 693                                 # Bluntly search first K items of
 694                                 # source.
 695                                 # s = chunks[0].replacement_text ()
 696                                 if re.search (k, source[:1024]):
 697                                         default_ly_options[LINEWIDTH] = v
 698                                         break
 699
 700 class Chunk:
 701         def replacement_text (self):
 702                 return ''
 703
 704         def filter_text (self):
 705                 return self.replacement_text ()
 706
 707         def ly_is_outdated (self):
 708                 return 0
 709
 710         def png_is_outdated (self):
 711                 return 0
 712
 713         def is_plain (self):
 714                 return False
 715
 716 class Substring (Chunk):
 717         def __init__ (self, source, start, end, line_number):
 718                 self.source = source
 719                 self.start = start
 720                 self.end = end
 721                 self.line_number = line_number
 722                 self.override_text = None
 723
 724         def is_plain (self):
 725                 return True
 726
 727         def replacement_text (self):
 728                 if self.override_text:
 729                         return self.override_text
 730                 else:
 731                         return self.source[self.start:self.end]
 732
 733 class Snippet (Chunk):
 734         def __init__ (self, type, match, format, line_number):
 735                 self.type = type
 736                 self.match = match
 737                 self.hash = 0
 738                 self.option_dict = {}
 739                 self.format = format
 740                 self.line_number = line_number
 741
 742         def replacement_text (self):
 743                 return self.match.group ('match')
 744
 745         def substring (self, s):
 746                 return self.match.group (s)
 747
 748         def __repr__ (self):
 749                 return `self.__class__` + ' type = ' + self.type
 750
 751 class Include_snippet (Snippet):
 752         def processed_filename (self):
 753                 f = self.substring ('filename')
 754                 return os.path.splitext (f)[0] + format2ext[format]
 755
 756         def replacement_text (self):
 757                 s = self.match.group ('match')
 758                 f = self.substring ('filename')
 759
 760                 return re.sub (f, self.processed_filename (), s)
 761
 762 class Lilypond_snippet (Snippet):
 763         def __init__ (self, type, match, format, line_number):
 764                 Snippet.__init__ (self, type, match, format, line_number)
 765                 os = match.group ('options')
 766                 self.do_options (os, self.type)
 767
 768         def ly (self):
 769                 return self.substring ('code')
 770
 771         def full_ly (self):
 772                 s = self.ly ()
 773                 if s:
 774                         return self.compose_ly (s)
 775                 return ''
 776
 777         def do_options (self, option_string, type):
 778                 self.option_dict = {}
 779
 780                 options = split_options (option_string)
 781
 782                 for i in options:
 783                         if string.find (i, '=') > 0:
 784                                 (key, value) = re.split ('\s*=\s*', i)
 785                                 self.option_dict[key] = value
 786                         else:
 787                                 if i in no_options.keys ():
 788                                         if no_options[i] in self.option_dict.keys ():
 789                                                 del self.option_dict[no_options[i]]
 790                                 else:
 791                                         self.option_dict[i] = None
 792
 793                 has_linewidth = self.option_dict.has_key (LINEWIDTH)
 794                 no_linewidth_value = 0
 795
 796                 # If LINEWIDTH is used without parameter, set it to default.
 797                 if has_linewidth and self.option_dict[LINEWIDTH] == None:
 798                         no_linewidth_value = 1
 799                         del self.option_dict[LINEWIDTH]
 800
 801                 for i in default_ly_options.keys ():
 802                         if i not in self.option_dict.keys ():
 803                                 self.option_dict[i] = default_ly_options[i]
 804
 805                 if not has_linewidth:
 806                         if type == 'lilypond' or FRAGMENT in self.option_dict.keys ():
 807                                 self.option_dict[RAGGEDRIGHT] = None
 808
 809                         if type == 'lilypond':
 810                                 if LINEWIDTH in self.option_dict.keys ():
 811                                         del self.option_dict[LINEWIDTH]
 812                         else:
 813                                 if RAGGEDRIGHT in self.option_dict.keys ():
 814                                         if LINEWIDTH in self.option_dict.keys ():
 815                                                 del self.option_dict[LINEWIDTH]
 816
 817                         if QUOTE in self.option_dict.keys () or type == 'lilypond':
 818                                 if LINEWIDTH in self.option_dict.keys ():
 819                                         del self.option_dict[LINEWIDTH]
 820
 821                 if not INDENT in self.option_dict.keys ():
 822                         self.option_dict[INDENT] = '0\\mm'
 823
 824                 # The QUOTE pattern from ly_options only emits the `linewidth'
 825                 # keyword.
 826                 if has_linewidth and QUOTE in self.option_dict.keys ():
 827                         if no_linewidth_value:
 828                                 del self.option_dict[LINEWIDTH]
 829                         else:
 830                                 del self.option_dict[QUOTE]
 831
 832         def compose_ly (self, code):
 833                 if FRAGMENT in self.option_dict.keys ():
 834                         body = FRAGMENT_LY
 835                 else:
 836                         body = FULL_LY
 837
 838                 # Defaults.
 839                 relative = 1
 840                 override = {}
 841                 # The original concept of the `exampleindent' option is broken.
 842                 # It is not possible to get a sane value for @exampleindent at all
 843                 # without processing the document itself.  Saying
 844                 #
 845                 #   @exampleindent 0
 846                 #   @example
 847                 #   ...
 848                 #   @end example
 849                 #   @exampleindent 5
 850                 #
 851                 # causes ugly results with the DVI backend of texinfo since the
 852                 # default value for @exampleindent isn't 5em but 0.4in (or a smaller
 853                 # value).  Executing the above code changes the environment
 854                 # indentation to an unknown value because we don't know the amount
 855                 # of 1em in advance since it is font-dependent.  Modifying
 856                 # @exampleindent in the middle of a document is simply not
 857                 # supported within texinfo.
 858                 #
 859                 # As a consequence, the only function of @exampleindent is now to
 860                 # specify the amount of indentation for the `quote' option.
 861                 #
 862                 # To set @exampleindent locally to zero, we use the @format
 863                 # environment for non-quoted snippets.
 864                 override[EXAMPLEINDENT] = r'0.4\in'
 865                 override[LINEWIDTH] = texinfo_linewidths['@smallbook']
 866                 override.update (default_ly_options)
 867
 868                 option_list = []
 869                 for (key, value) in self.option_dict.items ():
 870                         if value == None:
 871                                 option_list.append (key)
 872                         else:
 873                                 option_list.append (key + '=' + value)
 874                 option_string = string.join (option_list, ',')
 875
 876                 compose_dict = {}
 877                 compose_types = [NOTES, PREAMBLE, LAYOUT, PAPER]
 878                 for a in compose_types:
 879                         compose_dict[a] = []
 880
 881                 for (key, value) in self.option_dict.items ():
 882                         (c_key, c_value) = \
 883                           classic_lilypond_book_compatibility (key, value)
 884                         if c_key:
 885                                 if c_value:
 886                                         ly.warning \
 887                                           (_ ("deprecated ly-option used: %s=%s" \
 888                                             % (key, value)))
 889                                         ly.warning \
 890                                           (_ ("compatibility mode translation: %s=%s" \
 891                                             % (c_key, c_value)))
 892                                 else:
 893                                         ly.warning \
 894                                           (_ ("deprecated ly-option used: %s" \
 895                                             % key))
 896                                         ly.warning \
 897                                           (_ ("compatibility mode translation: %s" \
 898                                             % c_key))
 899
 900                                 (key, value) = (c_key, c_value)
 901
 902                         if value:
 903                                 override[key] = value
 904                         else:
 905                                 if not override.has_key (key):
 906                                         override[key] = None
 907
 908                         found = 0
 909                         for type in compose_types:
 910                                 if ly_options[type].has_key (key):
 911                                         compose_dict[type].append (ly_options[type][key])
 912                                         found = 1
 913                                         break
 914
 915                         if not found and key not in simple_options:
 916                                 ly.warning (_ ("ignoring unknown ly option: %s") % key)
 917
 918                 # URGS
 919                 if RELATIVE in override.keys () and override[RELATIVE]:
 920                         relative = string.atoi (override[RELATIVE])
 921
 922                 relative_quotes = ''
 923
 924                 # 1 = central C
 925                 if relative < 0:
 926                         relative_quotes += ',' * (- relative)
 927                 elif relative > 0:
 928                         relative_quotes += "'" * relative
 929
 930                 program_name = __main__.program_name
 931
 932                 paper_string = string.join (compose_dict[PAPER],
 933                                             '\n  ') % override
 934                 layout_string = string.join (compose_dict[LAYOUT],
 935                                              '\n  ') % override
 936                 notes_string = string.join (compose_dict[NOTES],
 937                                             '\n  ') % vars ()
 938                 preamble_string = string.join (compose_dict[PREAMBLE],
 939                                                '\n  ') % override
 940
 941                 font_dump_setting = ''
 942                 if FONTLOAD in self.option_dict:
 943                         font_dump_setting = '#(define-public force-eps-font-include #t)\n'
 944
 945                 return (PREAMBLE_LY + body) % vars ()
 946
 947         # TODO: Use md5?
 948         def get_hash (self):
 949                 if not self.hash:
 950                         self.hash = abs (hash (self.full_ly ()))
 951                 return self.hash
 952
 953         def basename (self):
 954                 if FILENAME in self.option_dict:
 955                         return self.option_dict[FILENAME]
 956                 if use_hash_p:
 957                         return 'lily-%d' % self.get_hash ()
 958                 raise 'to be done'
 959
 960         def write_ly (self):
 961                 outf = open (self.basename () + '.ly', 'w')
 962                 outf.write (self.full_ly ())
 963
 964                 open (self.basename () + '.txt', 'w').write ('image of music')
 965
 966         def ly_is_outdated (self):
 967                 base = self.basename ()
 968
 969                 tex_file = '%s.tex' % base
 970                 eps_file = '%s.eps' % base
 971                 system_file = '%s-systems.tex' % base
 972                 ly_file = '%s.ly' % base
 973                 ok = os.path.exists (ly_file) \
 974                      and os.path.exists (system_file)\
 975                      and os.stat (system_file)[stat.ST_SIZE] \
 976                      and re.match ('% eof', open (system_file).readlines ()[-1])
 977                 if ok and (not use_hash_p or FILENAME in self.option_dict):
 978                         ok = (self.full_ly () == open (ly_file).read ())
 979                 if ok:
 980                         # TODO: Do something smart with target formats
 981                         #       (ps, png) and m/ctimes.
 982                         return None
 983                 return self
 984
 985         def png_is_outdated (self):
 986                 base = self.basename ()
 987                 ok = self.ly_is_outdated ()
 988                 if format == HTML or format == TEXINFO:
 989                         ok = ok and os.path.exists (base + '.eps')
 990
 991                         page_count = 0
 992                         if ok:
 993                                 page_count = ly.ps_page_count (base + '.eps')
 994
 995                         if page_count == 1:
 996                                 ok = ok and os.path.exists (base + '.png')
 997                         elif page_count > 1:
 998                                 for a in range (1, page_count + 1):
 999                                                 ok = ok and os.path.exists (base + '-page%d.png' % a)
1000
1001                 return not ok
1002
1003         def texstr_is_outdated (self):
1004                 if backend == 'ps':
1005                         return 0
1006
1007                 base = self.basename ()
1008                 ok = self.ly_is_outdated ()
1009                 ok = ok and (os.path.exists (base + '.texstr'))
1010                 return not ok
1011
1012         def filter_text (self):
1013                 code = self.substring ('code')
1014                 s = run_filter (code)
1015                 d = {
1016                         'code': s,
1017                         'options': self.match.group ('options')
1018                 }
1019                 # TODO
1020                 return output[self.format][FILTER] % d
1021
1022         def replacement_text (self):
1023                 func = Lilypond_snippet.__dict__['output_' + self.format]
1024                 return func (self)
1025
1026         def get_images (self):
1027                 base = self.basename ()
1028                 # URGUGHUGHUGUGH
1029                 single = '%(base)s.png' % vars ()
1030                 multiple = '%(base)s-page1.png' % vars ()
1031                 images = (single,)
1032                 if os.path.exists (multiple) \
1033                    and (not os.path.exists (single) \
1034                         or (os.stat (multiple)[stat.ST_MTIME] \
1035                             > os.stat (single)[stat.ST_MTIME])):
1036                         count = ly.ps_page_count ('%(base)s.eps' % vars ())
1037                         images = ['%s-page%d.png' % (base, a) for a in range (1, count+1)]
1038                         images = tuple (images)
1039                 return images
1040
1041         def output_html (self):
1042                 str = ''
1043                 base = self.basename ()
1044                 if format == HTML:
1045                         str += self.output_print_filename (HTML)
1046                         if VERBATIM in self.option_dict:
1047                                 verb = verbatim_html (self.substring ('code'))
1048                                 str += write (output[HTML][VERBATIM] % vars ())
1049                         if QUOTE in self.option_dict:
1050                                 str = output[HTML][QUOTE] % vars ()
1051
1052                 str += output[HTML][BEFORE] % vars ()
1053                 for image in self.get_images ():
1054                         (base, ext) = os.path.splitext (image)
1055                         alt = self.option_dict[ALT]
1056                         str += output[HTML][OUTPUT] % vars ()
1057                 str += output[HTML][AFTER] % vars ()
1058                 return str
1059
1060         def output_info (self):
1061                 str = ''
1062                 for image in self.get_images ():
1063                         (base, ext) = os.path.splitext (image)
1064
1065                         # URG, makeinfo implicitly prepends dot to extension.
1066                         # Specifying no extension is most robust.
1067                         ext = ''
1068                         alt = self.option_dict[ALT]
1069                         str += output[TEXINFO][OUTPUTIMAGE] % vars ()
1070
1071                 base = self.basename ()
1072                 str += output[format][OUTPUT] % vars ()
1073                 return str
1074
1075         def output_latex (self):
1076                 str = ''
1077                 base = self.basename ()
1078                 if format == LATEX:
1079                         str += self.output_print_filename (LATEX)
1080                         if VERBATIM in self.option_dict:
1081                                 verb = self.substring ('code')
1082                                 str += (output[LATEX][VERBATIM] % vars ())
1083
1084                 str += (output[LATEX][OUTPUT] % vars ())
1085                 if QUOTE in self.option_dict:
1086                         str = output[LATEX][QUOTE] % vars ()
1087                 return str
1088
1089         def output_print_filename (self, format):
1090                 str = ''
1091                 if PRINTFILENAME in self.option_dict:
1092                         base = self.basename ()
1093                         filename = self.substring ('filename')
1094                         str = output[format][PRINTFILENAME] % vars ()
1095
1096                 return str
1097
1098         def output_texinfo (self):
1099                 str = ''
1100                 if self.output_print_filename (TEXINFO):
1101                         str += ('@html\n'
1102                                 + self.output_print_filename (HTML)
1103                                 + '\n@end html\n')
1104                         str += ('@tex\n'
1105                                 + self.output_print_filename (LATEX)
1106                                 + '\n@end tex\n')
1107                 base = self.basename ()
1108                 if TEXIDOC in self.option_dict:
1109                         texidoc = base + '.texidoc'
1110                         if os.path.exists (texidoc):
1111                                 str += '@include %(texidoc)s\n\n' % vars ()
1112
1113                 if VERBATIM in self.option_dict:
1114                         verb = verbatim_texinfo (self.substring ('code'))
1115                         str += (output[TEXINFO][VERBATIM] % vars ())
1116                         if not QUOTE in self.option_dict:
1117                                 str = output[TEXINFO][NOQUOTE] % vars ()
1118
1119                 str += self.output_info ()
1120
1121 #               str += ('@ifinfo\n' + self.output_info () + '\n@end ifinfo\n')
1122 #               str += ('@tex\n' + self.output_latex () + '\n@end tex\n')
1123 #               str += ('@html\n' + self.output_html () + '\n@end html\n')
1124
1125                 if QUOTE in self.option_dict:
1126                         str = output[TEXINFO][QUOTE] % vars ()
1127
1128                 # need par after image
1129                 str += '\n'
1130
1131                 return str
1132
1133 class Lilypond_file_snippet (Lilypond_snippet):
1134         def ly (self):
1135                 name = self.substring ('filename')
1136                 return '\\renameinput \"%s\"\n%s' \
1137                          % (name, open (find_file (name)).read ())
1138
1139 snippet_type_to_class = {
1140         'lilypond_file': Lilypond_file_snippet,
1141         'lilypond_block': Lilypond_snippet,
1142         'lilypond': Lilypond_snippet,
1143         'include': Include_snippet,
1144 }
1145
1146 def find_linestarts (s):
1147         nls = [0]
1148         start = 0
1149         end = len (s)
1150         while 1:
1151                 i = s.find ('\n', start)
1152                 if i < 0:
1153                         break
1154
1155                 i = i + 1
1156                 nls.append (i)
1157                 start = i
1158
1159         nls.append (len (s))
1160         return nls
1161
1162 def find_toplevel_snippets (s, types):
1163         res = {}
1164         for i in types:
1165                 res[i] = ly.re.compile (snippet_res[format][i])
1166
1167         snippets = []
1168         index = 0
1169         ## found = dict (map (lambda x: (x, None),
1170         ##                    types))
1171         ## urg python2.1
1172         found = {}
1173         map (lambda x, f = found: f.setdefault (x, None),
1174              types)
1175
1176         line_starts = find_linestarts (s)
1177         line_start_idx = 0
1178         # We want to search for multiple regexes, without searching
1179         # the string multiple times for one regex.
1180         # Hence, we use earlier results to limit the string portion
1181         # where we search.
1182         # Since every part of the string is traversed at most once for
1183         # every type of snippet, this is linear.
1184
1185         while 1:
1186                 first = None
1187                 endex = 1 << 30
1188                 for type in types:
1189                         if not found[type] or found[type][0] < index:
1190                                 found[type] = None
1191                                 m = res[type].search (s[index:endex])
1192                                 if not m:
1193                                         continue
1194
1195                                 cl = Snippet
1196                                 if snippet_type_to_class.has_key (type):
1197                                         cl = snippet_type_to_class[type]
1198
1199
1200                                 start = index + m.start ('match')
1201                                 line_number = line_start_idx
1202                                 while (line_starts[line_number] < start):
1203                                         line_number += 1
1204
1205                                 line_number += 1
1206                                 snip = cl (type, m, format, line_number)
1207                                 found[type] = (start, snip)
1208
1209                         if found[type] \
1210                            and (not first \
1211                                 or found[type][0] < found[first][0]):
1212                                 first = type
1213
1214                                 # FIXME.
1215
1216                                 # Limiting the search space is a cute
1217                                 # idea, but this *requires* to search
1218                                 # for possible containing blocks
1219                                 # first, at least as long as we do not
1220                                 # search for the start of blocks, but
1221                                 # always/directly for the entire
1222                                 # @block ... @end block.
1223
1224                                 endex = found[first][0]
1225
1226                 if not first:
1227                         snippets.append (Substring (s, index, len (s), line_start_idx))
1228                         break
1229
1230                 while (start > line_starts[line_start_idx+1]):
1231                         line_start_idx += 1
1232
1233                 (start, snip) = found[first]
1234                 snippets.append (Substring (s, index, start, line_start_idx + 1))
1235                 snippets.append (snip)
1236                 found[first] = None
1237                 index = start + len (snip.match.group ('match'))
1238
1239         return snippets
1240
1241 def filter_pipe (input, cmd):
1242         if verbose_p:
1243                 ly.progress (_ ("Opening filter `%s'") % cmd)
1244
1245         (stdin, stdout, stderr) = os.popen3 (cmd)
1246         stdin.write (input)
1247         status = stdin.close ()
1248
1249         if not status:
1250                 status = 0
1251                 output = stdout.read ()
1252                 status = stdout.close ()
1253                 error = stderr.read ()
1254
1255         if not status:
1256                 status = 0
1257         signal = 0x0f & status
1258         if status or (not output and error):
1259                 exit_status = status >> 8
1260                 ly.error (_ ("`%s' failed (%d)") % (cmd, exit_status))
1261                 ly.error (_ ("The error log is as follows:"))
1262                 sys.stderr.write (error)
1263                 sys.stderr.write (stderr.read ())
1264                 ly.exit (status)
1265
1266         if verbose_p:
1267                 ly.progress ('\n')
1268
1269         return output
1270
1271 def run_filter (s):
1272         return filter_pipe (s, filter_cmd)
1273
1274 def is_derived_class (cl, baseclass):
1275         if cl == baseclass:
1276                 return 1
1277         for b in cl.__bases__:
1278                 if is_derived_class (b, baseclass):
1279                         return 1
1280         return 0
1281
1282 def process_snippets (cmd, ly_snippets, texstr_snippets, png_snippets):
1283         ly_names = filter (lambda x: x,
1284                            map (Lilypond_snippet.basename, ly_snippets))
1285         texstr_names = filter (lambda x: x,
1286                            map (Lilypond_snippet.basename, texstr_snippets))
1287         png_names = filter (lambda x: x,
1288                             map (Lilypond_snippet.basename, png_snippets))
1289
1290         status = 0
1291         def my_system (cmd):
1292                 status = ly.system (cmd,
1293                                     ignore_error = 1, progress_p = 1)
1294
1295                 if status:
1296                         ly.error ('Process %s exited unsuccessfully.' % cmd)
1297                         raise Compile_error
1298
1299         # UGH
1300         # the --process=CMD switch is a bad idea
1301         # it is too generic for lilypond-book.
1302         if texstr_names and invokes_lilypond:
1303                 my_system (string.join ([cmd, '--backend texstr',
1304                                          'snippet-map.ly'] + texstr_names))
1305                 for l in texstr_names:
1306                         my_system ('latex %s.texstr' % l)
1307
1308         if ly_names:
1309                 my_system (string.join ([cmd, 'snippet-map.ly'] + ly_names))
1310
1311 LATEX_INSPECTION_DOCUMENT = r'''
1312 \nonstopmode
1313 %(preamble)s
1314 \begin{document}
1315 \typeout{textwidth=\the\textwidth}
1316 \typeout{columnsep=\the\columnsep}
1317 \makeatletter\if@twocolumn\typeout{columns=2}\fi\makeatother
1318 \end{document}
1319 '''
1320
1321 # Do we need anything else besides `textwidth'?
1322 def get_latex_textwidth (source):
1323         m = re.search (r'''(?P<preamble>\\begin\s*{document})''', source)
1324         preamble = source[:m.start (0)]
1325         latex_document = LATEX_INSPECTION_DOCUMENT % vars ()
1326         # Workaround problems with unusable $TMP on Cygwin:
1327         tempfile.tempdir = ''
1328         tmpfile = tempfile.mktemp('.tex')
1329         logfile = os.path.splitext (tmpfile)[0] + '.log'
1330         open (tmpfile,'w').write (latex_document)
1331         ly.system ('latex %s' % tmpfile)
1332         parameter_string = open (logfile).read()
1333         os.unlink (tmpfile)
1334         os.unlink (logfile)
1335
1336         columns = 0
1337         m = re.search ('columns=([0-9.]*)', parameter_string)
1338         if m:
1339                 columns = string.atoi (m.group (1))
1340
1341         columnsep = 0
1342         m = re.search ('columnsep=([0-9.]*)pt', parameter_string)
1343         if m:
1344                 columnsep = string.atof (m.group (1))
1345
1346         textwidth = 0
1347         m = re.search ('textwidth=([0-9.]*)pt', parameter_string)
1348         if m:
1349                 textwidth = string.atof (m.group (1))
1350                 if columns:
1351                         textwidth = (textwidth - columnsep) / columns
1352
1353         return textwidth
1354
1355 def modify_preamble (chunk):
1356         str = chunk.replacement_text ()
1357         if (re.search (r"\\begin{document}", str)
1358             and not re.search ("{graphic[sx]", str)):
1359                 str = re.sub (r"\\begin{document}",
1360                               r"\\RequirePackage{graphics}" + '\n'
1361                               + r"\\begin{document}",
1362                               str)
1363                 chunk.override_text = str
1364
1365
1366
1367 ext2format = {
1368         '.html': HTML,
1369         '.itely': TEXINFO,
1370         '.latex': LATEX,
1371         '.lytex': LATEX,
1372         '.tely': TEXINFO,
1373         '.tex': LATEX,
1374         '.texi': TEXINFO,
1375         '.texinfo': TEXINFO,
1376         '.xml': HTML,
1377 }
1378
1379 format2ext = {
1380         HTML: '.html',
1381         # TEXINFO: '.texinfo',
1382         TEXINFO: '.texi',
1383         LATEX: '.tex',
1384 }
1385
1386 class Compile_error:
1387         pass
1388
1389 def write_file_map (lys, name):
1390         snippet_map = open ('snippet-map.ly', 'w')
1391         snippet_map.write ("""
1392 #(define version-seen? #t)
1393 #(ly:add-file-name-alist '(
1394 """)
1395         for ly in lys:
1396                 snippet_map.write ('("%s.ly" . "%s:%d (%s.ly)")\n'
1397                                    % (ly.basename (),
1398                                       name,
1399                                       ly.line_number,
1400                                       ly.basename ()))
1401
1402         snippet_map.write ('))\n')
1403
1404 def do_process_cmd (chunks, input_name):
1405         all_lys = filter (lambda x: is_derived_class (x.__class__,
1406                                                       Lilypond_snippet),
1407                           chunks)
1408
1409         write_file_map (all_lys, input_name)
1410         ly_outdated = \
1411           filter (lambda x: is_derived_class (x.__class__,
1412                                               Lilypond_snippet)
1413                             and x.ly_is_outdated (),
1414                   chunks)
1415         texstr_outdated = \
1416           filter (lambda x: is_derived_class (x.__class__,
1417                                               Lilypond_snippet)
1418                             and x.texstr_is_outdated (),
1419                   chunks)
1420         png_outdated = \
1421           filter (lambda x: is_derived_class (x.__class__,
1422                                               Lilypond_snippet)
1423                             and x.png_is_outdated (),
1424                   chunks)
1425
1426         ly.progress (_ ("Writing snippets..."))
1427         map (Lilypond_snippet.write_ly, ly_outdated)
1428         ly.progress ('\n')
1429
1430         if ly_outdated:
1431                 ly.progress (_ ("Processing..."))
1432                 ly.progress ('\n')
1433                 process_snippets (process_cmd, ly_outdated, texstr_outdated, png_outdated)
1434         else:
1435                 ly.progress (_ ("All snippets are up to date..."))
1436         ly.progress ('\n')
1437
1438 def guess_format (input_filename):
1439         format = None
1440         e = os.path.splitext (input_filename)[1]
1441         if e in ext2format.keys ():
1442                 # FIXME
1443                 format = ext2format[e]
1444         else:
1445                 ly.error (_ ("can't determine format for: %s" \
1446                              % input_filename))
1447                 ly.exit (1)
1448         return format
1449
1450 def write_if_updated (file_name, lines):
1451         try:
1452                 f = open (file_name)
1453                 oldstr = f.read ()
1454                 new_str = string.join (lines, '')
1455                 if oldstr == new_str:
1456                         ly.progress (_ ("%s is up to date.") % file_name)
1457                         ly.progress ('\n')
1458                         return
1459         except:
1460                 pass
1461
1462         ly.progress (_ ("Writing `%s'...") % file_name)
1463         open (file_name, 'w').writelines (lines)
1464         ly.progress ('\n')
1465
1466 def do_file (input_filename):
1467         # Ugh.
1468         if not input_filename or input_filename == '-':
1469                 in_handle = sys.stdin
1470                 input_fullname = '<stdin>'
1471         else:
1472                 if os.path.exists (input_filename):
1473                         input_fullname = input_filename
1474                 elif format == LATEX and ly.search_exe_path ('kpsewhich'):
1475                         # urg python interface to libkpathsea?
1476                         input_fullname = ly.read_pipe ('kpsewhich '
1477                                                        + input_filename)[:-1]
1478                 else:
1479                         input_fullname = find_file (input_filename)
1480                 in_handle = open (input_fullname)
1481
1482         if input_filename == '-':
1483                 input_base = 'stdin'
1484         else:
1485                 input_base = os.path.basename \
1486                              (os.path.splitext (input_filename)[0])
1487
1488         # Only default to stdout when filtering.
1489         if output_name == '-' or (not output_name and filter_cmd):
1490                 output_filename = '-'
1491                 output_file = sys.stdout
1492         else:
1493                 # don't complain when output_name is existing
1494                 output_filename = input_base + format2ext[format]
1495                 if output_name:
1496                         if not os.path.isdir (output_name):
1497                                 os.mkdir (output_name, 0777)
1498                         os.chdir (output_name)
1499                 else:
1500                         if os.path.exists (input_filename) \
1501                            and os.path.exists (output_filename) \
1502                            and os.path.samefile (output_filename, input_fullname):
1503                            ly.error (
1504                            _ ("Output would overwrite input file; use --output."))
1505                            ly.exit (2)
1506
1507         try:
1508                 ly.progress (_ ("Reading %s...") % input_fullname)
1509                 source = in_handle.read ()
1510                 ly.progress ('\n')
1511
1512                 set_default_options (source)
1513
1514
1515                 # FIXME: Containing blocks must be first, see
1516                 #        find_toplevel_snippets.
1517                 snippet_types = (
1518                         'multiline_comment',
1519                         'verbatim',
1520                         'lilypond_block',
1521         #               'verb',
1522                         'singleline_comment',
1523                         'lilypond_file',
1524                         'include',
1525                         'lilypond',
1526                 )
1527                 ly.progress (_ ("Dissecting..."))
1528                 chunks = find_toplevel_snippets (source, snippet_types)
1529
1530                 if format == LATEX:
1531                         for c in chunks:
1532                                 if (c.is_plain () and
1533                                     re.search (r"\\begin{document}", c.replacement_text())):
1534                                         modify_preamble (chunks[0])
1535                                         break
1536                 ly.progress ('\n')
1537
1538                 if filter_cmd:
1539                         write_if_updated (output_filename,
1540                                           [c.filter_text () for c in chunks])
1541                 elif process_cmd:
1542                         do_process_cmd (chunks, input_fullname)
1543                         ly.progress (_ ("Compiling %s...") % output_filename)
1544                         ly.progress ('\n')
1545                         write_if_updated (output_filename,
1546                                           [s.replacement_text ()
1547                                            for s in chunks])
1548
1549                 def process_include (snippet):
1550                         os.chdir (original_dir)
1551                         name = snippet.substring ('filename')
1552                         ly.progress (_ ("Processing include: %s") % name)
1553                         ly.progress ('\n')
1554                         return do_file (name)
1555
1556                 include_chunks = map (process_include,
1557                                       filter (lambda x: is_derived_class (x.__class__,
1558                                                                           Include_snippet),
1559                                               chunks))
1560
1561
1562                 return chunks + reduce (lambda x,y: x + y, include_chunks, [])
1563
1564         except Compile_error:
1565                 os.chdir (original_dir)
1566                 ly.progress (_ ("Removing `%s'") % output_filename)
1567                 ly.progress ('\n')
1568                 raise Compile_error
1569
1570 def do_options ():
1571         global format, output_name, psfonts_p
1572         global filter_cmd, process_cmd, verbose_p
1573
1574         (sh, long) = ly.getopt_args (option_definitions)
1575         try:
1576                 (options, files) = getopt.getopt (sys.argv[1:], sh, long)
1577         except getopt.error, s:
1578                 sys.stderr.write ('\n')
1579                 ly.error (_ ("getopt says: `%s'" % s))
1580                 sys.stderr.write ('\n')
1581                 ly.help ()
1582                 ly.exit (2)
1583
1584         for opt in options:
1585                 o = opt[0]
1586                 a = opt[1]
1587
1588                 if 0:
1589                         pass
1590                 elif o == '--filter' or o == '-F':
1591                         filter_cmd = a
1592                         process_cmd = 0
1593                 elif o == '--format' or o == '-f':
1594                         format = a
1595                         if a == 'texi-html' or a == 'texi':
1596                                 format = TEXINFO
1597                 elif o == '--tex-backend ':
1598                         backend = 'tex'
1599                 elif o == '--help' or o == '-h':
1600                         ly.help ()
1601                         sys.exit (0)
1602                 elif o == '--include' or o == '-I':
1603                         include_path.append (os.path.join (original_dir,
1604                                                            os.path.abspath (a)))
1605                 elif o == '--output' or o == '-o':
1606                         output_name = a
1607                 elif o == '--process' or o == '-P':
1608                         process_cmd = a
1609                         filter_cmd = 0
1610                 elif o == '--version' or o == '-v':
1611                         ly.identify (sys.stdout)
1612                         sys.exit (0)
1613                 elif o == '--verbose' or o == '-V':
1614                         verbose_p = 1
1615                 elif o == '--psfonts':
1616                         psfonts_p = 1
1617                 elif o == '--warranty' or o == '-w':
1618                         if 1 or status:
1619                                 ly.warranty ()
1620                         sys.exit (0)
1621         return files
1622
1623 def main ():
1624         files = do_options ()
1625         if not files or len (files) > 1:
1626                 ly.help ()
1627                 ly.exit (2)
1628
1629         file = files[0]
1630
1631         basename = os.path.splitext (file)[0]
1632         basename = os.path.split (basename)[1]
1633
1634         global process_cmd, format
1635         if not format:
1636                 format = guess_format (files[0])
1637
1638         formats = 'ps'
1639         if format == TEXINFO or format == HTML:
1640                 formats += ',png'
1641         if process_cmd == '':
1642                 process_cmd = lilypond_binary \
1643                               + ' --formats=%s --backend eps ' % formats
1644
1645         if process_cmd:
1646                 process_cmd += string.join ([(' -I %s' % commands.mkarg (p))
1647                                              for p in include_path])
1648
1649         ly.identify (sys.stderr)
1650
1651         try:
1652                 chunks = do_file (file)
1653                 if psfonts_p and invokes_lilypond ():
1654                         fontextract.verbose = verbose_p
1655                         snippet_chunks = filter (lambda x: is_derived_class (x.__class__,
1656                                                                               Lilypond_snippet),
1657                                                  chunks)
1658
1659                         psfonts_file = basename + '.psfonts'
1660                         if not verbose_p:
1661                                 ly.progress (_ ("Writing fonts to %s...") % psfonts_file)
1662                         fontextract.extract_fonts (psfonts_file,
1663                                                    [x.basename() + '.eps'
1664                                                     for x in snippet_chunks])
1665                         if not verbose_p:
1666                                 ly.progress ('\n')
1667
1668         except Compile_error:
1669                 ly.exit (1)
1670
1671         if format == TEXINFO or format == LATEX:
1672                 if not psfonts_p:
1673                         ly.warning (_ ("option --psfonts not used"))
1674                         ly.warning (_ ("processing with dvips will have no fonts"))
1675
1676                 psfonts_file = os.path.join (output_name, basename + '.psfonts')
1677                 output = os.path.join (output_name, basename +  '.dvi' )
1678
1679                 ly.progress ('\n')
1680                 ly.progress (_ ("DVIPS usage:"))
1681                 ly.progress ('\n')
1682                 ly.progress ("    dvips -h %(psfonts_file)s %(output)s" % vars ())
1683                 ly.progress ('\n')
1684
1685 if __name__ == '__main__':
1686         main ()