release: 1.3.133

[lilypond.git] / Documentation / user / refman.itely

@c Note:
@c
@c A menu is needed before every deeper *section nesting of @nodes
@c Run M-x texinfo-all-menus-update
@c to automagically fill in these menus
@c before saving changes


@ignore
 TODO:

   fix all FIXMEs

   Rhythm staff (clef, x-notehead)

@end ignore


@c .{Reference Manual}

@node Reference Manual
@chapter Reference Manual

This document describes GNU LilyPond and its input format. This document
has been revised for LilyPond 1.3.131



@menu
* Overview::                    
* Note entry::                  
* Music notation::              
* Polyphony::                   
* Spanners::                    
* Repeats::                     
* Piano music::                 
* Lyrics::                      
* Chords::                      
* Writing parts::               
* Custodes::                    
* Tuning output::               
* Page layout::                 
* Sound::                       
* Music entry::                 
* Engravers::                   
* Syntactic details::           
@end menu

@c . {Overview}
@node Overview
@section Overview


The purpose of LilyPond is explained informally by the term `music
typesetter'.  This is not a fully correct name: not only does the
program print musical symbols, it also makes esthetic decisions.  All
symbols and their placement is @emph{generated} from a high-level
musical description.  In other words, LilyPond would be best described
by `music compiler' or `music to notation compiler'.

Internally, LilyPond is written in a mixture of Scheme and C++. Most of
the algorithms and low-level routines are written in C++, but these low
level components are glued together using Scheme data
structures. LilyPond is linked to GUILE, GNU's Scheme library for
extension.

When lilypond is run to typeset sheet music, the following happens:

@itemize @bullet
@item GUILE Initialization: various scheme files are read
@item parsing: first standard .ly initialization  files are read, and
then the user @file{.ly} file is read.
@item interpretation: the music in the file is processed "in playing
order", i.e. in the same order as your eyes scan sheet music, and in the
same order that you hear the notes play.

@item typesetting:
in this step, the results of the interpretation, a typesetting
specification, is solved.

@item the visible results ("virtual ink") is written to the output file.
@end itemize

These stages, involve data of a specific type: during parsing,
@strong{Music} objects are created.  During the interpretation,
@strong{context} is constructed, and with this context af network of
@strong{graphical objects} (``grobs'') is created. The grobs contain
unknown variables, and the network forms a set of equations. After
solving the equations and filling in these variables, the printed output
(in the form of @strong{molecules}) is written to an output file.

These threemanship of tasks (parsing, translating, typesetting) and
data-structures (music, context, graphical objects) permeates the entire
design of the program.  This manual is ordered in terms of user
tasks. With each concept will be explained to which of the three parts
it belongs.

LilyPond input can be classified into three types:
@itemize @bullet
  @item musical expressions: a musical expression is some combination of
rest, notes, lyrics
  @item output definitions: recipes for translating those musical
expressions into performances (MIDI) or graphics (eg. PostScript).

  @item declarations: by declaring and naming musical expressions, you
can enter and edit them in manageable chunks.
@end itemize




@c . {Note entry}
@node Note entry
@section Note entry
@cindex Note entry

@menu
* Notes mode::                  
* Pitches::                     
* Defining pitch names::        
* Durations::                   
* Notes::                       
* Note head tweaks::            
* Rests::                       
* Skip::                        
@end menu

@c .  {Notes mode}
@node Notes mode
@subsection Notes mode

@cindex note mode

@cindex @code{\notes}
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.

Since combinations of numbers and dots are used for indicating
durations, it is not possible to enter real numbers in this mode.

@cindex Notes mode

@c .  {Pitches}
@node Pitches
@subsection Pitches

@cindex Pitch names
@cindex Note specification
@cindex pitches
@cindex entering notes

The verbose syntax for pitch specification is

@cindex @code{\pitch}
@example
  \pitch @var{scmpitch}
@end example

@var{scmpitch} is a pitch scheme object, see @ref{Pitch data type}.

In Note and Chord mode, pitches may be designated by names.  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 octave above that C.  In Dutch,
@cindex note names, 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}.  @code{aes} and
@code{ees} are contracted to @code{as} and @code{es} in Dutch, but both
forms will be accepted.

LilyPond has predefined sets of notenames for various other languages.
To use them, simply include the language specific init file.  For
example: @code{\include "english.ly"}.  The available language files and
the names they define are:

@example 
                        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  sib si  -d          -b
catalan.ly     do  re  mi  fa  sol la  sib si  -d/-s       -b 
@end example 

@cindex @code{'}
@cindex @code{,}




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.

@lilypond[fragment,verbatim,center]
  c' d' e' f' g' a' b' c''
@end lilypond

@lilypond[fragment,verbatim,center]
  cis' dis' eis' fis' gis' ais' bis'
@end lilypond

@lilypond[fragment,verbatim,center]
  ces' des' es' fes' ges' as' bes'
@end lilypond

@lilypond[fragment,verbatim,center]
  cisis' eisis' gisis' aisis' beses'
@end lilypond

@lilypond[fragment,verbatim,center]
  ceses' eses' geses' ases' beses'
@end lilypond


@c .  {Defining pitch names}
@node Defining pitch names
@subsection Defining pitch names

@cindex defining pitch names
@cindex pitch names, defining 

Note names and chord modifiers can be customised for nationalities.  The
syntax is as follows.

@cindex @code{\pitchnames}
@cindex @code{\chordmodifiers}
@example
   \pitchnames @var{scheme-alist}
   \chordmodifiers @var{scheme-alist}
@end example

See @file{ly/nederlands.ly} and @file{ly/chord-modifiers.ly} for
specific examples how to do this.  Some national note names have been
provided, among others: Norwegian, Swedish, German, Italian, Catalan,
French, Dutch and English.


@c .  {Durations}
@node Durations
@subsection Durations


@cindex duration
@cindex @code{\duration}

The syntax for an verbose duration specification is
@example
 \duration @var{scmduration}
@end example

In Note, Chord, and Lyrics mode, durations may be designated by numbers
and dots: durations are entered as their reciprocal values.  For notes
longer than a whole note, use identifiers.

@quotation

@example 
c'\longa c'\breve  
c'1 c'2 c'4 c'8 c'16 c'32 c'64 c'64 
r\longa r\breve  
r1 r2 r4 r8 r16 r32 r64 r64 
@end example 


@lilypond[]
\score {
  \notes \relative c'' {
    a\longa a\breve  \autoBeamOff
    a1 a2 a4 a8 a16 a32 a64 a64 
    r\longa r\breve  
    r1 r2 r4 r8 r16 r32 r64 r64 
  }
  \paper {
    \translator {
      \StaffContext
        \remove "Clef_engraver";
        \remove "Staff_symbol_engraver";
        \remove "Time_signature_engraver";
        \consists "Pitch_squash_engraver";
    }
  }
}
@end lilypond
@end quotation

As you can see, the longa is not printed. To get a longa note head, you
have to use a mensural note heads. This is done accomplished by setting
the @code{style} property of the NoteHead grob to @code{mensural}.

If the duration is omitted then it is set equal to the previous duration
entered.  At the start of parsing there is no previous duration, so then
a quarter note is assumed.  The duration can be followed by a dot
(`@code{.}')  to obtain dotted note lengths.
@cindex @code{.}

@lilypond[fragment,verbatim,center]
  a'4. b'4. c'2..
@end lilypond
@cindex @code{r}
@cindex @code{s}

You can alter the length of duration by writing `@code{*}@var{fraction}'
after it.  This will not affect the appearance of note heads or rests.

@c . {Notes}
@node Notes
@subsection Notes

A note specification has the form

@example
  @var{pitch}[@var{octavespec}][!][?][@var{duration}]
@end example


LilyPond will determine what accidentals to typeset depending on the key
and context, so alteration refer to what note is heard, not to whether
accidentals are printed.  A reminder accidental
@cindex reminder accidental
@cindex @code{?}
can be forced by adding an exclamation mark @code{!} after the pitch.
A cautionary accidental,
@cindex cautionary accidental

i.e., an accidental within parentheses can be obtained by adding the
question mark `@code{?}' after the pitch.

@lilypond[fragment,verbatim,center]
  cis' d' e' cis'  c'? d' e' c'!
@end lilypond


@node Note head tweaks
@subsection Note head tweaks

[TODO]

The note head style can be adjusted with  the @code{style} property of
@code{NoteHead}.

@lilypond[fragment,singleline,relative,verbatim]
c'4
\property Voice.NoteHead \set #'style = #'cross
c'4
@end lilypond

[discuss more options]

@cindex easy notation
@cindex Hal Leonard

A entirely different type of note head is the "easyplay" note head: a
note head that includes a note name.  It is used in some publications by
the Hal-Leonard Corporation (a music publishing company).

@lilypond[singleline,verbatim]
\score {
        \notes { c'2 e'4 f' | g'1 }
        \paper { \translator { \EasyNotation } } 
}
@end lilypond

Note that @code{EasyNotation} overrides a @code{Score} context.  You
probably will want to print it with magnification to make it better
readable.

Limitations: The staff-lines show through the letters.


@c .  {Rests}
@node  Rests
@subsection Rests
@cindex Rests

Rests are entered like notes, with note name `@code{r}'.
There is also a note name
`@code{s}', which produces a space of the specified
duration.


@c .  {Skip}
@node Skip
@subsection Skip
@cindex Skip


@example
  \skip @var{duration} @code{;}
@end example
@cindex @code{\skip}

Skips the amount of time specified by @var{duration}.  If no other
music is played, a gap will be left for the skipped time with no
notes printed.  It works in Note Mode or Lyrics Mode.  In Note mode,
this has the same effect as the spacer rest.



@c . {Music notation}
@node Music notation
@section Music notation
@cindex Music notation
@menu
* Key::                         
* Breath marks::                
* Time signature::              
@end menu

@c .  {Key}
@node Key
@subsection Key
@cindex Key

@cindex @code{\key}

@example
  @code{\key} @var{pitch} @var{type} @code{;}
@end example
@cindex @code{\minor}
@cindex @code{\major}
@cindex @code{\minor}
@cindex @code{\ionian}
@cindex @code{\locrian}
@cindex @code{\aeolian}
@cindex @code{\mixolydian}
@cindex @code{\lydian}
@cindex @code{\phrygian}
@cindex @code{\dorian}

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.

This command sets @code{Staff.keySignature}.



@cindex @code{keySignature}

@c .   {Clef changes}
@subsubsection Clef changes
@cindex @code{\clef}
@example
  \clef @var{clefname} @code{;}
@end example

Short-cut for

@example
  \property Staff.clefGlyph = @var{symbol associated with clefname} 
  \property Staff.clefPosition = @var{clef Y-position for clefname}
  \property Staff.clefOctavation = @var{extra pitch of clefname}
@end example

Supported clef-names include 

@itemize @bullet
@item treble, violin, G, G2: G clef on 2nd line
@item french: G clef on 1st line
@item soprano: C clef on 1st line
@item mezzosoprano: C clef on 2nd line
@item alto: C clef on 3rd line
@item tenor: C clef on 4th line
@item baritone: C clef on 5th line
@item varbaritone: F clef on 3rd line
@item bass, F: F clef on 4th line
@item subbass: F clef on 5th line
@item percussion: percussion clef
@end itemize

Supported associated symbols (for Staff.clefGlyph) are:

@itemize @bullet
@item clefs-C: modern style C clef
@item clefs-F: modern style F clef
@item clefs-G: modern style G clef
@item clefs-vaticana_do: Editio Vaticana style do clef
@item clefs-vaticana_fa: Editio Vaticana style fa clef
@item clefs-medicaea_do: Editio Medicaea style do clef
@item clefs-medicaea_fa: Editio Medicaea style fa clef
@item clefs-mensural1_c: modern style mensural C clef
@item clefs-mensural2_c: historic style small mensural C clef
@item clefs-mensural3_c: historic style big mensural C clef
@item clefs-mensural1_f: historic style traditional mensural F clef
@item clefs-mensural2_f: historic style new mensural F clef
@item clefs-mensural_g: historic style mensural G clef
@item clefs-hufnagel_do: historic style hufnagel do clef
@item clefs-hufnagel_fa: historic style hufnagel fa clef
@item clefs-hufnagel_do_fa: historic style hufnagel combined do/fa clef
@item clefs-percussion: modern style percussion clef
@end itemize

@emph{Modern style} means "as is typeset in current editions".
@emph{Historic style} means "as was typeset or written in contemporary
historic editions".  @emph{Editio XXX style} means "as is/was printed in
Editio XXX".

@node Breath marks
@subsection Breath marks

Breath marks are entered using @code{\breathe}:

@lilypond[fragment,relative]
c'4 \breathe d4
@end lilypond



@c .  {Time signature}
@node Time signature
@subsection Time signature
@cindex Time signature
@cindex meter
@cindex @code{\time}

@example
  \time @var{numerator}@code{/}@var{denominator} @code{;}
@end example

A short-cut for doing
@example
     \property Score.timeSignatureFraction = #'(@var{numerator} . @var{denominator})
@end example

See the documentation of @code{timeSignatureFraction}


@c .   {Partial}
@subsubsection Partial
@cindex Partial
@cindex anacrusis
@cindex upstep
@cindex partial measure
@cindex measure, partial
@cindex shorten measures
@cindex @code{\partial}
@example
  \partial @var{duration} @code{;}
@end example

Short cut for 

@example
  \property Score.measurePosition = @var{length of duration}
@end example
@cindex @code{|}

See the documentation of @code{measurePosition}.





@c .   {Polyphony}
@node Polyphony
@section Polyphony
@cindex Polyphony

[todo : collisiosn, rest-collisinos, voiceX identifiers, how to
which  contexts to instantiate.]


@table @code
@cindex @code{\shiftOff}  
  @item @code{\shiftOff}
    Disable horizontal shifting of note heads that collide. 

@cindex @code{\shiftOn}  
  @item @code{\shiftOn}
    Enable note heads that collide with other note heads to be
    shifted horiztonally. Also @code{\shiftOnn} and @code{\shiftOnnn}
set different shift values.

@cindex @code{\stemBoth}  
  @item @code{\stemBoth}
    Allow stems, beams, and slurs to point either upwards or
    downwards, decided automatically by LilyPond.

@cindex @code{\stemDown}  
  @item @code{\stemDown}
    Force stems, beams, and slurs to point down.

@cindex @code{\stemUp}  
  @item @code{\stemUp}
    Force stems, beams and slurs to point up.
@end table

@c .  {Spanners}
@node Spanners
@section Spanners
@cindex Spanners

@menu
* Beam::                        
* Slur ::                       
* Phrasing slur::               
* Ornaments::                   
* Grace notes::                 
* Bar check::                   
@end menu



@c .   {Beam}
@node Beam
@subsection Beams

@cindex beams

@c .    {Automatic beams}
@subsubsection Automatic beams


@cindex automatic beam generation
@cindex autobeam
@cindex @code{Voice.noAutoBeaming}

LilyPond will group flagged notes and generate beams autmatically, where
appropriate.

This feature can be disabled by setting the @code{Voice.noAutoBeaming}
property to true, which you may find necessary for the melody that goes
with lyrics, eg.  Automatic beaming can easily be overridden for
specific cases by specifying explicit beams. This is discussed in the
next subsubsection.



@cindex @code{Voice.autoBeamSettings}
@cindex @code{(end * * * *)}
@cindex @code{(begin * * * *)}

A large number of Voice properties are used to decide how to generate
beams.  Their default values appear in @file{scm/auto-beam.scm}.  In
general, beams can begin anywhere, but their ending location is
significant.  Beams can end on a beat, or at durations specified by the
properties in @code{Voice.autoBeamSettings}.  To end beams every quarter
note, for example, you could set the property @code{(end * * * *)} to
@code{(make-moment 1 4)}.  To end beams at every three eighth notes you
would set it to @code{(make-moment 1 8)}.  The same syntax can be used
to specify beam starting points using @code{(begin * * * *)}, eg:
@quotation
@example
\property Voice.autoBeamSettings \override
    #'(end * * * *) = #(make-moment 1 4)
\property Voice.autoBeamSettings \override
    #'(begin * * * *) = #(make-moment 1 8)
@end example
@end quotation

To allow different settings for different time signatures, instead of
the first two asterisks @code{* *} you can specify a time signature; use
@code{(end N M * *)} to restrict the definition to
`@var{N}@code{/}@var{M}' time.  For example, to specify beams ending
only for 6/8 time you would use the property @code{(end 6 8 * *)}.

To allow different endings for notes of different durations, instead of
th last two asterisks you can specify a duration; use @code{(end * * N
M)} to restrict the definition to beams that contain notes of
`@var{N}@code{/}@var{M}' duration.

For example, to specify beam endings for beams that contain 32nd notes,
you would use @code{(end * * 1 32)}.



@c .    {Manual beams}
@cindex Automatic beams
@subsubsection Manual beams
@cindex beams, manual
@cindex @code{]}
@cindex @code{[}

In some cases it may be necessary to override LilyPond's automatic
beaming algorithm.  For example, the auto beamer will not beam over
rests or bar lines, so if you want that, specify the begin and end point
manually using @code{[} and @code{]}:

@quotation
@lilypond[fragment,relative,verbatim]
  \context Staff {
    r4 [r8 g'' a r8] r8 [g | a] r8
  }
@end lilypond


@cindex @code{stemLeftBeamCount}

If you have specific wishes for the number of beams, you can fully
control the number of beams through the properties
y@code{Voice.stemLeftBeamCount} and @code{Voice.stemRightBeamCount}.

@lilypond[fragment,relative,verbatim]
  \context Staff {
    [f'8 r16 f g a]
    [f8 r16 \property Voice.stemLeftBeamCount = #1 f g a]
  }
@end lilypond
@end quotation
@cindex @code{stemRightBeamCount}


@c .    {Adjusting beams}
@unnumberedsubsubsec Adjusting beams
@cindex Adjusting beams

FIXME


        

@c .   {Slur}
@node Slur 
@subsection Slur
@cindex slur

@menu
* Slur attachments::            
@end menu

A slur connects chords and is used to indicate legato.  Slurs avoid
crossing stems.  A slur is started with @code{(} and stopped with
@code{)}.  The starting @code{(} appears to the right of the first note
in the slur.  The terminal @code{)} appears to the left of the last note
in the slur.  This makes it possible to put a note in slurs from both
sides:

@lilypond[fragment,verbatim,center]
  f'()g'()a' [a'8 b'(] a'4 g'2 )f'4
@end lilypond

@c .    {Adjusting slurs}
@unnumberedsubsubsec Adjusting slurs


@node Slur attachments
@subsubsection Slur attachments

The ending of a slur should whenever possible be attached to a note
head.  Only in some instances where beams are involved, LilyPond may
attach a slur to a stem end.  In some cases, you may want to override
LilyPond's decision, e.g., to attach the slur to the stem end.  This can
be done through @code{Voice.Slur}'s grob-property @code{attachment}:


@quotation
@lilypond[fragment,relative,verbatim]
  \property Voice.Slur \set #'direction = #1
  \property Voice.Stem \set #'length = #5.5
  g''8(g)g4
  \property Voice.Slur \set #'attachment = #'(stem . stem)
  g8(g)g4
@end lilypond
@end quotation

Similarly, slurs can be attached to note heads even when beams are
involved:

@quotation
@lilypond[fragment,relative,verbatim]
  \property Voice.Slur \set #'direction = #1
  \property Voice.Slur \set #'attachment = #'(head . head)
  g''16()g()g()g()d'()d()d()d
@end lilypond
@end quotation

If a slur would strike through a stem or beam, LilyPond will move the
slur away vertically (upward or downward).  In some cases, this may
cause ugly slurs that you may want to correct:

@quotation
@lilypond[fragment,relative,verbatim]
  \property Voice.Stem \set #'direction = #1
  \property Voice.Slur \set #'direction = #1
  d'32( d'4 )d8..
  \property Voice.Slur \set #'attachment = #'(stem . stem)
  d,32( d'4 )d8..
@end lilypond
@end quotation

LilyPond will increase the curvature of a slur trying to stay free of
note heads and stems.  However, if the curvature would increase too much,
the slur will be reverted to its default shape.  This decision is based
on @code{Voice.Slur}'s grob-property @code{beautiful} value.  In some
cases, you may find ugly slurs beautiful, and tell LilyPond so by
increasing the @code{beautiful} value:

[hoe  gedefd?? wat betekent beautiful = X?]

@quotation
@lilypond[verbatim]
\score {
  \notes \context PianoStaff <
    \time 6/4;
    \context Staff=up { s1 * 6/4 }
    \context Staff=down <
      \clef bass;
      \autochange Staff \context Voice
        \notes \relative c {
          d,8( a' d f a d f d a f d )a
        }
    >
  >
  \paper {
    linewidth = -1.;
    \translator {
      \VoiceContext
      Slur \override #'beautiful = #5.0
      Slur \override #'direction = #1
      Stem \override #'direction = #-1
      autoBeamSettings \override #'(end * * * *)
        = #(make-moment 1 2)
    }
    \translator {
      \PianoStaffContext
      VerticalAlignment \override #'threshold = #'(5 . 5)
    }
  }
}
@end lilypond
@end quotation

@cindex Adusting slurs



@c .   {Phrasing slur}
@node Phrasing slur
@subsection Phrasing slur
@cindex phrasing slur
@cindex phrasing mark

A phrasing slur (or phrasing mark) connects chords and is used to
indicate a musical sentence.  Phrasing slurs avoid crossing stems.  A
phrasing slur is started with @code{\(} and stopped with @code{\)}.  The
starting @code{\(} appears to the right of the first note in the
phrasing slur.  The terminal @code{\)} appears to the left of the last
note in the phrasing slur.

@lilypond[fragment,verbatim,center,relative]
  \time 6/4; c''\((d)e f(e)\)d
@end lilypond

[TODO: put together with breath mark.]


@c .   {Tie}
@menu
* Tie::                         
* Tuplets::                     
* Text spanner::                
* Ottava::                      
* Span requests::               
@end menu

@node Tie
@subsubsection Tie

@cindex Tie
@cindex ties
@cindex @code{~}

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{~}'.
If you try to tie together chords which have no common pitches, a
warning message will appear and no ties will be created.

@lilypond[fragment,verbatim,center]
  e' ~ e' <c' e' g'> ~ <c' e' g'>
@end lilypond

[sparseTies]


@c .   {Tuplets}
@node Tuplets
@subsubsection Tuplets
@cindex Tuplets
@cindex Times 

Tuplets are made out of a music expression by multiplying their duration
with a fraction.

@cindex @code{\times}
@example
  \times @var{fraction} @var{musicexpr}
@end example

The duration of @var{musicexpr} will be multiplied by the fraction. 
In print, the fraction's denominator will be printed over the notes,
optionally with a bracket.  The most common tuplet is the triplet in
which 3 notes have the length of 2, so the notes are 2/3 of
their written length:

@lilypond[fragment,verbatim,center]
  g'4 \times 2/3 {c'4 c' c'} d'4 d'4
@end lilypond

[todo: document tupletSpannerDuration]



@c .   {Text spanner}
@node Text spanner
@subsubsection Text spanner
@cindex Text spanner

@c .   {Ottava}
@node Ottava
@subsubsection Ottava
@cindex Ottava
@unnumberedsubsubsec Ottava

[move to trick. Not a supported feature.]

@lilypond[fragment,relative,verbatim]
  a'''' b c a
  \property Voice.TextSpanner \set #'type = #'dotted-line
  \property Voice.TextSpanner \set #'edge-height = #'(0 . 1.5)
  \property Voice.TextSpanner \set #'edge-text = #'("8va " . "")
  \property Staff.centralCPosition = #-13
  a\spanrequest \start "text" b c a \spanrequest \stop "text"
@end lilypond



@c .   {Span requests}
@node Span requests
@subsubsection Span requests
@cindex Span requests

@cindex @code{\spanrequest}

@example
  \spanrequest @var{startstop} @var{type}
@end example
@cindex @code{\start}
@cindex @code{\stop}

Define a spanning request. The @var{startstop} parameter is either -1
(@code{\start}) or 1 (@code{\stop}) and @var{type} is a string that
describes what should be started.  Among the supported types are
@code{crescendo}, @code{decrescendo}, @code{beam}, @code{slur}.This is
an internal command.  Users should use the shorthands which are defined
in the initialization file @file{spanners.ly}.

You can attach a (general) span request to a note using the following
syntax.

@lilypond[fragment,verbatim,center]
  c'4-\spanrequest \start "slur"
  c'4-\spanrequest \stop "slur"
@end lilypond

The slur syntax with parentheses is a shorthand for this.

@c .  {Ornaments}
@node Ornaments
@subsection Ornaments
@cindex Ornaments
@menu
* Articulation::                
* Text scripts::                
@end menu

@c .   {Articulation}
@node Articulation
@subsubsection Articulation
@cindex Articulation

@cindex articulations
@cindex scripts
@cindex 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 or below the note by writing
`@var{note}@code{^\}@var{name}' and `@var{note}@code{_\}@var{name}'
respectively.  Here is a chart showing symbols above notes, with the
name of the corresponding symbol appearing underneath.

@lilypond[]

  \score {
    < \notes {
        \property Score.LyricSyllable \override #'font-family =
#'typewriter
        \property Score.LyricSyllable \override #'font-shape = #'upright
        c''-\accent      c''-\marcato      c''-\staccatissimo c''-\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       c''-\segno        c''-\coda
      }
      \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__       segno__        coda
      }
    >
    \paper {
      linewidth = 5.875\in;          
      indent    = 0.0;
    }
  }

@end lilypond

@c .   {Text scripts}
@node Text scripts
@subsubsection Text scripts
@cindex Text scripts

In addition, it is possible to place arbitrary strings of text or markup
text (see @ref{Text markup}) above or below notes by using a string
instead of an identifier: @code{c^"text"}.  It is possible to use @TeX{}
commands, but this should be avoided because this makes it impossible
for LilyPond to compute the exact length of the string, which may lead
to collisions.  Also, @TeX{} commands won't work with direct postscript
output.  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.

@c .    {Fingerings}
@unnumberedsubsubsec Fingerings
@cindex Fingerings

To save typing, fingering instructions (digits 0 to 9 are
supported) and single characters shorthands exist for a few
common symbols

@lilypond[]
  \score {
    \notes \context Voice {
      \property Voice.TextScript \set #'font-family = #'typewriter
      \property Voice.TextScript \set #'font-shape = #'upright
      c''4-._"c-."      s4
      c''4--_"c-{}-"    s4
      c''4-+_"c-+"      s4
      c''4-|_"c-|"      s4
      c''4->_"c->"      s4
      c''4-^_"c-\\^{ }" s4
      c''4-1_"c-1"      s4
      c''4-2_"c-2"      s4
      c''4-3_"c-3"      s4
      c''4-4_"c-4"      s4
    }
    \paper {
      linewidth = 5.875 \in;
      indent    = 0.0;
    }
  }

@end lilypond


@cindex @code{\textscript}

@example

  \textscript @var{text} @var{style}
@end example

Defines a text to be printed over or under a note.  @var{style} is a
string that may be one of @code{roman}, @code{italic}, @code{typewriter}, 
@code{bold}, @code{Large}, @code{large}, @code{dynamic} or @code{finger}.

You can attach a general textscript request using this syntax:

@quotation

@example 
c4-\textscript "6" "finger"
c4-\textscript "foo" "normal" 
@end example 

@end quotation

This is equivalent to @code{c4-6 c4-"foo"}.  

@cindex @code{\script}
@cindex scripts
@cindex superscript
@cindex subscript

@example
  \script @var{alias}
@end example

Prints a symbol above or below a note.  The argument is a string which
points into the script-alias table defined in @file{scm/script.scm}.
Usually the @code{\script} keyword is not used directly.  Various
helpful identifier definitions appear in @file{script.ly}.

For information on how to add scripts, consult @file{scm/script.scm}.




@c .   {Grace notes}
@node Grace notes
@subsection Grace notes







@cindex Grace music
@cindex @code{\grace}
@cindex ornaments
@cindex grace notes
@cindex @code{graceAlignPosition}

@example
  \grace @var{musicexpr}
@end example

A grace note expression has duration 0; the next real note is
assumed to be the main note.

You cannot have the grace note after the main note, in terms of
duration, and main notes, but you can typeset the grace notes to the
right of the main note using the property
@code{graceAlignPosition}.
@cindex @code{flagStyle}

When grace music is interpreted, a score-within-a-score is set up:
@var{musicexpr} has its own time bookkeeping, and you could (for
example) have a separate time signature within grace notes.  While in
this score-within-a-score, you can create notes, beams, slurs, etc.
Unbeamed eighth notes and shorter by default have a slash through the
stem.  This behavior can be controlled with the
@code{flagStyle} property.

@quotation
@lilypond[fragment,verbatim]
\relative c'' {
  \grace c8 c4 \grace { [c16 c16] } c4
  \grace { \property Grace.flagStyle = "" c16 } c4
}

@end lilypond
@end quotation


At present, nesting @code{\grace} notes is not supported. The following
may cause run-time errors:
@example
  @code{\grace @{ \grace c32 c16 @} c4}
@end example
Since the meaning of such a construct is unclear, we don't consider
this a loss.  Similarly, juxtaposing two @code{\grace} sections is
syntactically valid, but makes no sense and may cause runtime errors.

Ending a staff or score with grace notes may also generate a run-time
error, since there will be no main note to attach the grace notes to.

The present implementation is not robust and generally kludgy. We expect
it to change after LilyPond 1.4. Syntax changes might also be
implemented.








@menu
* Glissando ::                  
* Dynamics::                    
* Crescendo and Decrescendo::   
* Bar lines::                   
@end menu



@c .   {Glissando}
@node Glissando 
@subsubsection Glissando
@cindex Glissando 

@cindex @code{\glissando}

A glissando line can be requested by attaching a @code{\glissando} to a
note:

@quotation
@lilypond[fragment,relative,verbatim]
  c'' \glissando c'
@end lilypond
@end quotation

Printing of an additional text (such as @emph{gliss.}) must be done
manually.



@c .   {Dynamics}
@node Dynamics
@subsubsection Dynamics
@cindex Dynamics



@cindex @code{\ppp}
@cindex @code{\pp}
@cindex @code{\p}
@cindex @code{\mp}
@cindex @code{\mf}
@cindex @code{\f}
@cindex @code{\ff}
@cindex @code{\fff}
@cindex @code{\ffff}
@cindex @code{\fp}
@cindex @code{\sf}
@cindex @code{\sff}
@cindex @code{\sp}
@cindex @code{\spp}
@cindex @code{\sfz}
@cindex @code{\rfz}






Dynamic marks are specified by using an identifier after a note:
@code{c4-\ff}.  The available dynamic marks are:
@code{\ppp}, @code{\pp}, @code{\p}, @code{\mp}, @code{\mf}, @code{\f},
@code{\ff}, @code{\fff}, @code{\fff}, @code{\fp}, @code{\sf},
@code{\sff}, @code{\sp}, @code{\spp}, @code{\sfz}, and @code{\rfz}.

@c .   {Crescendo and Decrescendo}
@node Crescendo and Decrescendo
@subsubsection Crescendo and Decrescendo

@cindex Crescendo and Decrescendo
@cindex crescendo
@cindex @code{\cr}
@cindex @code{\rc}
@cindex @code{\decr}
@cindex @code{\rced}
@cindex @code{\<}
@cindex @code{\>}
@cindex @code{\"!}



A crescendo mark is started with @code{\cr} and terminated with
@code{\rc}, the textual reverse of @code{cr}.  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.

@lilypond[fragment,verbatim,center]
  c'' \< \! c''   d'' \decr e'' \rced 
  < f''1 { s4 \< \! s2 \> \! s4 } >
@end lilypond

You can also use a text saying @emph{cresc.} instead of hairpins. Here
is an example how to do it:

@lilypond[fragment,relative,verbatim]
  \context Voice {
    \property Voice.crescendoText = "cresc."
    \property Voice.crescendoSpanner = #'dashed-line
    a''2\mf\< a a \!a 
  }
@end lilypond



@c .   {Bar lines}
@node Bar lines
@subsubsection Bar lines
@cindex Bar lines

@cindex @code{\bar}
@cindex measure lines
@cindex repeat bars

@example
  \bar @var{bartype};
@end example

This is a short-cut for doing
@example
  \property Score.whichBar = @var{bartype} 
@end example

You are encouraged to use @code{\repeat} for repetitions.  See
@ref{Repeats}, and the documentation of @code{whichBar} in
@ref{(lilypond-internals)LilyPond context properties}.


[FIXME]


@c .  {Bar check}
@node Bar check
@subsection Bar check
@cindex Bar check

@cindex bar check
@cindex @code{barCheckNoSynchronize}
@cindex @code{|}


Whenever a bar check is encountered during interpretation, a warning
message is issued if it doesn't fall at a measure boundary.  This can
help you find errors in the input.  Depending on the value of
@code{barCheckNoSynchronize}, the beginning of the measure will be
relocated, so this can also be used to shorten measures.

A bar check is entered using the bar symbol, @code{|}





@c .  {Repeats}
@node Repeats
@section Repeats


@cindex repeats
@cindex @code{\repeat}

In order to specify repeats, use the @code{\repeat}
keyword.  Since repeats look and sound differently when played or
printed, there are a few different variants of repeats.

@table @asis
@item unfolded  
Repeated music is fully written (played) out.  Useful for MIDI
output.

@item volta  
This is the normal notation: Repeats are not written out, but
alternative endings (voltas) are printed, left to right.

@item folded  
Alternative endings are written stacked.  Which is unfortunately not
practical for anything right now.

@item tremolo
Make tremolo beams.
@end table  

@menu
* Repeat syntax::               
* Manual repeat commands::      
* Tremolo repeats::             
* Tremolo subdivision::         
@end menu

@node Repeat syntax
@subsection Repeat syntax

The syntax for repeats is

@example
  \repeat @var{variant} @var{repeatcount} @var{repeatbody}
@end example

If you have alternative endings, you may add

@cindex @code{\alternative}
@example
 \alternative @code{@{} @var{alternative1}
            @var{alternative2}
            @var{alternative3} @dots{} @code{@}}
@end example

where each @var{alternative} is a Music expression.

Normal notation repeats are used like this:

@quotation

@lilypond[fragment,verbatim]
  c'1
  \repeat volta 2 { c'4 d' e' f' }
  \repeat volta 2 { f' e' d' c' }
@end lilypond
@end quotation

With alternative endings:

@quotation

@lilypond[fragment,verbatim]
  c'1
  \repeat volta 2 {c'4 d' e' f'} 
  \alternative { {d'2 d'} {f' f} }
@end lilypond
@end quotation

Folded repeats look like this:@footnote{Folded repeats offer little
more over simultaneous music.  However, it is to be expected that
more functionality -- especially for the MIDI backend -- will be
implemented at some point in the future.}

@quotation

@lilypond[fragment,verbatim]
  c'1
  \repeat fold 2 {c'4 d' e' f'} 
  \alternative { {d'2 d'} {f' f} }

@end lilypond
@end quotation


If you don't give enough alternatives for all of the repeats, then
the first alternative is assumed to be repeated often enough to equal
the specified number of repeats.

@quotation
@lilypond[fragment,verbatim]
\context Staff {
  \relative c' {
    \partial 4;
    \repeat volta 3 { e | c2 d2 | e2 f2 | }
    \alternative { { g4 g g } { a | a a a a | b2. } }
  }
}

@end lilypond
@end quotation


As you can see, LilyPond doesn't remember the timing information, nor
are slurs or ties repeated, so you have to reset timing information
after a repeat, eg using bar-checks, @code{Score.measurePosition} or
@code{\partial}. We hope to fix this after 1.4.

It is possible to nest @code{\repeat}, although it probably is only
meaningful for unfolded repeats.

@node Manual repeat commands
@subsection Manual repeat commands

@cindex @code{repeatCommands}

The property @code{repeatCommands} can be used to control the layout of
repeats. Its value is a Scheme list of repeat commands, where each repeat
command can be

@table @code
@item 'start-repeat
 Print a |: bar line
@item 'stop-repeat
 Print a :| bar line
@item (volta . @var{text})
  Print a volta bracket saying @var{text}.
@item (volta . #f)
  Stop a running volta bracket
@end table

@lilypond[verbatim, fragment]
 c''4
    \property Score.repeatCommands = #'((volta "93") end-repeat)
 c4 c4
    \property Score.repeatCommands = #'((volta #f))
 c4 c4
@end lilypond


@node Tremolo repeats
@subsection Tremolo repeats
@cindex tremolo beams

To place tremolo marks between notes, use @code{\repeat} with tremolo
style.  
@lilypond[verbatim,center]
\score { 
  \context Voice \notes\relative c' {
    \repeat "tremolo" 8 { c16 d16 }
    \repeat "tremolo" 4 { c16 d16 }    
    \repeat "tremolo" 2 { c16 d16 }
    \repeat "tremolo" 4 c16
  }
  \paper {
    linewidth = 40*\staffspace;
  }  
}
@end lilypond

@node Tremolo subdivision
@subsection Tremolo subdivision
@cindex tremolo marks
@cindex @code{tremoloFlags}

Tremolo marks can be printed on a single 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{tremoloFlags} property if there was no last value.

@lilypond[verbatim,fragment,center]
  c'2:8 c':32
@end lilypond

Tremolos in this style do not carry over into the MIDI output.

Using this mechanism pays off when you entering many tremolos, since the
default argument saves a lot of typing.





@c . {Piano music}
@node Piano music
@section Piano music
@menu
* Automatic staff changes::     
* Manual staff switches::       
* Pedals::                      
* Arpeggio::                    
* Follow Thread::               
@end menu 


@c .   {Automatic staff changes}
@node Automatic staff changes
@subsection Automatic staff changes
@cindex Automatic staff changes

Voices can be switched from top to bottom staff automatically. The
syntax for this is
@example
        \autochange @var{contexttype} @var{musicexp}
@end example
This will switch notation context of @var{musicexp} between a
@var{contexttype} named @code{up} and @code{down}. Typically, you use
@code{Staff} for @var{contexttype}.  The autochanger switches on basis
of pitch (central C is the turning point), and it looks ahead skipping
over rests to switch rests in advance.
        
@lilypond[verbatim,singleline]
\score { \notes \context PianoStaff <
        \context Staff = "up" {
                \autochange Staff \context Voice = VA < \relative c' { g4 a  b c d r4 a g } >
        }
        \context Staff = "down" {
                \clef bass; 
                s1*2
        } > }
@end lilypond




@node Manual staff switches
@subsection Manual staff switches

@cindex manual staff switches
@cindex staff switch, manual

@cindex @code{\translator}
@example
  \translator @var{contexttype} = @var{name}
@end example

A music expression indicating that the context which is a direct
child of the a context of type @var{contexttype} should be shifted to
a context of type @var{contexttype} and the specified name.

Usually this is used to switch staffs in Piano music, e.g.

@example
  \translator Staff = top @var{Music}
@end example


@c .   {Pedals}
@node Pedals
@subsection Pedals
@cindex Pedals

Piano pedals can be entered using the following span requests of the
types @code{Sustain}, @code{UnaChorda} and @code{Sostenuto}:
@lilypond[fragment,verbatim]
c''4 \spanrequest \start "Sustain"  c4 c4  \spanrequest \stop "Sustain"
@end lilypond

For these verbose expressions, standard shorthands have been defined:
@table @code
@item sustainDown
@item sustainUp
@item unaChorda
@item treChorde
@item sostenutoDown
@item sostenutoUp
@end table

The symbols that are printed can be modified by setting pedalXStrings,
where one of the pedal types. Refer to the generaetd documentation for
more information.

Currently, brackets are not supported, only text markings (ie. *Ped
style).


@c .   {Arpeggio}
@node Arpeggio
@subsection Arpeggio
@cindex Arpeggio

@cindex broken arpeggio
@cindex @code{\arpeggio}

You can specify an arpeggio sign on a chord by attaching an
@code{\arpeggio} to a note of the chord.


@quotation
@lilypond[fragment,relative,verbatim]
  \context Voice <c'\arpeggio e g c>
@end lilypond
@end quotation

When an arpeggio crosses staffs in piano music, you attach an arpeggio
to the chords in both staffs, and set
@code{PianoStaff.connectArpeggios}. LilyPond will connect the arpeggios
in both staffs.

@quotation
@lilypond[fragment,relative,verbatim]
  \context PianoStaff <
    \property PianoStaff.connectArpeggios = ##t
    \context Voice = one  { <c''\arpeggio e g c> }
    \context Voice = other { \clef bass;  <c,,\arpeggio e g>}
  >  
@end lilypond
@end quotation



@c .    {Follow Thread}
@node Follow Thread
@subsection Follow Thread
@cindex follow thread
@cindex staff switching
@cindex cross staff

[todo: different name, eg. voice line ? ]

@cindex @code{followThread}

Whenever a voice switches to another staff a line connecting the notes
can be printed automatically. This is enabled if the property
@code{PianoStaff.followThread} is set to true:

@quotation
@lilypond[fragment,relative,verbatim]
  \context PianoStaff <
    \property PianoStaff.followThread = ##t
    \context Staff \context Voice {
      c'1
      \translator Staff=two
      b2 a
    }
    \context Staff=two {\clef bass; \skip 1*2;}
  >  
@end lilypond
@end quotation


@c . {Lyrics}
@node Lyrics
@section Lyrics


@menu
* Lyrics mode::                 
* Printing lyrics::             
* Automatic syllable durations::  
* More stanzas::                
@end menu

@c .  {Lyrics mode}
@node Lyrics mode
@subsection Lyrics mode
@cindex Lyrics mode

@cindex lyric mode
@cindex @code{\lyrics}

Lyrics mode is introduced by the keyword @code{\lyrics}.  This mode has
rules that make it easy to include punctuation and diacritical marks in
words: The purpose of Lyrics mode is that you can enter lyrics in @TeX{}
format or a standard encoding without needing quotes.  The precise
definition of this mode is ludicrous, and this will remain so until the
authors of LilyPond acquire a deeper understanding of character
encoding, or someone else steps up to fix this.

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. However, LilyPond will
issue a warning.  Any @code{_} character which appears in an unquoted
word is converted to a space.  This provides 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 written with the above
rules.  Here are some examples.  Not all of these words are printable by
@TeX{}.

@example 
Ah!             % a word
2B_||_!2B       % not a word because it starts with a digit
``Hello''       % not a word because it starts with `
_ _ _ _         % 4 words, each one a space 
@end example 

Since combinations of numbers and dots are used for indicating
durations, you can not enter real numbers in this mode.

@cindex lyrics expressions

Syllables 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{Lexical modes} for a description of what is interpreted as
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.  Printing
lyrics is discussed in the next section.


@c .  {Printing lyrics}
@node Printing lyrics
@subsection Printing lyrics
@cindex lyrics


Lyric syllables must be interpreted within a @code{Lyrics} context for
printing them. Here is a full example:

@quotation
@lilypond[verbatim]
\score {
  <
    \notes \transpose c'' {
      c d e c | c d e c |
      e f g2 | e4 f g2 \bar "|.";
    }
    \context Lyrics \lyrics { 
      Va-4 der Ja- cob Va- der Ja- cob
      Slaapt gij nog?2 Slaapt4 gij nog?2
    }
  >
}

@end lilypond
@end quotation




@cindex extender
@cindex lyric extender

You may want a continuous line after the syllables to show melismata. 
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 (using @code{_}).

@quotation

@lilypond[verbatim]
\score {
  <
    \notes \relative c'' {
      a4 () b () c () d | c () d () b () a | c () d () b () a
    }
    \context Lyrics \lyrics {
      foo1 __ | bar2. __ _4 | baz1 __
    }
  >
}

@end lilypond
@end quotation

@cindex Lyric hyphen

If you want to have hyphens centered between syllables (rather than
attached to the end of the first syllable) you can use the special
`@code{-}@code{-}' lyric as a separate word between syllables.  This
will result in a hyphen which length varies depending on the space
between syllables, and which will be centered between the syllables. 
For example:

@quotation

@lilypond[verbatim]
\score {
  <
    \notes \transpose c'' {
      c d e c | c d e c |
      e f g2 | e4 f g2 \bar "|.";
    }
    \context Lyrics \lyrics {
      Va4 -- der Ja -- cob | Va -- der Ja -- cob |
      Slaapt gij nog?2 | Slaapt4 gij nog?2
    }
  >
}

@end lilypond
@end quotation


@c .  {Automatic syllable durations}
@node Automatic syllable durations
@subsection Automatic syllable durations
@cindex Automatic syllable durations


@cindex automatic lyric durations
@cindex @code{\addlyrics}

If you have lyrics that are set to a melody, you can import the rhythm
of that melody into the lyrics using @code{\addlyrics}.  The syntax for
this is
@example
  \addlyrics @var{musicexpr1 musicexpr2}
@end example

This means that both @var{musicexpr1} and @var{musicexpr2} are
interpreted, but that every non-command atomic music expression
(``every syllable'') in @var{musicexpr2} is interpreted using timing
of @var{musicexpr1}.
@cindex @code{automaticMelismata}

If the property @code{automaticMelismata} is set in the
context of @var{musicexpr1}, no lyrics will be put on slurred or tied
notes.

@quotation
@lilypond[verbatim,fragment]
\addlyrics
\transpose c'' {
  \property Voice.automaticMelismata = ##t
  c8 () cis d8. e16 f2
}
\context Lyrics \lyrics {
 do4 re mi fa }
@end lilypond
@end quotation

You should use a single rhythm melody, and single rhythm lyrics (a
constant duration is the obvious choice).  If you do not, you will get
undesired effects when using multiple stanzas:

@quotation
@lilypond[verbatim,fragment]
\addlyrics
\transpose c'' {
  c8 () cis d8. e16 f2
}
\context Lyrics \lyrics
< { do4 re mi fa }
  { do8 re mi fa } >

@end lilypond
@end quotation

It is valid (but probably not very useful) to use notes instead of
lyrics for @var{musicexpr2}.

@node More stanzas
@subsection More stanzas

@cindex phrasing

If you have multiple stanzas printed underneath each other, the separate
syllables should be aligned around punctuation. LilyPond can do this if
you explain it which lyric lines belong to which melody.

To this end, give the Voice context an identity, and set the LyricsVoice
to name starting with that identity. In the following example, the Voice
identity is @code{duet}, and the identities of the LyricsVoices are
@code{duet-1} and @code{duet-2}.


@lilypond[singleline,verbatim]
\score {
\addlyrics
  \notes \relative c'' \context Voice = duet { \time 3/4; g2 e4 a2 f4 g2.  }
  \lyrics \context Lyrics <
  \context LyricsVoice = "duet-1" {
    \property LyricsVoice . stanza = "Bert"
    Hi, my name is bert.    }
  \context LyricsVoice = "duet-2" {
    \property LyricsVoice . stanza = "Ernie" 
    Ooooo, ch\'e -- ri, je t'aime. }
  >
}
@end lilypond

You can add stanza numbers by setting @code{LyricsVoice.Stanza} (for the
first system) and @code{LyricsVoice.stz} for the following systems.

@cindex stanza numbering


@c . {Chords}
@node Chords
@section Chords
@cindex Chords

[chords vs. simultaneous music]

@menu
* Chords mode::                 
* Entering named chords::       
* Printing named chords::       
@end menu

@c .  {Chords mode}
@node Chords mode
@subsection Chords mode
@cindex Chords mode

Chord mode is introduced by the keyword
@code{\chords}.  It is similar to Note mode, but
words are also looked up in a chord modifier table (containing
@code{maj}, @code{dim}, etc).

Since combinations of numbers and dots are used for indicating
durations, you can not enter real numbers in this mode.  Dashes
and carets are used to indicate chord additions and subtractions,
so scripts can not be entered in Chord mode.

@c .  {Entering named chords}
@node Entering named chords
@subsection Entering named chords
@cindex Chords names

Chord names are a way to generate simultaneous music expressions that
correspond with traditional chord names.  It can only be used in
Chord mode (see section @ref{Lexical modes}).

@example

  @var{tonic}[@var{duration}][@code{-}@var{modifiers}][@code{^}@var{subtractions}][@code{/}@var{inversion}][@code{/+}@var{bass}].
@end example

@var{tonic} should be the tonic note of the chord, and @var{duration}
is the chord duration in the usual notation.  There are two kinds of
modifiers.  One type is @emph{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.  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
must be separated by a dot (@code{.}).


Throughout these examples, chords have been shifted around the staff
using @code{\transpose}.


@quotation

@lilypond[fragment,verbatim]
\transpose c'' {
  \chords {
    c1  c:3-       c:7     c:8
    c:9 c:9-.5+.7+ c:3-.5- c:4.6.8
  }
}

@end lilypond
@end quotation

@cindex @code{aug}
@cindex @code{dim}
@cindex @code{maj}
@cindex @code{sus}

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.

@quotation

@lilypond[fragment,verbatim]
\transpose c'' {
  \chords {
    c1:m c:min7 c:maj c:aug c:dim c:sus
  }
}

@end lilypond
@end quotation
 

Chord subtractions are used to eliminate notes from a chord.  The
notes to be subtracted are listed after a @code{^} character,
separated by dots.

@lilypond[fragment,verbatim,center]
  \transpose c'' {
    \chords {
      c1^3 c:7^5.3 c:8^7
    }
  }
@end lilypond 
@cindex @code{/}

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, a
warning will be printed.

@lilypond[fragment,verbatim,center]
  \transpose c''' {
    \chords {
      c1 c/e c/g c:7/e
    }
  }

@end lilypond 
@cindex @code{/+}

Bass notes can be added by `@code{/+}' and
the name of a single note to a chord.  This has the effect of
adding the specified note to the chord, lowered by an octave,
so it becomes the lowest note in the chord.

@lilypond[fragment,verbatim,center]
  \transpose c''' {
    \chords {
      c1 c/+c c/+g c:7/+b
    }
  }

@end lilypond 

The most interesting application is printing  chord names, which is
explained in the next subsection.

You should not combine @code{\relative} with named chords. [FIXME]

@c .  {Printing named chords}
@node Printing named chords
@subsection Printing named chords





@cindex printing chord names
@cindex chord names
@cindex chords
@cindex @code{ChordNames}
@cindex @code{ChordNameVoice}

For displaying printed chord names, use the @code{ChordNames} and
@code{ChordNameVoice} contexts.  The chords may be entered either using
the notation described above, or directly using simultaneous music.

@quotation
@lilypond[verbatim,singleline]
scheme = \notes {
  \chords {a1 b c} <d f g>  <e g b>
}
\score {
  \notes<
    \context ChordNamesVoice \scheme
    \context Staff \transpose c'' \scheme
  >
}
@end lilypond
@end quotation

You can make the chord changes stand out more by setting property
@code{ChordNames.chordChanges} to true.  This will only display chord
names when there's a change in the chords scheme, but always display the
chord name after a line break:

@c bug
@quotation
@lilypond[verbatim]
scheme = \chords {
  c1:m \break c:m c:m c:m d
}

\score {
  \notes <
    \context ChordNames \scheme
    \context Staff \transpose c'' \scheme
  >
  \paper{
    linewidth = 40 * \staffspace;
    \translator {
      \ChordNamesContext
      chordChanges = ##t
    }
  }
}
@end lilypond
@end quotation



LilyPond examines chords specified as lists of notes to determine a
name to give the chord. LilyPond will not try to
identify chord inversions or added base, which may result in strange
chord names when chords are entered as a list of pitches:

@quotation
@lilypond[verbatim,center,singleline]
scheme = \notes {
  <c'1 e' g'>
  <e' g' c''>
  <e e' g' c''>
}

\score {
  <
    \context ChordNamesVoice \scheme
    \context Staff \scheme
  >
}
@end lilypond
@end quotation

To specify chord inversions, append @code{/<notename>}.  To specify an
added bass note, append @code{/+<notename}:

@quotation
@lilypond[verbatim,center,singleline]
scheme = \chords {
  d1 d/a d/+gis
}

\score {
  \notes <
    \context ChordNames \scheme
    \context Staff \transpose c'' \scheme
  >
}
@end lilypond
@end quotation

The chord names that LilyPond should print are fully customizable.  The
code to print chord names is written in Scheme. It can be found in
@file{scm/chord-name.scm}.  Chord names are based on Banter style
naming, which is unambiguous and has a logical structure.  Typical
American style chord names are implemented as a variation on Banter
names, they can be selected by setting property @code{ChordName.style}
to @code{american}:

@quotation
@lilypond[verbatim]
\include "english.ly"

scheme = \chords {
  c         % Major triad
  cs:m      % Minor triad
  df:m5-    % Diminished triad
  c:5^3     % Root-fifth chord
  c:4^3     % Suspended fourth triad
  c:5+      % Augmented triad
  c:2^3     % "2" chord
  c:m5-.7-  % Diminished seventh
  c:7+      % Major seventh
  c:7.4^3   % Dominant seventh suspended fourth
  c:5+.7    % Augmented dominant seventh
  c:m5-.7   % "Half" diminished seventh
  c:5-.7    % Dominant seventh flat fifth
  c:5-.7+   % Major seventh flat fifth
  c:m7+     % Minor-major seventh
  c:m7      % Minor seventh
  c:7       % Dominant seventh
  c:6       % Major sixth
  c:m6      % Minor sixth
  c:9^7     % Major triad w/added ninth
  c:6.9^7   % Six/Nine chord
  c:9       % Dominant ninth 
  c:7+.9    % Major ninth
  c:m7.9    % Minor ninth
}

\score {
  \notes <
    \context ChordNames \scheme
    \context Staff \transpose c'' \scheme
  >
  \paper {
    \translator { 
      \ChordNamesContext
      ChordName \override #'word-space = #1 
      ChordName \override #'style = #'american
    }
  }
}
@end lilypond
@end quotation

Similarly, Jazz style chord names are implemented as a variation on
American style names:
@quotation
@lilypond[verbatim]
scheme = \chords {
  % major chords
  c
  c:6           % 6 = major triad with added sixth
  c:maj         % triangle = maj
  c:6.9^7       % 6/9 
  c:9^7         % add9

  % minor chords
  c:m           % m = minor triad
  c:m.6         % m6 = minor triad with added sixth
  c:m.7+        % m triangle = minor major seventh chord
  c:3-.6.9^7    % m6/9 
  c:m.7         % m7
  c:3-.9        % m9
  c:3-.9^7      % madd9

  % dominant chords
  c:7           % 7 = dominant
  c:7.5+        % +7 = augmented dominant
  c:7.5-        % 7b5 = hard diminished dominant
  c:9           % 7(9)
  c:9-          % 7(b9)
  c:9+          % 7(#9)
  c:13^9.11     % 7(13)
  c:13-^9.11    % 7(b13)
  c:13^11       % 7(9,13)
  c:13.9-^11    % 7(b9,13)
  c:13.9+^11    % 7(#9,13)
  c:13-^11      % 7(9,b13)
  c:13-.9-^11   % 7(b9,b13)
  c:13-.9+^11   % 7(#9,b13)

  % half diminished chords
  c:m5-.7               % slashed o = m7b5
  c:9.3-.5-     % o/7(pure 9)

  % diminished chords
  c:m5-.7-      % o = diminished seventh chord
}

\score {
  \notes <
    \context ChordNames \scheme
    \context Staff \transpose c'' \scheme
  >
  \paper {
    \translator { 
      \ChordNamesContext
      ChordName \override #'word-space = #1 
      ChordName \override #'style = #'jazz
    }
  }
}
@end lilypond
@end quotation

@node Writing parts
@section Writing parts

@c .  {Transpose}
@menu
* Rehearsal marks::             
* Instrument names::            
* Transpose::                   
* Sound output for transposing instruments::  
* Multi measure rests::         
* Automatic part combining::    
@end menu

@c .   {Rehearsal marks}
@node Rehearsal marks
@subsection Rehearsal marks
@cindex Rehearsal marks
@cindex mark
@cindex @code{\mark}
@cindex @code{Mark_engraver}

@example
  \mark @var{unsigned};
  \mark @var{string};
  \mark ; 
@end example

With this command, you can print a rehearsal mark above the system. You
can provide a number, a string or a markup text as argument. If there is
no argument, the property @code{rehearsalMark} is used and automatically
incremented.

@lilypond[fragment,verbatim]
\relative c'' {
  c1 \mark "A2";
  c1 \mark ; 
  c1 \mark ; 
  c1 \mark "12";
  c1 \mark #'(music "scripts-segno") ;
  c1
}
@end lilypond

@node Instrument names
@subsection Instrument names

You can specify an instrument name for a staff by setting
@code{Staff.instrument} and @code{Staff.instr}. This will print a string
before the start of the staff. For the first start, @code{instrument} is
used, for the next ones @code{instr} is used.

@lilypond[verbatim,singleline]
\score { \notes {
  \property Staff.instrument = "instr " { c''4 } }
  \paper { 
    \translator { \StaffContext
    \consists "Instrument_name_engraver"; } } }
@end lilypond

This requires  that you add the @code{Instrument_name_engraver} to the
staff context.


@node Transpose
@subsection Transpose
@cindex Transpose
@cindex transposition of pitches
@cindex @code{\transpose}

A music expression can be transposed with @code{\transpose}.  The syntax
is
@example
  \transpose @var{pitch} @var{musicexpr}
@end example

This means that middle C in @var{musicexpr} is transposed to
@var{pitch}.

@code{\transpose} distinguishes between enharmonic pitches: both
@code{\transpose cis'} or @code{\transpose des'} will transpose up half
a tone.  The first version will print sharps and the second version
will print flats.

@quotation
@lilypond[fragment,verbatim]
\context Staff {
  \clef "F";
  { \key e \major; c d e f }
  \clef "G";
  \transpose des'' { \key e \major; c d e f }
  \transpose cis'' { \key e \major; c d e f }
}

@end lilypond
@end quotation

If you want to use both @code{\transpose} and @code{\relative}, then
you must use @code{\transpose} first.  @code{\relative} will have no
effect music that appears inside a @code{\transpose}.

@node Sound output for transposing instruments
@subsection Sound output transposing instruments

When you want to play a score containing transposed and untransposed
instruments, you have to instruct LilyPond the pitch offset (in
semitones) for the transposed instruments. This is done using
@code{transposing}.

@cindex @code{transposing}

@example
        \property Staff.instrument = #"Cl. in B-flat"
        \property Staff.transposing = #-2
@end example


@c .  {Multi measure rests}
@node  Multi measure rests
@subsection Multi measure rests
@cindex Multi measure rests

@cindex @code{R}

Multi measure rests are entered using `@code{R}'. It is specifically
meant for entering parts: the rest can expand to fill a score with
rests, or it can be printed as a single multimeasure rest This expansion
is controlled by the property @code{Score.skipBars}. If this is set to true,
Lily will not expand empty measures, and the appropriate number is added
automatically.

@lilypond[fragment,verbatim]
 \time 3/4; R2.*2 \property Score.skipBars = ##t R2.*17  R2.*4
@end lilypond

Currently, there is  no way to condense multiple rests into a single
multimeasure rest.

@cindex condensing rests

@node Automatic part combining
@subsection Automatic part combining

[TODO]


@c . {Custodes}
@node Custodes
@section Custodes
@cindex Custos
@cindex Custodes

A @emph{custos} (plural: @emph{custodes}; latin word for "guard") is a
staff context symbol that appears at the end of a staff line.  It
anticipates the pitch of the first note(s) of the following line and
thus helps the player or singer to manage line breaks during
performance, thus enhancing readability of a score.

@quotation
@lilypond[verbatim]
\score {
  \notes { c'1 d' e' d' \break c' d' e' d' }
  \paper {
    \translator {
      \StaffContext
      \consists Custos_engraver;
      Custos \override #'style = #'mensural;
    }
  }
}
@end lilypond
@end quotation

Custodes were frequently used in music notation until the 16th century.
There were different appearences for different notation styles.
Nowadays, they have survived only in special forms of musical notation
such as via the editio vaticana dating back to the beginning of the 20th
century.

For typesetting custodes, just put a @code{Custos_engraver} into the
@code{StaffContext} when declaring the @code{\paper} block.  In this
block, you can also globally control the appearance of the custos symbol
by setting the custos @code{style} property.  Currently supported styles
are @code{vaticana}, @code{medicaea}, @code{hufnagel} and
@code{mensural}.

@quotation
\paper @{
  \translator @{
      \StaffContext
      \consists Custos_engraver;
      Custos \override #'style = #'mensural;
  @}
@}
@end quotation

The property can also be set locally, for example in a @code{\notes}
block:

@quotation
\notes @{
  \property Staff.Custos \override #'style = #'vaticana
  c'1 d' e' d' \break c' d' e' d'
@}
@end quotation

@c . {Tuning output}
@node Tuning output
@section Tuning output

LilyPond tries to take as much formatting as possible out of your
hands. Nevertheless, there are situations where it needs some help, or
where you want to override its decisions.

Here we discuss how you can do that.

Notational output is specified in so called grobs (graphic
objects). Each grob carries with it a set of properties (grob
properties) specific to that grob.  For example, a stem grob has grob
properties that specify its direction, length and thickness.

The most common way of tuning the output is to alter the values of these
properties. There are two ways of doing that: first, you can
specifically select a set of grobs at one point, and set properties as
you wish, or secondly, you can (temporarily) modify the definition of a
grob, thereby affecting an entire group of grobs.

@menu
* Tuning groups of grobs ::     
* Tuning per grob ::            
* What to tune?::               
* Text markup::                 
@end menu

@node Tuning groups of grobs 
@subsection Tuning groups of grobs 

@cindex grob description

A grob definition is an association list, that is stored in a context
property.  By assigning to that property (using plain @code{\property}),
you can change the resulting grobs.  
@lilypond[verbatim, fragment]
c'4 \property Voice.Stem = #'((meta .  ((interfaces . ())))) c'4
@end lilypond
The @code{\property} statement effectively empties the definition of the
Stem object. One of the effects is that property specifying how it
should be printed is erased, with the effect of rendering it invisible.

@cindex \override
@cindex \revert
@cindex \set


This mechanism is fairly crude, since you can only set, but not modify,
the definition of a grob. For this reason, there is a more advanced
mechanism: you can add a property on top of an existing definition, or
remove a property: @code{\override} adds a settings, @code{\revert}
removes that setting.
@lilypond[verbatim]
c'4 \property Voice.Stem \override #'thickness = #4.0
c'4 \property Voice.Stem \revert #'thickness
c'4
@end lilypond

For the digirati, the grob description is an Scheme association
list. Since it is singly linked, we can treat it as a stack, and
@code{\override} and @code{\revert} are just push and pop
operations. This pushing and popping is also used in the
@code{autoBeamSettings} property.

If you revert a setting which was not set in the first place, then it
has no effect. However, if the setting was set as a system default, it
may remove the default value, and this may give surprising results,
including crashes.  In other words, if you use @code{\override} and
@code{\revert}, be sure to balance the overrides and reverts.

If balancing them is too much work, use the following shorthand:
@code{\set} performs a revert followed by an override:
@example
\property Voice.Stem \set #'thickness = #2.0
@end example

Formally the syntax for these constructions is
@example
\property @var{context}.@var{grobname} \override @var{symbol} = @var{value}
\property @var{context}.@var{grobname} \set @var{symbol} = @var{value}
\property @var{context}.@var{grobname} \revert @var{symbol}
@end example
Here @var{symbol} is a Scheme expression of symbol type, @var{context}
and @var{grobname} are strings and @var{value} is a Scheme expression.

LilyPond will hang or crash if @var{value} contains cyclic references.



@node Tuning per grob 
@subsection Tuning per grob 

@cindex \outputproperty

A second way of tuning grobs is the more arcane @code{\outputproperty}
feature.
Syntax is as follows
@example
\outputproperty @var{predicate} @var{symbol} = @var{value}
@end example
Here @code{predicate} is a Scheme functoin taking a grob a argument
argument, and returning a boolean.  This statement is processed by the
@code{Output_property_engraver}.  It instructs the engraver to feed all
grobs that it sees to @var{predicate}. Whenever the predicate returns
true, the grob property @var{symbol} will be set to @var{value}.

You will need to combine this statement with @code{\context} to select
the appropriate context to apply this to.

If possible, avoid this feature: the semantics are not very clean, and
the syntax and semantics are up for rewrite.

Here are some random examples:

@lilypond[fragment,verbatim,singleline]
\relative c'' { c4
  \context Staff \outputproperty
  #(make-type-checker 'note-head-interface)
  #'extra-offset = #'(0.5 . 0.75)
  <c8 e g> }
@end lilypond

@cindex @code{extra-offset}

This selects all note heads occurring at current staff level, and sets
the @code{extra-offset} of those heads to @code{(0.5,0.75)}, shifting
them up and right.

Move the text "m.d.", but not the fingering instruction "2".
@lilypond[verbatim,singleline]
#(define (make-text-checker text)
   (lambda (grob) (equal? text (ly-get-elt-property grob 'text))))

\score {    
  \notes\relative c''' {
    \property Voice.Stem \set #'direction = #1
    \outputproperty #(make-text-checker "m.d.")
      #'extra-offset = #'(-3.5 . -4.5)
    a^2^"m.d."    
  }
}
@end lilypond




@node What to tune?
@subsection What to tune?

This all tells you how to tune grobs, but what variables are there? The
question is not  answered in this manual (although you may encounter
some examples.).

Grob properties are tied directly to the implementation of LilyPond, and
they are thus a moving target. Refer to the automatically generated
documentation of the internals (available from the website).

You need the following information

@itemize @bullet
@item
which grob to modify
@item
which property to modify
@item
which context the grob comes from.
@end itemize

Included with the automatically generated documentation is a master list
of grobs. Each one can be clicked, taking you to a overview of the
available properties.

There is also a master list of contexts. Clicking each takes you to an
overview of the context, listing which grob types are created there.



@node Text markup
@subsection Text markup
@cindex text markup
@cindex markup text

LilyPond has an internal mechanism to typeset texts. You can
form text markup expressions by composing scheme expressions
in the following way.

@lilypond[verbatim]
\score { \notes \relative c' {
  b-#"text"
  c-#'(bold "text")
  d-#'(lines "one" (bold "text"))
  e-#'(music (named "noteheads-2" "flags-u3"))
}
\paper { linewidth = 10.\cm; } }
@end lilypond

Normally, the Scheme markup text is stored in the @code{text} property
of a grob.  Formally, it is defined as follows:

@example
text: string | (head? text+)
head: markup | (markup+)
markup-item: property | abbrev | @var{fontstyle}
property: (@var{key} . @var{value})
abbrev: @code{rows lines roman music bold italic named super sub text}
@end example

The markup is broken down and converted into a list of grob properties,
which are prepended to the grop's property list.  The
@var{key}-@var{value} pair is a grob property.

The following abbreviations are currently
defined:

@table @code
@item rows
horizontal mode: set all text on one line (default)
@item lines
 vertical mode: set every text on new line
@item roman
 select roman font
@item music
 select feta font
@item bold
 select bold series
@item italic
 select italic shape
@item named
 lookup by character name
@item text
 plain text lookup (by character value)
@item super
 superscript
@item sub
 subscript
@end table

@var{fontstyle} may be any of @code{finger volta timesig mmrest mark
script large Large dynamic}


@c . {Page layout}
@node Page layout
@section Page layout
@cindex Page layout

@menu
* Paper block::                 
* Paper variables::             
* Font Size::                   
* Paper size::                  
* Line break::                  
* Page break::                  
@end menu

@c .  {Paper block}
@node Paper block
@subsection Paper block
@cindex Paper block

The most important output definition is the @code{\paper} block, for
music notation.  The syntax is

@example
  @code{\paper @{} [@var{paperidentifier}] @var{items} @code{@}}
@end example

where each of the items is one of

@itemize @bullet
  @item  An assignment.  The assignment must be terminated by a
       semicolon.  

  @item  A context definition.  See Section @ref{Notation Contexts} for
       more information on context definitions.

  @item  \stylesheet  declaration.  Its syntax is
       @example
                \stylesheet @var{alist}
       @end example

        See @file{font.scm} for details of @var{alist}.
@end itemize

@c .  {Paper variables}
@node Paper variables
@subsection Paper variables 
@cindex Paper variables

The paper block has some variables you may want to use or change:

@table @code
@cindex @code{indent}
  @item @code{indent}  
    The indentation of the first line of music.
@cindex @code{staffspace}

  @item @code{staffspace}
    The distance between two staff lines, calculated from the center
    of the lines.  You should use either this or @code{stafflinethickness}
    as a unit for distances you modify.
  
@cindex @code{linewidth}
  @item @code{linewidth}  
    Sets the width of the lines.

If set to a negative value, a single
    unjustified line is produced.

@cindex @code{textheight}

  @item @code{textheight}  
    Sets the total height of the music on each page. Only used by
    ly2dvi.
@cindex @code{interscoreline}

  @item @code{interscoreline}  
    Sets the spacing between the score lines. Defaults to 16 pt.
@cindex @code{interscorelinefill}

  @item @code{interscorelinefill}  
    If set to a positive number, the distance between the score 
    lines will stretch in order to fill the full page. In that
    case @code{interscoreline} specifies the minimum spacing.
    Defaults to 0.
@cindex @code{stafflinethickness}

  @item @code{stafflinethickness}  
    Determines the thickness of staff lines, and also acts as a scaling
    parameter for other line thicknesses.
@end table



@c .  {Font size}
@node Font Size
@subsection Font size
@cindex font size

The Feta font provides musical symbols at six different sizes.  These
fonts are 11 point, 13 point, 16 point, 20 point,
23 point, and 26 point.  The point size of a font is the
height of the five lines in a staff when displayed in the font.

Definitions for these sizes are the files @file{paperSZ.ly}, where
@code{SZ} is one of 11, 13, 16, 20, 23 and 26.  If you include any of
these files, the identifiers @code{paperEleven}, @code{paperThirteen},
@code{paperSixteen}, @code{paperTwenty}, @code{paperTwentythree}, and
@code{paperTwentysix} are defined respectively.  The default
@code{\paper} block is also set.

The font definitions are generated using a Scheme function. For more
details, see the file @file{font.scm}.



@c .  {Paper size}
@node Paper size
@subsection Paper size
@cindex Paper size

@cindex paper size
@cindex page size
@cindex @code{papersize}

To change the paper size, you must first set the
@code{papersize} variable at top level.  Set it to
the strings @code{a4}, @code{letter}, or @code{legal}.  After this
specification, you must set the font as described above.  If you want
the default font, then use the 20 point font.  The new paper size will
not take effect if the font is not loaded and selected afterwards.

@example
        papersize = "a4"
        \include "paper16.ly"

        \score @{
                ...
                \paper @{ \paperSixteen @}
        @}
@end example

The file "paper16.ly" will now include a file named @file{a4.ly}, which
will set the paper variables @code{hsize} and @code{vsize} (used by
@code{ly2dvi})







@c .  {Line break}
@node Line break
@subsection Line break

@cindex line breaks
@cindex breaking lines

Line breaks are normally computed automatically. They are chosen such
that the resulting spacing has low variation, and looks neither cramped
nor loose.

Occasionally you might want to override the automatic breaks; you can do
this by specifying @code{\break}. This will force a line break at this
point. Do remember that line breaks can only occur at places where there
are barlines.  If you want to have a line break where there is no
barline, you can force a barline by entering @code{\bar "";}.

Similarly, @code{\noBreak} forbids a  line break at a certain point.

@cindex @code{\penalty}

The @code{\break} and @code{\noBreak} commands are defined in terms of
the penalty command:
@example
  \penalty @var{int} @code{;}
@end example

This imposes   encourages or discourages LilyPond to make a line break
at this point.

@strong{Warning} do not use @code{\penalty} directly. It is rather
kludgy, and slated for rewriting.

@c .  {Page break}
@node Page break
@subsection Page break

@cindex page breaks
@cindex breaking pages


Page breaks are normally computed by @TeX{}, so they are not under direct
control.  However, you can insert a commands into the @file{.tex} output to
instruct @TeX{} where to break pages. For more details, see  the
example file @file{input/test/between-systems.ly}

[or -> Tricks? ]






@c . {Sound}
@node Sound
@section Sound
@cindex Sound

LilyPond allows MIDI output, with the purpose of proof-hearing the music
you enter. The performance lacks lots of interesting effects, such as
swing, articulation, slurring, tieing, etc.

Also note that it is not possible to use the percussion channel
(generally channel 10 of a MIDI file).

@menu
* MIDI block::                  
* MIDI instrument names::       
* Tempo::                       
@end menu

@c .  {MIDI block}
@node MIDI block
@subsection MIDI block
@cindex MIDI block


The MIDI block is analogous to the paper block, but it is somewhat
simpler.  The @code{\midi} block can contain:
@cindex MIDI block

@itemize @bullet
  @item  a @code{\tempo} definition
  @item  context definitions
@end itemize

Assignments in the @code{\midi} block are not allowed.



@cindex context definition

Context definitions follow precisely the same syntax as within the
\paper block.  Translation modules for sound are called performers.
The contexts for MIDI output are defined in @file{ly/performer.ly}.


@c .  {MIDI instrument names}
@node MIDI instrument names
@subsection MIDI instrument names
@cindex instrument names
@cindex @code{Staff.midiInstrument}
@cindex @code{Staff.instrument}

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 the following list.
If the selected string does not exactly match, then LilyPond uses the
default piano.

[FIXME: to appendix ]


@example 
"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)" 
@end example 





@c .  {Tempo}
@node Tempo
@subsection Tempo
@cindex Tempo
@cindex beats per minute
@cindex metronome marking

@cindex @code{\tempo}
@example
  \tempo @var{duration} = @var{perminute} @code{;}
@end example

Used to specify the tempo.  For example, @code{\tempo 4 = 76;} requests
output with 76 quarter notes per minute.





@c . {Music entry}
@node Music entry
@section Music entry
@cindex Music entry
@menu
* Relative::                    
* Point and click::             
@end menu



@c .  {Relative}
@node Relative
@subsection Relative
@cindex Relative
@cindex relative octave specification

Octaves are specified by adding @code{'} and @code{,} to pitch names.
When you copy existing music, it is easy to accidentally put a pitch in
the wrong octave and hard to find such an error.  To prevent these
errors, LilyPond features octave entry.

@cindex @code{\relative}
@example
  \relative @var{startpitch} @var{musicexpr}
@end example

The octave of notes that appear in @var{musicexpr} are calculated as
follows: If no octave changing marks are used, the basic interval
between this and the last note is always taken to be a fourth or less.
  The octave changing marks @code{'} and @code{,} can then
be added to raise or lower the pitch by an extra octave.  Upon entering
relative mode, an absolute starting pitch must be specified that will
act as the predecessor of the first note of @var{musicexpr}.

This distance is determined without regarding accidentals: a
@code{fisis} following a @code{ceses} will be put above the
@code{ceses}.

Entering scales is straightforward in relative mode.

@lilypond[fragment,verbatim,center]
  \relative c'' {
    g a b c d e f g g, g
  }
@end lilypond

And octave changing marks are used for intervals greater than a fourth.

@lilypond[fragment,verbatim,center]
  \relative c'' {
    c g c f, c' a, e'' }
@end lilypond

If the preceding 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
preceding note.

@lilypond[fragment,verbatim,center]
  \relative c' {
    c <c e g> 
    <c' e g>
    <c, e' g>
  }
@end lilypond 
@cindex @code{\notes}

The pitch after the @code{\relative} contains a notename.  To parse
the pitch as a notename, you have to be in note mode, so there must
be a surrounding @code{\notes} keyword (which is not
shown here).

The relative conversion will not affect @code{\transpose} or
@code{\relative} sections in its argument.  If you want to use
relative within transposed music, you must place an additional
@code{\relative} inside the @code{\transpose}.


@c .  {Point and click}
@node Point and click
@subsection Point and click

[todo]

@c . {Engravers}
@node Engravers
@section Engravers
@cindex engravers
@menu
* Notation Contexts::           
* Creating contexts::           
* Default contexts::            
* Context properties::          
* Changing context definitions::  
* Defining new contexts::       
@end menu

@c .  {Music expressions}



@c .  {Notation Contexts}
@node Notation Contexts
@subsection Notation Contexts

@cindex notation contexts

Notation contexts are objects that only exist during a run of LilyPond.
During the interpretation phase of LilyPond (when lily prints
"interpreting music"), music a @code{\score} block is interpreted in
time order, i.e. in much the same order that humans read, play, and
write music.

During this reading, the notation context is holds the state
for the current point within the music. It contains information like

@itemize @bullet
  @item What notes are playing at this point?
  @item What symbols will be printed at this point?
  @item What is the current key signature, time signature, point within
       the measure, etc.?
@end itemize

Contexts are grouped hierarchically: A @code{Voice} context is
contained in a @code{Staff} context (because a staff can contain
multiple voices at any point), a @code{Staff} context is contained in
a @code{Score}, @code{StaffGroup}, or @code{ChoirStaff} context (because
these can all contain multiple staffs).


Contexts associated with sheet music output are called @emph{notation
contexts}, those for sound output are called performance contexts.


@node Creating contexts
@subsection Creating contexts

@cindex @code{\context}
@cindex context selection

Contexts for a music expression can be selected manually, using the
following music expression.

@example
  \context @var{contexttype} [= @var{contextname}] @var{musicexpr}
@end example

This instructs lilypond to interpret @var{musicexpr} within the context
 of type @var{contexttype} and with name @var{contextname}.  If this
context does not exist, it will be created.  

@quotation

@lilypond[verbatim,singleline]
\score {
  \notes \relative c'' {
    c4 <d4 \context Staff = "another" e4> f
  }
}

@end lilypond
@end quotation

In this example, the @code{c} and @code{d} are printed on the
default staff.  For the @code{e}, a context Staff called
@code{another} is specified; since that does not exist, a new
context is created.  Within @code{another}, a (default) Voice context
is created for the @code{e4}.  When all music referring to a
context is finished, the context is ended as well.  So after the
third quarter, @code{another} is removed.



@node Default contexts
@subsection Default contexts

Most music expressions don't need @code{\context}: they inherit the
notation context from their parent. Each note is a music expression, and
as you can see in the following example, only the sequential music
enclosing the three notes has an explicit context. 

@lilypond[verbatim,singleline]
\score { \notes \context Voice = goUp { c'4 d' e' } } 
@end lilypond

There are some quirks that you must keep in mind when dealing with
defaults:

Every top-level music is interpreted by the Score context, in other
words, you may think of @code{\score} working like
@example
        \score @{
                \context Score @var{music}
        @}
@end example

Sequential music follows the contexts of its "children".  Take this example
@lilypond[verbatim, singleline]
\score { \context Score \notes { c'4 (  d' )e' } }
@end lilypond

The sequential music is interpreted by the Score context initially
(notice that the @code{\context} specification is redundant), but when a
note is encountered, contexts are setup to accept that note. In this
case, a Thread, Voice and Staff are created. The rest of the sequential
music is also interpreted with the same Thread, Voice and Staff context,
putting the notes on the same staff, in the same voice.

This is a convenient mechanism, but do not expect opening chords to work
without @code{\context}. For every note, a separate staff is
instantiated.

@lilypond[verbatim, singleline]
\score { \notes <c'4 es'> } 
@end lilypond

Of course, if the chord is preceded by a normal note in sequential
music, the chord will be interpreted by the Thread of the preceding
note:
@lilypond[verbatim,singleline]
\score { \notes { c'4 <c'4 es'> }  }
@end lilypond



@node Context properties
@subsection Context properties

Notation contexts can be modified from within the @file{.ly} file. The
following music expression does that job:

@cindex @code{\property}
@example
  \property @var{contextname}.@var{propname} =  @var{value}
@end example

Sets the @var{propname} property of the context @var{contextname} to the
specified Scheme expression @var{value}.  All @var{propname} and
@var{contextname} are strings, which are typically unquoted.

Properties that are set in one context are inherited by all of the
contained contexts.  This means that a property valid for the
@code{Voice} context can be set in the @code{Score} context (for
example) and thus take effect in all @code{Voice} contexts.




@c .  {Context definitions}
@node Changing context definitions
@subsection Changing context definitions

@cindex context definition
@cindex translator definition

The most common way to define a context is by extending an existing
context.  You can change an existing context from the paper block, by
first initializing a translator with an existing context identifier:
@example
\paper @{
  \translator @{
    @var{context-identifier}
  @} @}
@end example
Then you can add engravers, remove engravers and set context
properties. The syntax for these operations are respectively
@example
 \remove @var{engravername}
 \consists @var{engravername}
 @var{propname} = @var{value} 
@end example

Here @var{engravername} is a string, the name of an engraver in the
system. @var{propname} is a string and @var{value} is a Scheme
expression.

@lilypond[verbatim,singleline]
\score {  \notes {
        c'4 c'4 }
  \paper {
    \translator  { \StaffContext
        \consists Instrument_name_engraver;
        instrument = #"foo"
        \remove Clef_engraver;
       } } }
@end lilypond

@cindex engraver

These type of property assignments happen before interpretation starts,
so a @code{\property} expression will override any predefined settings.

Engravers are the actual C++ modules that do the work in the
interpretation phase.


There are some pre-defined identifiers to simplify editing translators,
they are defined in @file{ly/engraver.ly}.  These pre-defined
identifiers are:

@table @code
@cindex @code{StaffContext}
  @item @code{StaffContext}  
    Default Staff context. 
@cindex @code{RhythmicStaffContext}

  @item @code{RhythmicStaffContext}  
    Default RhythmicStaff context. 
@cindex @code{VoiceContext}

  @item @code{VoiceContext}  
    Default Voice context.  
@cindex @code{ScoreContext}

  @item @code{ScoreContext}  
    Default Score context. 

@cindex @code{HaraKiriStaffContext}

  @item @code{HaraKiriStaffContext}  
    Staff context that does not print if it only contains rests. 
    Useful for orchestral scores.@footnote{Harakiri, also called
    Seppuku, is the ritual suicide of the Japanese Samourai warriors.}
@end table

@node Defining new contexts
@subsection Defining new contexts

If you want to build a context from scratch, you must also supply the
following extra information:
@itemize @bullet
  @item  A name, specified by @code{\name @var{contextname};}.

  @item A cooperation engraver. This is specified by   @code{\type
@var{typename};}.
@end itemize


A context definition has this syntax:

@example

  \translator @code{@{}
                      @var{translatorinit} @var{translatormodifierlist}
                    @code{@}}
@end example

@var{translatorinit} can be an identifier or 
@example

@end example
where @var{typename} is one of

The cooperation engraver groups other engravers, and specifies how they
should cooperate. Choices are:

@table @code
@cindex @code{Engraver_group_engraver}
  @item @code{Engraver_group_engraver}  
    The standard cooperation engraver.

@cindex @code{Score_engraver}

  @item @code{Score_engraver}  
    This is cooperation module that should be in the top level context,
and only the toplevel context.

@cindex @code{Grace_engraver_group}

  @item @code{Grace_engraver_group}  
    This is a special cooperation module (resembling
    @code{Score_engraver}) that is used to created an embedded
    `miniscore'.
@end table 

@var{translatormodifierlist} is a list of items where each item is
one of

@itemize @bullet
  @item  @code{\consists} @var{engravername} @code{;}  
    Add @var{engravername} to the list of modules in this context. 
  The order of engravers added with @code{\consists} is
    significant.
  
  @item  @code{\consistsend} @var{engravername} @code{;}  
    Analogous to @code{\consists}, but makes sure that
    @var{engravername} is always added to the end of the list of
    engravers.

    Some engraver types need to be at the end of the list; this
    insures they are put there, and stay there, if a user adds or
    removes engravers.  This command is usually not needed for
    end-users.
    
  @item  @code{\accepts} @var{contextname} @code{;}  
    Add @var{contextname} to the list of  context this context can
    contain.  The first listed context is the context to create by
    default.

  @item @code{\denies}. The opposite of @code{\accepts}. Added for
completeness, but is never used in practice.
 
  
  @item  @code{\remove} @var{engravername} @code{;}  
    Remove a previously added (with @code{\consists}) engraver.
  
  @item  @code{\name} @var{contextname} @code{;}  
    This sets name of the context, e.g. @code{Staff}, @code{Voice}.  If
    the name is not specified, the translator won't do anything.

  @item  @var{propname} @code{=} @var{value} @code{;}  
    A property assignment.
@end itemize

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

@quotation

@example 
\paper @{
  foo = \translator @{ @dots{} @}
@}
\score @{
  \notes @{
    @dots{}
  @}
  \paper @{
    \translator @{ \foo @dots{} @}
  @}
@} 
@end example 

@end quotation


@cindex paper types, engravers, and pre-defined translators

      


        Properties can be preset within the @code{\translator} block
corresponding to the appropriate context.  In this case, the syntax
is

@example
  @var{propname} @code{=} @var{value}
@end example

The property settings are used during the interpretation phase.  They
are read by the LilyPond modules where interpretation contexts are
built of.  These modules are called @emph{translators}.  Translators for
notation are called @emph{engravers}, and translators for sound are
called @emph{performers}.




@c . {Syntactic details}
@node Syntactic details
@section Syntactic details
@cindex Syntactic details
@menu
* Top level::                   
* Identifiers::                 
* Music expressions::           
* Manipulating music expressions::  
* Assignments::                 
* Lexical details::             
* Lexical modes::               
* Ambiguities::                 
@end menu

@c .  {Top level}
@node Top level
@subsection Top level
@cindex Top level

This section describes what you may enter at top level.


@c .   {Score}
@subsubsection Score
@cindex Score

@cindex score definition

The output is generated combining a music expression with an output
definition.  A score block has the following syntax:

@example
  \score @{ @var{musicexpr} @var{outputdefs} @}
@end example

@var{outputdefs} are zero or more output definitions.  If no output
definition is supplied, the default @code{\paper} block will be added.



@c .   {Default output}
@subsubsection Default output

Default values for the @code{\paper} and @code{\midi} block are set by
entering such a block at top-level.

@c .   {Header}
@subsubsection Header
@cindex Header
@cindex @code{\header}

The syntax is

@example
  \header @{ @var{key1} = @var{val1};
@cindex @code{ly2dvi}
             @var{key2} = @var{val2}; @dots{} @}
@end example


A header describes the file's contents.  It can also appear in a
@code{\score} block.  Tools like @code{ly2dvi} can use this
information for generating titles.  Key values that are used by
@code{ly2dvi} are: title, subtitle, composer, opus, poet, instrument,
metre, arranger, piece and tagline.

It is customary to put the @code{\header} at the top of the file.

@subsubsection Default output

A @code{\midi} or @code{\paper} block at top-level sets the default

paper block for all scores that lack an explicit paper block.

@c .  {Identifiers}
@node Identifiers
@subsection Identifiers
@cindex  Identifiers

All of the information in a LilyPond input file, is represented as a
Scheme value. In addition to normal Scheme data types (such as pair,
number, boolean, etc.), LilyPond has a number of specialized data types,

@itemize @bullet
@item Input
@item c++-function
@item Music
@item Identifier
@item Translator_def
@item Duration
@item Pitch
@item Score
@item Music_output_def
@item Moment (rational number)
@end itemize

LilyPond also includes some transient object types. Objects of these
types are built during a LilyPond run, and do not `exist' per se within
your input file. These objects are created as a result of your input
file, so you can include commands in the input to manipulate them,
during a lilypond run.

@itemize @bullet
@item Grob: short for Graphical object. See @ref{Grobs}. 
@item Molecule: device-independent page output object,
including dimensions.  Produced by some Grob functions
See @ref{Molecules}
@item Translator: object that produces audio objects or Grobs. This is
not yet user accessible.
@item Font_metric: object representing a font. (See @ref{Font metrics})

@end itemize


@node Music expressions
@subsection Music expressions

@cindex music expressions

Music in LilyPond is entered as a music expression.  Notes, rests, lyric
syllables are music expressions, and you can combine music expressions
to form new ones, for example by enclosing a list of expressions in
@code{\sequential @{ @}} or @code{< >}.  In this example, a compound
expression is formed out of the quarter note @code{c} and a quarter note
@code{d}:

@example 
\sequential @{ c4 d4 @} 
@end example 

@cindex Sequential music
@cindex @code{\sequential}
@cindex sequential music
@cindex @code{<}
@cindex @code{>}
@cindex Simultaneous music
@cindex @code{\simultaneous}

The two basic compound  music expressions are simultaneous  and
sequential music.

@example
  \sequential @code{@{} @var{musicexprlist} @code{@}}
  \simultaneous @code{@{} @var{musicexprlist} @code{@}}
@end example
For both, there is a shorthand:
@example
  @code{@{} @var{musicexprlist} @code{@}}
@end example
for sequential and
@example
  @code{<} @var{musicexprlist} @code{>}
@end example
for simultaneous music.
Other compound music expressions include
@example
 \repeat @var{expr}
 \transpose @var{pitch} @var{expr}
 \apply @var{func} @var{expr}
 \context @var{type} = @var{id} @var{expr}
 \times @var{fraction} @var{expr}
@end example

In principle, the way in which you nest sequential and simultaneous to
produce music is not relevant.  In the following example, three chords
are expressed in two different ways:

@lilypond[fragment,verbatim,center]
  \notes \context Voice {
    <a c'> <b  d' > <c' e'>
    < { a b  c' } { c' d' e' } >
  }
@end lilypond

However, in some cases, LilyPond will also try to choose contexts, and
use the structure of the music expression  to do so. This can have
undesired effects: for example, LilyPond will create a separate staff
for each note if you start a @code{\score} with a  chord:
@lilypond[verbatim,center,singleline]
  \score {
    \notes <c''4 e''>
  }
@end lilypond
  The solution is to explicitly instantiate the context you desire.
In this case this is typically a Voice context
@lilypond[verbatim,center,singleline]
  \score {
    \notes\context Voice <c''4 e''>
  }
@end lilypond
If you use @code{\context Staff} you will get separate stems for each
note head, leading to collisions, so don't use that.



@c . {Manipulating music expressions}
@node Manipulating music expressions
@subsection  Manipulating music expressions

The @code{\apply} mechanism gives you access to the internal
representation of music. You can write Scheme-functions that operate
directly on it. The syntax is 
@example
        \apply #@var{func} @var{music}
@end example
This means that @var{func} is applied to @var{music}.  The function
@var{func} should return a music expression.

This example replaces the text string of a script. It also shows a dump
of the music it processes, which is useful if you want to know more
about how music is stored.
@lilypond[verbatim]
#(define (testfunc x)
        (if (equal? (ly-get-mus-property x 'text) "foo")
                (ly-set-mus-property x 'text "bar"))
        ;; recurse
        (ly-set-mus-property x 'elements
          (map testfunc (ly-get-mus-property x 'elements)))
        (display x)
        x        
)
\score { \notes
  \apply #testfunc { c4_"foo" }
} 
@end lilypond

For more information on what is possible, see the @ref{Tricks} and the
automatically generated documentation.

As always: directly accessing internal representations is dangerous: the
implementation is subject to changes, so you should not use this if
possible.


@c .   {Assignments}
@node Assignments
@subsection Assignments
@cindex Assignments

Identifiers allow objects to be assigned to names during the parse
stage.  To assign an identifier, you use @var{name}@code{=}@var{value}
and to refer to an identifier, you preceed its name with a backslash:
`@code{\}@var{name}'.  @var{value} is any valid Scheme value or any of
the input-types listed above.  Identifier assignments can appear at top
level in the LilyPond file, but also in @code{\paper} blocks.

Semicolons are forbidden after top level assignments, but mandatory in
other places. The rules about semicolons and assignments are very
confusing, but when LilyPond input evolves more towards Scheme, we hope
that this problem will grow smaller.

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,
being entirely alphabetical.  It is impossible to refer to an identifier
whose name is the same as the name of a keyword.

The right hand side of an identifier assignment is parsed completely
before the assignment is done, so it is allowed to redefine an
identifier in terms of its old value, e.g.

@example
foo = \foo * 2.0
@end example

When an identifier is referenced, the information it points to is
copied.  For this reason, an identifier reference must always be the
first item in a block.
@example
\paper  @{
        foo = 1.0
        \paperIdent % wrong and invalid
@}

\paper @{
        \paperIdent % correct
        foo = 1.0 @}
@end example

@c .  {Lexical details}
@node Lexical details
@subsection Lexical details
@cindex Lexical details
@menu
@end menu

@c .   {Comments}
@subsubsection Comments
@cindex Comments

@cindex @code{%}


A one line comment is introduced by a @code{%} character. 
Block comments are started by @code{%@{} and ended by @code{%@}}. 
They cannot be nested.

@c .  {Direct Scheme}
@subsubsection Direct Scheme
@cindex Scheme
@cindex GUILE
@cindex Scheme, in-line code


LilyPond contains a Scheme interpreter (the GUILE library) for
internal use. In some places Scheme expressions also form valid syntax:
whereever it is allowed,
@example
  #@var{scheme}
@end example
evaluates the specified Scheme code. If this is used at toplevel, then
the result is discarded. Example:
@example
  \property Staff.TestObject \override #'foobar =  #(+ 1 2)
@end example

@code{\override} expects two Scheme expressions, so there are two Scheme
expressions. The first one is a symbol (@code{foobar}), the second one
an integer (namely, 3).

Scheme is a full-blown programming language, and a full discussion is
outside the scope of this document. Interested readers are referred to
the website @uref{http://www.schemers.org/} for more information on
Scheme.


@c .   {Keywords}
@subsubsection Keywords
@cindex Keywords


Keywords start with a backslash, followed by a number of lower case
alphabetic characters.  These are all the keywords.

@example
apply arpeggio autochange spanrequest commandspanrequest
simultaneous sequential accepts alternative bar breathe
char chordmodifiers chords clef cm consists consistsend
context denies duration dynamicscript elementdescriptions
font grace header in lyrics key mark pitch
time times midi mm name pitchnames notes outputproperty
override set revert partial paper penalty property pt
relative remove repeat addlyrics partcombine score
script stylesheet skip textscript tempo translator
transpose type
@end example

@c .   {Integers}
@subsubsection Integers

@cindex integers
@cindex @code{+}
@cindex @code{-}
@cindex @code{*}
@cindex @code{/}

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

@c .   {Reals}
@subsubsection Reals
@cindex real numbers





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.

@cindex @code{\mm},
@cindex @code{\in}
@cindex @code{\cm}
@cindex @code{\pt}
@cindex dimensions

A real constant can be followed by one of the dimension keywords:
@code{\mm} @code{\pt}, @code{\in}, or @code{\cm}, for millimeters,
points, inches and centimeters, respectively.  This converts the number
to a real that is the internal representation of dimensions.


@c .   {Strings}
@subsubsection Strings
@cindex string
@cindex concatenate

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
@ref{Lexical modes} for details on unquoted strings; their
interpretation varies depending on the situation.  Strings can be
concatenated with the @code{+} operator.

The tokenizer accepts the following commands. They have no grammatical
function, hence they can appear anywhere in the input.


@c .   {Main input}
@subsubsection Main input
@cindex Main input

@cindex @code{\maininput}

The @code{\maininput} command is used in init files to signal that the
user file must be read. This command cannot be used in a user file.

@c .   {File inclusion}
@subsubsection Main input
@cindex Main input

@subsubsection File inclusion
@cindex @code{\include}
@example
  \include @var{filename}
@end example

Include @var{filename}.  The argument @var{filename} may be a quoted string (an
unquoted string will not work here!) or a string identifier.  The full
filename including the @file{.ly} extension must be given,

@subsubsection Version information 
@cindex @code{\version}
@example
  \version @var{string} ;
@end example

Specify the version of LilyPond that a file was written for.  The
argument is a version string in quotes, for example @code{"1.2.0"}. 
This is used to detect invalid input, and to aid
@code{convert-ly}  a tool that automatically upgrades input files. See
See @ref{convert-ly} for more information on @code{convert-ly}.

@cindex convert-ly


@c .   {Pitch names}
@subsubsection Defining pitch names
@cindex Lexical modes
@cindex definining pitch names
@cindex pitch names, definining
@cindex note names
@cindex chord modifier names

A @code{\paper} block at top level sets the default paper block.  A
@code{\midi} block at top level works similarly.

@c .   {Assignments}
@subsubsection Assignments
@cindex assignments
@cindex @code{#}

Identifier assignments may appear at top level.  @ref{Assignments}



@c .    {Direct scheme}
@subsubsection Direct scheme
@cindex Direct scheme

Scheme statements maybe issued to produce interesting side-effects. 


@c .  {Lexical modes}
@node Lexical modes
@subsection Lexical modes
@cindex Lexical modes
@cindex input mode
@cindex mode, input 
@cindex @code{\notes}
@cindex @code{\chords}
@cindex @code{\lyrics}

To simplify entering notes, lyrics, and chords, LilyPond has three
special input modes on top of the default mode: note, lyrics and chords
mode.  These input modes change the way that normal, unquoted words are
interpreted: for example, the word @code{cis} may be interpreted as a
C-sharp, as a lyric syllable `cis' or as a C-sharp major triad
respectively.

A mode switch is entered as a compound music expressions
@example
@code{\notes} @var{musicexpr}
@code{\chords} @var{musicexpr}
@code{\lyrics}  @var{musicexpr}.
@end example

In each of these cases, these expressions do not add anything to the
meaning of their arguments.  They are just a way to indicate that the
arguments should be parsed in indicated mode.  The modes are treated in
more detail in the sections @ref{Note entry}, @ref{Lyrics} and
@ref{Chords}.

You may nest different input modes.

@c .  {Ambiguities}
@node Ambiguities
@subsection Ambiguities
@cindex ambiguities
@cindex grammar


The grammar contains a number of ambiguities. We hope to resolve them at
some time.

@itemize @bullet
  @item  The assignment

         @example 
foo = bar 
@end example 

       can be interpreted as making a string identifier @code{\foo}
       containing @code{"bar"}, or a music identifier @code{\foo}
       containing the syllable `bar'.

  @item  The assignment

         @example 
foo = -6 
@end example 

       can be interpreted as making an integer identifier
       containing -6, or a Request identifier containing the
       fingering `6' (with neutral direction).

  @item  If you do a nested repeat like

       @quotation

@example 
\repeat @dots{}
\repeat @dots{}
\alternative 
@end example 

       @end quotation

       then it is ambiguous to which @code{\repeat} the
       @code{\alternative} belongs.  This is the classic if-then-else
       dilemma.  It may be solved by using braces.

  @item  (an as yet unidentified ambiguity :-)
@end itemize





@c .{Local emacs vars}
@c Local variables:
@c mode: texinfo
@c minor-mode: font-lock
@c minor-mode: outline
@c outline-layout: (-1 : 0)
@c outline-use-mode-specific-leader: "@c \."
@c outline-primary-bullet: "{"
@c outline-stylish-prefixes: nil
@c outline-override-protect: t
@c End: