+2003-09-09 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ * stepmake/GNUmakefile.in: remove nested stepmake packaging stuff.
+
+ * VERSION: remove
+
+ * scripts/*2ly.py: update <> syntax
+
+2003-09-09 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
+ * lily/chord-name-engraver.cc (process_music): add origin for
+ chord name.
+
+ * input/regression/chord-name-exceptions.ly (theMusic): add base too.
+
+ * scm/chord-ignatzek-names.scm (ignatzek-chord-names): bugfix: do
+ bass notes for exceptions too.
+
+ * scm/define-grobs.scm (all-grob-descriptions): rename
+ HaraKiriVerticalGroup to RemoveEmptyVerticalGroup
+
+ * scm/define-grob-properties.scm (remove-first): add remove-first
+ property for orchestral scores.
+
+ * Documentation/user/*.itely: switch <<>> and <>
+
+ * lily/glissando-engraver.cc (process_music): bugfix: move line to
+ last_line only once. This fixes the two consecutive glissandi problem.
+
2003-09-09 Juergen Reuter <reuter@ipd.uka.de>
* lily/vaticana-ligature-engraver.cc: bugfix: fixed programming
author = {Donald Byrd},
school = {Indiana University},
-note = {Describes the SMUT (sic) system for automated music printout.}
-
+ note = {Describes the SMUT (sic) system for automated music printout.}
}
@InProceedings{assayaag86,
}
@Article {smdl-web,
- author={unknown},
title = {SMDL, Standard Musical Description Language},
pdf= {ftp://ftp.ornl.gov/pub/sgml/wg8/smdl/10743.pdf},
- note={ISO/IEC DIS 10743
-
-SGML instance for describing music. Very comprehensive in music
+ number={ISO/IEC DIS 10743},
+ year = {1992}
+ annote = {SGML instance for describing music. Very comprehensive in music
definition, but no support for notation / performance whatsoever (They
basically say: "You can embed a NIFF or MIDI file")}
work.
@end itemize
+The HTML files can be installed into the standard documentation path
+by issuing
+
+@example
+ make out=www web-install
+@end example
+
+
@section Building LilyPond
To install GNU LilyPond, type
files as shown, and move them to the appropriate paths. Of course, the
.deb version number should correspond to what you are installing.
-
-
If you are doing an upgrade, you should remove all @file{feta}
@code{.pk} and @code{.tfm} files. A script has been provided to do the
work for you, see @file{buildscripts/clean-fonts.sh}.
@end lilypond
-@item @code{< \new Staff ... >}
+@item @code{<< \new Staff ... >>}
@tab more staves
@tab
@lilypond[fragment]
-< \new Staff { c'1 }
- \new Staff { c'1 } >
+<< \new Staff { c'1 }
+ \new Staff { c'1 } >>
@end lilypond
@end lilypond
-@item @code{<< >>}
+@item @code{< >}
@tab chord
@tab
@lilypond[fragment, relative 1]
-<<c e>>
+<c e>
@end lilypond
\context ChordNames \chords { c:dim f:maj7 }
@end lilypond
-@item @code{< @dots{} \\ @dots{} >}
+@item @code{<< @dots{} \\ @dots{} >>}
@tab polyphony
@tab
@lilypond[fragment,relative 1]
-\context Staff < c \\ g' >
+\context Staff << c \\ g' >>
@end lilypond
@lilypond[verbatim,singleline]
\score {
\notes \relative c'' {
- c4 <d4 \context Staff = "another" e4> f
+ c4 <<d4 \context Staff = "another" e4>> f
}
}
@end lilypond
Notes, rests, lyric syllables are music expressions. Small music
expressions may be combined to form larger ones, for example, by
-enclosing a list of expressions in @code{\sequential @{ @}} or @code{<
->}. In the following example, a compound expression is formed out of
+enclosing a list of expressions in @code{\sequential @{ @}} or @code{<<
+>>}. In the following example, a compound expression is formed out of
the quarter note @code{c} and a quarter note @code{d}:
@example
@cindex Sequential music
@cindex @code{\sequential}
@cindex sequential music
-@cindex @code{<}
-@cindex @code{>}
+@cindex @code{<<}
+@cindex @code{>>}
@cindex Simultaneous music
@cindex @code{\simultaneous}
for sequential and
@example
-@code{<} @var{musicexprlist} @code{>}
+@code{<<} @var{musicexprlist} @code{>>}
@end example
@noindent
@lilypond[fragment,verbatim,center,quote]
\notes \context Voice {
- <a c'> <b d'> <c' e'>
- < { a b c' } { c' d' e' } >
+ <<a c'>> <<b d'>> <<c' e'>>
+ << { a b c' } { c' d' e' } >>
}
@end lilypond
-However, using @code{<} and @code{>} for entering chords leads to
+However, using @code{<<} and @code{>>} for entering chords leads to
various peculiarities. For this reason, a special syntax
-for chords was introduced in version 1.7: @code{<< >>}.
+for chords was introduced in version 1.7: @code{< >}.
Some of the input syntax is also implemented as recursive music
functions. For example, the syntax for polyphony
@example
- < a \\ b>
+ << a \\ b>>
@end example
@noindent
is actually implemented as a recursive function that replaces the
above by the internal equivalent of
@example
- < \context Voice = "1" @{ \voiceOne a @}
- \context Voice = "2" @{ \voiceTwo b @} >
+ << \context Voice = "1" @{ \voiceOne a @}
+ \context Voice = "2" @{ \voiceTwo b @} >>
@end example
Other applications of @code{\apply} are writing out repeats
By adding chord names and lyrics we obtain a lead sheet:
@lilypond[raggedright]
-\score { <
+\score { <<
\context ChordNames \chords { c2 c f2 c }
\notes \relative c' { \time 2/4 c4 c g'4 g a4 a g2 }
- \context Lyrics \lyrics { twin4 kle twin kle lit tle star2 } > }
+ \context Lyrics \lyrics { twin4 kle twin kle lit tle star2 } >> }
@end lilypond
Polyphonic notation and piano music can also be printed. The following
Then the short version:
@example
-@@lilypond[11pt]@{<<c' e' g'>>@}
+@@lilypond[11pt]@{<c' e' g'>@}
@end example
@noindent
produces
-@lilypond[11pt]{ <<c' e' g'>> }
+@lilypond[11pt]{ <c' e' g'> }
@command{lilypond-book} knows the default margins and a few paper
sizes. One of these commands should be in the beginning of the document:
Then the short version:
@example
-\lilypond[11pt]@{<<c' e' g'>>@}
+\lilypond[11pt]@{<c' e' g'>@}
@end example
@noindent
produces
-@lilypond[11pt]{<<c' e' g'>>}
+@lilypond[11pt]{<c' e' g'>}
The linewidth of the music will be adjust by examining the commands in
the document preamble, the part of the document before
\time 4/4
%\property Score.TextScript \set #'font-style = #'large
-<<d a fis>>4_"notation" r
+<d a fis>4_"notation" r
{ \property Voice.Stem \override #'flag-style = #'()
\grace g16
\property Voice.Stem \revert #'flag-style
g8 fis16 g |
\cadenzaOn a4 \bar "||" \cadenzaOff }
\notes\relative c'' {
-<<d a fis>>4_"performance" r g16 ( fis) e fis a ( g) fis g |
+<d a fis>4_"performance" r g16 ( fis) e fis a ( g) fis g |
\cadenzaOn a4 \bar "||" \cadenzaOff }
@end lilypond
\time 2/4
% \property Score.TextScript \set #'font-style = #'large
\grace { bes16 } as8_"notation" as16 bes as8 g |
- \grace { as16[( bes] } << c as >>4-)
- \grace { as16[( bes] } << c as >>4-) \bar "||"
+ \grace { as16[( bes] } < c as >4-)
+ \grace { as16[( bes] } < c as >4-) \bar "||"
\grace { bes16 } as8_"performance" as16 bes as8 g |
- < \context Voice = va { \stemUp\tieUp as32 bes c8. as32 bes c8. }
- \context Voice = vb { \stemDown\tieDown as16 ~ as8. as16 ~ as8. } >
+ << \context Voice = va { \stemUp\tieUp as32 bes c8. as32 bes c8. }
+ \context Voice = vb { \stemDown\tieDown as16 ~ as8. as16 ~ as8. } >>
\bar "||"
}
@end lilypond
N: ?.
@lilypond
-\notes \context PianoStaff <
+\notes \context PianoStaff <<
\context Staff = SA \relative c'' {
\time 4/4
\clef treble
r8 a,16 d f a, d f r8 a,16 d f a, d f \bar "||" }
\context Staff = SB \relative c' {
\clef bass
- < \context Voice = va {
+ << \context Voice = va {
\stemUp
r16 e8. ( e4) r16 e8. ( e4) |
r16 d8. ( d4) r16 d8. ( d4) }
\context Voice = vb {
\stemDown
- c2 c | c c } >
+ c2 c | c c } >>
}
->
+>>
@end lilypond
@aitem{ascending interval}
orchestral or choral score.
@lilypond
-\notes\context GrandStaff <
+\notes\context GrandStaff <<
\relative c''\context Staff = SA { \clef treble g4 e c2 }
- \relative c \context Staff = SB { \clef bass c1 \bar "|." } >
+ \relative c \context Staff = SB { \clef bass c1 \bar "|." } >>
@end lilypond
@lilypond
-\context StaffGroup <
+\context StaffGroup <<
% \property StaffGroup.minVerticalAlign = #12
\notes\relative c'' \context Staff = SA { \clef treble g4 e c2 }
- \notes\relative c \context Staff = SB { \clef bass c1 \bar "|." } >
+ \notes\relative c \context Staff = SB { \clef bass c1 \bar "|." } >>
@end lilypond
@aitem{brass}
%\property Voice.TextScript \set #'font-style = #'large
\addlyrics
\context Staff \notes\relative c'' {
- <<g b d>>1 s s
- <<g bes d>> s s
- <<g bes des>> s s
- <<g b dis>> s s
- <<g b d f>> s s
- <<g b d f a>> s s
+ <g b d>1 s s
+ <g bes d> s s
+ <g bes des> s s
+ <g b dis> s s
+ <g b d f> s s
+ <g b d f a> s s
}
\context Lyrics \lyrics{
\property Lyrics . LyricText \override #'alignment = #-1
@lilypond[11pt,noquote]
\property Score.TimeSignature \override #'style = #'()
-\notes\context PianoStaff <
+\notes\context PianoStaff <<
\context Staff = SA \relative c' {
\key bes \major
\time 4/4
\clef treble
- < \context Voice = rha {
+ << \context Voice = rha {
\stemUp
r1 | r2 r8 g'8 bes d, |
cis4 d r8 e!16 f g8 f16 e |
\stemDown
r1 | r | r | r2 s8
}
- >
+ >>
}
\context Staff = SB \relative c' {
\clef bass
\key bes \major
- < \context Voice = lha {
+ << \context Voice = lha {
\stemUp
r8 d es g, fis4 g | r8 a16 bes c8 bes16 a bes4 g |
r8 a16 g f8 g16 a bes8 g e! cis' |
\context Voice = lhb {
\stemDown
r1 | r | r | r2 s8
- } >
+ } >>
}
->
+>>
@end lilypond
@aitem{counter tenor}
\property Staff.Custos \set #'style = #'hufnagel
c'1
- \break << d' a' f''>>1
+ \break < d' a' f''>1
}
\paper {
\translator {
%\property Score.TextScript \set #'font-style = #'large
\addlyrics
\context Staff \notes\relative c'' {
- gis1 s s as s s <<des g,!>> s s <<cis g!>> s s
+ gis1 s s as s s <des g,!> s s <cis g!> s s
}
\context Lyrics \lyrics {
\property Lyrics . LyricText \override #'alignment = #-1
%\property Score.TextScript \set #'font-style = #'large
\addlyrics
\context Voice \notes\relative c'' {
- <<g e c >>1 << a f d >> << b g e >>
- <<c a f >> << d b g >> << e c a >> << f d b >> }
+ <g e c >1 < a f d > < b g e >
+ <c a f > < d b g > < e c a > < f d b > }
\context Lyrics \lyrics { T Sp Dp S D Tp "D{\\kern-5pt}$\\mid$" }
@end lilypond
section. @aref{functional harmony}.
@lilypond
-\notes\context PianoStaff <
+\notes\context PianoStaff <<
\context Staff = SA \relative c'' {
\time 4/4
\clef treble
\context Voice
- \partial 4 << c g e >>4 |
- << c a f >> << b g d >> << c g e >>2
+ \partial 4 < c g e >4 |
+ < c a f > < b g d > < c g e >2
}
% %\property Score.LyricText \set #'font-style = #'large
\addlyrics
\context Lyrics \lyrics {
T S D T
}
->
+>>
@end lilypond
@aitem{harmony}
\property Score.automaticBars = ##f
%\property Score.TextScript \set #'font-style = #'large
\context Voice \notes\relative c'' {
- <<g g>>1_"unisone " s
- <<g b>>_"third " s
- <<g c>>_"fourth " s
- <<g d'>>_"fifth " s
- <<g e'>>_"sixth " s
- <<g g'>>_"octave " s
- <<g b'>>_"decime" s s
+ <g g>1_"unisone " s
+ <g b>_"third " s
+ <g c>_"fourth " s
+ <g d'>_"fifth " s
+ <g e'>_"sixth " s
+ <g g'>_"octave " s
+ <g b'>_"decime" s s
}
@end lilypond
\property Score.automaticBars = ##f
%\property Score.TextScript \set #'font-style = #'large
\context Voice \notes\relative c'' {
- <<g a>>1_"second " s s
- <<g f'>>_"seventh " s s
- <<g a'>>_"ninth" s s
+ <g a>1_"second " s s
+ <g f'>_"seventh " s s
+ <g a'>_"ninth" s s
}
@end lilypond
%\property Score.TextScript \set #'font-style = #'large
\addlyrics
\context Voice \notes\relative c'' {
- << g g >>1 s
- << g as >>^"minor" s
- << g a! >> s
- << g ais >>^"augm" s
- << gis bes >>^"dimin" s
- << g! bes >>^"minor" s
- << g b! >>^"major" s
- << g bis >>^"augm" s
+ < g g >1 s
+ < g as >^"minor" s
+ < g a! > s
+ < g ais >^"augm" s
+ < gis bes >^"dimin" s
+ < g! bes >^"minor" s
+ < g b! >^"major" s
+ < g bis >^"augm" s
}
\context Lyrics \lyrics {
"unisone " "second " "second " "second "
%\property Score.TextScript \set #'font-style = #'large
\addlyrics
\context Staff \notes\relative c'' {
- << g c >>^"perfect" s
- << g cis >>^"augm" s
- << g d' >>^"perfect" s
- << g des' >> ^"dim" s
- << gis es' >>^"dimin" s
- << g! es' >>^"minor" s
- << g e'! >>^"major" s
- << g eis' >>^"augm" s
+ < g c >^"perfect" s
+ < g cis >^"augm" s
+ < g d' >^"perfect" s
+ < g des' > ^"dim" s
+ < gis es' >^"dimin" s
+ < g! es' >^"minor" s
+ < g e'! >^"major" s
+ < g eis' >^"augm" s
}
\context Lyrics \lyrics {
"fourth " "fourth " "fifth " "fifth "
%\property Score.TextScript \set #'font-style = #'large
\addlyrics
\context Staff \notes\relative c'' {
- << gis f'! >>1^"dimin" s
- << g! f'! >>^"minor" s
- << g fis' >>^"major" s
- << g g' >> s
- << g as' >>^"minor" s
- << g a'! >>^"major" s
- << g bes' >>^"minor" s
- << g b'! >>^"major" s
+ < gis f'! >1^"dimin" s
+ < g! f'! >^"minor" s
+ < g fis' >^"major" s
+ < g g' > s
+ < g as' >^"minor" s
+ < g a'! >^"major" s
+ < g bes' >^"minor" s
+ < g b'! >^"major" s
}
\context Lyrics \lyrics {
"seventh " "seventh " "seventh " "octave "
\property Score.automaticBars = ##f
%\property Score.TextScript \set #'font-style = #'large
\context Staff \notes\relative c'' {
- << g a >>1_"second " s s << g' a, >>_"seventh " s s \bar "||"
- << g, b >>_"third " s s << g' b, >>_"sixth " s s \bar "||"
- << g, c >>_"fourth " s s << g' c, >>_"fifth " s s \bar "||"
+ < g a >1_"second " s s < g' a, >_"seventh " s s \bar "||"
+ < g, b >_"third " s s < g' b, >_"sixth " s s \bar "||"
+ < g, c >_"fourth " s s < g' c, >_"fifth " s s \bar "||"
}
@end lilypond
the upper note is played first.
@lilypond
-<
+<<
\context Staff = sa {
% \property Score.TextScript \set #'font-style = #'large
\notes\relative c'' {
c2. c32 b c b c b c b | c1
c2. b32 c b c \times 4/5 { b c b c b } | c1
}
->
+>>
@end lilypond
Other frequently used ornaments are the @emph{turn}, the @emph{mordent} and the
@emph{prall} (inverted mordent).
@lilypond
-<
+<<
\context Staff = sa {
% \property Score.TextScript \set #'font-style = #'large
\notes\relative c'' {
g4 a b16-[ a b8] a4
e'4 e32[ d e d ~ d8] c2
}
->
+>>
@end lilypond
@aref{appoggiatura}.
c1 d e f g a b c
}
\context Lyrics \lyrics {
- < { I II III IV V VI VII I }
- { T "" "" S D } >
+ << { I II III IV V VI VII I }
+ { T "" "" S D } >>
}
@end lilypond
@aref{chord}s to be played above the bass notes.
@lilypond
-\context GrandStaff <
+\context GrandStaff <<
\context Staff = lh \notes\relative c'' {
\time 4/4
\key es \major
\clef treble
- < \context Voice = rha {
+ << \context Voice = rha {
\stemUp
es4 d c bes | bes }
\context Voice = rhb {
\stemDown
- << bes g >>8 as << as f >> g << g es >> f << d f >> es | << g es >>4 }
- >
+ < bes g >8 as < as f > g < g es > f < d f > es | < g es >4 }
+ >>
}
\addlyrics
\context Staff = rh \notes\relative c' {
\context Lyrics \lyrics {
% \property Lyrics . LyricText \set #'font-style = #'Large
\property Lyrics . VerticalAlign \override #'threshold = #'(6 . 12)
- < { "" "6" "" "4" "" "6" "" "" "6" "4" }
- { "" "" "" "2" "" "" "" "" "" "2" } >
+ << { "" "6" "" "4" "" "6" "" "" "6" "4" }
+ { "" "" "" "2" "" "" "" "" "" "2" } >>
}
->
+>>
@end lilypond
@aitemii{tie,bind}
@node Chords
@subsection Chords
-A chord is formed by a enclosing a set of pitches in @code{<<} and
-@code{>>}. A chord may be followed by a duration, and a set of
+A chord is formed by a enclosing a set of pitches in @code{<} and
+@code{>}. A chord may be followed by a duration, and a set of
articulations, just like simple notes.
@lilypond[singleline,verbatim]
\score {
- \context Staff <
+ \context Staff <<
{ \time 4/8 \skip 2 \time 4/4 }
\notes\relative c'' { a2 a1 }
- >
+ >>
}
@end lilypond
musical phrasing. A tie is entered using the tilde symbol `@code{~}':
@lilypond[fragment,verbatim,center]
- e' ~ e' <<c' e' g'>> ~ <<c' e' g'>>
+ e' ~ e' <c' e' g'> ~ <c' e' g'>
@end lilypond
When a tie is applied to a chord, all note heads whose pitches match
@lilypond[fragment,verbatim,center]
\relative c' {
- c <<c e g>>
- <<c' e g>>
- <<c, e' g>>
+ c <c e g>
+ <c' e g>
+ <c, e' g>
}
@end lilypond
@cindex @code{\notes}
connected between different staves of a @internalsref{StaffGroup}:
@c
@lilypond[fragment, verbatim]
-< \context StaffGroup <
+<< \context StaffGroup <<
\new Staff { e'4 d'
\bar "||"
f' e' }
- \new Staff { \clef bass c4 g e g } >
-\new Staff { \clef bass c2 c2 } >
+ \new Staff { \clef bass c4 g e g } >>
+\new Staff { \clef bass c2 c2 } >>
@end lilypond
@lilypond[verbatim,fragment]
\context Staff \relative c'' {
- c4 < { f d e } \\ { b c2 } > c4 < g' \\ b, \\ f' \\ d >
+ c4 << { f d e } \\ { b c2 } >> c4 << g' \\ b, \\ f' \\ d >>
}
@end lilypond
@lilypond[singleline, verbatim]
\relative c''
-\context Staff < \new Voice { \voiceOne cis2 b }
+\context Staff << \new Voice { \voiceOne cis2 b }
\new Voice { \voiceThree b4 ais ~ ais4 gis4 }
- \new Voice { \voiceTwo fis4~ fis4 f ~ f } >
+ \new Voice { \voiceTwo fis4~ fis4 f ~ f } >>
@end lilypond
Normally, note heads with a different number of dots are not merged, but
when the object property @code{merge-differently-dotted} is set in
the @internalsref{NoteCollision} object, they are merged:
@lilypond[verbatim,fragment,singleline]
-\relative c'' \context Voice < {
+\relative c'' \context Voice << {
g8 g8
\property Staff.NoteCollision \override
#'merge-differently-dotted = ##t
g8 g8
} \\ { g8.[ f16] g8.[ f16] }
- >
+ >>
@end lilypond
Similarly, you can merge half note heads with eighth notes, by setting
@code{merge-differently-headed}:
@lilypond[fragment, relative=2,verbatim]
-\context Voice < {
+\context Voice << {
c8 c4.
\property Staff.NoteCollision
\override #'merge-differently-headed = ##t
- c8 c4. } \\ { c2 c2 } >
+ c8 c4. } \\ { c2 c2 } >>
@end lilypond
LilyPond also vertically shifts rests that are opposite of a stem:
@lilypond[singleline,fragment,verbatim]
-\context Voice < c''4 \\ r4 >
+\context Voice << c''4 \\ r4 >>
@end lilypond
creation of the piano staff:
@example
\score @{
- \notes \relative c'' <
+ \notes \relative c'' <<
\new Staff @{ cis4 d e2 @}
- \context GrandStaff <
+ \context GrandStaff <<
\pianoAccidentals
\new Staff @{ cis4 d e2 @}
\new Staff @{ es2 c @}
- >
+ >>
\new Staff @{ es2 c @}
- >
+ >>
@}
@end example
@lilypond[singleline]
\score {
- \notes \relative c'' <
+ \notes \relative c'' <<
\new Staff { cis4 d e2 }
- \context GrandStaff <
+ \context GrandStaff <<
\pianoAccidentals
\new Staff { cis4 d e2 }
\new Staff { es2 c }
- >
+ >>
\new Staff { es2 c }
- >
+ >>
\paper {
\translator {
\StaffContext
because accidentals from one voice do not get cancelled in other
voices:
@lilypond[singleline,relative,fragment,verbatim,quote]
- \context Staff <
+ \context Staff <<
\voiceAccidentals
- <
+ <<
{ es g } \\
{ c, e }
- > >
+ >> >>
@end lilypond
Hence you should only use @code{\voiceAccidentals} if the voices
are to be read solely by individual musicians. If the staff is to be
@lilypond[singleline,fragment,verbatim]
\property Staff.autoAccidentals = #'( Staff (any-octave . 0) )
-cis'4 <<c'' c'>> r2 | cis'4 <<c' c''>> r2
-| <<cis' c''>> r | <<c'' cis'>> r |
+cis'4 <c'' c'> r2 | cis'4 <c' c''> r2
+| <cis' c''> r | <c'' cis'> r |
@end lilypond
This problem can be solved by manually inserting @code{!} and @code{?}
They are entered using parentheses:
@lilypond[fragment,verbatim,center]
f'( g')( a') a'8[ b'(] a'4 g'2 f'4)
- <<c' e'>>2( <<b d'>>2)
+ <c' e'>2( <b d'>2)
@end lilypond
played with your thumb (used in cello music):
@lilypond[verbatim, singleline, fragment]
- <<a' a''-3>>8(_\thumb[ <<b' b''-3>>)_\thumb
- <<c'' c'''-3>>(_\thumb <<d'' d'''-3>>)_\thumb]
+ <a' a''-3>8(_\thumb[ <b' b''-3>)_\thumb
+ <c'' c'''-3>(_\thumb <d'' d'''-3>)_\thumb]
@end lilypond
Fingerings for chords can also be added to individual notes
of the chord by adding them after the pitches:
@lilypond[verbatim,singleline,fragment,relative=1]
- << c-1 e-2 g-3 b-5 >> 4
+ < c-1 e-2 g-3 b-5 > 4
@end lilypond
Setting @code{fingeringOrientations} will put fingerings next
@lilypond[verbatim,singleline,fragment,relative=1]
\property Voice.fingeringOrientations = #'(left down)
- <<c-1 es-2 g-4 bes-5 >> 4
+ <c-1 es-2 g-4 bes-5 > 4
\property Voice.fingeringOrientations = #'(up right down)
- <<c-1 es-2 g-4 bes-5 >> 4
+ <c-1 es-2 g-4 bes-5 > 4
@end lilypond
@seealso
example is shown here with timing tuples:
@lilypond[singleline]
-<
+<<
\relative c''{
c4 \grace c16 c4 \grace {
c16[ d16] } c4
\markup { (\fraction 2 4 , \fraction "-1" 16 ) } 16
}
\markup { ( \fraction 2 4 , 0 ) }
- } >
+ } >>
@end lilypond
every eighth grace note:
@lilypond[relative=2,verbatim,fragment]
-< \new Staff { e4 \grace { c16[ d e f] } e4 }
- \new Staff { c'4 \grace { g8[ b] } c4 } >
+<< \new Staff { e4 \grace { c16[ d e f] } e4 }
+ \new Staff { c'4 \grace { g8[ b] } c4 } >>
@end lilypond
is to put the grace notes before a phantom ``space note'', e.g.
@lilypond[fragment,verbatim, relative=2]
\context Voice {
- < { d1^\trill ( }
- { s2 \grace { c16[ d] } } >
+ << { d1^\trill ( }
+ { s2 \grace { c16[ d] } } >>
c4)
}
@end lilypond
care when you mix staves with grace notes and staves without, for example,
@lilypond[relative=2,verbatim,fragment]
-< \new Staff { e4 \bar "|:" \grace c16 d4 }
- \new Staff { c4 \bar "|:" d4 } >
+<< \new Staff { e4 \bar "|:" \grace c16 d4 }
+ \new Staff { c4 \bar "|:" d4 } >>
@end lilypond
Grace sections should only be used within sequential music
@lilypond[fragment,verbatim,center,quote]
c''\< c''\! d''\decr e''\rced
- < f''1 { s4 s4\< s4\! \> s4\! } >
+ << f''1 { s4 s4\< s4\! \> s4\! } >>
@end lilypond
This may give rise to very short hairpins. Use @code{minimum-length}
in @internalsref{Voice}.@internalsref{Hairpin} to lengthen them, for
up = \notes { crashcymbal4 hihat8 halfopenhihat hh hh hh openhihat }
down = \notes { bassdrum4 snare8 bd r bd sn4 }
\score {
- \apply #(drums->paper 'drums) \context Staff <
+ \apply #(drums->paper 'drums) \context Staff <<
\clef percussion
\new Voice { \voiceOne \up }
\new Voice { \voiceTwo \down }
- >
+ >>
}
@end lilypond
mus = \notes { cymc cyms cymr hh hhc hho hhho hhp cb hc
bd sn ss tomh tommh tomml toml tomfh tomfl s16 }
\score {
- <
- \apply #(drums->paper 'drums) \context Staff <
+ <<
+ \apply #(drums->paper 'drums) \context Staff <<
\clef percussion
\mus
- >
+ >>
\context Lyrics \nam
- >
+ >>
\paper {
linewidth = 100.0\mm
\translator {
nam = \lyrics { timh ssh timl ssl cb }
mus = \notes { timh ssh timl ssl cb s16 }
\score {
- <
- \apply #(drums->paper 'timbales) \context Staff <
+ <<
+ \apply #(drums->paper 'timbales) \context Staff <<
\clef percussion
\mus
- >
+ >>
\context Lyrics \nam
- >
+ >>
\paper {
\translator {
\StaffContext
nam = \lyrics { cgh cgho cghm ssh cgl cglo cglm ssl }
mus = \notes { cgh cgho cghm ssh cgl cglo cglm ssl s16 }
\score {
- <
- \apply #(drums->paper 'congas) \context Staff <
+ <<
+ \apply #(drums->paper 'congas) \context Staff <<
\clef percussion
\mus
- >
+ >>
\context Lyrics \nam
- >
+ >>
\paper {
\translator {
\StaffContext
nam = \lyrics { boh boho bohm ssh bol bolo bolm ssl }
mus = \notes { boh boho bohm ssh bol bolo bolm ssl s16 }
\score {
- <
- \apply #(drums->paper 'bongos) \context Staff <
+ <<
+ \apply #(drums->paper 'bongos) \context Staff <<
\clef percussion
\mus
- >
+ >>
\context Lyrics \nam
- >
+ >>
\paper {
\translator {
\StaffContext
nam = \lyrics { tri trio trim gui guis guil cb cl tamb cab mar hc }
mus = \notes { tri trio trim gui guis guil cb cl tamb cab mar hc s16 }
\score {
- <
- \apply #(drums->paper 'percussion) \context Staff <
+ <<
+ \apply #(drums->paper 'percussion) \context Staff <<
\clef percussion
\mus
- >
+ >>
\context Lyrics \nam
- >
+ >>
\paper {
\translator {
\StaffContext
up = \notes { hh8 hh hh hh hhp4 hhp }
down = \notes { bd4 sn bd toml8 toml }
\score {
- \apply #(drums->paper 'mydrums) \context Staff <
+ \apply #(drums->paper 'mydrums) \context Staff <<
\clef percussion
\new Voice { \voiceOne \up }
\new Voice { \voiceTwo \down }
- >
+ >>
}
@end lilypond
\include "nederlands.ly"
bass = \notes \transpose c c,, { a4. e8 r e g e }
\score {
- <
- \apply #(drums->paper 'drums) \new Staff <
+ <<
+ \apply #(drums->paper 'drums) \new Staff <<
\clef percussion
\new Voice { \voiceOne \up }
\new Voice { \voiceTwo \down }
- >
+ >>
\new Staff { \clef "F_8" \bass }
- >
+ >>
}
@end lilypond
@example
\score @{
- \apply #(drums->paper 'mydrums) \context Staff <
+ \apply #(drums->paper 'mydrums) \context Staff <<
\clef percussion
@{ \up @} \\
@{ \down @}
- >
+ >>
\paper@{@}
@}
\score @{
- \context Staff <
+ \context Staff <<
\property Staff.instrument = #'drums
\up \down
- >
+ >>
\midi@{@}
@}
@end example
advance. Here is a practical example:
@lilypond[verbatim,singleline,quote]
-\score { \notes \context PianoStaff <
+\score { \notes \context PianoStaff <<
\context Staff = "up" {
- \autochange Staff \context Voice = VA < \relative c' {
- g4 a b c d r4 a g } > }
+ \autochange Staff \context Voice = VA << \relative c' {
+ g4 a b c d r4 a g } >> }
\context Staff = "down" {
\clef bass
s1*2
-} > }
+} >> }
@end lilypond
@noindent
@lilypond[fragment,relative,verbatim]
- <<c e g c>>\arpeggio
+ <c e g c>\arpeggio
@end lilypond
When an arpeggio crosses staves, you attach an arpeggio to the chords
@internalsref{PianoStaff}.@code{connectArpeggios}:
@lilypond[fragment,relative,verbatim]
- \context PianoStaff <
+ \context PianoStaff <<
\property PianoStaff.connectArpeggios = ##t
- \new Staff { <<c' e g c>>\arpeggio }
- \new Staff { \clef bass <<c,, e g>>\arpeggio }
- >
+ \new Staff { <c' e g c>\arpeggio }
+ \new Staff { \clef bass <c,, e g>\arpeggio }
+ >>
@end lilypond
The direction of the arpeggio is sometimes denoted by adding an
@lilypond[fragment,relative,verbatim]
\context Voice {
\property Voice.Arpeggio \set #'arpeggio-direction = #1
- <<c e g c>>\arpeggio
+ <c e g c>\arpeggio
\property Voice.Arpeggio \set #'arpeggio-direction = #-1
- <<c e g c>>\arpeggio
+ <c e g c>\arpeggio
}
@end lilypond
@lilypond[fragment,relative,verbatim]
\property PianoStaff.Arpeggio \override
#'molecule-callback = \arpeggioBracket
- <<c' e g c>>\arpeggio
+ <c' e g c>\arpeggio
@end lilypond
@refcommands
@code{PianoStaff.followVoice} is set to true:
@lilypond[fragment,relative,verbatim]
- \context PianoStaff <
+ \context PianoStaff <<
\property PianoStaff.followVoice = ##t
\context Staff \context Voice {
c1
b2 a
}
\context Staff=two { \clef bass \skip 1*2 }
- >
+ >>
@end lilypond
The associated object is @internalsref{VoiceFollower}.
more complex orderings, the best way is to setup the hierarchy of
staves and lyrics first, e.g.
@example
-\context ChoirStaff \notes <
+\context ChoirStaff \notes <<
\new Lyrics @{ s1 @}
\new Staff @{ s1 @}
\new Lyrics @{ s1 @}
\new Staff @{ s1 @}
->
+>>
@end example
and then combine the appropriate melodies and lyric lines:
@example
putting both together, you would get
@example
-\context ChoirStaff \notes <
+\context ChoirStaff \notes <<
\new Lyrics @dots{}
\new Staff @dots{}
\addlyrics @dots{}
->
+>>
@end example
@cindex SATB
\addlyrics
\notes \relative c'' \context Voice = duet { \time 3/4
g2 e4 a2 f4 g2. }
- \lyrics \context Lyrics <
+ \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
}
\score {
\context ChoirStaff {
- <
+ <<
\new Staff { \upper }
\new Staff { \lower }
- >
+ >>
}
\paper {
\translator {
e8 fis gis a b cis' dis' e'
}
\score {
- \context StaffGroup <
+ \context StaffGroup <<
\context Staff { \clef "G_8" \frag }
\context TabStaff { \frag }
- >
+ >>
}
@end lilypond
g:
@lilypond[fragment,verbatim]
- \context TabStaff <
+ \context TabStaff <<
\outputproperty #(make-type-checker 'staff-symbol-interface)
#'line-count = #4
\notes {
a,4 c' a e' e c' a e'
}
- >
+ >>
@end lilypond
It is possible to change the Scheme function to format the tablature
@cindex Chords
LilyPond has support for both printing chord names. Chords may be
-entered in musical chord notation, i.e. @code{<< .. >>}, but they can
+entered in musical chord notation, i.e. @code{< .. >}, but they can
also be entered by name. Internally, the chords are represented as a
set of pitches, so they can be transposed:
\chords {
c1 f:sus4 bes/f
}
- <<c e g>>
- <<f bes c'>>
- <<f bes d'>>
+ <c e g>
+ <f bes c'>
+ <f bes d'>
}
\score {
- < \context ChordNames \twoWays
- \context Voice \twoWays > }
+ << \context ChordNames \twoWays
+ \context Voice \twoWays >> }
@end lilypond
This example also shows that the chord printing routines do not try to
For displaying printed chord names, use the @internalsref{ChordNames} context.
The chords may be entered either using the notation
-described above, or directly using @code{<<} and @code{>>}:
+described above, or directly using @code{<} and @code{>}:
@lilypond[verbatim,singleline]
scheme = \notes {
- \chords {a1 b c} <<d' f' a'>> <<e' g' b'>>
+ \chords {a1 b c} <d' f' a'> <e' g' b'>
}
\score {
- \notes<
+ \notes<<
\context ChordNames \scheme
\context Staff \scheme
- >
+ >>
}
@end lilypond
c1:m c:m \break c:m c:m d
}
\score {
- \notes <
+ \notes <<
\context ChordNames {
\property ChordNames.chordChanges = ##t
\scheme }
\context Staff \transpose c c' \scheme
- >
+ >>
}
@end lilypond
Chord names are determined solely from the list of pitches. Chord
inversions are not identified, and neither are added bass notes. This
may result in strange chord names when chords are entered with the
-@code{<< .. >>} syntax.
+@code{< .. >} syntax.
@lilypond[fragment,verbatim,singleline]
\notes {
\property Staff.instrument = \markup {
- \column << "Clarinetti"
+ \column < "Clarinetti"
{ "in B"
\smaller \musicglyph #"accidentals--1"
}
- >>
+ >
}
{ c''1 }
}
polyphony:
@lilypond[verbatim,singleline,fragment]
- \context Staff <
+ \context Staff <<
\context Voice=one \partcombine Voice
\context Thread=one \relative c'' {
g a( b) r
\context Thread=two \relative c'' {
g r4 r f
}
- >
+ >>
@end lilypond
The first @code{g} appears only once, although it was
may set the property @var{soloADue} to false:
@lilypond[verbatim,singleline,fragment]
- \context Staff <
+ \context Staff <<
\property Staff.soloADue = ##f
\context Voice=one \partcombine Voice
\context Thread=one \relative c'' {
\context Thread=two \relative c'' {
d,2 a4 g'
}
- >
+ >>
@end lilypond
@seealso
measure:
@lilypond[fragment,singleline]
- \context Staff <
+ \context Staff <<
\context Voice=one \partcombine Voice
\context Thread=one \relative c'' {
c b c b c a c a
\context Thread=two \relative c'' {
b b b b f a f a
}
- >
+ >>
@end lilypond
The part combiner is rather buggy, and it will be replaced by a better
@lilypond[verbatim]
\score {
- \notes \relative c' <
+ \notes \relative c' <<
\new Staff { e4 f g a \break c1 }
\new Staff { c4 d e f \break R1 }
- >
+ >>
\paper {
linewidth = 6.\cm
\translator { \RemoveEmptyStaffContext }
}
@end lilypond
+In orchestral scores, the first page usually shows all staffs in
+full. To prevent empty staffs from being discarded from the first
+page, set @code{remove-first} to false in
+@internalsref{RemoveEmptyVerticalGroup}.
@node Different editions from one source
@subsection Different editions from one source
@example
c1
- \relative c' <
- \tag #'part <
+ \relative c' <<
+ \tag #'part <<
R1 \\
@{
\property Voice.fontSize = #-1
c4_"cue" f2 g4 @}
- >
+ >>
\tag #'score R1
- >
+ >>
c1
@end example
\fatText
s
^\markup {
- \column <<
+ \column <
"vaticana"
{ " " \musicglyph #"accidentals-vaticana-1"
" " \musicglyph #"accidentals-vaticana0" }
- >>
- \column <<
+ >
+ \column <
"medicaea"
{ " " \musicglyph #"accidentals-medicaea-1" }
- >>
- \column <<
+ >
+ \column <
"hufnagel"
{ " " \musicglyph #"accidentals-hufnagel-1" }
- >>
- \column <<
+ >
+ \column <
"mensural"
{ " " \musicglyph #"accidentals-mensural-1"
" " \musicglyph #"accidentals-mensural1" }
- >>
+ >
}
}
\paper {
\fatText
s
^\markup {
- \column <<
+ \column <
"vaticana"
{ " " \musicglyph #"custodes-vaticana-u0" }
- >>
- \column <<
+ >
+ \column <
"medicaea"
{ " " \musicglyph #"custodes-medicaea-u0" }
- >>
- \column <<
+ >
+ \column <
"hufnagel"
{ " " \musicglyph #"custodes-hufnagel-u0" }
- >>
- \column <<
+ >
+ \column <
"mensural"
{ " " \musicglyph #"custodes-mensural-u0" }
- >>
+ >
}
}
\paper {
LilyPond has limited support for figured bass:
@lilypond[verbatim,fragment]
-<
+<<
\context Voice \notes { \clef bass dis4 c d ais}
\context FiguredBass
\figures {
- < 6 >4 < 7 >8 < 6+ [_!] >
+ < 6 >4 < 7 >8 < 6+ [_!] >
< 6 >4 <6 5 [3+] >
}
- >
+ >>
@end lilypond
The support for figured bass consists of two parts: there is an input
takes care of making @internalsref{BassFigure} objects.
In figures input mode, a group of bass figures is delimited by
-@code{<} and @code{>}. The duration is entered after the @code{>}:
+@code{<} and @code{>}. The duration is entered after the @code{>>}:
@example
<4 6>
@end example
@code{notes-to-clusters} to a sequence of chords, e.g.
@c
@lilypond[relative 1,verbatim]
- \apply #notes-to-clusters { <<c e >> <<b f'>> }
+ \apply #notes-to-clusters { <c e > <b f'> }
@end lilypond
The following example (from
@refbugs
-Music expressions like @code{< @{ g8 e8 @} a4 >} are not printed
-accurately. Use @code{<<g a>>8 <<e a>>8} instead.
+Music expressions like @code{<< @{ g8 e8 @} a4 >>} are not printed
+accurately. Use @code{<g a>8 <e a>8} instead.
@lilypond[singleline]
\score {
- < \addlyrics \notes {
+ << \addlyrics \notes {
b'
^\shortfermata
_\shortfermata
}
\context Lyrics \lyrics {
"shortfermata" "fermata" "longfermata" "verylongfermata"
- } >
+ } >>
}
@end lilypond
In markup mode you can compose expressions, similar to mathematical
expressions, XML documents and music expressions. The braces group
notes into horizontal lines. Other types of lists also exist: you can
-stack expressions grouped with @code{<<}, and @code{>>} vertically with
+stack expressions grouped with @code{<}, and @code{>} vertically with
the command @code{\column}. Similarly, @code{\center} aligns texts by
their center lines:
@lilypond[verbatim,fragment,relative=1]
- c1^\markup { \column << a bbbb c >> }
- c1^\markup { \center << a bbbb c >> }
- c1^\markup { \line << a b c >> }
+ c1^\markup { \column < a bbbb c > }
+ c1^\markup { \center < a bbbb c > }
+ c1^\markup { \line < a b c > }
@end lilypond
The markup mechanism is extensible. Refer to
For linebreaks at regular intervals use @code{\break} separated by
skips and repeated with @code{\repeat}:
@example
-< \repeat unfold 7 @{ s1 * 4 \break @}
+<< \repeat unfold 7 @{ s1 * 4 \break @}
@emph{the real music}
->
+>>
@end example
@noindent
In this example, @code{\simultaneous } indicates that both music
fragments happen at the same time, and must be printed stacked
-vertically. The notation @code{< .. >} can also be used as a
+vertically. The notation @code{<< .. >>} can also be used as a
shorthand for @code{\simultaneous @{ .. @}}.
@code{\context} introduces a ``notation context''. To understand this
@lilypond[verbatim,singleline]
\score {
\notes
- < \new Staff {
+ << \new Staff {
\time 3/4
\clef violin
\relative c'' {
c2 e4 g2.
f4 e d c2.
}
- >
+ >>
\paper {}
}
@end lilypond
@code{c2}, @code{e4}, etc. of the second staff, are combined to form a
larger chunk by enclosing it in braces. Again, a larger chunk is
formed by prefix @code{\context Staff} to it, and that chunk is
-combined with @code{< >}. This mechanism is similar with mathematical
+combined with @code{<< >>}. This mechanism is similar with mathematical
formulas: in a formula, a so-called expression is formed by combining
simpler expressions into larger expressions. For example,
the next one. The simplest expressions are numbers and operators
(like +, * and /). Parentheses are used to group expressions. In
LilyPond input, a similar mechanism is used. Here, the simplest
-expressions are notes and rests. By enclosing expressions in @code{<
->} and @code{@{ @}}, more complex music is formed. The @code{\context}
+expressions are notes and rests. By enclosing expressions in @code{<<
+>>} and @code{@{ @}}, more complex music is formed. The @code{\context}
also forms new expressions; prepending it to a music expression yields
a new expression.
Like mathematical expressions, music expressions can be nested
arbitrarily deep, e.g.
@lilypond[verbatim,relative 1]
- { c <c e>
- < { e f } { c <b d> }
- >
+ { c <<c e>>
+ << { e f } { c <<b d>> }
+ >>
}
@end lilypond
braces at the end of an expression. For example,
@example
\score @{
- \notes <
+ \notes <<
@{
@dots{}
@}
@{
@dots{}
@}
- >
+ >>
@}
@end example
@cindex chords
Chords can be made by
-surrounding pitches with @code{<<} and @code{>}>:
+surrounding pitches with @code{<} and @code{>}:
@quotation
@lilypond[relative 0, fragment,verbatim]
-r4 <<c e g>>4 <<c f a>>8
+r4 <c e g>4 <c f a>8
@end lilypond
@end quotation
@separate
must be placed outside the chord markers:
@quotation
@lilypond[relative 0, fragment,verbatim]
-r4 <<c e g>>8[ <<c f a>>]-~ <<c f a>>
+r4 <c e g>8[ <c f a>]-~ <c f a>
@end lilypond
@end quotation
@quotation
@example
-r4 <<c e g>>8\>( <<c e g>> <<c e g>> <<c f a>>8\!)
+r4 <c e g>8\>( <c e g> <c e g> <c f a>8\!)
@end example
@lilypond[relative 0, fragment]
\slurUp
-r4 <<c e g>>8\>( <<c e g>> <<c e g>> <<c f a>>8\!)
+r4 <c e g>8\>( <c e g> <c e g> <c f a>8\!)
@end lilypond
@end quotation
@separate
@noindent
The result of @code{\chords} is a list of chords, and is equivalent
-to entering chords with @code{<<@dots{}>>}.
+to entering chords with @code{<@dots{}>}.
Other chords can be created by adding modifiers, after a colon. The
following example shows a few common modifiers:
@example
\score @{
- <
+ <<
\context ChordNames \chords @{ @emph{chords} @}
\addlyrics
\notes @emph{the melody}
\context Lyrics \lyrics @{ @emph{the text} @}
- >
+ >>
\paper @{ @}
@}
@end example
@lilypond[]
\score {
- <
+ <<
\context ChordNames \chords { r8 c2:sus4 f }
\addlyrics
\notes \relative c' {
c8
\times 2/3 { f g g } \times 2/3 { g4( a2) } }
\context Lyrics \lyrics { I want to break free __ }
- >
+ >>
\paper{ raggedright = ##t }
}
@end lilypond
@cindex bibliographic information
@cindex titles
@cindex composer
-
+@cindex Engraved by LilyPond
When the file is processed by @code{lilypond}, the title and composer
specified are printed above the music. The `tagline' is a short line
voices with @code{\\}:
@example
- < @{ a4 g2 f4-~ f4 @} \\
- @{ r4 g4 f2 f4 @} >
+ << @{ a4 g2 f4-~ f4 @} \\
+ @{ r4 g4 f2 f4 @} >>
@end example
@lilypond[relative 1]
-\context Staff < { a4 g2 f4-~ f4 } \\
- { r4 g4 f2 f4 } >
+\context Staff << { a4 g2 f4-~ f4 } \\
+ { r4 g4 f2 f4 } >>
@end lilypond
For polyphonic music typesetting, spacer rests can also be convenient: these
are rests that do not print. It is useful for filling up voices that
temporarily do not play:
@example
- < @{ a4 g2 f4-~ f4 @} \\
- @{ s4 g4 f2 f4 @} >
+ << @{ a4 g2 f4-~ f4 @} \\
+ @{ s4 g4 f2 f4 @} >>
@end example
@lilypond[relative 1]
-\context Staff < { a4 g2 f4-~ f4 } \\
- { s4 g4 f2 f4 } >
+\context Staff << { a4 g2 f4-~ f4 } \\
+ { s4 g4 f2 f4 } >>
@end lilypond
Again, these expressions can be nested arbitrarily:
@lilypond[fragment]
-<
+<<
\new Staff
\relative c''
- < { a4 g2 f4-~ f4 } \\
- { s4 g4 f2 f4 } >
+ << { a4 g2 f4-~ f4 } \\
+ { s4 g4 f2 f4 } >>
\new Staff
- < { \clef bass <<c g>>1 } \\
+ << { \clef bass <c g>1 } \\
{ f4 d e2 }
- >
->
+ >>
+>>
@end lilypond
Printing such a staff is done similar to the polyphonic example in
@ref{Combining music into compound expressions}:
@example
- < \new Staff @{ @dots{} @}
+ << \new Staff @{ @dots{} @}
\new Staff @{ @dots{} @}
- >
+ >>
@end example
but now this entire expression must be interpreted as a
@code{PianoStaff}:
@example
- \context PianoStaff < \context Staff @dots{} >
+ \context PianoStaff << \context Staff @dots{} >>
@end example
Here is a full-fledged example:
@lilypond[relative 0,fragment]
\context PianoStaff
- < \new Staff { \time 2/4
+ << \new Staff { \time 2/4
c4 c g' g }
\new Staff {
\clef bass c,, c' e c }
- >
+ >>
@end lilypond
More information on formatting piano music is in @ref{Piano music}.
in that voice, the tie appears to cross voices:
@lilypond[fragment,relative 1,verbatim]
-\context Staff < {
+\context Staff << {
\once \property Voice.Stem \set #'transparent = ##t
b8~ b8
} \\ {
b[ g8]
- } >
+ } >>
@end lilypond
@item
README_FILES = ChangeLog COPYING DEDICATION ROADMAP THANKS
README_TXT_FILES = AUTHORS.txt README.txt INSTALL.txt NEWS.txt
IN_FILES := $(wildcard *.in)
-EXTRA_DIST_FILES = $(wildcard *.el) lilypond.vim vimrc VERSION $(README_FILES) $(SCRIPTS) $(IN_FILES) emacsclient.patch server.el.patch darwin.patch .cvsignore lexer-gcc-3.1.sh
+EXTRA_DIST_FILES = $(wildcard *.el) lilypond.vim vimrc $(README_FILES) $(SCRIPTS) $(IN_FILES) emacsclient.patch server.el.patch darwin.patch .cvsignore lexer-gcc-3.1.sh
NON_ESSENTIAL_DIST_FILES = $(README_TXT_FILES)
INSTALLATION_DIR=$(local_lilypond_datadir)
INSTALLATION_FILES=$(config_make) VERSION
+++ /dev/null
-PACKAGE_NAME=LilyPond
-MAJOR_VERSION=1
-MINOR_VERSION=9
-PATCH_LEVEL=5
-MY_PATCH_LEVEL=
-
-# Use the above to send patches: MY_PATCH_LEVEL is always empty for a
-# released version.
-#
-# Please don't move these comments up; the patch should fail if
-# the previous version was wrong.
MISSING_OPTIONAL = @OPTIONAL@
MISSING_REQUIRED = @REQUIRED@
+PACKAGE_NAME = @PACKAGE_NAME@
+MAJOR_VERSION = @MAJOR_VERSION@
+MINOR_VERSION = @MINOR_VERSION@
+PATCH_LEVEL = @PATCH_LEVEL@
+MY_PATCH_LEVEL = @MY_PATCH_LEVEL@
+
# @configure_input@
package-depth = @package_depth@
AC_CONFIG_AUX_DIR([stepmake/bin])
# For stepmake package:
# AC_CONFIG_AUX_DIR(bin)
+
+
+export PACKAGE_NAME=LilyPond
+export MAJOR_VERSION=1
+export MINOR_VERSION=9
+export PATCH_LEVEL=5
+export MY_PATCH_LEVEL=
+
+
STEPMAKE_INIT
+AC_SUBST(PACKAGE_NAME)
+AC_SUBST(MAJOR_VERSION)
+AC_SUBST(MINOR_VERSION)
+AC_SUBST(PATCH_LEVEL)
+AC_SUBST(MY_PATCH_LEVEL)
+
+
# List a file that identifies your package.
AC_CONFIG_SRCDIR([lily/main.cc])
# Move to aclocal.m4?
AC_CONFIG_HEADER([$CONFIGFILE.h:config.hh.in])
-# For all packages except the StepMake package itself
-AC_CONFIG_SUBDIRS(stepmake)
-
# Uncomment the configuration options your package needs.
# must come before any header checks
ignatzekExceptions)
theMusic = \chords {
- c:7sus4 c:dim7
+ c:7sus4 c:dim7/+f
\property Current.chordNameExceptions = #chExceptions
- c:7sus4 c:dim7 }
+ c:7sus4 c:dim7/+f }
\score {
\score{
<<
- \context ChordNames {
+ \new ChordNames {
\property ChordNames.instrument = #"Ignatzek (default)"
\property ChordNames.instr = #"Def"
\chs }
\chs
}
%}
- \context Staff \notes \transpose c c' { \chs }
+ \new Staff \notes \transpose c c' { \chs }
>>
\paper{
indent = 3.\cm
Spanner*
Hara_kiri_engraver::get_spanner () const
{
- Spanner * sp = new Spanner (get_property ("HaraKiriVerticalGroup"));
-
+ Spanner * sp = new Spanner (get_property ("RemoveEmptyVerticalGroup"));
+
return sp;
}
}
}
+
Hara_kiri_engraver::Hara_kiri_engraver()
{
}
ENTER_DESCRIPTION(Hara_kiri_engraver,
/* descr */ "Like Axis_group_engraver, but make a hara kiri spanner, and add "
"interesting items (ie. note heads, lyric syllables and normal rests) ",
-/* creats*/ "HaraKiriVerticalGroup",
+/* creats*/ "RemoveEmptyVerticalGroup",
/* accepts */ "",
/* acks */ "grob-interface",
/* reads */ "",
chord_name_ = new Item (get_property ("ChordName"));
chord_name_->set_grob_property("text", markup);
- announce_grob(chord_name_, SCM_EOL);
+ announce_grob(chord_name_, notes_[0]->self_scm ());
SCM s = get_property ("chordChanges");
if (to_boolean (s) && gh_pair_p (last_chord_)
&& gh_equal_p (chord_as_scm, last_chord_))
{
if (event_)
{
- last_line_ = line_;
-
line_ = new Spanner (get_property ("Glissando"));
announce_grob (line_, event_->self_scm ());
}
typeset_grob (last_line_);
last_line_ =0;
}
-
- last_line_ = line_;
+ if (line_)
+ {
+ if ( last_line_)
+ programming_error ("Overwriting glissando.");
+ last_line_ = line_;
+ }
line_ = 0;
event_ = 0;
}
endh = height;
}
+ /*
+ TODO: set line style.
+ */
Molecule mol = Lookup::line (thick,
Offset (0, starth),
Offset (width, endh));
void
Hara_kiri_group_spanner::consider_suicide (Grob*me)
{
+ Spanner*sp = dynamic_cast<Spanner*> (me);
SCM worth = me->get_grob_property ("items-worth-living");
if (gh_pair_p (worth))
return ;
+ if (!to_boolean (me->get_grob_property ("remove-first"))
+ && broken_spanner_index (sp) == 0)
+ {
+ return ;
+ }
+
Link_array<Grob> childs = Axis_group_interface::get_children (me);
for (int i = 0; i < childs.size (); i++)
childs[i]->suicide ();
we don't contain any interesting items after linebreaking, then \
gracefully commit suicide. Objective: don't disgrace Lily by \
typesetting empty lines in orchestral scores.", \
- "items-worth-living");
+ "items-worth-living remove-first");
ChordNamesContext = \translator {
\type "Engraver_group_engraver"
\name ChordNames
-\description " Typesets chord names."
+ \description "Typesets chord names."
\consists "Rest_swallow_translator"
\consists "Output_property_engraver"
\consists "Chord_name_engraver"
\consists "Skip_event_swallow_translator"
\consistsend "Hara_kiri_engraver"
+
minimumVerticalExtent = #'(0 . 2.5)
extraVerticalExtent = ##f
verticalExtent = ##f
# make/Stepmake.make
include $(depth)/make/toplevel-version.make
-
# Use alternate configurations alongside eachother:
#
# ./configure --enable-config=debug
# Toplevel_version.make
-include $(depth)/VERSION
-TOPLEVEL_MAJOR_VERSION:=$(MAJOR_VERSION)
-TOPLEVEL_MINOR_VERSION:=$(MINOR_VERSION)
-TOPLEVEL_PATCH_LEVEL:=$(PATCH_LEVEL)
+TOPLEVEL_MAJOR_VERSION=$(MAJOR_VERSION)
+TOPLEVEL_MINOR_VERSION=$(MINOR_VERSION)
+TOPLEVEL_PATCH_LEVEL=$(PATCH_LEVEL)
# use to send patches, always empty for released version:
-TOPLEVEL_MY_PATCH_LEVEL:=$(MY_PATCH_LEVEL)
+TOPLEVEL_MY_PATCH_LEVEL=$(MY_PATCH_LEVEL)
;;;
-;;; chord-name.scm -- chord name utility functions
+;;; chord-ignatzek-names.scm -- chord name utility functions
;;;
;;; source file of the GNU LilyPond music typesetter
;;;
;;; (c) 2000--2003 Han-Wen Nienhuys <hanwen@cs.uu.nl>
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;
alterations
suffixes
add-markups) sep))
- (base-stuff (if bass-pitch
+ (base-stuff (if (ly:pitch? bass-pitch)
(list sep (name-note bass-pitch))
'()))
)
(markup-join prefixes sep)
(make-super-markup to-be-raised-stuff))
base-stuff))
- (make-line-markup base-stuff)
+ (make-line-markup base-stuff)
))
+ (define (ignatzek-format-exception
+ root
+ exception-markup
+ bass-pitch)
+
+ (make-line-markup
+ `(
+ ,(name-root root)
+ ,exception-markup
+ .
+ ,(if (ly:pitch? bass-pitch)
+ (list (ly:get-context-property context 'chordNameSeparator)
+ (name-note bass-pitch))
+ '()))))
+
(let*
(
(root (car in-pitches))
(suffixes '())
(add-steps '())
(main-name #f)
- (bass-note #f)
+ (bass-note
+ (if (ly:pitch? inversion)
+ inversion
+ bass))
(alterations '())
)
-
- (if
- exception
- (make-line-markup
- (list (name-root root) exception))
+
+ (if exception
+ (ignatzek-format-exception root exception bass-note)
(begin ; no exception.
(set! alterations (delq main-name alterations))
(set! add-steps (delq main-name add-steps))
- (if (ly:pitch? inversion)
- (set! bass-note inversion)
- )
-
- (if (ly:pitch? bass)
- (set! bass-note bass)
- )
;; chords with natural (5 7 9 11 13) or leading subsequence.
;; etc. are named by the top pitch, without any further
(set! main-name (last alterations))
(set! alterations '())
))
-
+
(ignatzek-format-chord-name root prefixes main-name alterations add-steps suffixes bass-note)
- )
- ))))
+ )))
+ ))
+
(grob-property-description 'layer number? "The output layer [0..2]. The default is 1.")
(grob-property-description 'left-position number? "position of left part of spanner.")
-(grob-property-description 'right-position number? "position of right part of spanner.")
(grob-property-description 'left-padding ly:dimension? "space left of accs.")
(grob-property-description 'length ly:dimension? "Stem length for unbeamed stems, only for user override.")
(grob-property-description 'positions pair? "cons of staff positions (LEFT . RIGHT")
(grob-property-description 'prefix-set number? "DOCME")
(grob-property-description 'ratio number? "Slur parameter. See height-limit.")
+(grob-property-description 'remove-first boolean?
+ "Remove the first staff of a orchestral score?")
(grob-property-description 'right-padding ly:dimension? "space right of accs.")
+(grob-property-description 'right-position number? "position of right part of spanner.")
(grob-property-description 'right-trim-amount ly:dimension? "shortening of the lyric extender on the right.")
(grob-property-description 'script-priority number? "A sorting key that determines in what order a script is within a stack of scripts.")
(grob-property-description 'self-alignment-X number-or-grob? "real number: -1 =
))
- (HaraKiriVerticalGroup
+ (RemoveEmptyVerticalGroup
. (
(Y-offset-callbacks . (,Hara_kiri_group_spanner::force_hara_kiri_callback))
(Y-extent-callback . ,Hara_kiri_group_spanner::y_extent)
+ (remove-first . #t)
(axes . (1))
(meta . ((interfaces . (axis-group-interface hara-kiri-group-interface item-interface spanner-interface))))
))
def dump_lyrics (outf):
if (len(lyrics)):
- outf.write("\n\\score\n{\n \\context Lyrics\n <\n")
+ outf.write("\n\\score\n{\n \\context Lyrics\n <<\n")
for i in range (len (lyrics)):
outf.write ( lyrics [i])
outf.write ("\n")
- outf.write(" >\n \\paper{}\n}\n")
+ outf.write(" >>\n \\paper{}\n}\n")
def dump_default_bar (outf):
"""
def dump_score (outf):
outf.write (r"""\score{
- \notes <
+ \notes <<
""")
ks = voice_idx_dict.keys ();
outf.write ("\t \\voice%s " % m)
outf.write ("\n\t}\n")
if len ( slyrics [voice_idx_dict[k]] ):
- outf.write ("\n\t\\context Lyrics=\"%s\" \n\t<\t" % k)
+ outf.write ("\n\t\\context Lyrics=\"%s\" \n\t<<\t" % k)
if re.match('[1-9]',k):
m = alphabet[string.atoi(k)]
else:
for i in range (len(slyrics[voice_idx_dict[k]])):
l=alphabet[i]
outf.write("\n\t { \\words%sV%s }" % ( m, l) )
- outf.write ( "\n\t>\n" )
- outf.write ("\n >")
+ outf.write ( "\n\t>>\n" )
+ outf.write ("\n >>")
outf.write ("\n\t\\paper {\n")
if part_names:
outf.write ("\t \\translator \n\t {\n")
conversions.append (((1,9,4), conv, 'Swap < > and << >>'))
+def conv (str):
+ str = re.sub ('HaraKiriVerticalGroup', 'RemoveEmptyVerticalGroup', str)
+
+ return str
+
+conversions.append (((1,9,5), conv, 'HaraKiriVerticalGroup -> RemoveEmptyVerticalGroup'))
+
################################
# END OF CONVERSIONS
################################
stafdef = stafdef + ' \\' + i
- str = str + '%s = \\context Staff = %s <\n %s\n >\n' % \
+ str = str + '%s = \\context Staff = %s <<\n %s\n >>\n' % \
(self.staffid (), self.staffid (), stafdef)
return str
if not self.pitches:
s = 'r'
if len (self.pitches) > 1:
- s = '<< %s >>' % s
+ s = '<%s>' % s
s = s + '%d%s' % (self.duration[0], '.'* self.duration[1])
s = self.note_prefix + s + self.note_suffix
s = s + dump (notes[0])
elif len (notes) > 1:
global reference_note
- s = s + '<<'
+ s = s + '<'
s = s + notes[0].dump (dump_dur = 0)
r = reference_note
for i in notes[1:]:
s = s + i.dump (dump_dur = 0 )
- s = s + '>>'
+ s = s + '>'
s = s + notes[0].duration.dump()
reference_note = r
s = s + ' ' + dump_channel (channels[i][0], skip)
s = s + '}\n\n'
- s = s + '%s = <\n' % track
+ s = s + '%s = <<\n' % track
if clef.type != 2:
s = s + clef.dump () + '\n'
else:
s = s + ' \\context Voice = %s \\%s\n' % (channel,
track + channel)
- s = s + '>\n\n'
+ s = s + '>>\n\n'
return s
def thread_first_item (thread):
for i in range (len (tracks)):
s = s + dump_track (tracks[i], i)
- s = s + '\n\\score {\n <\n'
+ s = s + '\n\\score {\n <<\n'
for i in range (len (tracks)):
track = track_name (i)
item = track_first_item (tracks[i])
s = s + ' \\context Staff=%s \\%s\n' % (track, track)
elif item and item.__class__ == Text:
s = s + ' \\context Lyrics=%s \\%s\n' % (track, track)
- s = s + ' >\n}\n'
+ s = s + ' >>\n}\n'
progress (_ ("%s output to `%s'...") % ('LY', o))
str = str + v.dump()
refs = refs + '\n \\' + v.idstring ()
str = str + '''
-%s = \context Staff = %s <%s
->
+%s = \context Staff = %s <<%s
+>>
''' % (self.idstring (), self.idstring (), refs)
return str
str = self.note_prefix +str + self.note_suffix
if len (self.pitches) > 1:
- str = '<<%s>>' % str
+ str = '<%s>' % str
elif self.multimeasure:
str = 'R'
elif len (self.pitches) == 0:
str = str + '''
\score {
- <%s
- >
+ <<%s
+ >>
\paper {}
\midi {}
}
str = str + pitch_to_lily_string (p)
if len (self.pitches) > 1:
- str = '<<%s>>' % str
+ str = '<%s>' % str
elif len (self.pitches) == 0:
str = 'r'
- str = str + sd + '-(' * len (self.slurstart) + '-)' * len (self.slurstart)
+ str = str + sd + '(' * len (self.slurstart) + ')' * len (self.slurstart)
for s in self.scripts:
str = str + '-' + s
found_ids = found_ids + '\\%s\n' % id
-found_ids = '\n\n\n\\score { < %s > } ' % found_ids
+found_ids = '\n\n\n\\score { << %s >> } ' % found_ids
ly_head = ''
if ref_file:
e= self.end_chord
if e and s:
- s.note_suffix = s.note_suffix + '-('
- e.note_prefix = e.note_suffix + '-)'
+ s.note_suffix = s.note_suffix + '('
+ e.note_prefix = e.note_suffix + ')'
else:
sys.stderr.write ("\nOrphaned slur")
str = str + v.dump()
refs = refs + '\\' + v.idstring ()+ ' '
- str = str + '\n\n%s = \\context Staff = %s \n < \n %s >\n\n\n'% (self.idstring (), self.idstring (), refs)
+ str = str + '\n\n%s = \\context Staff = %s \n << \n %s >>\n\n\n'% (self.idstring (), self.idstring (), refs)
return str
class Tuplet:
str = str + pitch_to_lily_string (p)
if len (self.pitches) > 1:
- str = '<<%s>>' % str
+ str = '<%s>' % str
elif len (self.pitches) == 0:
str = 'r'
str = str + s.dump ()
refs = '\\' + s.idstring() + refs
- str = str + "\n\n\\score { <\n %s\n > }" % refs
+ str = str + "\n\n\\score { <<\n %s\n >> }" % refs
return str
--- /dev/null
+# -*-Makefile-*-
+# title specific top level makefile for StepMake
+
+# subdir level:
+#
+depth = ..
+
+# descent order into subdirectories:
+#
+SUBDIRS = bin stepmake
+
+# list of distribution files:
+#
+SCRIPTS = aclocal.m4
+README_FILES = CHANGES README TODO
+README_TXT_FILES =
+EXTRA_DIST_FILES = $(README_FILES) $(SCRIPTS)
+NON_ESSENTIAL_DIST_FILES = $(README_TXT_FILES)
+#
+
+# bootstrap stepmake:
+#
+STEPMAKE_TEMPLATES= texinfo
+include $(depth)/make/stepmake.make
+
+# don't install stepmake
+install: local-install
+ @echo Not installing stepmake
+
+bla:
+ echo $(TOPLEVEL_MAJOR_VERSION)
+
+localclean:
+ rm -f bin/*.pyc
+++ /dev/null
-# -*-Makefile-*-
-# title specific top level makefile for StepMake
-
-# subdir level:
-#
-depth = .
-#
-
-# descent order into subdirectories:
-#
-ifeq ($(PACKAGE),STEPMAKE)
-SUBDIRS = bin make stepmake
-else
-SUBDIRS = stepmake
-endif
-#
-
-# list of distribution files:
-#
-SCRIPTS = configure aclocal.m4 autogen.sh
-README_FILES = CHANGES README TODO
-README_TXT_FILES =
-EXTRA_DIST_FILES = $(IN_FILES) VERSION $(README_FILES) $(SCRIPTS) INSTALL.texi
-NON_ESSENTIAL_DIST_FILES = $(README_TXT_FILES)
-#
-
-# bootstrap stepmake:
-#
-STEPMAKE_TEMPLATES=toplevel texinfo
-include $(depth)/make/stepmake.make
-#
-
-# 2nd: THIS IS NO MISTAKE
-# this makes lilypond's make dist descent into stepmake
-# should check if we can remove the above
-# descent order into subdirectories:
-#
-ifeq ($(PACKAGE),STEPMAKE)
-SUBDIRS = bin make stepmake
-else
-SUBDIRS = stepmake
-# don't install stepmake
-install: local-install
- @echo Not installing stepmake
-endif
-#
-
-#urg urg
-stepmake/aclocal.m4:
- -$(LN) aclocal.m4 $@
-
-ifeq ($(PACKAGE),STEPMAKE)
-INSTALLATION_DIR=$(package_datadir)
-INSTALLATION_FILES=$(DIST_FILES) $(NON_ESSENTIAL_DIST_FILES) GNUmakefile config.make config.status
-include $(stepdir)/install-targets.make
-endif
-
-localclean:
- rm -f bin/*.pyc
- rm -f stepmake/stepmake stepmake/bin stepmake/aclocal.m4
+++ /dev/null
-PACKAGE_NAME=StepMake
-MAJOR_VERSION=0
-MINOR_VERSION=1
-PATCH_LEVEL=81
-MY_PATCH_LEVEL=
-
-# use the above to send patches, always empty for released version:
-# please don't move these comments up; the patch should fail if
-# the previous version was wrong.
AC_DEFUN(STEPMAKE_INIT, [
AC_PREREQ(2.50)
- . $srcdir/VERSION
FULL_VERSION=$MAJOR_VERSION.$MINOR_VERSION.$PATCH_LEVEL
if test x$MY_PATCH_LEVEL != x; then
FULL_VERSION=$FULL_VERSION.$MY_PATCH_LEVEL
# bin/Makefile
-depth = ..
+depth = ../..
EXTRA_DIST_FILES = install-sh config.sub config.guess
STEPMAKE_TEMPLATES=script install
import re
import sys
+import getopt
vf = 'VERSION'
ls = f.readlines ()
mypatch = 0
defs = []
-for l in ls:
- l = re.sub ('#.*','', l)
- m = re.search ('([^ =]*)[\t ]*=[ \t]*([^ \t]*)[ \t]*\n', l)
+for a in sys.argv[1:]
+ m = re.search ('([^ =]*)=([^ \t]*)[ \t]*\n', a)
if m:
defs.append ((m.group(1), m.group(2)))
+++ /dev/null
-# -*-Makefile-*-
-
-# @configure_input@
-
-package-depth = @package_depth@
-
-USER_CFLAGS = @CFLAGS@
-USER_CXXFLAGS = @CXXFLAGS@ @CPPFLAGS@
-USER_LDFLAGS =
-
-CC = @CC@
-CXX = @CXX@
-GCC = @GCC@
-LD = @LD@
-PACKAGE = @PACKAGE@
-package = @package@
-PACKAGE_NAME = @PACKAGE_NAME@
-stepmake = @stepmake@
-state-vector = @STATE_VECTOR@
-CONFIGSUFFIX = @CONFIGSUFFIX@
-MAKEINFO_PROGRAM = @MAKEINFO@
-ICFLAGS = @ICFLAGS@
-ILDFLAGS = @ILDFLAGS@
-builddir = @ugh_ugh_autoconf250_builddir@
-libdir = @libdir@
-prefix = @prefix@
-srcdir = @srcdir@
-TEXPREFIX = @TEXPREFIX@
-TEXDIR = @TEXDIR@
-MFDIR = @MFDIR@
-mandir = @mandir@
-infodir = @infodir@
-exec_prefix = @exec_prefix@
-bindir = @bindir@
-includedir = @includedir@
-datadir = @datadir@
-localedir = @localedir@
-EXTRA_LIBES = @EXTRA_LIBES@ @LIBS@
-RANLIB = @RANLIB@
-DEFS = @DEFS@
-#SET_MAKE = @SET_MAKE@
-DEFINES = @DEFS@ @DEFINES@
-COMPILEINFO = @COMPILEINFO@
-DOTEXE = @DOTEXE@
-INSTALL = @INSTALL@
-BASH = @BASH@
-BISON = @BISON@
-FIND = @FIND@
-FLEX = @FLEX@
-INIMETAFONT = @INIMETAFONT@
-INIMETAPOST = @INIMETAPOST@
-LN = @LN@
-LN_S = @LN_S@
-METAFONT = @METAFONT@
-METAPOST = @METAPOST@
-MSGFMT = @MSGFMT@
-PATHSEP = @PATHSEP@
-PERL = @PERL@
-PYTHON = @PYTHON@
-SHELL = @SHELL@
-STRIPROFF = @STRIPROFF@
-TAR= @TAR@
-TBL = @TBL@
-TROFF = @TROFF@
-YODL= @YODL@
-YODL2HTML= @YODL2HTML@
-YODL2LATEX= @YODL2LATEX@
-YODL2LESS_DIR= @YODL2LESS_DIR@
-YODL2MAN= @YODL2MAN@
-YODL2MSLESS= @YODL2MSLESS@
-YODL2TEXINFO= @YODL2TEXINFO@
-YODL2TXT= @YODL2TXT@
-ZIP = @ZIP@
-
+++ /dev/null
-# file make/Makefile
-
-depth = ..
-STEPMAKE_TEMPLATES=makedir install
-BLURBS=BLURB # COPERTINA FLAPTEKST
-
-ifneq ($(strip $(state-vector)),)
-EXTRA_DIST_FILES = STATE-VECTOR
-endif
-
-include $(depth)/make/stepmake.make
-
-INSTALLATION_DIR=$(datadir)/make
-INSTALLATION_FILES=$(DIST_FILES)
+++ /dev/null
-# title package specific rules
-
-#UGH
-
-include $(depth)/make/substitute.make
-
-$(outdir)/%: %.in
- rm -f $@
- cat $< | sed $(sed-atfiles) $(sed-atvariables) > $@
-
-
+++ /dev/null
-# title package specific targets
-
-.PHONY : check-dist-deps check-make-deps check-rpm-doc-deps check-html-deps check-web-doc check-rpm-icons
-
-#check-html-deps:
-# $(MAKE) -C $(depth)/Documentation html
-
-#check-web-doc:
-# $(MAKE) CONFIGSUFFIX='www' -C Documentation outdirs
-# $(MAKE) CONFIGSUFFIX='www' -C Documentation WWW
-
-# check-rpm-doc-deps:
-# $(MAKE) -C $(depth)/Documentation gifs
-
-#check-rpm-icons:
-
-#check-make-deps:
-# $(MAKE) -C $(depth)/make
-
+++ /dev/null
-# title package specific variables
-#
-# do not change this file for site-wide extensions; please use
-# make/$(outdir)/Site.make;
-#
-# Any change in files in this directory (make/) would be distributed, if
-# you do make dist
-#
-
-# dummydeps
-#
-DUMMYDEPS=\
-
-#
-
-STEPMAKE_INCLUDES =
-STEPMAKE_LDFLAGS =
-STEPMAKE_LIBES =
-
+++ /dev/null
-# -*-Makefile-*-
-# specific srcdir makefile for StepMake
-
-depth=..
-
-# Don't try to outsmart us, you puny computer!
-ifeq (0,${MAKELEVEL})
- MAKE:=$(MAKE) --no-builtin-rules
-endif
-
-# Use alternate configurations alongside eachother:
-#
-# ./configure --enable-configsuffix=debug
-# make conf=debug
-#
-# uses config-debug.make and config-debug.h; output goes to out-debug.
-#
-ifdef conf
- CONFIGSUFFIX=-$(conf)
-endif
-
-# Use same configuration, but different output directory:
-#
-# make out=WWW
-#
-# uses config.make and config.h; output goes to out-WWW.
-#
-ifdef out
- outbase=out-$(out)
-else
- outbase=out$(CONFIGSUFFIX)
-endif
-
-config = config$(CONFIGSUFFIX).make
-
-include $(config)
-
-SRCDIR=$(MAKE) -C $(srcdir) -f GNUmakefile.in builddir=$(builddir) $@
-
-default: all
-
-%:
- $(SRCDIR)
+++ /dev/null
-Begin3
-Title: StepMake
-Version: @TOPLEVEL_VERSION@
-Entered-date: @DATE@
-Description: @BLURB@
-Keywords: music notation typesetting midi fonts engraving
-Author: janneke@gnu.org (Jan Nieuwenhuizen)
- hanwen@cs.ruu.nl (Han-Wen Nienhuys)
-Maintained-by: janneke@gnu.org (Jan Nieuwenhuizen)
-Primary-site: sunsite.unc.edu /pub/Linux/apps/sound/convert
- 40k @package@-@TOPLEVEL_VERSION@.tar.gz
-Original-site: pcnov095.win.tue.nl /pub/lilypond/development/
- 40k @package@-@TOPLEVEL_VERSION@.tar.gz
-Copying-policy: GPL
-End
+++ /dev/null
-# make/Stepmake.make
-
-include $(depth)/make/toplevel-version.make
-
-# Use alternate configurations alongside eachother:
-#
-# ./configure --enable-config=debug
-# make conf=debug
-#
-# uses config-debug.make and config-debug.h; output goes to out-debug.
-#
-ifdef conf
- CONFIGSUFFIX=-$(conf)
-endif
-
-# Use same configuration, but different output directory:
-#
-# make out=www
-#
-# uses config.make and config.h; output goes to out-www.
-#
-ifdef out
- outbase=out-$(out)
-else
- outbase=out$(CONFIGSUFFIX)
-endif
-
-ifdef config
- config_make=$(config)
-else
- ifeq ($(builddir),)
- config_make=$(depth)/config$(CONFIGSUFFIX).make
- else
- config_make=$(builddir)/config$(CONFIGSUFFIX).make
- endif
-endif
-
-ifeq ($(builddir),)
- outroot=.
-else
- outroot=$(builddir)/$(patsubst $(shell cd $(depth); pwd)%,%,$(pwd))
-endif
-
-include $(config_make)
-
-outdir=$(outroot)/$(outbase)
-config_h=$(builddir)/config$(CONFIGSUFFIX).h
-
-# The outdir that was configured for: best guess to find binaries
-outconfbase=out$(CONFIGSUFFIX)
-outconfdir=$(outroot)/$(outconfbase)
-
-# user package
-# stepdir = $(stepmake)/stepmake
-# for stepmake package
-stepdir = $(depth)/stepmake
-
-STEPMAKE_TEMPLATES := generic $(STEPMAKE_TEMPLATES)
-LOCALSTEPMAKE_TEMPLATES:= generic $(LOCALSTEPMAKE_TEMPLATES)
-
-
-# Don't try to outsmart us, you puny computer!
-# Well, UGH. This only removes builtin rules from
-# subsequent $(MAKE)s, *not* from the current run!
-ifeq ($(BUILTINS_REMOVED),)
- export BUILTINS_REMOVED = yes
- MAKE:=$(MAKE) --no-builtin-rules
- include $(stepdir)/no-builtin-rules.make
-endif
-.SUFFIXES:
-
-all:
-
--include $(addprefix $(depth)/make/,$(addsuffix -inclusions.make, $(LOCALSTEPMAKE_TEMPLATES)))
-
--include $(addprefix $(stepdir)/,$(addsuffix -inclusions.make, $(STEPMAKE_TEMPLATES)))
-
-
-include $(addprefix $(stepdir)/,$(addsuffix -vars.make, $(STEPMAKE_TEMPLATES)))
-
-# ugh. need to do this because of PATH :=$(topdir)/..:$(PATH)
-include $(addprefix $(depth)/make/,$(addsuffix -vars.make, $(LOCALSTEPMAKE_TEMPLATES)))
-
-
-include $(addprefix $(depth)/make/,$(addsuffix -rules.make, $(LOCALSTEPMAKE_TEMPLATES)))
-include $(addprefix $(stepdir)/,$(addsuffix -rules.make, $(STEPMAKE_TEMPLATES)))
-include $(addprefix $(depth)/make/,$(addsuffix -targets.make, $(LOCALSTEPMAKE_TEMPLATES)))
-include $(addprefix $(stepdir)/,$(addsuffix -targets.make, $(STEPMAKE_TEMPLATES)))
-
-
+++ /dev/null
-Name: @package@
-Version: @TOPLEVEL_VERSION@
-Release: 1
-Copyright: GPL
-Group: Development
-Source0: pcnov095.win.tue.nl:/pub/lilypond/development/@package@-@TOPLEVEL_VERSION@.tar.gz
-Summary: generic make package
-Packager: janneke@gnu.org (Jan Nieuwenhuizen)
-Buildroot: /tmp/stepmake-install
-
-%description
-@BLURB@
-
-%prep
-%setup
-%build
-./configure --prefix=/usr
-make all
-%install
-rm -rf $RPM_BUILD_ROOT
-make prefix="$RPM_BUILD_ROOT/usr" install
-%files
-# urg
-/usr/bin/make-patch
-%post
-
+++ /dev/null
-# Substitute.make
-
-include $(stepdir)/substitute-vars.make
-ATVARIABLES = \
- BASH\
- DATE\
- date\
- DIR_DATADIR\
- PACKAGE\
- package\
- PERL\
- PYTHON\
- SHELL\
- TOPLEVEL_VERSION\
- step-bindir\
- abs-step-bindir\
-
-
+++ /dev/null
-
-include $(depth)/VERSION
-TOPLEVEL_MAJOR_VERSION:=$(MAJOR_VERSION)
-TOPLEVEL_MINOR_VERSION:=$(MINOR_VERSION)
-TOPLEVEL_PATCH_LEVEL:=$(PATCH_LEVEL)
-# use to send patches, always empty for released version:
-TOPLEVEL_MY_PATCH_LEVEL:=$(MY_PATCH_LEVEL)
+++ /dev/null
-# title user changeable settings
-# file make/User.make
-
-# will be split into CFLAGS/EXTRA_CFLAGS etc,
-# so that defineable generically and per module
-
-#
-# -lefence = ElectricFence.
-#
-# ElectricFence is a memory debugger which uses the
-# VM hardware to trap malloc/free errors.
-#
-
-EXTRALIB+= #-lefence
-
# subdir level:
#
-depth = ..
+depth = ../..
#
# descent order into subdirectories:
$(LOOP)
-# ugh . -> $(outdir)
-$(outdir)/VERSION: $(depth)/VERSION
- cp -p $< $@
-
-$(outdir)/version.hh: $(outdir)/VERSION
- $(PYTHON) $(step-bindir)/make-version.py $< > $@
+$(outdir)/version.hh: $(config_make)
+ $(PYTHON) $(step-bindir)/make-version.py PACKAGE_NAME=$(PACKAGE_NAME) \
+ MAJOR_VERSION=$(MAJOR_VERSION) \
+ MINOR_VERSION=$(MINOR_VERSION) \
+ MY_PATCH_LEVEL=$(MY_PATCH_LEVEL) \
+ PATCH_LEVEL=$(PATCH_LEVEL) \
+ > $@
$(outdir)/config.h: $(config_h)
cp -p $< $@
spec: $(OUTSPEC_FILES)
-$(OUTSPEC_FILES): $(depth)/VERSION
-$(OUTLSM_FILES): $(depth)/VERSION
do_pod2html=$($(POD2HTML_VERSION))
-$(outdir)/%.html: $(outdir)/%.pod $(depth)/VERSION
+$(outdir)/%.html: $(outdir)/%.pod
$(do_pod2html)
$(outdir)/%.pod: %.pod
-$(outdir)/%: %.pl $(config_make) $(depth)/VERSION
+$(outdir)/%: %.pl $(config_make)
cat $< | sed $(sed-atvariables) > $@
chmod 755 $@
-$(outdir)/%: %.bash $(config_make) $(depth)/VERSION
+$(outdir)/%: %.bash $(config_make)
cat $< | sed $(sed-atvariables) > $@
chmod 755 $@
-$(outdir)/%: %.scm $(config_make) $(depth)/VERSION
+$(outdir)/%: %.scm $(config_make)
cat $< | sed $(sed-atvariables) > $@
chmod 755 $@
-$(outdir)/%: %.expect $(config_make) $(depth)/VERSION
+$(outdir)/%: %.expect $(config_make)
cat $< | sed $(sed-atvariables) > $@
chmod 755 $@
-$(outdir)/%: %.sh $(config_make) $(depth)/VERSION
+$(outdir)/%: %.sh $(config_make)
cat $< | sed $(sed-atvariables) > $@
chmod 755 $@
-$(outdir)/%: %.py $(config_make) $(depth)/VERSION
+$(outdir)/%: %.py $(config_make)
cat $< | sed $(sed-atvariables) > $@
chmod 755 $@
projects / lilypond.git / commitdiff