but more complex scores.
@menu
-* How LilyPond files work::
+* How LilyPond input files work::
* Voices contain music::
* Contexts and engravers::
* Extending the templates::
@end menu
-@node How LilyPond files work
-@section How LilyPond files work
+@node How LilyPond input files work
+@section How LilyPond input files work
The LilyPond input format is quite free-form, giving experienced
users a lot of flexibility to structure their files however they
@cindex Music expression, compound
We saw the general organization of LilyPond input files in the
-previous section, @ref{How LilyPond files work}. But we seemed to
+previous section, @ref{How LilyPond input files work}. But we seemed to
skip over the most important part: how do we figure out what to
write after @code{\score}?
known to LilyPond it will not cause any action to be taken.
This is one of the reasons why it is highly recommended to
use a context-sensitive editor with syntax highlighting for
-editing LilyPond files, such as Vim, Jedit, ConTEXT or Emacs,
+editing LilyPond input files, such as Vim, Jedit, ConTEXT or Emacs,
since unknown property names will be highlighted differently.
The @code{instrumentName} property will take effect only
if it is set in the @code{Staff} context, but
some properties can be set in more than one context.
For example, the property @code{extraNatural} is by
-default set to ##t (true) for all staves.
-If it is set to ##f (false) in one particular @code{Staff}
+default set to ##t (true) for all staves.
+If it is set to ##f (false) in one particular @code{Staff}
context it applies just to the accidentals on that staff.
If it is set to false in the @code{Score} context
it applies to all staves.
@menu
* Compiling a file::
* Simple notation::
-* Working on text files::
-* How to read the manual::
+* Working on input files::
+* How to read the manual::
@end menu
@node Compiling a file
@subsection Compiling a file
-@qq{Compiling} is the term used for processing an input text file
+@qq{Compiling} is the term used for processing an input file
in LilyPond format to produce a file which can be printed and
-(optionally) a MIDI file which can be played. The first example
-shows what a simple input text file looks like.
+(optionally) a MIDI file which can be played. LilyPond input
+files are simple text files. The first example
+shows what a simple input file looks like.
-To create sheet music, we write a text file that specifies the
+To create sheet music, we write an input file that specifies the
notation. For example, if we write:
@example
@ruser{Time signature}, @ruser{Clef}.
-@node Working on text files
-@subsection Working on text files
+@node Working on input files
+@subsection Working on input files
LilyPond input files are similar to source files in many common
programming languages. They are case sensitive, and white-space
@subsection How to read the manual
LilyPond input must be surrounded by @{ @} marks or a
-@code{\relative c'' @{ ... @}}, as we saw in @ref{Working on text
+@code{\relative c'' @{ ... @}}, as we saw in @ref{Working on input
files}. For the rest of this manual, most examples will omit
this. To replicate the examples, you may copy and paste the
displayed input but you @strong{must} add the @code{\relative c''
There are more tips for constructing input files in
-@ref{Suggestions for writing LilyPond files}. But it might be
+@ref{Suggestions for writing LilyPond input files}. But it might be
best to read through the rest of the tutorial first.
@menu
-* Suggestions for writing LilyPond files::
+* Suggestions for writing LilyPond input files::
* When things don't work::
* Scores and parts::
@end menu
-@node Suggestions for writing LilyPond files
-@section Suggestions for writing LilyPond files
+@node Suggestions for writing LilyPond input files
+@section Suggestions for writing LilyPond input files
-Now you're ready to begin writing larger LilyPond files -- not just the
-little examples in the tutorial, but whole pieces. But how should you
-go about doing it?
+Now you're ready to begin writing larger LilyPond input files --
+not just the little examples in the tutorial, but whole pieces.
+But how should you go about doing it?
-As long as LilyPond can understand your files and produces the output
-that you want, it doesn't matter what your files look like. However,
-there are a few other things to consider when writing LilyPond files.
+As long as LilyPond can understand your input files and produce
+the output that you want, it doesn't matter what your input files
+look like. However, there are a few other things to consider when
+writing LilyPond input files.
@itemize
@item What if you make a mistake? The structure of a LilyPond
file can make certain errors easier (or harder) to find.
-@item What if you want to share your files with somebody
-else? In fact, what if you want to alter your own files in
-a few years? Some LilyPond files are understandable at
-first glance; other files may leave you scratching your head
+@item What if you want to share your input files with somebody
+else? In fact, what if you want to alter your own input files in
+a few years? Some LilyPond input files are understandable at
+first glance; others may leave you scratching your head
for an hour.
@item What if you want to upgrade your LilyPond file for use
with a later version of LilyPond? The input syntax changes
occasionally as LilyPond improves. Most changes can be
done automatically with @code{convert-ly}, but some changes
-might require manual assistance. LilyPond files can be
+might require manual assistance. LilyPond input files can be
structured in order to be easier (or harder) to update.
@end itemize
either in the music
itself or in the output you desire, it's often good to write only one bar
per line. Saving screen space by cramming eight bars per line just isn't
-worth it if you have to @q{debug} your files.
+worth it if you have to @q{debug} your input files.
-@item @strong{Comment your files}. Use either bar numbers (every so often)
-or
+@item @strong{Comment your input files}. Use either bar numbers
+(every so often) or
references to musical themes (@q{second theme in violins,} @q{fourth
variation,} etc.). You may not need comments when you're writing the piece
for the first time, but if you want to go back to change something two or
@subsection Large projects
When working on a large project, having a clear structure to your
-lilypond files becomes vital.
+lilypond input files becomes vital.
@itemize
@end lilypond
Using variables is also a good way to reduce work if the
-LilyPond input syntax changes (see @ref{Updating old files}). If
+LilyPond input syntax changes (see @ref{Updating old input files}). If
you have a single definition (such as @code{\dolce}) for all your
-files (see @ref{Style sheets}), then if the syntax changes, you
+input files (see @ref{Style sheets}), then if the syntax changes, you
only need to update your single @code{\dolce} definition,
instead of making changes throughout every @code{.ly} file.
The output that LilyPond produces can be heavily modified; see
@ref{Tweaking output}, for details. But what if you have many
-files that you want to apply your tweaks to? Or what if you
+input files that you want to apply your tweaks to? Or what if you
simply want to separate your tweaks from the actual music? This
is quite easy to do.
definitions. They produce the output we desire, but we might want
to use them in another piece. We could simply copy-and-paste them
at the top of every file, but that's an annoyance. It also leaves
-those definitions in our music files, and I personally find all
+those definitions in our input files, and I personally find all
the @code{#()} somewhat ugly. Let's hide them in another file:
@example
@section When things don't work
@menu
-* Updating old files::
+* Updating old input files::
* Troubleshooting (taking it all apart)::
* Minimal examples::
@end menu
-@node Updating old files
-@subsection Updating old files
+@node Updating old input files
+@subsection Updating old input files
The LilyPond input syntax occasionally changes. As LilyPond itself
improves, the syntax (input language) is modified accordingly. Sometimes
@code{ë} must be entered directly into the LilyPond file as an
UTF-8 character. @code{convert-ly} cannot change all the LaTeX
special characters into UTF-8 characters; you must manually update
-your old LilyPond files.
+your old LilyPond input files.
@node Troubleshooting (taking it all apart)