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