release: 1.1.50

[lilypond.git] / Documentation / tex / refman.yo

mailto(gnu-music-discuss@gnu.org)
COMMENT(-*-text-*-)

redef(var)(1)(whenlatex(latexcommand({\normalfont\scshape )ARG1+latexcommand(}))\
    whenhtml(sc(ARG1)))


redef(code)(1)(tt(ARG1))


COMMENT(

  BUGS:

    Causes segfault:

    \score{
      \notes{  \context Voice {
         \repeat fold 2 { a b c d } {}
     }
     }
    }
    

   restStyle=mensural doesn't seem to work (lots of characters not found
     for rests.fly)

TODO:
   thread
   paper size?
   paper variables
   the explanation of how lyrics mode parses words seems ridiculous.  
      Is there a simple way to explain this, or is the behavior
      too complicated for a reasonable explanation?
   accordion symbols
   interstaff beams (beam-interstaff.ly)
   interstaff slurs (see preludes-1.ly)
)


COMMENT( 
This document contains Mudela fragments.  You need at least
Yodl-1.30.18 to convert this to tex or html.
)

htmlbodyopt(bgcolor)(white)
htmlcommand(<font color=black>)

latexlayoutcmds(
\setlength{\topmargin}{-0.25in}
\setlength{\textheight}{9in}
\setlength{\textwidth}{5.875in} 
\setlength{\oddsidemargin}{0.25in}   
\setlength{\evensidemargin}{0.25in}
\input mudela-book
)

whentexinfo(notableofcontents())

article(Mudela 1.0.21 / LilyPond 1.1.49 Reference Manual)
      (Adrian Mariano, Han-Wen Nienhuys and Jan Nieuwenhuizen)
      (nop()PIPETHROUGH(date "+%B %d, %Y")()()nop())

COMMENT(

* The [ ] look weird

* paragraphs have too much space.

)


latexcommand(\def\interexample{})
latexcommand(\def\preexample{\par})
latexcommand(\def\postexample{\par\medskip})
latexcommand(\def\file#1{{code(#1)}})
COMMENT(
latexcommand(\def\texttt#1{\tt #1})
latexcommand(\def\textbf#1{\bf #1})
)

COMMENT(urg, texinfo include breaks)
whenhtml(
includefile(html-disclaimer.yo-urg)
)

bf(This document is not up to date).  All rendered examples of course
are current, but the rest probably isn't.  Adjusting the tutorial was
considered more important than writing the reference manual.  We
apologize for the inconvenience.  For a complete and up-to-date
definition, see file(lily/parser.yy), file(lily/lexer.ll), and the
init files.

This document describes the the GNU LilyPond input format, which is an
effective language for defining music.  We call this language (rather
arrogantly) The Musical Definition Language or Mudela, for
short.footnote(If anybody comes up with a better name, we'd gladly
  take this. Gourlay already uses Musical Description Language,
  G-Sharp Score Definition Language.  ISO standard 10743 defines a
  Standard Music Description Language.  We're not being original here.)

The first aim of Mudela is to define a piece of music, being complete
from both from a musical typesetting, as from a musical performing
point of view.

The Musical Definition Language (Mudela), has a logical structure,
making use of identifiers, that allows for flexible input, and
definition reuse. See the documentation file file(MANIFESTO), included
with the LilyPond sources for reasons and design considerations.


sect(Running LilyPond)

When invoked with a filename that has no extension, LilyPond will try adding
a file(.fly) extension first, and a file(.ly) extension second.  
If the filename ends with 
file(.fly),  LilyPond processes  the file as music using
file(init.fly).  In this case, LilyPond does something
like:
verb(\score {
  \notes\relative c {
    \input "yourfile.fly"
  }
  \paper{}
  \midi{}
})
If you invoke LilyPond with a file file(foo.)var(ext) that doesn't
have the file(.ly) extension then LilyPond will look for a file called
file(init.)var(ext) and process this file.  The file
file(init.)var(ext) must contain the code(\maininput) keyword or LilyPond
will not read the user specified file.

When LilyPond processes file(filename.ly) it will produce file(filename.tex) as
output.  If file(filename.ly) contains a second code(\paper) keyword, then
LilyPond will produce file(filename-1.tex) as well.  Subsequent code(\paper)
keywords will produces sequentially numbered file names.  Several files can be
specified; they will each be processed independently.

sect(Syntax)

subsect(Basic Mudela)

A Mudela file consists of keywords with arguments and identifier
assignments separated by spaces, tabs or newlines.  Semicolons are
used by some keywords and are inconsistantly required in other
circumstances.  A one line comment is introduced by a code(%)
character.  Block comments are started by code(%{) and ended by
code(%}).  They cannot be nested.

Mudela supports several types:

description(

dit(integer) 
Formed from an optional minus sign followed by digits.  Arithmetic
operations cannot be done with integers, and integers cannot be mixed
with reals.

dit(real) 
Formed from an optional minus sign and a sequence of digits followed
by a emph(required) decimal point and an optional exponent such as
code(-1.2e3).  Reals can be built up using the usual operations:
code(+), code(-), code(*), and code(/), with parentheses for grouping.

dit(string) 
Begins and ends with the code(") character.  To include a code(")
character in a string write code(\").  Various other backslash
sequences have special interpretations as in the C language.  A string
that contains no spaces can be written without the quotes.  See
Section ref(modes) for details on unquoted strings; their
interpretation varies depending on the situation.  On the right side
of identifier assignments and within the code(\header) keyword,
strings can be concatenated using the code(+) character.

dit(dimension) Consists of a real followed by one of the dimension
keywords: code(\mm), code(\pt), code(\in), or code(\cm).  Dimensions
are converted immediately to a real which gives the dimension in
points, so they can be mixed with reals, but the result is no longer
of type dimension.  The keywords that require a dimension
(code(\shape)).

dit(pitch) 
A pitch is a string which is the name of a pitch.  Example: code(a).
The pitch names can be redefined with the code(\notenames) keyword.
See Section(notelang) for pitch names in different languages.  Pitches
can only be specified inside note mode which is specified with
code(\notes).  Therefore, keywords which require pitch arguments must
appear inside code(\notes).  

dit(music) 
Music is a compound type: arbitrarily complicated expressions with a
hierarchical structure can be formed from simple building blocks.  The
simplest expression of type music is a single note.  A note is formed
from a pitch and an optional duration and must be specified within
code(\notes).  See Section ref(notedesc) for details.  More
complicated expressions of type music are formed by surrounding a
sequence of expressions of type music with braces code({) and code(})
or with angle brackets code(<) and code(>).  Items appearing in braces
will be treated as serial. Items in angle brackets will be
simultaneous.  So for example code({ c e g }) represents an arpeggio
and code(< c e g >) represents a chord.  These items can be nested any
way you like.  This simple example shows how three chords can be
expressed in two different ways:
mudela(fragment,verbatim,center)(
\notes{
  c
  <a c' e'> <b  d' f'> <c' e' g'>
  <{a b  c'}{c' d' e'}{e' f' g'}>
})

)



subsect(Identifiers)

Identifiers allow names to be assigned to constants, music, or other
Mudela structures.  To assign an identifier you use
var(name)=var(value) and to refer to an identifier, you preceed its
name with a backslash: code(\)var(name).  It is legal to redefine an
identifier in terms of its old value: code(foo = \foo * 2.0).
Identifier assignments must appear at the top level in the Mudela
file.  Note that semicolons are forbidden after assignments appearing
at the top level but they are obligatory after assignments appearing
elsewhere.  (Semicolons are also forbidden after code(\property) assignments.)

An identifier can be created with any string for its name, but you
will only be able to refer to identifiers whose names begin with a
letter and are entirely alphanumeric.  It is also impossible to refer
to an identifier whose name is the same as the name of a keyword.  The
following words are keywords:
verb(accepts         duration      midi          relative      textscript 
alternative     font          mm            remove        time       
bar             grouping      musicalpitch  repeat        times      
cadenza         header        name          scm           translator 
chordmodifiers  in            notenames     scmfile       transpose  
chords          include       notes         score         type       
clef            key           paper         script        version
cm              keysignature  partial       shape      
consists        lyrics        penalty       skip       
consistsend     maininput     property      spanrequest
context         mark          pt            tempo)

The right hand side of an identifier assignment is parsed completely
when the assignment is made.  It therefore must have any context
specified in the definition.  For example, you must write
code(foo=\notes{a8 b c}) rather than code(foo={a8 b c}).  Even though
the context is specified in the definition, you must refer to the
identifier inside the correct context:
verb(foo = \paper{ linewidth = 6.0\in; }
\score{
  \notes{ ... }
  \paper{ \foo }
})
If code(\foo) is used here without the surrounding code(\paper) then
an error will result.  Note however that the following is acceptible
verb(foo = \notes { ... }
\score{ \foo })  
It is not necessary to specify code(\notes).

Identifiers can be set equal to integers, reals, strings, music,
durations (specified with code(\duration)), note ornaments (specified
with code(\script), dynamics commands, or code(:)), note name tables
(specified with code(\notenames), translator definitions, the
code(\paper) block, the code(\midi) block or the code(\score) block.
When identifiers are used for translators, the code(\paper),
code(\midi), and code(\score) blocks, they may only be referred to as
the first item in a block.  So code(\paper{\one \two}) is illegal
because the identifier code(\two) is not the first thing in the block.
Unlike other identifier definitions, translator identifier definitions
can only appear within code(\midi) or code(\paper) blocks.  See
Section ref(translators) for more information.



subsect(Modes)
label(modes)

To simplify different aspects of music definition (entering the notes
and manipulating them) Mudela has three different input modes which
affect how unquoted strings are interpreted.
In each mode, words are identified on the input.  If code("word") is
encountered, it is treated as a string.  If code(\word) is
encountered it is treated as a keyword or as an identifier.  The
behavior of the modes differs in two ways: different modes treat
unquoted words different, and different modes have different rules for
deciding what is a word.  

description(

dit(Normal mode)
At the start of parsing, Mudela is in normal mode.
In normal mode, a word is an alphabetic character followed by
alphanumeric characters.  If code(word) is encountered on the input it
is treated as a string. 

dit(Note mode) Note mode is introduced by the keyword
code(\notes).  In Note mode, words can only contain alphabetic
characters.  If code(word) is encountered, LilyPond first checks for a
notename of code(word).  If no notename is found, then code(word) is
treated as a string.  If you mistype a notename, the parser will most
likely complain that you should be in code(\lyrics) mode to do lyrics. 

dit(Chord mode) Chord mode is instroduced by the keyword code(\chords).
Very similar to Note mode.  
COMMENT(I'm not sure how it differs)

dit(Lyric mode) Lyrics mode is introduced by the keyword
code(\lyrics).  This mode is has rules that make it easy to include
punctuation and diacritical marks in words.  A word in Lyrics mode
begins with: an alphabetic character, code(_),
code(?), code(!), code(:), code('), 
the control characters code(^A) through code(^F), code(^Q) through
code(^W), code(^Y), code(^^), any 8-bit character with ASCII code over
127, or a two character combination of a backslash followed by one
of code(`), code('), code(") or code(^).  
Subsequent characters of a word can be any character that is not a
digit and not white space.  One important consequence of this is that
a word can end with code(}), which may be confusing if you thought the
code(}) was going to terminate lyrics mode.  Any code(_) characters
which appear in an unquoted word are converted to spaces, providing a
mechanism for introducing spaces into words without using quotes.  
Quoted words can also be used in lyrics mode to specify words that
cannot be specified with the above rules.  Here are some examples.
Not all of these words are printable by TeX().  
verb(a&@&@&TSI|{[    % a word
\'afoo}         % a word
1THtrhortho     % not a word because it starts with a digit
``Hello''       % not a word because it starts with `
Leise DOEXPAND(Fl\)DOEXPAND("u\)ss{}teren meine Sapfe       % 4 words
_ _ _ _         % 4 words, each one a space
))

It is possible to create words that break the rules by prefixing them with the
dollar sign code($).  Regardless of the context, a word beginning with code($)
extends until the next white space character.  Such words can contain numbers
(even in Note mode), or other forbidden characters.  The dollar sign can be
used to create and access identifiers that could not otherwise be used.  

COMMENT(
These modes are of a lexical nature. Normal and Note mode largely
resemble each other, save the possibility of entering Reals, 
meaning of code(_) and the resolution of words

What's this about reals?  When can you enter them or not enter them?)


sect(Note Description)
label(notedesc)

subsect(Basic Note Specification)

A note specification has the form 
var(pitch)[var(octavespec)][code(!)][code(?)][var(duration)].
The pitch of the note is specified by the note's name.  

LilyPond has predefined note names for various languages.  The default
names are the Dutch note names.  The notes are specified by the
letters code(c) through code(b), where code(c) is an octave below
middle C and the letters span the ocatave above that C.  
In Dutch, a sharp is formed by adding
code(-is) to the end of a pitch name.  A flat is formed by adding code(-es).
Double sharps and double flats are obtained by adding code(-isis) or
code(-eses).  
Lily has predefined sets of notenames
for various nop(languages).  See Section ref(notelang) for details.
Rests are specified with the note name code(r) or code(R).  
There is also a note name code(s) which produces a nonprinting note of the
specified duration.

The optional octave specification takes the form of a series of single
quote 
code(') characters or a series of comma code(,) characters.  Each
code(') raises the pitch by one octave; each code(,) lowers the pitch
by an octave.  

mudela(fragment,verbatim,center)(
c' d' e' f' g' a' b' c''
)

mudela(fragment,verbatim,center)(
cis' dis' eis' fis' gis' ais' bis'
)

mudela(fragment,verbatim,center)(
ces' des' es' fes' ges' as' bes'
)

mudela(fragment,verbatim,center)(
cisis' eisis' gisis' aisis' beses'
)

mudela(fragment,verbatim,center)(
ceses' eses' geses' ases' beses'
)

Whenever a C-sharp is desired,  you must specify a C-sharp.  LilyPond
will determine what accidentals to  typeset  depending on the  key and
context.   
A reminder accidental can be forced by
using the  optional exclamation mark `code(!)'
on the pitch.
A cautionary accidental, i.e., an accidental within paranthesis
can be obtained using the optional question mark `code(?)' on the pitch.
mudela(fragment,verbatim,center)(
cis' d' e' cis'  c'? d' e' c'!  
)


Durations are entered as their reciprocal values
mudela(fragment,verbatim,center)(
a'1 a'2 a'4 a a'8 a a'16 a'32 a'64
)
mudela(fragment,verbatim,center)(
r1 r2 r4 r8 r16 r32
)

If the duration is omitted then it is set equal to the previous
duration.  If there is no previous duration, then a quarter note is
assumed.  
The duration can be followed by a dot code(.) to obtain dotted note
lengths.  
mudela(fragment,verbatim,center)(
a'4. b'4.
)

Extra long notes can be obtained using the code(\breve) and
code(longa) durations:
mudela(fragment,verbatim,center)(
c'\breve gis'\longa
)

In order to get triplets and other tuplets, you must use the
code(\times) keyword which multiplies the duration by a fraction.  The
syntax is code(\times) var(fraction) var(music).  The length of all of
the specified music will be multiplied by the fraction and the
fraction's denominator will be printed over the notes.  The most
common tuplet is the triplet in which 3 notes have the length of 2, so
the notes are 2/3 their written length:
mudela(fragment,verbatim,center)( b'4 \times 2/3 {c'4 c' c'} d'4 d'4 )
If you try to use code(\times) as the first thing in your music, you
may encounter the warning ``No one to print a tuplet start bracket''.
This happens because the Tuplet-engraver is in Voice and no Voice has
been created yet.  You must explicitly specify the Voice context in
this situation 
mudela(fragment,verbatim,center)( 
\context Voice { \times 2/3 {c'4 d' e'}} 
)

A shorthand for code(\times) is to write code(*)var(fraction) after a
duration.  This shorthand will not label triplets correctly, but
it is convenient for long rests.  
For long rests with durations equal to an integer number of whole notes,
LilyPond produces output that indicates the duration of the rest.  If you use
code(r) then one rest symbol will be printed and several measures left blank.
If you use code(R) then all of the measure will be filled with whole rests.
mudela(fragment,verbatim,center)(
r1 r1*3 R1*3
)
If you set the code(Score.skipBars) property, then only one measure will be
printed; with code(R), a number indicating the length of the rest will be
displayed.  
mudela(fragment,verbatim,center)(
\property Score.skipBars=1
r1 r1*3 R1*3
)
Even though the code(\times) command is not explicit, it is still
necessary to specify a code(Voice) context if the music begins with
rests lengthened using code(*).  
Otherwise, the following will result:
mudela(fragment,verbatim,center)(
R1*3 c'1 d'
)


subsect(Automatic Beam Generation)
label(autobeam)

By default, Lilypond will generate beams automatically.  This feature can be
disabled by setting the code(Voice.beamAuto) property to 0.  It can be
overridden for specific cases by specifying explicit beams as
described in Section ref(manualbeam).  

In order to decide how to generate beams, Lilypond uses a large number
of Voice properties, whose default values appear in
file(auto-beam-settings.ly).  In general, beams can begin anywhere,
but their ending location is significant.  Beams can end on a beat, or
at durations specified by the code(Voice.beamAutoEnd) property.  To
end beams every quarter note, for example, you could use set
code(Voice.beamAutoEnd) equal to code("1/4").  To end beams every
three eighth notes you would set it to code("3/8").  The same syntax
can be used to specify beam starting points using code(Voice.beamAutoBegin).

To allow different settings for different time signatures, these
property names can start with code(time)var(N)code(_)var(M) to
restrict the definition to var(N)code(/)code(M) time.  So for example,
to specify beams ending only for 6/8 time you would use the property
code(Voice.time6_8beamAutoEnd).  To allow different endings for notes
of different durations, the duration can be tacked onto the end of the
property.  To specify beam endings for beams that contain 32nd notes,
you would use code(Voice.beamAutoEnd_32).


subsect(Note Spanners: Beams, Slurs and Ties)
label(manualbeam)

A beam is specified by surrounding the beamed notes with brackets
code([) and code(]).  
mudela(fragment,verbatim,center)(
[a'8 a'] [a'16 a' a' a'] 
)
Some more elaborate constructions:
mudela(fragment,verbatim,center)(
[a'16 <a' c''> c'' <a' c''>]
\times 2/3 { [e'8 f' g'] }
)

Another type of spanner is the slur.  Slurs connects chords and try to
avoid crossing stems.  A slur is started with code(CHAR(40)) and stopped with
code(CHAR(41)).  The starting code(CHAR(40)) appears to the right of the first note
in the slur.  The terminal code(CHAR(41)) apppears to the left of the first
note in the slur.  This makes it possible to put a note in slurs from
both sides:
mudela(fragment,verbatim,center)(
f'()g'()a' [a'8 b'(] a'4 g' )f'
)

A tie connects two adjacent note heads of the same pitch.  
When used with chords, it
connects all of the note heads whose pitches match.  
Ties are indicated using the tilde symbol
code(~) by analogy with TeX()'s tie which connects words.  
Note that if you try to tie together chords which have no common
pitches, then a warning message will appear and no tie will be created.
(Note that ties between different pitches can be enabled using the
property Voice.oldTieBehavior.)

mudela(fragment,verbatim,center)(
e' ~ e' <c' e' g'> ~ <c' e' g'>
)

It is possible to create beams and slurs that cross staffs by switching the
context:
mudela(fragment,verbatim,center)(
\context PianoStaff <
\context Staff=one \notes\relative c'{
  \stemup
  [c8 c \translator Staff=two \stemup c c]
  \translator Staff=one
  d4( \translator Staff=two )a4
  }
\context Staff=two \notes{ \clef bass; s1}
>
)



subsect(Note Ornaments)

A variety of symbols can appear above and below notes to indicate
different characteristics of the performance.  These symbols can be
added to a note with `var(note)code(-\)var(name)'.  Numerous symbols
are defined in file(script.ly) and file(script.scm).  Symbols can be
forced to appear above the note by writing
`var(note)code(^\)var(name)', and they can be forced to appear below
by writing `var(note)code(_\)var(name)'.  Here is a chart showing
symbols above notes, with the name of the corresponding symbol
appearing underneath.

mudela()(
\score{
 < \notes{ c''-\accent c''-\marcato c''-\staccatissimo f'-\fermata 
          c''-\stopped c''-\staccato c''-\tenuto c''-\upbow c''-\downbow
          c''-\lheel c''-\rheel  c''-\ltoe  c''-\rtoe  c''-\turn
          c''-\open  c''-\flageolet  c''-\reverseturn 
          c''-\trill
          c''-\prall c''-\mordent c''-\prallprall  c''-\prallmordent
          c''-\upprall c''-\downprall c''-\thumb }
  \context Lyrics \lyrics{  
        accent__ marcato__ staccatissimo__ fermata stopped__
        staccato__ tenuto__ upbow downbow__ lheel__ rheel__ ltoe
        rtoe__ turn__ open__ flageolet reverseturn__ trill__ prall__
        mordent prallprall__ prallmordent__ uprall__ downprall thumb }
  >
  \paper{ linewidth = 5.875\in;          
          indent = 0.0;        }
 }
)

In addition, it is possible to place arbitrary strings of text or
TeX() above or below notes by using a string instead of an identifier:
`code(c^"text")'.  Fingerings can be placed by simply using digits.
All of these note ornaments appear in the printed output but have no
effect on the MIDI rendering of the music.

To save typing,  a few common symbols  can  be  abbreviated  with
single characters:
mudela()(
\score{ \notes {
        \property Voice.textStyle = typewriter
        c''4-._"c-." s4
        c''4--_"c-{}-"  s4
        c''4-+_"c-+" s4
        c''4-|_"c-|" s4
        c''4->_"c->"  s4
        c''4-^_"c-\\^{ }"  s4 }
        \paper { linewidth = 12.\cm; }})

Dynamic marks are specified by using an identifier after a note without a dash:
code(c4 \ff).  Note that this syntax is inconsistent with the syntax for other
types of ornaments.  The available dynamic marks are: code(\pppppp),
code(\ppppp), code(\pppp), code(\ppp), code(\pp), code(\p), code(\mp),
code(\mf), code(\f), code(\ff), code(\fff), code(\ffff), code(\fffff),
code(\ffffff), code(\fp), code(\sf), code(\sff), code(\sp), code(\spp),
code(\sfz) and code(\rfz).

A crescendo mark is started with code(\cr) and terminated with
code(\rc).  A decrescendo mark is started with code(\decr) and
terminated with code(\rced).  There are also shorthands for these
marks.  A crescendo can be started with code(\<) and a decrescendo can
be started with code(\>).  Either one can be terminated with code(\!).
Note that code(\!) must go before the last note of the dynamic mark whereas
code(\rc) and code(\rced) go after the last note.  Because these marks are
bound to notes, if you want to get several marks during one note, you must use
spacer notes. 
mudela(fragment,verbatim,center)(
c'' \< \! c''   d'' \decr e'' \rced 
< f''1 {s4 \< \! s4 \> \! s2 } >)


COMMENT(Broken!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!)

Tremolo marks can be printed by a note by adding code(:)[var(length)]
after the note.  The length must be at least 8.  A var(length) value
of 8 gives one line across the note stem.  
If the length is omitted,
then the last value is used, or the value of the code(Abbrev)
property if there was no last value.  To place tremolo marks in
between two notes, begin with code([:)var(length) and end with code(]).
The tremolo marks will appear instead of beams.  Putting more than two
notes in such a construction will produce odd effects. 

[TREMOLO BEAMS TEMPORARILY OUT OF ORDER]

COMMENT(mudela (fragment,verbatim,center)(
c'2:8 c':32 [:16 e'1 g'] [:8 e'4 f']
))

COMMENT(
Is the last paragraph correct?  Is it called "tremolo"?  Why is
"abbreviation" used?  (What is the unabreviated form?)

COMMENT(
mudela (fragment,verbatim,center)(
c'4:32 [:16 c'8 d'8]
))

)


sect(Other Ways to Enter Pitches)

subsect(Pitch Names in Other Languages)
label(notelang)

The pitch names can be easily redefined using the code(\notenames) command.
Note name definitions have been provided in various languages.  
Simply include the language specific init file.  For example:
code(\include "english.ly").  The available language files and the names
they define are:

verb(                        Note Names               sharp       flat
nederlands.ly  c   d   e   f   g   a   bes b   -is         -es
english.ly     c   d   e   f   g   a   bf  b   -s/-sharp   -f/-flat
deutsch.ly     c   d   e   f   g   a   b   h   -is         -es
norsk.ly       c   d   e   f   g   a   b   h   -iss/-is    -ess/-es
svenska.ly     c   d   e   f   g   a   b   h   -iss        -ess
italiano.ly    do  re  mi  fa  sol la  sid si  -d          -b
catalan.ly     do  re  mi  fa  sol la  sid si  -d/-s       -b)

subsect(Relative Pitch Specification)
label(relative)

One very common error when entering music is to place notes in the wrong
octave.  One way to avoid being confused by large numbers of octave changing
marks is to use
the code(\relative) keyword. 
Music which appears within code(\relative) is
interpreted differently.  The octave of a note is determined by making it as
close to the previous note as possible.  The octave changing marks code(') and
code(,) can then be added to raise or lower this note by octaves.  You have to
specify a starting pitch because the first note of a list has no predecessor.  

mudela(fragment,verbatim,center)(
\relative c'' { c d b c, d b c' d 
                b c,, d b }
)

When the preceeding item is a chord, the first note of the chord is used to
determine the first note of the next chord.  But other notes within the second
chord are determined by looking at the immediately preceeding note.  

mudela(fragment,verbatim,center)(
\relative c' { c <c e g> 
    <c' e g> <c, e' g> }
) 

The code(\relative) keyword can only appear in music, so there must be a
surrounding code(\notes) keyword which does not appear in the fragments shown
above.  Also note that if the music passed to a code(\relative) keyword 
contains a code(\transpose) keyword, the tranposed music will not be
processed in relative mode.  An additional code(\relative) must be placed
inside the code(\transpose).  If code(\relative) will be used several
times, or if it will be used in the same music with code(\transpose),
then you may get bizarre effects.  This can be fixed by using an
explicit code(Staff) context.   


subsect(Tranposition of Pitches)
label(transpose)

Another way to modify the meaning of the note names is to use the
code(\transpose) keyword.  This keyword allows you to transpose music.
To use transposition, specify the pitch that middle C should be tranposed to.
It is important to distinguish between enharmonic pitches as they can produce
different transpositions.  To transpose up half a step, for example, either 
code(\transpose cis') or code(\transpose des') will work.  But the first
version will print sharps and the second version will print flats.  
In this example, a scale in the key of E is transposed to F, or to E-sharp 
with odd results.
mudela(fragment,verbatim,center)(
\relative c' { \key e; 
  e fis gis a b cis dis e }
)
mudela(fragment,verbatim,center)(
\transpose des' \relative c' { \key e; 
   e fis gis a b cis dis e }
)
mudela(fragment,verbatim,center)(
\transpose cis' \relative c' { \key e; 
    e fis gis a b cis dis e }
)
If you want to use both code(\transpose) and code(\relative), then you must use
code(\transpose) first.  Any code(\relative) keywords that are outside the 
code(\transpose) have no effect on notes that appear inside the
code(\transpose).  As with code(\relative), using code(\transpose)
repeatedly can cause bizarre effects.  An explicit code(Staff) context
will eliminate the problems.  

sect(Chords)

Chords can be entered either by name or by listing the notes in angle brackets.
Chords can be displayed either as notes or by name.  To enter chords by name,
either place them inside the code(\chords) keyword, or use
code(\notes) and surround them with
code(@) characters. 
Chord names have the form
var(tonic)[var(duration)][code(-)var(modifier)][code(^)var(subtractions)][code(/)var(inversion)]
The var(tonic) should be the tonic note of the chord, and the var(duration) is
the chord duration in the usual notation.  There are two kinds of modifiers.
One type is chord additions, which are obtained by listing intervals separated
by dots.  An interval is written by its number with an optional code(+) or
code(-) to indicate raising or lowering by half a step.  A chord additions has
two effects:  it adds the specified interval and all lower odd numbered
intervals to the chord, and it may lower or raise the specified interval.
Intervals can be separated by a dot (code(.)) if you need to list
several unmodified intervals.
Repeating a code(-) character will remove a half step from the preceeding
interval.  
mudela(fragment,verbatim,center)(
\transpose c''{ 
\chords{
  c1 c-3- c-7 c-8 c-9  
  c-9-5+7+ c-3-5- c-4.6.8
}}) 
The second type of modifier that may appear after the code(-) is 
a named modifier. 
Named modifiers are listed in the file file(chord-modifiers.ly).  The
available modifiers are code(m) and code(min) which lower
the 3rd half a step, code(aug) which raises the 5th, code(dim) which lowers
the 5th, code(maj) which adds a raised 7th, and code(sus) which replaces the
5th with a 4th.  
mudela(fragment,verbatim,center)(
\transpose c''{ 
\chords{
  c1-m c-min c-maj c-aug c-dim c-sus
}}) 

Chord subtractions are used to eliminate notes from a chord.  The notes to be
subtracted are listed after a code(^) character, separated by dots.  
mudela(fragment,verbatim,center)(
\transpose c''{ 
\chords{
  c1^3 c-7^5.3 c-8^7
}}) 

Chord inversions can be specified by appending code(/) and the name of a
single note to a chord.  This has the effect of lowering the specified note by
an octave so it becomes the lowest note in the chord.  If the
specified note is not in the chord then a warning will be printed.  
mudela(fragment,verbatim,center)(
\transpose c'''{ 
 @c1@ @c/e@ @c/g@ @c-7/e@
}) 
Throughout these examples, chords have been shifted around the staff
using code(\transpose).  The code(\relative) keyword has odd effects
when combined with named chords.  

For displaying printed chord names, use the code(ChordNames) context.  
The chords may be entered either using the notation described above,
or directly using angle brackets. 
mudela(fragment,verbatim)(
<
  \context ChordNames { \chords{ a b c} \notes{ < d f g >  < e g b > } }
  \context Staff \notes{ a b c' d' e' }
>
)
Lilypond examines chords specified as lists of notes to determine a
name to give the chord.  By default, LilyPond will not try to identify
chord inversions:
mudela(fragment,verbatim,center)(
<
  \context ChordNames { 
     \notes{ < e' g' c'' > } }
  \context Staff \notes{ c' } 
>)
If you want inversions to be recognized, you must set the property
code(Score.chordInversion): 
mudela(fragment,verbatim,center)(
<
  \property Score.chordInversion = 1
  \context ChordNames { 
       \notes{ < e' g' c'' > } }
  \context Staff \notes{ c' } 
>)



sect(Lyrics)

Lyrics are entered like notes, with pitches replaced
by text.  For example code(Twin-4 kle4 twin-4 kle4) enters four
syllables, each with quarter note duration.  Note that the hyphen has
no special meaning for lyrics, and does not introduce special symbols.
See Section ref(modes) for a description of what is interpreted as a lyric.

In order to instruct LilyPond to write lyrics underneath the
staff, you must enter the lyrics context with code(\context Lyrics).  
Lyrics should be entered in lyrics mode which is entered with code(\lyrics).

Spaces can be introduced into a lyric either by using quotes (code("))
or by using an underscore without quotes: code(He_could4 not4).  All
unquoted underscores are converted to spaces.  Here is a full example: 
mudela(verbatim)(\score{
  <  \notes \transpose c'' {c d e c | c d e c | e f g'2 | 
                              e'4 f g'2 \bar "|."; }
     \context Lyrics \lyrics { 
              DOEXPAND(Fr\)`e-4 re Ja- que DOEXPAND(Fr\)`e- re Ja- que
              Dor- mez vous?2 Dor-4 mez vous?2  }
  >
})

COMMENT(
URG
                        Fr\`e-4 re Ja- que
                        Fr\`e- re Ja- que
Why does this warrant an URG?
)

When one word is attached to many notes, you may 
want a  continuous line after the lyric to show  this.   To achieve
this effect, add a code(__) lyric as a separate word 
after the lyric to be extended.  
This will create
an extender, a line  that extends over the entire duration of 
the lyric.  This line will run all the way to the start of the next
lyric, so you may want to shorten it by using a blank lyric.  
mudela(verbatim)(\score{
< \notes \relative c''{ 
     a4()b()c()d c()d()b()a c()d()b()a }
   \context Lyrics \lyrics {
     foo1 __  bar2. __ _4 baz1 __ }
> })
     


sect(Time)  

LilyPond aligns all musical objects according to the amount of time
they occupy.  All musical objects have a duration.  When music is
written sequentially using braces the duration is the sum of the 
durations of the elements.  When music is stacked into simultaneous music 
using angle
brackets, the duration is the maximum of the durations of the
elements.  

Because LilyPond knows the durations of all musical elements, the time
signature enables LilyPond to draw bar lines automatically.  The time
signature is specified with the code(\time) keyword: code(\time 3/4).
If no time signature is given, LilyPond assumes 4/4.  The automatic
generation of bar lines can toggled with the code(\cadenza) keyword or the
code(Staff.barNonAuto) property,
and an incomplete measure at the start of the music can be created
using the code(\partial) keyword: code(\partial 8*2;) creates a
starting measure lasting two eighth notes.

In order to help with error checking, you can insert bar markers in
your music by typing code(|).  Whenever LilyPond encounters a code(|)
that doesn't fall at a measure boundary, she prints a warning message.

Rhythmic grouping is  a concept closely associated with this. 
A default grouping is selected for the chosen time signature.  
The default consists of combinations of 2 and 3 beats with as many
groups of 3 as possible, and the groups of 3 coming first.  For
example, 4/4 is divided into 2+2 and 8/8 is divided into 3+3+2.  This
default grouping can be changed using the \grouping keyword which
takes a list of durations to specify the grouping. 


COMMENT(
sect(Composition: forming bigger structures)
label(sec:grammar)

The computer savy user may be interested in a more formal
specification.  We can capture what have learned about forming
sentences in Mudela in a context-free grammar.

latexcommand(\smallskip)

table(2)(lll)(
        row(cell(em(Music))cell(: em(Note)))
        row(cell()cell(code(|) em(Rest)))
        row(cell()cell(code(|) code({) em(MusicList) code(})))
        row(cell()cell(code(|) code(<) em(MusicList) code(>)))
        row(cell()cell(code(|) em(Command)))
        row(cell()cell(code(|) code(\context) em(string) code(=) em(string)  em(Music)))
        row(cell()cell(;))
        row(cell(em(MusicList))cell(: em(empty)))
        row(cell()cell(code(|)  em(MusicList)  em(Music)))
        row(cell()cell(;))
)

latexcommand(\smallskip)

In mathematics you can form expressions by combining expressions,
which are ultimately some kind of atom or terminal symbol.  The same
goes for Mudela: there are some basic building blocks, and by
combining those you create complex music.

You can combine music in three ways:
itemize(
it()If you enclose a sequence of music-elements in braces ( code({)
    and code(}) ), then you form another kind of music called
sequential music
    with those pieces.
  The duration of sequential composition is the sum of the durations of its elements
  verb(
      { c c g g a a g2 }      % twinkle twinkle
      { { c c g g} { a a g2 } }
  )
it()You can stack music by enclosing a sequence of music elements
    with code(<) and code(>). This is called simultaneous music.  
    The duration of a simultaneous composition is the maximum of the durations 
    of its elements Example:
    verb(
        <a4 {cis8 cis8} e'4>      % a-major chord
    )
it()You can form music by transposing music:
    verb(
    \transpose  
        d       % from c to the d that's almost one octave down
                { e4 f4 }       % the horizontal music
)
it()verb(\context)
it()verb(\property)
it()verb(\translator)
it()verb(\relative)
)

Of course you can also combine these three mechanisms.
verb(
{ c <c e> <c e g> <c e g \transpose d' dis > }  % 4 increasing chords
)

END OF COMMENT  )


sect(Repeats)

In order to specify repeats, use the code(\repeat) keyword.  By
default, repeats are printed with repeat symbols.  
mudela(fragment,verbatim,center)(
c'1
\repeat semi 2 { c'4 d' e' f' }
\repeat semi 2 { f' e' d' c' })
In order to specify alternate endings, use the code(\alternative)
keyword.  
mudela(fragment,verbatim,center)(
c'1
\repeat semi 2 {c'4 d' e' f'} 
\alternative { {d'2 d'} {f' f} })
The code(semi) specifies that normal repeats will be printed.  If
code(fold) is used instead then the alternatives will be stacked:
mudela(fragment,verbatim,center)(
c'1
\repeat fold 2 {c'4 d' e' f'} 
\alternative { {d'2 d'} {f' f} })
When the repeats involve partial measures, it will be necessary to use
code(\partial) keywords in a somewhat unexpected way 
to indicate some measure lengths.
mudela(fragment,verbatim)(
\context Staff { \relative c'{
  \repeat semi 2 { \partial 4; e | c2 d2 | e2 f2 | }
  \alternative { { g4 g g } {\partial 1; a a a a | b1 } }
}})
Repeats can be unfolded by setting the property Staff.unfoldRepeats.
Note also that if your music begins with code(\repeat), you must place
it in an explicit code(Staff) context or you will get bizarre results. 

If you don't give enough alternatives for all of the repeats, then the
first alternative is assumed to be repeated enough to equal to
specified number of repeats.  
mudela(fragment,verbatim)(
\context Staff { \relative c'{
  \repeat semi 3 { \partial 4; e | c2 d2 | e2 f2 | }
  \alternative { { g4 g g } {\partial 1; e4 e e } 
                 {\partial 1; a a a a | b1 } }
}})


sect(Keywords)

Keywords sometimes appear alone, but usually they require arguments.
A keyword may have a single argument, a sequence of arguments in
braces, or a sequence of arguments separated by spaces and terminated
by a semicolon.  The precise syntax of each keyword is shown below.
Keywords must appear in the right context.  If you use a keyword in
the wrong place, even if the usage is syntactically correct, you will
get the message ``parse error'' from LilyPond.


description(

dit(code(\absdynamic) code({) var(code) code(})) Internal keyword for
printing dynamic marks such as $f$ under music.  The parameter
var(code) is unsigned and specifies the dynamic mark to print.
Normally you should use the more user friendly abbreviations defined
in the init file file(dynamic.ly).

FIXME: Changed to code(\textscript) var(text) var(style).  Defines
a text-request.

dit(code(\accepts) var(string)code(;)) This keyword can appear only within a
code(\translator) block.  It specifies what contexts are allowed with the
context that is being defined.  See Section ref(translators).  

dit(code(\alternative) code({) var(music1) var(music2) ... code(}))
Specifies alternative endings.  Must come after a code(\repeat) keyword.  

dit(code(\bar) var(bartype)code(;)) Prints a special bar symbol, or at
measure boundaries, replaces the regular bar symbol with a special
symbol.  The argument var(bartype) is a string which specifies the
kind of bar to print.  Options are code(":|"), code("|:"),
code(":|:"), code("||"), code("|."), code(".|"), or code(".|.").
These produce respectively a right repeat, a left repeat, a double
repeat, a double bar, a start bar, an end bar, or a thick double bar.
If var(bartype) is set to code("empty") then nothing is printed, but a
line break is allowed at that spot.  Note that the printing of special bars
has no effect on the MIDI output.

dit(code(\cadenza) var(togglevalue)code(;)) Toggles the automatic generation
of bar lines.  If var(togglevalue) is 0 then bar line generation is
turned off.   If var(togglevalue) is  1  then a bar is  immediately
printed and bar generation is turned on.

dit(code(\clef) var(clefname)code(;)) Allowed only in music.  
Sets the current clef.  The argument is
a string which specifies the name of the clef.  Several clef names are
supported.  If code(_8) or code(^8) is added to the end of a clef
name then the clef lowered or raised an octave will be generated.  
Here are the supported clef names with middle C shown in each clef:
mudela(center)(
\score{
  \notes{ \cadenza 1;
   %\property Voice.textStyle = typewriter
   \clef subbass; c'4-"\kern-10mm subbass" 
           \clef bass;    c'4^"\kern -8mm bass"
           \clef baritone; c'4_"\kern -10mm baritone"
           \clef varbaritone; c'4^"\kern -10mm varbaritone"
           \clef tenor;     c'4_"\kern -10mm tenor"
           \clef "G_8";   c'4^"\kern -6mm G\_8" 
   }  
   \paper{ linewidth= 4.5 \in; }
}
)
mudela(center)(
\score{
  \notes{\cadenza 1; \clef alto;    c'4_"\kern -10mm alto"
      %     \clef scarlatti;    c'4_"\kern -4mm scarlatti"
           \clef mezzosoprano; c'4^"\kern -10mm mezzosoprano"
           \clef soprano;  c'4_"\kern -10mm soprano"
           \clef treble;  c'4^"\kern -6mm treble"
           \clef french;  c'4_"\kern -10mm french" }  
  \paper{ linewidth= 4.5 \in; }
}
)
The treble  clef  can also  be obtained using  the  names code(G) or
code(violin).  The bass clef is also available by code(\clef  F). 

dit(code(\chord) var(chordlist)) Parse var(chordlist) in chords mode.

dit(code(\chordmodifiers) var(modifierlist)) Specify the text chord
modifiers that may appear after chord names.  These are specified in
the file file(chord-modifiers.ly).  

dit(code(\cm)) Specify a dimension in centimeters. 

dit(code(\consists) var(string)code(;)) This keyword can appear only within a
code(\translator) block.  It specifies that an engraver or performer named
var(string) should be added to the translator.  See Section
ref(translators).

dit(code(\consistsend) var(string)code(;)) Unknown function.  

dit(code(\context) var(contexttype) [code(=) var(contextname)]
var(music) or code(\context) var(translatortype)code(;)) The first
variant is used only within music to create an instance of a
context.  The new context can optionally be given a name.  The
specified var(music) is processed in the new context. The second
variant appears within a code(\translator) block and specifies the
type of translator being created.

dit(code(\duration) code({) var(length) var(dotcount) code(})) Specify note
duration.  The parameter var(length) is the negative logarithm (base
2) of duration: 1 is a half note, 2 is a quarter note, 3 is an eighth
note, etc.  The number of dots  after  the  note is given by
var(dotcount). 

dit(code(\font) var(string)) Internal keyword.  Used within
code(\paper) to specify the font.

dit(code(\grouping) var(durationseq)code(;))  Sets  the  metric structure of
the measure.  Each argument specifies the duration of one metric unit.
For example, code(\duration 16*5;) specifies a grouping of five beats
together in 5/16 time.  The default grouping is to have as many groups
of 3 as possible followed by groups of two.  

dit(code(\header) code({) var(key1) = var(val1); var(key2) = var(val2); ... code(}))
Specifies information about the music.  A header should appear at the
top of the file describing the file's contents.  If a file has
multiple code(\score) blocks, then a header should appear in
each score block describing its contents.  Tools like code(ly2dvi) can
use this information for generating titles.   Key values that are used
by ly2dvi are: title, subtitle, composer, opus, poet, instrument,
metre, arranger, piece and tagline.  

dit(code(\in)) Specify a dimension in inches.  

dit(code(\include) var(file)) Include the specified file.  The
argument var(file) is a string.  The full filename including the
file(.ly) extension must be given, and the filename must be quoted.
(An unquoted string will not work here.)

dit(code(\key) var(pitch) var(type) code(;)) Change the key signature. 
var(type) should be code(\major) or code(\minor) to get
var(pitch)-major or var(pitch)-minor, respectively. The second
argument is optional, the default is major keys. 
The var(\context) argument can also be given as an integer, which tells
the number of semitones that should be added to the pitch given in the
subsequent code(\key) commands to get the corresponding major key,
e.g. code(\minor) is defined as 3.  The standard mode names 
code(\ionian), code(\locrian), code(\aeolian), code(\mixolydian),
code(\lydian), code(\phrygian), and code(\dorian) are also defined. 

dit(code(\keysignature) var(pitchseq)code(;))
Specify an arbitrary key signature.  The pitches from var(pitch) will
be printed in the key signature in the order that they appear on the list.

dit(code(\lyrics) var(lyriclist)) Parse var(lyriclist) in lyrics mode.

dit(code(\maininput)) Internal command.  This command is used for creating init
files like file(init.fly) that read the user file into the middle of another
file.  It is illegal to use this command in a user file.  
        
dit(code(\mark) var(unsigned)code(;) or code(\mark) var(string)code(;)) 
Allowed in music only.  Prints a mark over or under (depending on the
code(markDirection) property) the staff.
You must add code(Mark_engraver) to the Score context.

dit(code(\midi) var(statementlist)) Appears in a score block to
indicate that musical output should be produced and to set output
parameters.  Can also appear at the top level to set default output
parameters.  See code(\tempo).

dit(code(\mm)) Specify a dimension in millimeters. 

dit(code(\musicalpitch) code({) var(octave) var(note) var(shift) code(})) 
Specify note pitch.  The octave is specified by an integer,
zero for the octave containing middle C.  The note is a number from 0
to 7, with 0 corresponding to C and 7 corresponding to B.  The shift
is zero for a natural, negative to add flats, or positive to add
sharps.

dit(code(\name) var(context)code(;)) Appears within code(\translator) to
specify the name of the context that the translator handles. See Section
ref(translators).   

dit(code(\notenames) var(assignmentlist)) Define new note names.  This
keyword can appear only at the top level. 
The argument is a list of definitions of  the form
var(name) = var(pitch),  where var(pitch) is specified with the
code(\musicalpitch) keyword.  

dit(code(\notes) var(music)) Enter note mode and process the
specified music. 

dit(code(\paper) var(statmentlist)) 
Appears in a score block to indicate that the music should be printed
or to set output parameters.  Can also appear at the top level to set
default output parameters for all of the score blocks.  
The var(statmentlist) contains statements that change features of the
output.  See Section ref(paper).  

dit(code(\partial) var(duration)code(;)) Specify that the first measure of
the music lasts only for the specified duration.  Use also to specify
the duration of the first measure of the argument to
code(\alternative).  

dit(code(\penalty) var(int)code(;)) Allowed only in music.
Discourage or encourage line breaks.  See identifiers code(\break) and
code(\nobreak) in Section ref(ident). 

dit(code(\property) var(contextname)code(.)var(propname) code(=) var(value))
Sets the var(propname) property of the context var(contextname) to the
specified var(value).  All three arguments are strings.  Depending on
the context it may be necessary to quote the strings or to leave space
on both sides of the dot. 

dit(code(\pt)) Specify a dimension in points. 

dit(code(\relative) var(pitch) var(music)) Processes the specified
var(music) in relative pitch
mode.  In this mode, the octave of a pitch is chosen so that the
pitch is closest to the preceeding pitch.  
The argument var(pitch) is
the starting pitch for this comparision.  In the case of chords, the
first note of a chord is used as the base for the first pitches in the next
chord.  See Section ref(relative).

dit(code(\remove) var(string)code(;)) Can appear only in a
code(\translator) block.  Specifies that a performer or engraver named
var(string) should be removed.  See Section ref(translators).  

dit(code(\repeat) var(style) var(count) code({) var(music) code(}))
Repeats the specified
music var(count) times.  Alternative endings can be specified by adding a
code(\alternative) keyword after the code(\repeat).  The var(style)
parameter should be either code(semi), for regular repeats,  or
code(fold) for repeats displayed vertically. 

dit(code(\scm) var(scheme)code(;)) Embeds specified Scheme code.  

dit(code(\scmfile) var(filename)code(;)) Reads Scheme code from the specified
file.  

dit(code(\score) var(statementlist)) Create a Score context.  This
is the top level notation context.  
COMMENT(this still needs work)

dit(code(\script) var(alias)) Prints a symbol above or below a note.
The argument is a string which points into the script-alias table
defined in file(script.scm).  The scheme definitions specify whether
the symbol follows notes into the staff, dependence of symbol
placement on staff direction, and a priority for placing several
symbols over one note.  Usually the code(\script) keyword is not used
directly.  Various helpful identifier definitions appear in
file(script.ly).

dit(code(\shape) code(=) var(indent1) var(width1) var(indent2)
var(width2) ... code(;)) Allowed only within code(\paper).  Each pair
of var(indent) and var(width) values is a dimension specifying how far
to indent and how wide to make the line.  The indentation and width of
successive lines are specified by the successive pairs of dimensions.
The last pair of dimensions will define the characeristics of all
lines beyond those explicitly specified.

COMMENT(First pair of dimensions seems to be skipped.  At least it is
in the example file denneboom.ly.)

dit(code(\skip) var(duration)code(;)) Skips the amount of time specified by
var(duration).  A gap will be left for the skipped time with no notes
printed.  It works in Note Mode or Lyrics Mode (but generates a
mysterious error in lyrics).

dit(code(\spanrequest) var(startstop) var(type)).  Define a spanning request
var(startstop) is either -1 (code(\start)) or 1 (code(\stop)). The var(type)
parameter is a string that describes what should be started.  Supported types
are "crescendo", "decrescendo", "beam", "slur".  This is an internal command.
Users should use the abbreviations  which are defined in the
initialization file file(dynamic.ly).

dit(code(\tempo) var(duration) = var(perminute)code(;)) Used within
code(\midi) or within music to specify the tempo.  For example, 
`code(\midi { \tempo 4 = 76;})' requests output with 76 quarter notes
per minute.  Note that if the music contains several tempo commands,
only the last one is used to set the tempo for the entire MIDI output. 
COMMENT(Is this true?)

dit(code(\textscript) var(text) var(style)) Print the specified text as a
script in the specified style.  

dit(code(\time) var(numerator)code(/)var(denominator)code(;)) Change the time
signature.  The default time signature is 4/4.  

dit(code(\times) var(numerator)code(/)var(denominator) var(music))
Multiply the duration of var(music) by the specified fraction.

dit(code(\translator) var(statements) or code(\translator)
var(context) = var(name)) The first variant appears only within
code(\paper) and specifies a translator for
converting music to notation.  The translator is specified with a
single code(\context) statement and a series of code(\accepts), and
code(\consists) statements.  See Section ref(translators). 
The second variant appears in 
music.  It specifies that the current the contexts
contained within the specified context should be shifted to the
context with the specified name.  

COMMENT( \translator seems like a strange name for the second
operation, and is the overloading desireable? )

dit(code(\transpose) var(pitch) var(music)) Transposes the specified
music.  Middle C is tranposed to var(pitch).  This is allowed in music only,
and if it appears inside code(\relative), then any notes specified for
transposition should be specified inside another code(\relative).  See Section
ref(transpose).  

dit(code(\type) var(string)code(;)) Use inside code(\translator) to
specify the type of the translator.  

dit(code(\version) var(string)) Specify the version of Mudela that a
file was written for.  The argument is the version number, for example
code("1.0.1").  Note that the Mudela version is different from the
LilyPond version.

)  


sect(Notation Contexts)

Notation contexts provide information that appears in printed music
but not in the music itself.  A new musical context is created using
the code(\context) keyword: `code(\context) var(contexttype) [code(=)
var(contextname)] var(music)'.  The following context types are
allowed.

description(

dit(code(LyricVoice)) Corresponds to a voice with lyrics.  Handles the printing
of a single line of lyrics.  

dit(code(Voice)) Corresponds to a voice on a staff.
  This context handles the conversion of noteheads,
  dynamic signs, stems, beams, super- and subscripts, slurs, ties and rests.

dit(code(ChordNamesVoice)) A voice with chord names.  Handles printing
of a line of chord names.  

dit(code(ChordNames))  Typesets chord names.  Can contain
code(ChordNamesVoice) contexts.  

dit(code(Lyrics)) Typesets lyrics.  It can contain code(LyricVoice) contexts.

dit(code(Staff)) Handles clefs, bar lines, keys,
  accidentals.  It can contain code(Voice) contexts.

dit(code(RhythmicStaff)) A context like code(Staff) but for printing
rhythms.  Pitches are ignored; the notes are printed on one line.  
It can contain code(Voice) contexts. 

dit(code(GrandStaff)) Contains code(Staff) or code(RhythmicStaff)
contexts.  It adds a brace on the left side grouping the staffs
together. The bar lines of the contained staffs are connected vertically.
It can contain code(Staff) contexts.

dit(code(PianoStaff)) Just like code(GrandStaff) but with
code(minVerticalAlign) set equal to code(maxVerticalAlign) so that
interstaff beaming and slurring can be used.  

dit(code(StaffGroup)) Contains code(Staff) or code(RhythmicStaff)
contexsts.  Adds a bracket on the left side, grouping the staffs
together.  The bar lines of the contained staffs are connected vertically.
It can contain code(Staff), code(RhythmicStaff), code(GrandStaff) or code(Lyrics) contexts.  

dit(code(ChoirStaff)) Identical to code(StaffGroup) except that the
contained staffs are not connected vertically.  

dit(code(Score)) This is the top level notation context.  It is specified with
the code(\score) keyword rather than the code(\context) command.  No
other context can contain a code(Score) context.  This context handles
the administration of time signatures.  It also makes sure that items
such as clefs, time signatures, and key-signatures are aligned across
staffs.  It can contain code(Lyrics), code(Staff),
code(RhythmicStaff), code(GrandStaff), code(StaffGroup), and
code(ChoirStaff) contexts.

)

The various contexts have properties associated with them.  These
properties can be changed using the code(\property) command:
`code(\property) var(context)code(.)var(propname) code(=) var(value)'.
Properties can also be set within the code(\translator) block
corresponding to the appropriate context.  In this case, they are
assigned by `var(propname) code(=) var(value)'.  The settings made with
code(\property) are processed after settings made in the code(\translator)
block, so the code(\property) settings will override code(\translator)
settings.  

The code(\property) keyword will create any property you specify.
There is no guarantee that a property will actually be used.  If you
spell a property name wrong, there will be no error message.  In order to find
out what properties are used, you must search the source code 
for code(get_property).  
Properties that are set in one context are inherited by all of the
contained contexts.  This means that a property valid for the Voice
context can be set in the Score context (for example) and thus take
effect in all Voice contexts.  

subsubsubsect(Lyrics properties)

description(

dit(code(textStyle)) Set the font for lyrics.  The available font
choices are code(roman), code(italic), code(bold), code(large),
code(Large), code(typewriter), and code(finger).  The code(finger)
font can only display numbers.  Note also that you must be careful
when using code(\property) in Lyrics mode.  Because of the way strings
are parsed, either put quotes around the arguments to code(\property)
or be sure to leave a space on both sides of the dot.


)

subsubsubsect(Voice properties)

description(  

dit(code(stemLeftBeamCount)) Specify the number of beams to draw on
the left side of the next note.  

dit(code(stemRightBeamCount)) Specify the number of beams to draw on
the right side of the next note.  

dit(code(beamAuto)) If set to 1 then beams are generated
automatically.  If set to zero then no beams will be automatically
generated.  The default value is 1.  

dit(code(beamAutoEnd)) Specifies when automatically generated beams
can end.  See Section ref(autobeam).

dit(code(beamAutoBegin)) Specifies when automatically generated beams
can start.  See Section ref(autobeam). 

dit(code(textEmptyDimension)) If set to 1 then text placed above or
below the staff is assumed to have zero width.  

dit(code(noteheadStyle)) Selects type of note head.  Choices are
code(cross), code(diamond), code(harmonic), code(transparent), and
code("").  They are shown in that order below.  
mudela(center)(
\score{
  \notes{ 
     \property Staff.barNonAuto = 1
     \property Voice.noteHeadStyle = cross 
     a'
     \property Voice.noteHeadStyle = diamond
     a'
     \property Voice.noteHeadStyle = harmonic
     a'
     \property Voice.noteHeadStyle = transparent
     a' 
     \property Voice.noteHeadStyle = ""
     a'
  }
 \paper{ linewidth = -1.;}
}
)


dit(code(restStyle)) Change the layout of rests shorter than quarter notes. 
Currently, the standard layout code(restStyle="") and mensural notation
code(restStyle="mensural") are available.

dit(code("midiInstrument")) Sets the instrument for MIDI output.  This
property name must be quoted because of the embedded underscore.  If
this property is not set then LilyPond will use the code(instrument)
property.  This must be set to one of the strings on the list of MIDI
instruments that appears in Section ref(midilist).  If you use a
string which is not listed, LilyPond will silently substitute piano. 

dit(code(transposing)) Tranpose the MIDI output.  Set this property to
the number of half-steps to transpose by.

dit(code(oldTieBehavior)) Set to 1 in order to get old tie behavior
where ties would connect unequal pitches.  

dit(code(verticalDirection)) Determines the direction of stems, subscripts,
beams, slurs, and ties.  Set to code(\down) to force them down,
code(\up) to force them up, or code(\free) to let LilyPond decide.
This can be used to distinguish between voices on the same staff.  The
code(\stemdown), code(\stemup), and code(\stemboth) identifiers set
this property.  See also the identifiers code(\voiceone),
code(\voicetwo), code(\voicethree) and code(\voicefour).

dit(code(slurVerticalDirection)) Set to code(\free) for free choice of slur
direction, set to code(\up) to force slurs up, set to code(\down) to
force slurs down.  The shorthands code(\slurup), code(\slurdown), and
code(\slurboth) are available.

dit(code(tieVerticalDirection)) Set to code(\free) for free choice of tie
direction, set to code(\up) to force ties up, set to code(\down) to
force ties down.  

dit(code(slurdash)) Set to 0 for normal slurs, 1 for dotted slurs, and
a larger value for dashed slurs.  Identifiers code(\slurnormal) and
code(\slurdotted) are predefined to set the first two settings.

dit(code(horizontalNoteShift)) Set to 1 to enable LilyPond to shift notes
horizontally if they collide with other notes.  This is useful when
typesetting many voices on one staff.  The identifier code(\shift) is
defined to enable this.  If there are several voices, every voice must
have a distinct value of this property or no shifting will occur.

dit(code(dynamicDir)) Determines location of dynamic marks.  Set to
code(\up) to print marks above the staff; set to code(\down) to print
marks below the staff.

dit(code(dynamicStyle)) Set the text style for dynamics.  

dit(code(textStyle)) Set the text style for superscripts and
subscripts.  See above for list of text styles.

dit(code(textScriptPadding)) Determines the extra space added between
super-/subscripted text and the closest staff line or note.

dit(code(fontSize)) Can be used to select smaller font sizes for
music.  The normal font size is 0, and the two smaller sizes are -1
and -2.

dit(code(abbrev)) Set length for tremolo to be used if no length is
explicitly specified.

dit(code(tupletDirection)) Determines the direction of triplets and 
other tuplets.  Set to code(\down) to force them below the staff,
code(\up) to force them above, or code(\free) to let LilyPond decide.

dit(code(tupletVisibility)) Determines whether tuplets of notes are
labelled.  Setting to 0 shows nothing; setting to 1 shows a number;
setting to 2 shows a number and a bracket if there is no beam; setting
to 3 shows a number, and if there is no beam it adds a bracket;
setting to 4 shows both a number and a bracket unconditionally. The 
code(pletoff) and code(pleton) identifiers set the property to 0 and 3, 
respectively. 

dit(code(markScriptPadding)) Determines the extra space added between
the mark and the closest staff line or note.

dit(code(markDirection)) Determines if marks should be printed above
or below the staff. Set to code(\up) to print marks above the staff;
set to code(\down) to print marks below the staff.

dit(code(articulationScriptPadding)) Determines the extra space added 
between articulation marks, such as staccato, tenuto, trill, up/down 
bow or fermata, and the closest staff line or note.
)

subsubsubsect(Staff properties)

description(

dit(code(createInitdefaultClef)) Specify whether clefs are created on
default?  (Doesn't seem to do anything.)

dit(code(barNumberDirection)) Set to code(\up) or code(\down) to put
bar numbers above or below the staff.  

dit(code(barNumberHangOnClef)) Set to 1 to cause bar numbers to appear
above or below the clef instead of on the bar line.

dit(code(barNumberScriptPadding)) Sets extra space between the bar
number and the bar it labels.

dit(code(markHangOnClef)) Set to 1 to cause marks to appear by clefs
instead of by bar lines.

dit(code(marginDirection)) Set to code(\left) or code(\right) to
specify location of marginal scripts.  

dit(code(marginScriptPadding)) Specify extra space for marginal scripts.

dit(code(forgetAccidentals)) Causes accidentals to be printed at every
note instead of remembered for the duration of a measure.  

dit(code(noResetKey)) Do not reset the key at the start of a measure.
Accidentals will be printed only once and are in effect until
overridden, possibly many measures later. 

dit(code(staffLineLeading)) Specifies the distance (in points) between lines
of the staff.  

dit(code(postBreakPadding)) Extra space in points to be added after
the clef, time signature and key signature on the staff.

dit(code(barAtLineStart)) Set to 1 to produce a bar line after the
clef at the start of each line (but not at the beginning of the
music).  

dit(code(voltaVisibility)) Set to 0 to suppress the printing
of brackets over alternate endings specified by code(\alternative).

dit(code(voltaSpannerDuration)) Set to an integer to control the size
of the brackets printed by code(\alternative).  The integer specifies
the number of whole notes duration to use for the brackets.  It seems
to be rounded to the nearest measure.  This can be used to shrink the
length of brackets in the situation where one alternative is very
large.  It may have odd effects if the specified duration is longer
than the music given in an code(\alternative).  

dit(code(barNonAuto)) If set to 1 then bar lines will not be printed
automatically; they must be explicitly created with code(\bar) keywords.
Unlike with the code(\cadenza) keyword, measures are still counted.  Bar
generation will resume according to that count if this property is set to
zero.  

dit(code(defaultClef)) Determines the default clef.  See code(\clef)
keyword.

dit(code(nuberOfStaffLines)) Sets the number of lines that the staff has.
 
dit(code(barAlways)) If set to 1 a bar line is drawn after each note.

dit(code(defaultBarType)) Sets the default type of bar line.  See
code(\bar) keyword.

dit(code(keyoctaviation)) If set to 1, then keys are the same in all
octaves.  If set to 0 then the key signature for different octaves can
be different and is specified independently: code(\keysignature bes
fis').  The default value is 1.  Can be set to zero with
code(\specialkey) or reset to 1 with code(\normalkey).

dit(code(instrument) and code(instr)) If code(Staff_margin_engraver)
is added to the Staff translator, then the code(instrument) property
is used to label the first line of the staff and the code(instr)
property is used to label subsequent lines.  If the
code(midiInstrument) property is not set then code(instrument) is
used to determine the instrument for MIDI output.
COMMENT(This prints the instrument name on top of the staff lines.)

dit(code(createKeyOnClefChange)) Set to a nonempty string if you want key
signatures to be printed when the clef changes.  Set to the empty string (the
default) if you do not want key signatures printed.


dit(code(timeSignatureStyle)) Changes the default two-digit layout
   for time signatures. The following values are recognized:
   description(
      dit(code(C)) 4/4 and 2/2 are typeset as C and struck C,
      respectively. All other time signatures are written with two digits.
      dit(code(old)) 2/2, 3/2, 3/4, 4/4, 6/4, 9/4, 6/8 and 9/8 are typeset 
      with old-style mensuration marks. All other time signatures are 
      written with two digits.
      dit(code(1)) All time signatures are typeset with a single
      digit, e.g. 3/2 is written as 3.
      dit(code(C2/2), code(C4/4), code(old2/2), code(old3/2),
      code(old3/4), code(old4/4), code(old6/4), code(old9/4), 
      code(old6/8) or code(old9/8))Tells Lilypond to use a 
      specific symbol as time signature.
   )
The different time signature characters are shown below with
their names:
mudela(center)(
\score{
  \notes\relative c'' {
\property Voice.textStyle = typewriter
\property Staff.timeSignatureStyle = "C2/2"
\time 2/2; a2^"C2/2" a2 
\property Staff.timeSignatureStyle = "C4/4"
\time 2/2; a2^"C4/4" a2 
\property Staff.timeSignatureStyle = "old2/2"
\time 2/2; a2^"old2/2" a2 
\property Staff.timeSignatureStyle = "old3/2"
\time 2/2; a2^"old3/2" a2 
\property Staff.timeSignatureStyle = "old4/4"
\time 2/2; a2^"old4/4" a2 
\property Staff.timeSignatureStyle = "old6/4"
\time 2/2; a2^"old6/4" a2 
\property Staff.timeSignatureStyle = "old9/4"
\time 2/2; a2^"old9/4" a2 
\property Staff.timeSignatureStyle = "old6/8"
\time 2/2; a2^"old6/8" a2 
\property Staff.timeSignatureStyle = "old9/8"
\time 2/2; a2^"old9/8" a2 
}
   \paper{ linewidth= 4.5 \in; }
}
)

dit(code(clefStyle)) Determines how clefs are typeset. When set to
code(transparent), the clefs are not printed at all, when set to
code(fullSizeChanges), clef changes in the middle of a line are
typeset with a full size clef. By default, clef changes are typeset in
smaller size.

)
   
subsubsubsect(GrandStaff properties)

description( 

dit(code(alignmentReference)) Set to code(\center) for vertical
alignment reference point to be in the center of the vertical group.
Set to code(\up) to put the reference point at the top of the group. 

dit(code(maxVerticalAlign)) Set the maximum vertical distance between
staffs.

dit(code(minVerticalAlign)) Set the minimum vertical distance between
staffs.  

)

subsubsubsect(Score properties)

description(

dit(code(skipBars)) Set to 1 to skip the empty bars that are produced
by multimeasure notes and rests.  These bars will not appear on the
printed output.  Set to zero (the default) to expand multimeasure
notes and rests into their full length, printing the appropriate
number of empty bars so that synrchonization with other voices is
preserved.  COMMENT(meaning of "skip" here seems to be different from
the meaning used for the keyword \skip.)

dit(code(beamquantisation)) Set to code(\none) for no quantization.
Set to code(\normal) to quantize position and slope.  Set to
code(\traditional) to avoid wedges.  These three settings are
available via code(\beamposfree), code(\beamposnormal), and
code(\beampostraditional).

dit(code(beamslopedamping)) Set to code(\none) for undamped beams.
Set to code(\normal) for damped beams.  Set to code(\infinity) for
beams with zero slope.  The identifiers code(\beamslopeproportional),
code(\beamslopedamped), and code(\beamslopezero) each set the
corresponding value.

dit(code(chordInversion)) Determines whether LilyPond should look for
chord inversions when translating from notes to chord names.  Set to 1
to find inversions.  The default is 0 which does not look for inversions.

)



sect(Pre-defined Identifiers)
label(ident)

Various identifiers are defined in the initialization files to
provide shorthands for some settings.  

description(
dit(code(\aeolian)) Used as the second argument of the code(\key)
keyword to get an aeolian mode. 
dit(code(\break)) Force a line break in music by using a large
argument for the keyword code(\penalty). 
dit(code(\center)) Used for setting textalignment property.  Is set to 0.
dit(code(\cr)) Start a crescendo.
dit(code(\decr)) Start a decrescendo.
dit(code(\dorian)) Used as the second argument of the code(\key)
keyword to get a dorian mode.
dit(code(\down)) Used for setting direction setting properties.  Is
equal to -1.  
dit(code(\f)) Print forte symbol on the preceeding note.
dit(code(\ff)) Print fortissimo symbol on the preceeding note. 
dit(code(\fff)) Print fortississimo symbol on preceeding note. 
dit(code(\ffff)) Print fortissississimo symbol on preceeding note.
dit(code(\fffff)) Print fffff symbol on preceeding note.
dit(code(\ffffff)) Print ffffff symbol on preceeding note.
dit(code(\fp)) Print fortepiano symbol on preceeding note. 
dit(code(\free)) Used for setting direction setting properties.  Is
equal to 0.  
dit(code(\Gourlay)) Used for setting the paper variable
code(castingalgorithm).  Is equal to 1.0.  
dit(code(\infinity)) Used for setting the Score.beamslopedamping
property.  Is actually equal to 10000.  
dit(code(\ionian)) Used as the second argument of the code(\key)
keyword to get an ionian mode. 
dit(code(\left)) Used for setting textalignment property.  Is equal to -1.
dit(code(\locrian)) Used as the second argument of the code(\key)
keyword to get a locrian mode. 
dit(code(\lydian)) Used as the second argument of the code(\key)
keyword to get a lydian mode. 
dit(code(\major)) Used as the second argument of the code(\key)
keyword to get a major key.
dit(code(\minor)) Used as the second argument of the code(\key)
keyword to get a minor key.
dit(code(\mixolydian)) Used as the second argument of the code(\key)
keyword to get a mixolydian mode.
dit(code(\mf)) Print mezzoforte symbol on preceeding note. 
dit(code(\mp)) Print mezzopiano symbol on preceeding note. 
dit(code(\nobreak)) Prevent a line break in music by using a large
negative argument for the keyword code(\penalty). 
dit(code(\none)) Used for setting Score.beamslopedamping and
Score.beamquantisation properties.  Is equal to 0.
dit(code(\normal)) Used for setting Score.beamslopedamping and
Score.beamquantisation properties.  Is equal to 1.
dit(code(\normalkey)) Select normal key signatures where each octave
has the same key signature.  This sets the Staff.keyoctaviation property.
dit(code(\p)) Print a piano symbol on preceeding note. 
dit(code(\phrygian)) Used as the second argument of the code(\key)
keyword to get a phrygian mode.
dit(code(\pp)) Print pianissimo symbol on preceeding note. 
dit(code(\ppp)) Print pianississimo symbol on preceeding note. 
dit(code(\pppp)) Print pianissississimo symbol on preceeding note.
dit(code(\ppppp)) Print ppppp symbol on preceeding note.
dir(code(\pppppp)) Print pppppp symbol on preceeding note.
dit(code(\rc)) Terminate a crescendo. 
dit(code(\rced)) Terminate a decrescendo
dit(code(\rfz)) Print a rinforzato symbol on preceeding note.
dit(code(\right)) Used for setting textalignment property.  Is set to 1.
dit(code(\sf)) Print a subito-forte symbol on preceeding note. 
dit(code(\sff)) Print a subito-fortissimo symbol on preceeding note.
dit(code(\sfz)) Print a sforzato symbol on preceeding note. 
dit(code(\shiftoff)) Disable horizontal shifting of note heads that collide.  
Sets the Voice.horizontalNoteShift property.
dit(code(\shifton)) Enable note heads that collide with other note heads
to be shifted horiztonally.  Sets the Voice.horizontalNoteShift property.
dit(code(\slurboth)) Allow slurs to be above or below notes.  This
sets the Voice.slurVerticalDirection property. 
dit(code(\slurdown)) Force slurs to be below notes. This sets the
Voice.slurVerticalDirection property. 
dit(code(\slurup)) Force slurs to be above notes.  This sets the
Voice.slurVerticalDirection property.  
dit(code(\sp)) Print a subito-piano symbol on preceeding note.
dit(code(\spp)) Print a subito-forte symbol on preceeding note.
dit(code(\specialkey)) Allow keys signatures do differ in different
octaves.  This sets the Staff.keyoctaviation property.  
dit(code(\stemboth)) Allow stems, beams, and slurs to point either
direction.  This sets the Voice.verticalDirection property. 
dit(code(\stemdown)) Force stems, beams, and slurs to point down.
This sets the Voice.verticalDirection property. 
dit(code(\stemup)) Force stems, beams and slurs to point up.  This
sets the Voice.verticalDirection property. 
dit(code(\traditional)) Used for setting the 
Score.beamquantisation property.  Is equal to 2.  
dit(code(\up)) Used for setting various direction properties.  Is
equal to 1. 
dit(code(\voiceone)) Enter Voice context called code(one) and force stems down.
(See code(\stemdown).)
dit(code(\voicetwo)) Enter Voice context called code(two) and force stems
up. (See code(\stemup).)
dit(code(\voicethree)) Enter Voice context called code(three) and force stems
up.  
dit(code(\voicefour)) Enter Voice context called code(four), force stems down
and turn on horizontal shifting.  (See code(\stemdown) and code(\shifton).)
dit(code(\Wordwrap)) Used for setting the paper variable
code(castingalgorithm).  Equal to 0.0.  
)


sect(Output)
label(output)
label(paper)

The output produced by LilyPond is controlled by the code(\paper) and
code(\midi) keywords.  These keywords appear in the code(\score) block
to indicate that printed or musical output should be produced.  If
neither keyword appears in a code(\score) block, then paper output is
produced but MIDI output is not produced.  

The contents of the code(\paper) and code(\midi) blocks can change the
output in various ways.  These blocks can appear at the top level of a
Mudela file to set default parameters for each type of output.  It is
still necessary to explicitly specify the output type in the
code(\score) blocks if you don't want the default behavior of
producing only paper output.  

The code(\paper) and code(\midi) blocks 
may begin with an optional identifier reference.  No
identifier references are allowed anywhere else in the block.  
The code(\paper) block can contain the code(\shape) keyword; the
code(\midi) block can contain the code(\tempo) keyword.  Both of them
can contain code(\translator) keywords.  The code(\paper) block can
also contain identifier assignments and parameter assignments.  Unlike
at the top level, these assignments must be terminated by a semicolon.


subsect(Paper variables)

Warning: this section is outdated and inaccurate.  

There are a large number of paper variables that are used to control
details of the layout.  Usually you will not want to change these
variables; they are set by default to vaules that depend on the font
size in use.  The only way to find out what variables are supported is
to search the source code for code(get_var).  Two variables that you
may want to change are code(linewidth) and code(indent).

In order to change the font size used for the output, many variables
need to be changed.  Some identifiers and initialization files can
simplify this process.  The default size is 20pt.  In order to select
a different size, you must do two things.  At the top level, do
code(\include "paper)var(SZ)code(.ly") where var(SZ) is the height of
the staff in points.  Values presently allowed are 11, 13, 16, 20, and
26.  This loads some definitions, but does not cause them to take
effect.  In order to actually change the size, you must use one of the
identifiers: code(\paper_eleven), code(\paper_thirteen),
code(\paper_sixteen), code(\paper_twenty) or code(\paper_twentysix)
inside a code(\paper) block.


description(
  dit(var(integer)) If an integer appears on the left side of an
assignment then a code(\font) keyword must appear on the right
side.  This defines a music font at a particular size.  See Voice
property code(fontSize).

dit(code(arithmetic_basicspace) and code(arithmetic_multiplier))
The space taken by a note is determined by the formula 
COMMENT(

)verb(arithmetic_multiplier * ( c + log2 (time) ))COMMENT(

) where code(time) is the amount of time a note occupies.  The value
of code(c) is chosen such that the smallest space within a measure is
arithmetic_basicspace.  The smallest space is the one following the
shortest note in the measure.  Typically arithmetic_basicspace is set
to the width of a quarter note head.

dit(code(barsize)) Specify height of bars.  This value may need to be
adjusted if you change the number of lines in the staff.
dit(code(beam_dir_algorithm)) Specify algorithm for determining
whether beams go up or down.  It is real valued.  If set to 2.0 then
majority selection is used.  If set to 3.0, then mean selection is
used based on the mean center distance.  If set to 4.0 then median
selection is used, based on the median center distance.  
dit(code(castingalgorithm)) 
dit(code(crescendo_shorten))
dit(code(forced_stem_shorten)) Stems that have been forced to go the
unnatural direction are shortened by this amount.  Equal to
dit(code(forced_stem_shorten0))
dit(code(gourlay_energybound))
dit(code(gourlay_maxmeasures)) Maximum number of measures per line
when using Gourlay method.
Decreasing this greatly reduces computation time.  Default value: 10.  
dit(code(indent)) Sets the indentation of the first line of music.  
dit(code(interbeam))
dit(code(interbeam4))
dit(code(interline))  The distance between two staff
lines, calculated from the center of the lines.  
dit(code(linewidth))  Sets the width of the lines.  If it is set to
-1.0, then a single unjustified line is produced.  
dit(code(notewidth)) Width of an average note head.  
dit(code(output)) Specifies an alternate
name for the TeX() output.  A file(.tex) extension will be added to
the string you specify.
dit(code(rulethickness)) Determines thickness of staff lines and bars. 
dit(code(slur_clip_angle))
dit(code(slur_clip_height))
dit(code(slur_clip_ratio))
dit(code(slur_height_limit)) Specifies the maximum height of slurs.
Normally equal to staff_height.
dit(code(slur_ratio)) Specifes the ratio of slur hight to slur width
to aim for.  Default value is 0.3.  
dit(code(slur_rc_factor))
dit(code(slur_slope_damping)) Allows slurs to start and end at
different heights ????  Default value is 0.5.
dit(code(slur_thickness)) Specify slur thickness.  Equal to code(1.4 *
\staffline) by default.  
dit(code(slur_x_gap)) Horizontal space between note and slur.  Set to
code(\interline / 5) by default.  
dit(code(slur_x_minimum))
dit(code(staffheight)) The height of the staff from the center of the
bottom line to the center of the top line.  Equal to to code(4 * \interline).
dit(code(stem_length)) Specify length of stems for notes in the staff
that don't have beams.  
dit(code(stemthickness)) Specifies the thickness of the stem lines.  
dit(code(tie_slope_damping))
dit(code(tie_x_minimum))
)


subsect(MIDI Instrument Names)
label(midilist)

The MIDI instrument name is set by the code(Staff.midiInstrument)
property or, if that property is not set, the code(Staff.instrument)
property.  The instrument name should be chosen from this list.  If
string does not exactly match one from this list then LilyPond uses
the default piano.

COMMENT( acordina = accordion, tango accordian = concertina
         distortion guitar = distorted guitar
         orchestral strings = harp 
         pan flute = wood flute? )

verb("acoustic grand"               "contrabass"             "lead 7 (fifths)"
"bright acoustic"              "tremolo strings"        "lead 8 (bass+lead)"
"electric grand"               "pizzicato strings"      "pad 1 (new age)"
"honky-tonk"                   "orchestral strings"     "pad 2 (warm)"
"electric piano 1"             "timpani"                "pad 3 (polysynth)"
"electric piano 2"             "string ensemble 1"      "pad 4 (choir)"
"harpsichord"                  "string ensemble 2"      "pad 5 (bowed)"
"clav"                         "synthstrings 1"         "pad 6 (metallic)"
"celesta"                      "synthstrings 2"         "pad 7 (halo)"
"glockenspiel"                 "choir aahs"             "pad 8 (sweep)"
"music box"                    "voice oohs"             "fx 1 (rain)"
"vibraphone"                   "synth voice"            "fx 2 (soundtrack)"
"marimba"                      "orchestra hit"          "fx 3 (crystal)"
"xylophone"                    "trumpet"                "fx 4 (atmosphere)"
"tubular bells"                "trombone"               "fx 5 (brightness)"
"dulcimer"                     "tuba"                   "fx 6 (goblins)"
"drawbar organ"                "muted trumpet"          "fx 7 (echoes)"
"percussive organ"             "french horn"            "fx 8 (sci-fi)"
"rock organ"                   "brass section"          "sitar"
"church organ"                 "synthbrass 1"           "banjo"
"reed organ"                   "synthbrass 2"           "shamisen"
"accordion"                    "soprano sax"            "koto"
"harmonica"                    "alto sax"               "kalimba"
"concertina"                   "tenor sax"              "bagpipe"
"acoustic guitar (nylon)"      "baritone sax"           "fiddle"
"acoustic guitar (steel)"      "oboe"                   "shanai"
"electric guitar (jazz)"       "english horn"           "tinkle bell"
"electric guitar (clean)"      "bassoon"                "agogo"
"electric guitar (muted)"      "clarinet"               "steel drums"
"overdriven guitar"            "piccolo"                "woodblock"
"distorted guitar"             "flute"                  "taiko drum"
"guitar harmonics"             "recorder"               "melodic tom"
"acoustic bass"                "pan flute"              "synth drum"
"electric bass (finger)"       "blown bottle"           "reverse cymbal"
"electric bass (pick)"         "skakuhachi"             "guitar fret noise"
"fretless bass"                "whistle"                "breath noise"
"slap bass 1"                  "ocarina"                "seashore"
"slap bass 2"                  "lead 1 (square)"        "bird tweet"
"synth bass 1"                 "lead 2 (sawtooth)"      "telephone ring"
"synth bass 2"                 "lead 3 (calliope)"      "helicopter"
"violin"                       "lead 4 (chiff)"         "applause"
"viola"                        "lead 5 (charang)"       "gunshot"
"cello"                        "lead 6 (voice)")



subsect(Translators)
label(translators)

The behavior of notation contexts is defined by the translators for
those contexts.  The translator for a context specifies what notations
are handled by the context, it specifies what other contexts the
context can contain, and it sets property values for the context.  
There are different translators for each type of output.  The
translators for paper output are defined in file(engraver.ly).  The
translators for MIDI output are defined in file(performer.ly).  

The first thing that appears inside a code(\translator) definition is
the type of the context being created.  This is specified with the
code(\type) keyword: code(\type) var(typename)code(;).  After the type
of the context is specified, property assignments, the code(\name)
keyword and code(\consists), code(\accepts), and code(\remove)
keywords can appear in any order.  The code(\name) keyword specifies
the name of the context that is handled by the translator.  If the
name is not specified, the translator won't do anything.  Each
code(\accepts) keyword specifies what contexts can be contained inside
this one.  The code(\consists) keywords specify which notations are
handled by the context.  Each code(\consists) keyword specifies the
name of an engraver (for paper ouput) or performer (for MIDI output)
which handles a certain notation.  The code(\remove) keyword can be
used to remove a performer or engraver from the translator.

In the code(\paper) block, it is also possible to define translator
identifiers.  Like other block identifiers, the identifier can only
be used as the very first item of a translator.  In order to define
such an identifier outside of code(\score), you must do
verb(\paper{ foo=\translator{ ... }
\score{
  \notes{ ... }
  \paper{ \translator{ \foo ... } }
})

Some All of the standard translators have predefined identifiers,  making
it easy to redefine these contexts by adding or removing items. 
The predefined identifiers are:  code(StaffContext),
code(RhythmicStaffContext),  code(VoiceContext),  code(ScoreContext), code(ScoreWithNumbers)


subsubsect(Paper Types and Engravers and Pre-defined Translators)

Some pre-defined identifiers can simplify modification of translators.
The pre-defined identifiers are:  
description(
dit(code(StaffContext)) Default Staff  context. 
dit(code(RhythmicStaffContext)) Default RhythmicStaff  context. 
dit(code(VoiceContext)) Default Voice  context.  
dit(code(ScoreContext))  Default  Score context. 
dit(code(ScoreWithNumbers)) Score  context with numbering at  the
Score level.   
dit(code(BarNumberingStaffContext)) Staff context with numbering  at
the Staff level.  
dit(code(HaraKiriStaffContext))  
dit(code(OrchestralPartStaffContext))
dit(code(OrchestralScoreContext))
)
Using these pre-defined values, you can remove  or add items to the
translator verb(\paper{ \translator{ \StaffContext
                     \remove Some_engraver;
                     \consists Different_engraver;  }})
      


There are four types for paper translators:
description(
  dit(code(Engraver_group_engraver))
  dit(code(Hara_kiri_line_group_engraver))
  dit(code(Line_group_engraver_group))
  dit(code(Score_engraver))  
)
COMMENT( The names of these types seem somewhat confusing. )

The engravers for paper output are:

description(
dit(code(Abbreviation_beam_engraver))
dit(code(Bar_engraver)) Engraves bar lines.  Normally in code(Staff) and
code(RhythmicStaff).  
dit(code(Bar_number_engraver)) Engrave bar numbers.  These numbers
appear at the start of each line.  Not normally in any translator.  Can
be added to code(Score) for Score-wide numbering or to code(Staff) for
numbering on each staff.  

dit(code(Beam_engraver)) Handles beam requests by engraving beams.  Normally
appears in the code(Voice) translator.  If omitted, then notes will be printed
with flags instead of beams.

dit(code(Beam_req_swallow_translator)) Swallows beam requests.  In
code(LyricVoice).  
dit(code(Chord_name_engraver)) Engraves chord names.  Normally in
code(ChordNameVoice) 
dit(code(Clef_engraver)) Engraves the clef symbol.  Normally in code(Staff).
dit(code(Collision_engraver))
dit(code(Dot_column_engraver)) Engraves dots on dotted notes shifted to the
right of the note.  Normally in code(Voice).  If omitted, then dots appear on
top of the notes.  
dit(code(Dynamic_engraver)) Engraves dynamics symbols.  Normally in code(Voice).
dit(code(Font_size_engraver))
dit(code(Key_engraver)) Engraves the key signature.  Normally in code(Staff).
dit(code(Local_key_engraver))
dit(code(Lyric_engraver)) Engraves lyrics.  Normally in code(LyricVoice).
dit(code(Multi_measure_rest_engraver)) Engraves multi-measure rests that are
produced with code(R).  Normally in code(Voice).
dit(code(Piano_bar_engraver))
dit(code(Pitch_squash_engraver)) Treat all pitches as middle C.  Used in
code(RhythmicStaff).  Note that the notes move, but the locations of
accidentals stay the same. 
dit(code(Priority_horizontal_align_engraver))
dit(code(Repeat_engraver)) Handles repeats? In code(Staff) and 
   code(RhythmicStaff).
dit(code(Rest_collision_engraver)) Handles collisions of rests. In code(Staff).
dit(code(Rest_engraver)) Engraves rests.  Normally in code(Voice).
dit(code(Rhythmic_column_engraver))
dit(code(Score_priority_engraver))
dit(code(Script_engraver)) Handles note ornaments generated by code(\script).
Normally in code(Voice).  
dit(code(Separating_line_group_engraver))
dit(code(Skip_req_swallow_translator))
dit(code(Slur_engraver)) Engraves slurs.  Normally in code(Voice).
dit(code(Span_bar_engraver)) Engraves lines across multiple staffs.  Normally
in code(Staffgroup) and code(GrandStaff).  Removing this from code(StaffGroup)
gives the definition of code(ChoirStaff).  
dit(code(Span_score_bar_engraver))
dit(code(Staff_group_bar_engraver))
dit(code(Staff_margin_engraver)) Prints the name of the instrument
(specified by code(Staff.instrument) and code(Staff.instr)) at the
left of the staff.  
dit(code(Staff_sym_engraver))
dit(code(Stem_engraver)) Engraves stems.  Normally in code(Voice).
dit(code(Ties_engraver)) Engraves ties.  Normally in code(Voice).
dit(code(Time_signature_engraver)) Engraves the time signature.  Normally in
code(Staff) and code(RhythmicStaff).
dit(code(Timing_engraver)) Responsible for synchronizing timing information
from staffs.  Normally in code(Score).  In order to create polyrhythmic music,
this engraver should be removed from code(Score) and placed in code(Staff).
dit(code(Tuplet_engraver)) Engraves tuplet brackets?  In code(Staff).
dit(code(Vertical_align_engraver)) 
)


subsubsect(MIDI Types and Performers)

The types available for  MIDI translators are:
description(
dit(code(Performer_group_performer))
dit(code(Score_performer))
dit(code(Staff_performer))
)

The performers for MIDI translators are:
description(
dit(code(Key_performer))
dit(code(Time_signature_performer))
dit(code(Note_performer))
dit(code(Lyric_performer))
dit(code(Swallow_performer))
)