From: Tom Cato Amundsen Date: Sat, 21 Nov 1998 23:37:12 +0000 (+0100) Subject: patch::: 1.1.8.tca1 X-Git-Tag: release/1.1.9~6 X-Git-Url: https://git.donarmstrong.com/?a=commitdiff_plain;h=37be099a6bbb5f0818e3d1a66cdd71b04cafb4d4;p=lilypond.git patch::: 1.1.8.tca1 pl8.tca1 - changes to mudela-book. Junked fragment and floating options, added eps option. Options should not stay as long that you get comfortable with them. ;) - Also possible to define your own commands with a syntax like \mudela{c d e} - updated mudela-book-doc.doc ************** --- diff --git a/Documentation/tex/mudela-book-doc.doc b/Documentation/tex/mudela-book-doc.doc index 8edaf969c6..3aa58bedb9 100644 --- a/Documentation/tex/mudela-book-doc.doc +++ b/Documentation/tex/mudela-book-doc.doc @@ -1,155 +1,218 @@ -\documentclass[a4paper, 12pt, oneside]{article} +\documentclass[a4paper, 12pt]{article} \usepackage{t1enc,isolatin1} \usepackage{graphics} +%\usepackage[dvips]{graphicx} +\usepackage[rflt]{floatflt} %\usepackage{showframe} -\sloppy -\def\postMudelaExample{} +%\sloppy +\def\postMudelaExample{\setlength{\parindent}{1em}} +\title{Mudela-book tutorial} \begin{document} +\maketitle %\printparam -Mudela-book is a script that process your \LaTeX ~file and -with great help from GNU LilyPond -translates blocks of mudela code it finds inside \verb|mudela| -environment to tex or eps graphics. It then creates a new -file that can be sent through \LaTeX~ to create a document with -lines of music integrated with text. +Mudela-book is a script that process your \LaTeX~file and with great +help from GNU LilyPond it translates blocks of mudela code it finds +inside \verb|mudela| environments to tex or eps graphics. It then +creates a new file that can be sendt through \LaTeX~to create a .dvi +file with lines of music integrated with text. -So what does this look like? Well, here is a really -simple example: +Mudela-book will do its best to try to align the music to the left and +right margins. Currently the most used papersizes and one- and +twocolumn mode is supported, but if you use the geometry-package from +\LaTeX~or change the margins things will break. -\begin{mudela}[fragment, verbatim] - \relative c'{c4 d e f | g2 g} -\end{mudela} - -As you can see the mudela code is put inside a environment -called \verb|mudela|, shouldn't be too difficult to remember. -If you have never heard about \LaTeX, Mudela or that stuff -about environment, you should probably read some other manuals -before this. - -The code above produces this music: - -\begin{mudela}[fragment] - \relative c' {c4 d e f | g2 g } -\end{mudela} +This document assumes you have basic knowledge of GNU LilyPond and +\LaTeX. If the authors not-so-good english irritates you, please +send a patch. -The parameter \verb|fragment| means that mudela-book will insert -some red tape for you. There are one thing to remember. Currently -\verb|fragment|s don't know about margins and line width, so if -you type more than a few bars and want a line break, you can not -use \verb|fragment|. The \verb|verbatim| parameter is used to -make mudela-book print the mudela source instead of the -music. The parameter will probably not be visible in later versions -of mudela-book. +So what does this look like? Well, here is an example: -There are some conventions to follow to make the music respect -margins. You have to use \verb|\default_paper| as your paper, -to make mudela-book adjust the music to reach from the -left to the right margin. - -The following code \begin{mudela}[verbatim] \score{ - \notes\relative c'{c d e f | g2 g | a4 a a a | g1 | - f4 f f f | e2 e | d4 d d d | c1} - \paper{} + \notes\relative c'{ + \time 5/8; + [e16( g b c a g][e a b d] | )e2 d,8 | + [e16( g b c a g][e a b d] | )b2 [a16( f] | + [e a b d] )e4 c8 | [es16( bes a as g es][d c b! )g] | + [f( a b d b a][f a b d] | )e2 + } } \end{mudela} -gives this music: + +\noindent produces this music: + \begin{mudela} \score{ - \notes\relative c'{c d e f | g2 g | a4 a a a | g1 | - f4 f f f | e2 e | d4 d d d | c1} - \paper{} + \notes\relative c'{ + \time 5/8; + [e16( g b c a g][e a b d] | )e2 d,8 | + [e16( g b c a g][e a b d] | )b2 [a16( f] | + [e a b d] )e4 c8 | [es16( bes a as g es][d c b! )g] | + [f( a b d b a][f a b d] | )e2 + } } \end{mudela} -On my Debian 2.0 with LilyPond 1.0.17, teTex 0.9, -a4 paper and default line widht, the music is printet with -7 bars on the first line and 1 bars on the second. +If you are lucky, the above example show a nice feature of LilyPond +and \LaTeX. Since LilyPond can output the music as \TeX~graphics, +\LaTeX~can insert pagebreaks between the lines of music. -This does not look to well, but you can fix it by setting -the \verb|linewidth| variable to, let's say 8 cm. The paper -definition +Notice that there is no \verb|\paper| statement in the example +above. Mudela-book will insert some code for you that defines the +linewidth and the font to use. If you don't want to change the default, +there is no need to put an empty \verb|\paper{}| inside the \verb|\score|. +In the example above, something like +this might be inserted before your code: \begin{verbatim} -\paper{ -linewidth=8.\cm;} +\include "paper16.ly" +\paper{ \paper_sixteen + linewidth = 390.\pt; + castingalgorithm = \Gourlay; +} \end{verbatim} -makes this score: +The actual values for linewidth will differ depending on papersize and +number of columns. Also, if you use a different fontsize for the +music, another file than \verb|paper16.ly| will be included. + +If you want to make the music not so wide, you can insert a +\verb|\paper| statement that set the linewidth: + +\begin{mudela}[verbatim] +\score{ + \notes\relative c'{ + \time 5/8; + [e16( g b c a g][e a b d] | )e2 d,8 | + [e16( g b c a g][e a b d] | )b2 [a16( f] | + [e a b d] )e4 c8 | [es16( bes a as g es][d c b! )g] | + [f( a b d b a][f a b d] | )e2 + } + \paper{linewidth = 10.\cm;} +} +\end{mudela} + +\noindent produces this music: \begin{mudela} +% dette er en kommentar \score{ - \notes\relative c'{c d e f | g2 g | a4 a a a | g1 | - f4 f f f | e2 e | d4 d d d | c1} - \paper{ - linewidth=8.\cm;} + \notes\relative c'{ + \time 5/8; + [e16( g b c a g][e a b d] | )e2 d,8 | + [e16( g b c a g][e a b d] | )b2 [a16( f] | + [e a b d] )e4 c8 | [es16( bes a as g es][d c b! )g] | + [f( a b d b a][f a b d] | )e2 + } + \paper{linewidth = 10.\cm;} } \end{mudela} -The \verb|linewidth| variable is a LilyPond paper variable. -It is not spesific to mudela-book. See LilyPond tutorial and -reference manual for other variables. +Very often, if you mix music and text, the music is often only a +few notes or at most a few bars. This music should be as short as +possible and not stretched to be aligned to the right margin. -You can also, -\begin{mudela}[fragment, floating] - \relative c'{c c g' g | a a g2} -\end{mudela} -, include music in the middle of your text. Just give the option -\verb|floating| to \verb|\begin{mudela}| +If you only write voice-contents in the mudela block, mudela-book +will set the \verb|linewidth| variable to -1, so Lilypond +will make the music as short as possible but without breaking the +line. Here is a well know harmonic progression: +\begin{mudela} +% dette er en kommentar + +\end{mudela} +\noindent that is made by this code: +\begin{mudela}[verbatim] + +\end{mudela} + +If you want to place music examples in the text, +\begin{mudela}[eps] + +\end{mudela} +, you can use the \verb|eps| option. This will create the music as +eps graphics and include it into the document with the +\verb|\includegraphics| command. + +The code used look like this: +\begin{mudela}[eps, verbatim] + +\end{mudela} -Oh, you think the notes are to big to be in the middle of all those -small characters, that something like this, -\begin{mudela}[fragment, floating, 11pt] - \relative c'{c c g' g | a a g2} +You can also use the \verb|eps| option if the block is a complete +mudela source. This 5 cm long empty line, +\begin{mudela}[eps] +\score{ + \notes{s} + \paper{ linewidth = 5.\cm;} +} \end{mudela} -, is better? If you have a lot of small music examples like this -in the middle of your text, you might get a nicer look by using -``double'' line spacing. Put the \verb|\linespread{1.6}| command -into the preamble of your document. Then the line spacing will not -be increased between the lines where you have music printed with the -smalles font size. +was created with this code: +\begin{mudela}[eps, verbatim] +\score{ + \notes{s} + \paper{ linewidth = 5.\cm;} +} +\end{mudela} +To avoid that \LaTeX~places the music on a line of its one, there should +be no empty lines between the normal text and the mudela +environment. + +There is an even shorter way to write small musical fragments. This +triad, \mudela{}, was created with this code: +\verb|\mudela{}| +Mudela-book let you define your own commands, see the file +\verb|mudela-book-defs.py|. In a later version, it will be possible to +have your own file that defines new commands. To print small rhythms +like this, \mudelaRhythm{c4 r8 [c16 c] c4 c}, the default +\verb|mudela-book-defs.py| also defines a command \verb|mudelaRhythm|. +The last music was created like this: +\verb|\mudelaRhytm{c4 r8 [c16 c] c4 c}|. This feature is higly +experimental, so Things Will Change. -To change font size is easy, just give the fontsize as a parameter to -\verb|\begin{mudela}|. The last piece of music was created with this -code: -\begin{mudela}[fragment, floating, 11pt, verbatim] - \relative c'{c c g' g | a a g2} +The last example show that we need options to change the +% LONG line just to test multiple mudela on one line +fontsize of the music. 11pt, \mudela[11pt]{} or 13pt, \mudela[13pt]{} is probably a better fontsize +if you include music in the middle of the text. The code looks like this: +\verb|\mudela[11pt]{}| + +or +\begin{mudela}[13pt, verbatim] + \end{mudela} -You can use the following font sizes: +The following options set the fontsize: \begin{itemize} -\item 11 pt -\begin{mudela}[11pt, fragment, floating] +\item \verb|11pt| +\begin{mudela}[11pt, eps] \relative c'{ r16 [c d e][f d e c] [g'8 c][b-\prall c] | [d16 g, a b][c a b g][d'8 g f-\prall g] } \end{mudela} -\item 13 pt -\begin{mudela}[13pt, fragment, floating] +\item \verb|13pt| +\begin{mudela}[13pt, eps] \relative c'{ r16 [c d e][f d e c] [g'8 c][b-\prall c] | [d16 g, a b][c a b g][d'8 g f-\prall g] } \end{mudela} -\item 16 pt -\begin{mudela}[16pt, fragment, floating] +\item \verb|16pt| +\begin{mudela}[16pt, eps] \relative c'{ r16 [c d e][f d e c] [g'8 c][b-\prall c] | [d16 g, a b][c a b g][d'8 g f-\prall g] } \end{mudela} -\item 20 pt -\begin{mudela}[20pt, fragment, floating] +\item \verb|20pt| +\begin{mudela}[20pt, eps] \relative c'{ r16 [c d e][f d e c] [g'8 c][b-\prall c] | [d16 g, a b][c a b g][d'8 g f-\prall g] } \end{mudela} -\item 26 pt -\begin{mudela}[26pt, fragment, floating] +\item \verb|26pt| +\begin{mudela}[26pt, eps] \relative c'{ r16 [c d e][f d e c] [g'8 c][b-\prall c] | [d16 g, a b][c a b g][d'8 g f-\prall g] @@ -157,31 +220,110 @@ You can use the following font sizes: \end{mudela} \end{itemize} -As\marginpar{ +This was all options to \verb|\begin{mudela}|. The rest of the +document will show some ways you can use mudela in +\LaTeX~documents. It will also act as a simple test-suite for +mudela-book. You \marginpar{ marginpar! -\begin{mudela}[11pt, fragment, floating] - \relative c''{\key es; r8 [g g g] es2} +\begin{mudela}[eps, 11pt] + \relative c'' {\key c \minor; r4 [g8 g g] es2} \end{mudela} -} -you can see, \verb|floating| mudela don't know about margins. -Remember that to place the music anywhere\footnote{ +}can place \verb|eps| mudela in footnotes\footnote{ footnote! -\begin{mudela}[11pt, fragment, floating] - \relative c''{\key es; r8 [g g g] es2} +\begin{mudela}[eps, 11pt] + \relative c'' {\key c \minor;r4 [g8 g g] es2} \end{mudela} } - else than at the left margin you must use the option \verb|floating|. +and marginspars just as any other included eps graphics. + +\begin{floatingfigure}[r]{7cm} +\begin{mudela} +\score{ + \notes\relative c'{ + \time 12/8; + r4-\fermata [b16-.( )b-.] [f'8-- dis16-.( )dis-. gis8--] + [f16-.( )f-. dis8-- gis16-.( )gis-.] cis4.-\fermata | + + r4.-\fermata [cis,16 cis g'8 f16 f b][g16 g f8 b16 b] dis4.-\fermata + } + \paper{linewidth = 7.\cm;} +} +\end{mudela} +\end{floatingfigure} + +To the right you can see some bars from the trumpet fanfara from the +beginning of the fantastic street opera ``Houdini the Great'', by the +danish composer Andy Pape. The music is put inside a +\verb|floatingfigure| environment, and the music will be aligned by +the right marging if you set floatingfigure width and mudela linewidth +to the same value. The code looks like this: + +\verb|\begin{floatingfigure}{7cm}| +\begin{mudela}[verbatim] +\score{ + \notes\relative c'{ + \time 12/8; + r4.-\fermata [b16-.( )b-.] [f'8-- dis16-.( )dis-. gis8--] + [f16-.( )f-. dis8-- gis16-.( )gis-.] cis8.-\fermata | + + r4.-\fermata [cis,16 cis g'8 f16 f b] + [g16 g f8 b16 b] dis4.-\fermata + } + \paper{linewidth = 7.\cm;} +} +\end{mudela} +\verb|\end{floatingfigure}| -\twocolumn[\Large The following is written in two columns \normalsize] -Sinse the version number is quite low, 0.4.0 last I checked, you -should be careful not to mix braces that belongs to mudela-book and -\LaTeX ~on the same line. The following code will probably break: +\twocolumn[\large The following is written in two columns just to show +what mudela-book can do..\normalsize] -\verb|\footnote{\be|\verb|gin{mudela}| +Tabulars is also nice. Here you have a chance to learn the norwegian +names of some triads: +\vspace{1em} + +\begin{tabular}{|l|l|} +\hline + +dur & +\begin{mudela}[eps] + +\end{mudela} +\\ +\hline moll & +\begin{mudela}[eps] + +\end{mudela} +\\ +\hline forminsket & +\begin{mudela}[eps] + +\end{mudela} +\\ +\hline forstørret & +\begin{mudela}[eps] + +\end{mudela} +\\ +\hline +\end{tabular} + +\vspace{1em} +If you have a lot of small music examples +like this in the middle of your text, you might get a nicer look by +using ``double'' line spacing. Put the \verb|\linespread{1.6}| command +into the preamble of your document. Then the line spacing will not be +increased between the lines where you have music printed with the +smallest font size. + +Sinse the version number is quite low, you should be careful not to +mix braces that belongs to mudela-book and \LaTeX~on the same +line. The following code will probably break: + +\verb|\footnote{\begin{mudela}| \verb|\relative c''{ \key es; r8 [g g g] es2} | -\verb|\e|\verb|nd{mudela}}| +\verb|\end{mudela}}| Mudela-book does know about \verb|\onecolumn| and \verb|\twocolumn|. So the music will be adjusted to the new linewith: @@ -189,7 +331,6 @@ So the music will be adjusted to the new linewith: \score{ \notes\relative c'{c d e f | g2 g | a4 a a a | g1 | f4 f f f | e2 e | d4 d d d | c1} - \paper{} } \end{mudela} produces @@ -197,16 +338,12 @@ produces \score{ \notes\relative c'{c d e f | g2 g | a4 a a a | g1 | f4 f f f | e2 e | d4 d d d | c1} - \paper{} } \end{mudela} -As in one column mode, \verb|fragment|s don't know about -the line width: -\begin{mudela}[fragment] - \relative c'{[c8 e][d f][e g][f a] | [g b][a c][b d] c4 | - [e8 c][d b][c a][b g] | [a f][g e][f d] c4 } -\end{mudela} Verbatim environments will also ignore the page margins. That is -a feature of \LaTeX. +a feature of \LaTeX. (But you usually put things inside a verbatim +environment when you don't want \LaTeX~to do any linebreaking) + \end{document} + diff --git a/NEWS b/NEWS index a1f5cf865f..7a96658e8c 100644 --- a/NEWS +++ b/NEWS @@ -1,3 +1,11 @@ +pl8.tca1 + - changes to mudela-book. Junked fragment and floating options, + added eps option. Options should not stay as long that you get + comfortable with them. ;) + - Also possible to define your own commands with + a syntax like \mudela{c d e} + - updated mudela-book-doc.doc +************** pl 8 pl7.jcn3 diff --git a/VERSION b/VERSION index 0a70c242e4..f5b0cf0783 100644 --- a/VERSION +++ b/VERSION @@ -2,7 +2,7 @@ PACKAGE_NAME=LilyPond MAJOR_VERSION=1 MINOR_VERSION=1 PATCH_LEVEL=8 -MY_PATCH_LEVEL= +MY_PATCH_LEVEL=tca1 # use the above to send patches: MY_PATCH_LEVEL is always empty for a # released version. diff --git a/scripts/mudela-book.py b/scripts/mudela-book.py index cf176a6c1b..bdfc00b4ff 100644 --- a/scripts/mudela-book.py +++ b/scripts/mudela-book.py @@ -1,17 +1,19 @@ #!@PYTHON@ # All non-english comments are NOT in swedish, they are norwegian! - -# TODO: center option (??) -# * the verbatim option should not be visible in the created latex file -# * what the h.. does castingalgorithm do/mean??? +# TODO: +# * center option (??) +# * mudela-book should treat \begin{verbatim} that contains inline mudela +# correctly. +# * make mudela-book understand usepackage{geometry} +# * check that linewidth set in \paper is not wider than actual linewidth? # * the following fails because mudelabook doesn't care that the # last } after \end{mudela} finishes the marginpar: # \marginpar{ -# \begin{mudela}[fragment] +# \begin{mudela} # c d e f g # \end{mudela}} -# * fragments should know about margins - +# * force-verbatim is maybe not that useful since latex fails with footnotes, +# marginpars and others # log: # 0.3: # rewrite in Python. @@ -22,6 +24,18 @@ # - cleanup # - speedup, do all mudela parsing at the same time to avoid multiple # guile startup that takes some seconds on my computer +# 0.4.2: +# - fixed default latex fontsize, it should be 10pt not 11pt +# - verbatim option no longer visible +# - mudela-book produces .dvi output +# - change to use castingalgorithm = \Gourlay instead of \Wordwrap. It gives +# better result on small linewidths. +# - mudela-book-doc.doc rewritten +# 0.5: +# - junked floating and fragment options, added eps option +# - mudela-book will scan the mudela code to find out if it has to add +# paper-definition and \score{\notes{...}} +# - possible to define commands that look like this: \mudela{ c d e } import os import string @@ -30,17 +44,18 @@ import getopt import sys outdir = 'out' -program_version = '0.4.1' +initfile = '' +program_version = '0.5' out_files = [] -fontsize_i2a = {11:'eleven', 13:'thirteen', 16:'sixteen', 20:'twenty', 26:'twentysix'} +fontsize_i2a = {11:'eleven', 13:'thirteen', 16:'sixteen', + 20:'twenty', 26:'twentysix'} fontsize_pt2i = {'11pt':11, '13pt':13, '16pt':16, '20pt':20, '26pt':26} begin_mudela_re = re.compile ('^ *\\\\begin{mudela}') extract_papersize_re = re.compile('\\\\documentclass[\[, ]*(\w*)paper[\w ,]*\]\{\w*\}') -extract_fontsize1_re = re.compile('\\\\documentclass\[[^\]]*\]\{[^\}]*\}') -extract_fontsize2_re = re.compile('[ ,\[]*([0-9]*)pt') +extract_fontsize_re = re.compile('[ ,\[]*([0-9]*)pt') begin_mudela_opts_re = re.compile('\[[^\]]*\]') end_mudela_re = re.compile ('^ *\\\\end{mudela}') section_re = re.compile ('\\\\section') @@ -139,7 +154,7 @@ class Properties: 'mudela-fontsize' : {'init': 16}, 'papersize' : {'init': 'a4'}, 'num-column' : {'init': 1}, - 'tex-fontsize' : {'init': 11} + 'tex-fontsize' : {'init': 10} } def clear_for_new_file(self): for var in self.__data.keys(): @@ -182,51 +197,68 @@ class Mudela_output: self.basename = basename self.temp_filename = "%s/%s" %(outdir, 'mudela-temp.ly') self.file = open (self.temp_filename, 'w') + self.__lines = [] # 'tex' or 'eps' self.graphic_type = 'tex' - self.fragment = 0 + self.code_type = 'unknown' def write (self, line): # match only if there is nothing but whitespace before \begin HACK if re.search('^\s*\\\\begin{mudela}', line): self.scan_begin_statement(line) - self.write_red_tape() else: - self.file.write (line) + if self.code_type == 'unknown': + if re.search('^\s*\\\\score', line) or \ + re.search('^\s*\\\\paper', line) or \ + re.search('^\s*\\\\header', line) or \ + re.search('^\s*[A-Za-z]*\s*=', line): + self.code_type = 'ly' + self.__lines.append(line) def scan_begin_statement(self, line): r = begin_mudela_opts_re.search(line) if r: - o = r.group()[1:][:-1] - optlist = re.compile('[ ,]*').split(o) + o = r.group()[1:-1] + optlist = re.compile('[\s,]*').split(o) else: optlist = [] + if 'fragment' in optlist: + print "warning: obsolete option: fragment" if 'floating' in optlist: + print "warning: obsolete option: floating, change to eps" + if 'eps' in optlist: self.graphic_type = 'eps' - else: - self.graphic_type = 'tex' - if 'fragment' in optlist: - self.fragment = 1 - else: - self.fragment = 0 for pt in fontsize_pt2i.keys(): if pt in optlist: Props.setMudelaFontsize(fontsize_pt2i[pt], 'block') def write_red_tape(self): - self.file.write ('\\include \"paper%d.ly\"\n' % Props.getMudelaFontsize()) + self.file.write ('\\include \"paper%d.ly\"\n' \ + % Props.getMudelaFontsize()) + s = fontsize_i2a[Props.getMudelaFontsize()] - if self.fragment: - self.file.write("\\paper {" # mudela 1.0.4 - + "\\paper_%s\n linewidth = -1.\\pt;" % s - + "castingalgorithm = \Wordwrap; indent = 2.\cm; \n}") - self.file.write("\\score{\n\\notes{") + if self.code_type == 'fly': + linewidth_str = 'linewidth = -1.\cm;' else: - self.file.write ("\paper {" - + "\\paper_%s\n linewidth = %i.\\pt;" % \ - (s, Props.getLineWidth()) \ - + "castingalgorithm = \Wordwrap; indent = 2.\cm;\n}") + linewidth_str = 'linewidth = %i.\\pt;' % Props.getLineWidth() + self.file.write("\\paper {" + + "\\paper_%s " % s + + linewidth_str + + "castingalgorithm = \Gourlay; \n}") + #+ "castingalgorithm = \Wordwrap; indent = 2.\cm; \n}") + if self.code_type == 'fly': + self.file.write('\\score{\n\\notes{') def close (self): - if self.fragment: - self.file.write ('}\\paper { } }\n') - self.file.close () + if self.code_type == 'unknown': + self.code_type = 'fly' + if self.code_type == 'ly': + self.write_red_tape() + for l in self.__lines: + self.file.write(l) + else: + self.write_red_tape() + for l in self.__lines: + self.file.write(l) + self.file.write('}}') + + self.file.close() inf = outdir + self.basename + '.ly' outf = outdir + self.basename + '.tex' @@ -251,8 +283,11 @@ class Tex_output: def __init__ (self, name): self.output_fn = '%s/%s' % (outdir, name) self.__lines = [] - def open_verbatim (self): + def open_verbatim (self, line): self.__lines.append('\\begin{verbatim}\n') + s = re.sub('[\s,]*verbatim[\s]*', '', line) + s = re.sub('\[\]', '', s) + self.__lines.append(s); def close_verbatim (self): self.__lines.append('\\end{verbatim}\n') def write (self, s): @@ -267,31 +302,30 @@ class Tex_output: if need_recompile_b(outdir+g[1]+'.ly', outdir+g[1]+'.tex'): s = s + ' ' + g[1]+'.ly' if s != '': - os.system('cd %s; lilypond %s' %(outdir, s)) + e = os.system('cd %s; lilypond %s' %(outdir, s)) + if e: + print "error: lilypond exited with value", e + sys.exit(e) for g in g_vec: if g[0] == 'eps': compile('tex %s' % g[1]+'.tex', outdir, g[1]+'.tex', g[1]+'.dvi') compile('dvips -E -o %s %s' %(g[1]+'.eps', g[1]+'.dvi'), outdir, g[1]+'.dvi', g[1]+'.eps') def write_outfile(self): - outfn = self.output_fn+'.latex' - sys.stderr.write ('Writing output to `%s\'\n'% outfn) - file = open(outfn, 'w') + file = open(self.output_fn+'.latex', 'w') file.write('% Created by mudela-book\n') for line in self.__lines: if type(line)==type([]): if line[0] == 'tex': file.write('\\preMudelaExample\\input %s\n\postMudelaExample '\ -# % (outdir+line[1]+'.tex')) - # TeX applies the prefix of the main source automatically. - % (line[1]+'.tex')) + % (line[1]+'.tex')) +# % (outdir+line[1]+'.tex')) if line[0] == 'eps': ps_dim = ps_dimention(outdir+line[1]+'.eps') file.write('\\parbox{%ipt}{\includegraphics{%s}}\n' \ -# % (ps_dim[0], outdir+line[1]+'.eps')) % (ps_dim[0], line[1]+'.eps')) - +# % (ps_dim[0], outdir+line[1]+'.eps')) else: file.write(line) file.close() @@ -300,16 +334,18 @@ class Tex_input: for fn in [filename, filename+'.tex', filename+'.doc']: try: self.infile = open (fn) + self.filename = fn + return except: continue - self.filename = fn - break + raise IOError def get_lines (self): lines = self.infile.readlines () (retlines, retdeps) = ([],[self.filename]) for line in lines: r_inp = input_re.search (line) r_inc = include_re.search (line) + # Filename rules for \input : # input: no .tex ext # 1. will search for file with exact that name (tex-input.my will be found) @@ -321,20 +357,57 @@ class Tex_input: # Filename rules for \include : # 1. will only find files with name given to \include + .tex ext if r_inp: - t = Tex_input (r_inp.groups()[0]) - ls = t.get_lines () - retlines = retlines + ls[0] - retdeps = retdeps + ls[1] + try: + t = Tex_input (r_inp.groups()[0]) + ls = t.get_lines () + retlines = retlines + ls[0] + retdeps = retdeps + ls[1] + except: + print "warning: can't find %s, let's hope latex will" \ + % r_inp.groups()[0] + retlines.append (line) elif r_inc: - t = Tex_input (r_inc.groups()[0]+'.tex') - ls =t.get_lines () - ls[0].insert(0, '\\newpage\n') - ls[0].append('\\newpage\n') - retlines = retlines + ls[0] - retdeps = retdeps + ls[1] + try: + t = Tex_input (r_inc.groups()[0]+'.tex') + ls =t.get_lines () + ls[0].insert(0, '\\newpage\n') + ls[0].append('\\newpage\n') + retlines = retlines + ls[0] + retdeps = retdeps + ls[1] + except: + print "warning: can't find %s, let's hope latex will" \ + % r_inc.groups()[0] + retlines.append (line) else: - retlines.append (line) - return (retlines, retdeps) + r_mud = defined_mudela_cmd_re.search(line) + if r_mud: + ss = "\\\\verb(?P[^a-zA-Z])\s*\\\\%s\s*(?P=xx)" \ + % re.escape(r_mud.group()[1:]) + if re.search(ss, line): + retlines.append(line) + continue + while 1: + opts = r_mud.groups()[2] + if opts == None: + opts = '' + else: + opts = ', '+opts + (start, rest) = string.split(line, r_mud.group(), 1) + retlines.append(start+'\n') + v = string.split(defined_mudela_cmd[r_mud.groups()[0]], '\n') + for l in v[1:-1]: + l = re.sub(r'\\fontoptions', opts, l) + l = re.sub(r'\\maininput', r_mud.groups()[3], l) + retlines.append(l) + r_mud = defined_mudela_cmd_re.search(rest) + if not r_mud: + retlines.append(rest) + break; + line = rest + else: + retlines.append (line) + else: + return (retlines, retdeps) class Main_tex_input(Tex_input): @@ -360,19 +433,17 @@ class Main_tex_input(Tex_input): self.chapter = self.chapter + 1 def gen_basename (self): - return '%s-%d.%d.%d' % (self.outname,self.chapter,self.section,self.fine_count) - #return '%s/%s-%d.%d.%d' % (outdir, self.outname,self.chapter,self.section,self.fine_count) - + return '%s-%d.%d.%d' % (self.outname, self.chapter, + self.section, self.fine_count) def extract_papersize_from_documentclass(self, line): pre = extract_papersize_re.search(line) if not pre: return None return pre.groups()[0] def extract_fontsize_from_documentclass(self, line): - if extract_fontsize1_re.search(line): - r = extract_fontsize2_re.search(line) - if r: - return int(r.groups()[0]) + r = extract_fontsize_re.search(line) + if r: + return int(r.groups()[0]) def do_it(self): preMudelaDef = postMudelaDef = 0 (lines, self.deps) = self.get_lines () @@ -411,11 +482,11 @@ class Main_tex_input(Tex_input): optlist = [] if ('verbatim' in optlist) or (Props.force_verbatim_b): self.verbatim = 1 - self.mudtex.open_verbatim () + self.mudtex.open_verbatim (line) + continue else: self.verbatim = 0 self.mudela = Mudela_output (self.gen_basename ()) - elif end_mudela_re.search (line): if __debug__: if self.mode != 'mudela': @@ -451,15 +522,17 @@ Options:\n -o, --outname=FILE prefix for filenames --default-mudela-fontsize=??pt default fontsize for music --force-mudela-fontsize=??pt force fontsize for all inline mudela - --force-verbatim make all mudela verbatim\n""" + --force-verbatim make all mudela verbatim\n + --dependencies write dependencies + --init mudela-book initfile + """ ) sys.exit (0) def write_deps (fn, out, deps): out_fn = outdir + '/' + fn - out_fn = re.sub ('//', '/', out_fn) - print 'writing `%s\'\n' % out_fn + print '`writing `%s\'\n\'' % out_fn f = open (out_fn, 'w') f.write ('%s: %s\n'% (outdir + '/' + out + '.dvi', @@ -470,7 +543,7 @@ def identify(): sys.stderr.write ('This is %s version %s\n' % ('mudela-book', program_version)) def main(): - global outdir + global outdir, initfile, defined_mudela_cmd, defined_mudela_cmd_re outname = '' try: (options, files) = getopt.getopt( @@ -478,13 +551,13 @@ def main(): 'default-mudela-fontsize=', 'force-mudela-fontsize=', 'help', 'dependencies', - 'force-verbatim']) + 'force-verbatim', 'init=']) except getopt.error, msg: print "error:", msg sys.exit(1) do_deps = 0 - for opt in options: + for opt in options: o = opt[0] a = opt[1] if o == '--outname' or o == '-o': @@ -513,10 +586,40 @@ def main(): Props.force_mudela_fontsize = fontsize_pt2i[a] if o == '--force-verbatim': Props.force_verbatim_b = 1 - + if o == '--init': + initfile = a if outdir[-1:] != '/': outdir = outdir + '/' + std_init_filename = '' + for p in string.split(os.environ['LILYINCLUDE'], ':'): + try: + std_init_filename = p+os.sep+'mudela-book-defs.py' + break + except: + continue + if std_init_filename == '': + print "error: Can't find mudela-book-defs.py" + os.exit(-1) + f = open(std_init_filename) + s = f.read() + f.close() + defined_mudela_cmd = eval(s) + + if initfile != '': + f = open(initfile) + s = f.read() + f.close() + d = eval(s) + for i in d.keys(): + defined_mudela_cmd[i] = d[i] + del d + + c = defined_mudela_cmd.keys()[0] + for x in defined_mudela_cmd.keys()[1:]: + c = c + '|'+x + defined_mudela_cmd_re = re.compile("\\\\(%s)(\[(\d*pt)\])*{([^}]*)}" %c) + if not os.path.isdir(outdir): os.system('mkdir %s' % outdir) @@ -529,8 +632,7 @@ def main(): my_depname = my_outname + '.dep' inp = Main_tex_input (input_filename, my_outname) inp.do_it () - - +# os.system('latex %s/%s.latex' % (outdir, my_outname)) if do_deps: write_deps (my_depname, my_outname, inp.deps) diff --git a/scripts/old-mudela-book.py b/scripts/old-mudela-book.py new file mode 100644 index 0000000000..cf176a6c1b --- /dev/null +++ b/scripts/old-mudela-book.py @@ -0,0 +1,539 @@ +#!@PYTHON@ +# All non-english comments are NOT in swedish, they are norwegian! + +# TODO: center option (??) +# * the verbatim option should not be visible in the created latex file +# * what the h.. does castingalgorithm do/mean??? +# * the following fails because mudelabook doesn't care that the +# last } after \end{mudela} finishes the marginpar: +# \marginpar{ +# \begin{mudela}[fragment] +# c d e f g +# \end{mudela}} +# * fragments should know about margins + +# log: +# 0.3: +# rewrite in Python. +# 0.4: +# much rewritten by new author. I think the work has been split more +# logical between different classes. +# 0.4.1: +# - cleanup +# - speedup, do all mudela parsing at the same time to avoid multiple +# guile startup that takes some seconds on my computer + +import os +import string +import re +import getopt +import sys + +outdir = 'out' +program_version = '0.4.1' + +out_files = [] + +fontsize_i2a = {11:'eleven', 13:'thirteen', 16:'sixteen', 20:'twenty', 26:'twentysix'} +fontsize_pt2i = {'11pt':11, '13pt':13, '16pt':16, '20pt':20, '26pt':26} + +begin_mudela_re = re.compile ('^ *\\\\begin{mudela}') +extract_papersize_re = re.compile('\\\\documentclass[\[, ]*(\w*)paper[\w ,]*\]\{\w*\}') +extract_fontsize1_re = re.compile('\\\\documentclass\[[^\]]*\]\{[^\}]*\}') +extract_fontsize2_re = re.compile('[ ,\[]*([0-9]*)pt') +begin_mudela_opts_re = re.compile('\[[^\]]*\]') +end_mudela_re = re.compile ('^ *\\\\end{mudela}') +section_re = re.compile ('\\\\section') +chapter_re = re.compile ('\\\\chapter') +input_re = re.compile ('^\\\\input{([^}]*)') +include_re = re.compile ('^\\\\include{([^}]*)') +begin_document_re = re.compile ('^ *\\\\begin{document}') +documentclass_re = re.compile('\\\\documentclass') +twocolumn_re = re.compile('\\\\twocolumn') +onecolumn_re = re.compile('\\\\onecolumn') +preMudelaExample_re = re.compile('\\\\def\\\\preMudelaExample') +postMudelaExample_re = re.compile('\\\\def\\\\postMudelaExample') +boundingBox_re = re.compile('%%BoundingBox: ([0-9]*) ([0-9]*) ([0-9]*) ([0-9]*)') + +def file_exist_b(name): + try: + f = open(name) + except IOError: + return 0 + f.close () + return 1 + +def ps_dimention(fname): + fd = open(fname) + lines = fd.readlines() + for line in lines: + s = boundingBox_re.search(line) + if s: + break + return (int(s.groups()[2])-int(s.groups()[0]), + int(s.groups()[3])-int(s.groups()[1])) + + +class CompileStatus: + pass +class SomethingIsSeriouslyBroken: + pass + +def file_mtime (name): + return os.stat (name)[8] #mod time + +def need_recompile_b(infile, outfile): + indate = file_mtime (infile) + try: + outdate = file_mtime (outfile) + return indate > outdate + except os.error: + return 1 + +# +# executes os.system(command) if infile is newer than +# outfile or outfile don't exist +# +def compile (command, workingdir, infile, outfile): + "Test if infile is newer than outfile. If so, cd to workingdir" + "and execute command" + indate = file_mtime (workingdir+infile) + try: + outdate = file_mtime (workingdir+outfile) + recompile = indate > outdate + + except os.error: + recompile = 1 + + if recompile: + sys.stderr.write ('invoking `%s\'\n' % command) + if workingdir == '': + status = os.system (command) + else: + status = os.system ('cd %s; %s' %(workingdir, command)) + if status: + raise CompileStatus + +class Properties: + # + # init + # + def __init__(self): + self.__linewidth = { + 1: {'a4':{10: 345, 11: 360, 12: 390}, + 'a5':{10: 276, 11: 276, 12: 276}, + 'b5':{10: 345, 11: 356, 12: 356}, + 'letter':{10: 345, 11: 360, 12: 390}, + 'legal': {10: 345, 11: 360, 12: 390}, + 'executive':{10: 345, 11: 360, 12: 379}}, + 2: {'a4':{10: 167, 11: 175, 12: 190}, + 'a5':{10: 133, 11: 133, 12: 133}, + 'b5':{10: 167, 11: 173, 12: 173}, + 'letter':{10: 167, 11: 175, 12: 190}, + 'legal':{10: 167, 11: 175, 12: 190}, + 'executive':{10: 167, 11: 175, 12: 184}}} + # >0 --> force all mudela to this pt size + self.force_mudela_fontsize = 0 + self.force_verbatim_b = 0 + self.__data = { + 'mudela-fontsize' : {'init': 16}, + 'papersize' : {'init': 'a4'}, + 'num-column' : {'init': 1}, + 'tex-fontsize' : {'init': 11} + } + def clear_for_new_file(self): + for var in self.__data.keys(): + self.__data[var] = {'init': self.__data[var]['init']} + def clear_for_new_block(self): + for var in self.__data.keys(): + if self.__data[var].has_key('block'): + del self.__data[var]['block'] + def __get_variable(self, var): + if self.__data[var].has_key('block'): + return self.__data[var]['block'] + elif self.__data[var].has_key('file'): + return self.__data[var]['file'] + else: + return self.__data[var]['init'] + def setPapersize(self, size, requester): + self.__data['papersize'][requester] = size + def getPapersize(self): + return self.__get_variable('papersize') + def setMudelaFontsize(self, size, requester): + self.__data['mudela-fontsize'][requester] = size + def getMudelaFontsize(self): + if self.force_mudela_fontsize: + return self.force_mudela_fontsize + return self.__get_variable('mudela-fontsize') + def setTexFontsize(self, size, requester): + self.__data['tex-fontsize'][requester] = size + def getTexFontsize(self): + return self.__get_variable('tex-fontsize') + def setNumColumn(self, num, requester): + self.__data['num-column'][requester] = num + def getNumColumn(self): + return self.__get_variable('num-column') + def getLineWidth(self): + return self.__linewidth[self.getNumColumn()][self.getPapersize()][self.getTexFontsize()] + + +class Mudela_output: + def __init__ (self, basename): + self.basename = basename + self.temp_filename = "%s/%s" %(outdir, 'mudela-temp.ly') + self.file = open (self.temp_filename, 'w') + # 'tex' or 'eps' + self.graphic_type = 'tex' + self.fragment = 0 + def write (self, line): + # match only if there is nothing but whitespace before \begin HACK + if re.search('^\s*\\\\begin{mudela}', line): + self.scan_begin_statement(line) + self.write_red_tape() + else: + self.file.write (line) + def scan_begin_statement(self, line): + r = begin_mudela_opts_re.search(line) + if r: + o = r.group()[1:][:-1] + optlist = re.compile('[ ,]*').split(o) + else: + optlist = [] + if 'floating' in optlist: + self.graphic_type = 'eps' + else: + self.graphic_type = 'tex' + if 'fragment' in optlist: + self.fragment = 1 + else: + self.fragment = 0 + for pt in fontsize_pt2i.keys(): + if pt in optlist: + Props.setMudelaFontsize(fontsize_pt2i[pt], 'block') + def write_red_tape(self): + self.file.write ('\\include \"paper%d.ly\"\n' % Props.getMudelaFontsize()) + s = fontsize_i2a[Props.getMudelaFontsize()] + if self.fragment: + self.file.write("\\paper {" # mudela 1.0.4 + + "\\paper_%s\n linewidth = -1.\\pt;" % s + + "castingalgorithm = \Wordwrap; indent = 2.\cm; \n}") + self.file.write("\\score{\n\\notes{") + else: + self.file.write ("\paper {" + + "\\paper_%s\n linewidth = %i.\\pt;" % \ + (s, Props.getLineWidth()) \ + + "castingalgorithm = \Wordwrap; indent = 2.\cm;\n}") + def close (self): + if self.fragment: + self.file.write ('}\\paper { } }\n') + self.file.close () + + inf = outdir + self.basename + '.ly' + outf = outdir + self.basename + '.tex' + if not os.path.isfile(inf): + status = 1 + else: + status = os.system ('diff -q %s %s' % (self.temp_filename, inf)) + if status: + os.rename (self.temp_filename, inf) + if need_recompile_b(inf, outf): + out_files.append((self.graphic_type, inf)) + def insert_me_string(self): + "Returns a string that can be used directly in latex." + if self.graphic_type == 'tex': + return ['tex', self.basename] + elif self.graphic_type == 'eps': + return ['eps', self.basename] + else: + raise SomethingIsSeriouslyBroken + +class Tex_output: + def __init__ (self, name): + self.output_fn = '%s/%s' % (outdir, name) + self.__lines = [] + def open_verbatim (self): + self.__lines.append('\\begin{verbatim}\n') + def close_verbatim (self): + self.__lines.append('\\end{verbatim}\n') + def write (self, s): + self.__lines.append(s) + def create_graphics(self): + s = '' + g_vec = [] + for line in self.__lines: + if type(line)==type([]): + g_vec.append(line) + for g in g_vec: + if need_recompile_b(outdir+g[1]+'.ly', outdir+g[1]+'.tex'): + s = s + ' ' + g[1]+'.ly' + if s != '': + os.system('cd %s; lilypond %s' %(outdir, s)) + for g in g_vec: + if g[0] == 'eps': + compile('tex %s' % g[1]+'.tex', outdir, g[1]+'.tex', g[1]+'.dvi') + compile('dvips -E -o %s %s' %(g[1]+'.eps', g[1]+'.dvi'), outdir, + g[1]+'.dvi', g[1]+'.eps') + def write_outfile(self): + outfn = self.output_fn+'.latex' + sys.stderr.write ('Writing output to `%s\'\n'% outfn) + file = open(outfn, 'w') + file.write('% Created by mudela-book\n') + for line in self.__lines: + if type(line)==type([]): + if line[0] == 'tex': + file.write('\\preMudelaExample\\input %s\n\postMudelaExample '\ +# % (outdir+line[1]+'.tex')) + + # TeX applies the prefix of the main source automatically. + % (line[1]+'.tex')) + if line[0] == 'eps': + ps_dim = ps_dimention(outdir+line[1]+'.eps') + file.write('\\parbox{%ipt}{\includegraphics{%s}}\n' \ +# % (ps_dim[0], outdir+line[1]+'.eps')) + % (ps_dim[0], line[1]+'.eps')) + + else: + file.write(line) + file.close() +class Tex_input: + def __init__ (self, filename): + for fn in [filename, filename+'.tex', filename+'.doc']: + try: + self.infile = open (fn) + except: + continue + self.filename = fn + break + def get_lines (self): + lines = self.infile.readlines () + (retlines, retdeps) = ([],[self.filename]) + for line in lines: + r_inp = input_re.search (line) + r_inc = include_re.search (line) + # Filename rules for \input : + # input: no .tex ext + # 1. will search for file with exact that name (tex-input.my will be found) + # 2. will search for file with .tex ext, (tex-input.my + # will find tex-input.my.tex) + # input: with .tex ext + # 1. will find exact match + + # Filename rules for \include : + # 1. will only find files with name given to \include + .tex ext + if r_inp: + t = Tex_input (r_inp.groups()[0]) + ls = t.get_lines () + retlines = retlines + ls[0] + retdeps = retdeps + ls[1] + elif r_inc: + t = Tex_input (r_inc.groups()[0]+'.tex') + ls =t.get_lines () + ls[0].insert(0, '\\newpage\n') + ls[0].append('\\newpage\n') + retlines = retlines + ls[0] + retdeps = retdeps + ls[1] + else: + retlines.append (line) + return (retlines, retdeps) + + +class Main_tex_input(Tex_input): + def __init__ (self, name, outname): + + Tex_input.__init__ (self, name) # ugh + self.outname = outname + self.chapter = 0 + self.section = 0 + self.fine_count =0 + self.mudtex = Tex_output (self.outname) + self.mudela = None + self.deps = [] + self.verbatim = 0 + # set to 'mudela' when we are processing mudela code, + # both verbatim and graphic-to-be + self.mode = 'latex' + def set_sections (self, l): + if section_re.search (l): + self.section = self.section + 1 + if chapter_re.search (l): + self.section = 0 + self.chapter = self.chapter + 1 + + def gen_basename (self): + return '%s-%d.%d.%d' % (self.outname,self.chapter,self.section,self.fine_count) + #return '%s/%s-%d.%d.%d' % (outdir, self.outname,self.chapter,self.section,self.fine_count) + + def extract_papersize_from_documentclass(self, line): + pre = extract_papersize_re.search(line) + if not pre: + return None + return pre.groups()[0] + def extract_fontsize_from_documentclass(self, line): + if extract_fontsize1_re.search(line): + r = extract_fontsize2_re.search(line) + if r: + return int(r.groups()[0]) + def do_it(self): + preMudelaDef = postMudelaDef = 0 + (lines, self.deps) = self.get_lines () + for line in lines: + if documentclass_re.search (line): + p = self.extract_papersize_from_documentclass (line) + if p: + Props.setPapersize(p, 'file') + f = self.extract_fontsize_from_documentclass (line) + if f: + Props.setTexFontsize (f, 'file') + elif twocolumn_re.search (line): + Props.setNumColumn (2, 'file') + elif onecolumn_re.search (line): + Props.setNumColumn (1, 'file') + elif preMudelaExample_re.search (line): + preMudelaDef = 1 + elif postMudelaExample_re.search (line): + postMudelaDef = 1 + elif begin_document_re.search (line): + if not preMudelaDef: + self.mudtex.write ('\\def\\preMudelaExample{}\n') + if not postMudelaDef: + self.mudtex.write ('\\def\\postMudelaExample{}\n') + elif begin_mudela_re.search (line): + Props.clear_for_new_block() + if __debug__: + if self.mode == 'mudela': + raise AssertionError + self.mode = 'mudela' + r = begin_mudela_opts_re.search (line) + if r: + o = r.group()[1:][:-1] + optlist = re.compile('[ ,]*').split(o) + else: + optlist = [] + if ('verbatim' in optlist) or (Props.force_verbatim_b): + self.verbatim = 1 + self.mudtex.open_verbatim () + else: + self.verbatim = 0 + self.mudela = Mudela_output (self.gen_basename ()) + + elif end_mudela_re.search (line): + if __debug__: + if self.mode != 'mudela': + raise AssertionError + if self.mudela: + self.mudela.close () + self.mudtex.write (self.mudela.insert_me_string()) + del self.mudela + self.mudela = None + self.fine_count = self.fine_count + 1 + else: + self.mudtex.write (line) + self.mudtex.close_verbatim () + self.mode = 'latex' + continue + + if self.mode == 'mudela' and not self.verbatim: + self.mudela.write (line) + else: + self.mudtex.write (line) + self.set_sections(line) + self.mudtex.create_graphics() + self.mudtex.write_outfile() + del self.mudtex + + +def help(): + sys.stdout.write("""Usage: mudela-book [options] FILE\n +Generate hybrid LaTeX input from Latex + mudela +Options:\n + -h, --help print this help + -d, --outdir=DIR directory to put generated files + -o, --outname=FILE prefix for filenames + --default-mudela-fontsize=??pt default fontsize for music + --force-mudela-fontsize=??pt force fontsize for all inline mudela + --force-verbatim make all mudela verbatim\n""" + ) + sys.exit (0) + + +def write_deps (fn, out, deps): + out_fn = outdir + '/' + fn + out_fn = re.sub ('//', '/', out_fn) + print 'writing `%s\'\n' % out_fn + + f = open (out_fn, 'w') + f.write ('%s: %s\n'% (outdir + '/' + out + '.dvi', + reduce (lambda x,y: x + ' '+ y, deps))) + f.close () + +def identify(): + sys.stderr.write ('This is %s version %s\n' % ('mudela-book', program_version)) + +def main(): + global outdir + outname = '' + try: + (options, files) = getopt.getopt( + sys.argv[1:], 'hd:o:', ['outdir=', 'outname=', + 'default-mudela-fontsize=', + 'force-mudela-fontsize=', + 'help', 'dependencies', + 'force-verbatim']) + except getopt.error, msg: + print "error:", msg + sys.exit(1) + + do_deps = 0 + for opt in options: + o = opt[0] + a = opt[1] + if o == '--outname' or o == '-o': + if len(files) > 1: + #HACK + print "Mudela-book is confused by --outname on multiple files" + sys.exit(1) + outname = a + if o == '--outdir' or o == '-d': + outdir = a + if o == '--help' or o == '-h': + help () + if o == '--dependencies': + do_deps = 1 + if o == '--default-mudela-fontsize': + if not fontsize_pt2i.has_key(a): + print "Error: illegal fontsize:", a + print " accepted fontsizes are: 11pt, 13pt, 16pt, 20pt, 26pt" + sys.exit() + Props.setMudelaFontsize(fontsize_pt2i[a], 'init') + if o == '--force-mudela-fontsize': + if not fontsize_pt2i.has_key(a): + print "Error: illegal fontsize:", a + print " accepted fontsizes are: 11pt, 13pt, 16pt, 20pt, 26pt" + sys.exit() + Props.force_mudela_fontsize = fontsize_pt2i[a] + if o == '--force-verbatim': + Props.force_verbatim_b = 1 + + if outdir[-1:] != '/': + outdir = outdir + '/' + + if not os.path.isdir(outdir): + os.system('mkdir %s' % outdir) + + for input_filename in files: + Props.clear_for_new_file() + if outname: + my_outname = outname + else: + my_outname = os.path.basename(os.path.splitext(input_filename)[0]) + my_depname = my_outname + '.dep' + inp = Main_tex_input (input_filename, my_outname) + inp.do_it () + + + if do_deps: + write_deps (my_depname, my_outname, inp.deps) + +identify() +Props = Properties() +main()