Documentation/es/usage/suggestions.itely

   1 @c -*- coding: utf-8; mode: texinfo; documentlanguage: es -*-
   2
   3 @ignore
   4     Translation of GIT committish: d36171e34d236d890f5dc511b895037188c6c7cb
   5
   6     When revising a translation, copy the HEAD committish of the
   7     version that you are working on.  For details, see the Contributors'
   8     Guide, node Updating translation committishes..
   9 @end ignore
  10
  11 @c \version "2.19.21"
  12
  13 @node Sugerencias para escribir archivos de entrada
  14 @chapter Sugerencias para escribir archivos de entrada
  15 @translationof Suggestions for writing files
  16
  17 En este momento está preparado para comenzar a escribir archivos
  18 de LilyPond más grandes -- no sólo los pequeños ejemplos que
  19 aparecen en el tutorial, sino piezas completas --. Pero ¿cómo debe
  20 proceder para hacerlo?
  21
  22 En la medida en que LilyPond entienda sus archivos y produzca la
  23 salida que usted pretendía, realmente no importa mucho qué aspecto
  24 tengan sus archivos.  Sin embargo existen algunas otras cosas a
  25 tener en cuenta cuando se escriben archivos de LilyPond.
  26
  27 @itemize
  28 @item ¿Qué ocurre si comete un fallo?  La estructura de un archivo de
  29 LilyPond puede hacer que ciertos errores se hagan más fáciles (o
  30 más difíciles) de encontrar.
  31
  32 @item ¿Qué ocurre si quiere compartir sus archivos con otras personas?
  33 De hecho, ¿y si quiere alterar sus propios archivos después de
  34 algunos años?  Algunos archivos de LilyPond se comprenden a
  35 primera vista; otros pueden tenerle rascándose la cabeza durante
  36 una hora.
  37
  38 @item ¿Qué ocurre si quiere actualizar su archivo de LilyPond para
  39 poderlo usar con una versión más reciente del programa?
  40
  41 La sintaxis de la entrada se modifica de forma ocasional según
  42 LilyPond se va perfeccionando.  Casi todos los cambios se pueden
  43 hacer de forma automática con @code{convert-ly}, pero algunos
  44 podrían necesitar de una ayuda manual.  Los archivos de LilyPond
  45 se pueden estructurar para que sean más fáciles (o más difíciles)
  46 de actualizar.
  47
  48 @end itemize
  49
  50 @menu
  51 * Sugerencias de tipo general::
  52 * Tipografiar música existente::
  53 * Proyectos grandes::
  54 * Solución de problemas::
  55 * Make y los Makefiles::
  56 @end menu
  57
  58
  59 @node Sugerencias de tipo general
  60 @section Sugerencias de tipo general
  61 @translationof General suggestions
  62
  63 Presentamos algunas sugerencias que le pueden servir de ayuda para
  64 evitar o corregir los problemas más comunes al realizar trabajos
  65 de tipografía musical:
  66
  67 @itemize
  68 @item
  69 @strong{Incluya siempre el número de @code{\version} en los
  70 archivos de entrada}, aun en los más pequeños.  Ello evita tener
  71 que recordar para qué versión de LilyPond se creó el archivo y es
  72 especialmente relevante al
  73 @ref{Actualizar ficheros con convert-ly} (una instrucción que
  74 requiere que el enunciado @code{\version} esté presente); o si
  75 está enviando código de entrada a otros usuarios (p.ej. si está
  76 pidiendo ayuda en una de las listas de distribución de correo).
  77 Observe que todas las plantillas de LilyPond contienen números de
  78 @code{\version}.
  79
  80 @item
  81 @strong{Escriba un compás de música en cada línea del código de
  82 entrada}.  Esto hará que la búsqueda de problemas dentro de los
  83 archivos de entrada sea mucho más sencilla.
  84
  85 @item
  86 @strong{Inserte barras de
  87 @ruser{Comprobación de compás y de número de compás} así como
  88 códigos de @ruser{Comprobación de octava}}.  La inclusión de
  89 códigos de comprobación de estos tipos será de ayuda para
  90 localizar los errores mucho más rápidamente.  La frecuencia con
  91 que añadir las comprobaciones dependerá de la complejidad de la
  92 música que se está componiendo tipográficamente.  Para
  93 composiciones sencillas, las comprobaciones añadidas en ciertos
  94 puntos estratégicos dentro de la música pueden ser suficientes,
  95 pero para música más compleja, con muchas voces y/o pentagramas,
  96 sería mejor poner comprobaciones a cada compás.
  97
  98 @item
  99 @strong{Inserte comentarios en el código de entrada}.  Las
 100 referencias a los temas musicales (p.ej. @q{segundo tema en los
 101 violines}, @q{cuarta variación}, etc.), o simplemente la inclusión
 102 de los números de compás como compentarios, hará mucho más
 103 sencilla la navegación por el archivo de entrada, especialmente si
 104 más tarde se hace necesario alterar algo, o si estamos pasando los
 105 archivos de entrada a otra persona.
 106
 107 @item @strong{Escriba las duraciones explícitamente} al comienzo de las
 108 @q{secciones}.  Por ejemplo, si especifica @code{c4 d e f} al
 109 principio de una frase (en lugar de sólo @code{c d e f}) se puede
 110 ahorrar problemas si reelabora la música más tarde.
 111
 112 @item
 113 @strong{Aprenda a aplicar márgenes y sangrados a las llaves y a la
 114 música paralela}.  Muchos problemas suelen estar producidos por
 115 llaves de apertura o de cierre que faltan.  La aplicación clara de
 116 sangrados a las llaves curvas de apertura y de cierre (o a los
 117 indicadores @code{<<} y @code{>>}) será de ayuda para evitar tales
 118 problemas.
 119
 120 Por ejemplo:
 121
 122 @example
 123 \new Staff @{
 124   \relative @{
 125     r4 g'8 g c8 c4 d |
 126     e4 r8 |
 127     % sección de Ossia
 128     <<
 129       @{ f8 c c | @}
 130       \new Staff @{
 131         f8 f c |
 132       @}
 133     >>
 134     r4 |
 135   @}
 136 @}
 137 @end example
 138
 139 @noindent
 140 es mucho más fácil de seguir que:
 141
 142 @example
 143 \new Staff @{ \relative @{ r4 g'8 g c4 c8 d | e4 r8
 144 % sección de Ossia
 145 << @{ f8 c c @} \new Staff @{ f8 f c @} >> r4 | @} @}
 146 @end example
 147
 148
 149 @item
 150 @strong{Mantenga separados la música y el estilo} poniendo las
 151 sobreescrituras dentro del bloque @code{\layout}:
 152
 153 @example
 154 \score @{
 155   @var{@dots{}música@dots{}}
 156   \layout @{
 157    \override TabStaff.Stemstencil = ##f
 158  @}
 159 @}
 160 @end example
 161
 162 Esto no crea un contexto nuevo, sino que se aplicará en el momento
 163 de crear uno.  Véase también @rlearning{Ahorrar tecleo mediante
 164 variables y funciones} y @rlearning{Hojas de estilo}.
 165
 166 @end itemize
 167
 168
 169 @node Tipografiar música existente
 170 @section Tipografiar música existente
 171 @translationof Typesetting existing music
 172
 173 Si está introduciendo música a partir de una partitura existente
 174 (es decir, tipografiando una hoja de música ya impresa),
 175
 176 @itemize
 177
 178 @item Introduzca en LilyPond un sistema del manuscrito, o copia física,
 179 de cada vez (pero mantenga la práctica de escribir un compás por
 180 línea de texto), y compruebe cada sistema cuando lo haya
 181 terminado.  Puede usar las propiedades @code{showLastLength} o
 182 @code{showFirstLength} para acelerar el proceso (véase
 183 @ruser{Saltar la música corregida}).
 184
 185 @item Defina @code{mBreak = @{ \break @}} e inserte @code{\mBreak}
 186 dentro del archivo de entrada donde el manuscrito tenga un saldo
 187 de línea.  De esta forma le resultará mucho más fácil comparar la
 188 música de LilyPond con la original.  Cuando haya terminado de
 189 revisar su partitura podrá definir @code{mBreak = @{ @}} para
 190 quitar todos esos saltos de línea.  Así permitirá a LilyPond
 191 colocar los saltos donde éste lo estime más oportuno.
 192
 193 @item Al escribir una parte para un instrumento transpositor dentro de
 194 una variable, se recomienda que las notas estén envueltas dentro
 195 de
 196
 197 @example
 198 \transpose c altura-natural @{@dots{}@}
 199 @end example
 200
 201 @noindent
 202 (donde @code{altura-natural} es la afinación natural del
 203 instrumento) de forma que la música dentro de la variable esté
 204 realmente en Do mayor.  Después podemos volver a transportarlas en
 205 sentido inverso cuando se utiliza la variable, si es necesario,
 206 pero quizá no queramos hacerlo (p.ej., al imprimir una partitura
 207 en afinación de concierto, al convertir una parte de trombón de
 208 clave de Sol a clave de Fa, etc.).  Es menos probable cometer
 209 errores en los transportes si toda la música que está dentro de
 210 las variables se encuentra en un tono coherente.
 211
 212 Asimismo, haga los transportes exclusivamente hacia o desde Do
 213 mayor.  Esto significa que aparte de ésta, las únicas tonalidades
 214 que usaremos serán los tonos de afinación de los instrumentos
 215 transpositores: bes para una trompeta en Si bemol, aes para un
 216 clarinete en La bemol, etc.
 217
 218 @end itemize
 219
 220
 221
 222 @node Proyectos grandes
 223 @section Proyectos grandes
 224 @translationof Large projects
 225
 226 Al trabajar en proyectos grandes se hace esencial tener una
 227 estructura clara en los archivos de LilyPond:
 228
 229 @itemize
 230
 231 @item @strong{Utilice un identificador para cada voz}, con un mínimo de
 232 estructura dentro de la definición.  La estructura de la sección
 233 @code{\score} es la que cambiará con mayor probabilidad; por
 234 contra, es extremadamente improbable que cambie la definición de
 235 @code{violin} en versiones nuevas de LilyPond.
 236
 237 @example
 238 violin = \relative @{
 239 g'4 c'8. e16
 240 @}
 241 @dots{}
 242 \score @{
 243   \new GrandStaff @{
 244     \new Staff @{
 245       \violin
 246     @}
 247   @}
 248 @}
 249 @end example
 250
 251 @item @strong{Separe los trucos de las definiciones musicales}.  Ya se
 252 mencionó con anterioridad, pero para proyectos grandes es vital.
 253 Quizá tengamos que cambiar la definición de @code{fluegop}, pero
 254 en ese caso sólo lo tendremos que hacer una vez, y aún podremos
 255 evitar tocar nada dentro de @code{violin}.
 256
 257 @example
 258 fluegop = _\markup@{
 259   \dynamic f \italic \small @{ 2nd @} \hspace #0.1 \dynamic p @}
 260 violin = \relative @{
 261 g'4\fluegop c'8. e16
 262 @}
 263 @end example
 264
 265 @end itemize
 266
 267
 268 @node Solución de problemas
 269 @section Solución de problemas
 270 @translationof Troubleshooting
 271
 272 Antes o después escribirá un archivo que LilyPond no podrá
 273 compilar.  Los mensajes que LilyPond proporciona pueden ayudarle a
 274 encontrar el error, pero en muchos casos tendrá que llevar a cabo
 275 algún tipo de investigación para determinar el origen del
 276 problema.
 277
 278 Las herramientas más poderosas para este cometido son el
 279 comentario de una sola línea (indicado por @code{%}) y el
 280 comentario de bloque (indicado por @code{%@{@dots{}%@}}).  Si no
 281 sabe dónde está el problema, comience convirtiendo grandes
 282 secciones del archivo de entrada en un comentario.  Después de
 283 eliminar una sección convirtiéndola en un comentario, pruebe a
 284 compilar el archivo otra vez.  Si funciona, entonces el problema
 285 debía estar en la porción que había eliminado.  Si no funciona,
 286 continúe eliminando material (transformándolo en comentarios)
 287 hasta que tenga algo que funcione.
 288
 289 En un caso extremo podría terminar con sólo
 290
 291 @example
 292 \score @{
 293   <<
 294     % \melodia
 295     % \armonia
 296     % \bajo
 297   >>
 298   \layout@{@}
 299 @}
 300 @end example
 301
 302 @noindent
 303 (en otras palabras: un archivo sin música)
 304
 305 Si ocurre esto, no abandone.  Descomente un trozo pequeño --
 306 digamos la parte del bajo -- y observe si funciona.  Si no es así,
 307 transforme en comentarios toda la música del bajo (pero deje el
 308 @code{\bajo} de la sección @code{\score} no comentado.
 309
 310 @example
 311 bajo = \relative @{
 312 %@{
 313   c'4 c c c
 314   d d d d
 315 %@}
 316 @}
 317 @end example
 318
 319 Ahora empiece poco a poco descomentando cada vez más fracciones de
 320 la parte del @code{bajo} hasta que encuentre la línea del
 321 problema.
 322
 323 Otra técnica de depuración muy útil es la construcción de
 324 @rweb{Ejemplos mínimos}.
 325
 326
 327 @node Make y los Makefiles
 328 @section Make y los Makefiles
 329 @translationof Make and Makefiles
 330
 331 @cindex make, archivos de
 332 @cindex make
 333
 334 Posiblemente todas las plataformas en que puede correr LilyPond,
 335 contemplan una posibilidad de software llamada @code{make}. Este
 336 programa lee un archivo especial llamado @code{Makefile} que
 337 define las relaciones de dependencia entre los archivos y qué
 338 instrucciones necesitamos dar al sistema operativo para producir
 339 un archivo a partir de otro.  Por ejemplo, el archivo de make
 340 detallaría cómo obtener @file{balada.pdf} y @file{balada.midi} a
 341 partir de @file{balada.ly} mediante la ejecución de Lilypond.
 342
 343 Existen ocasiones en las que es buena idea crear un
 344 @code{Makefile} para nuestro proyecto, bien sea por nuestra propia
 345 comodidad o como cortesía para otros que posiblemente tengan
 346 acceso a nuestros archivos fuente.  Esto es cierto para proyectos
 347 muy grandes con muchos archivos de inclusión y distintas opciones
 348 de salida (p.ej. partitura completa, particellas, partitura del
 349 director, reducción para piano, etc.), o para proyectos que
 350 requieren instrucciones difíciles para montarlas (como los
 351 proyectos de @code{lilypond-book}). La complejidad y flexibilidad
 352 de los Makefiles varía enormemente según las necesidades y la
 353 habilidad de los autores.  El programa GNU Make viene instalado en
 354 las distribuciones de GNU/Linux y en MacOS X, y también existe
 355 para Windows.
 356
 357 Consulte el @strong{Manual de GNU Make} para ver todos los
 358 detalles sobre el uso de @code{make}, pues lo que sigue a
 359 continuación ofrece solamente una pincelada de todo lo que es
 360 capaz de hacer.
 361
 362 Las instrucciones que definen las reglas en un archivo de make
 363 difieren en función de la plataforma; por ejemplo, las distintas
 364 formas de GNU/Linux y MacOS usan @code{bash}, mientras que Windows
 365 usa @code{cmd}.  Observeque en MacOS X, tenemos que configurar el
 366 sistema para que utilice el intérprete de órdenes. A continuación
 367 presentamos algunos makefiles de ejemplo, con versiones tanto para
 368 GNU/Linux/MacOS como para Windows.
 369
 370 El primer ejemplo es para una obra orquestal en cuatro movimientos
 371 con la estructura de directorios siguiente:
 372
 373 @example
 374 Sinfonia/
 375 |-- MIDI/
 376 |-- Makefile
 377 |-- Notas/
 378 |   |-- cello.ily
 379 |   |-- cifras.ily
 380 |   |-- trompa.ily
 381 |   |-- oboe.ily
 382 |   |-- trioCuerdas.ily
 383 |   |-- viola.ily
 384 |   |-- violinUno.ily
 385 |   `-- violinDos.ily
 386 |-- PDF/
 387 |-- Particellas/
 388 |   |-- sinfonia-cello.ly
 389 |   |-- sinfonia-trompa.ly
 390 |   |-- sinfonia-oboes.ly
 391 |   |-- sinfonia-viola.ly
 392 |   |-- sinfonia-violinUno.ly
 393 |   `-- sinfonia-violinDos.ly
 394 |-- Partituras/
 395 |   |-- sinfonia.ly
 396 |   |-- sinfoniaI.ly
 397 |   |-- sinfoniaII.ly
 398 |   |-- sinfoniaIII.ly
 399 |   `-- sinfoniaIV.ly
 400 `-- sinfoniaDefs.ily
 401 @end example
 402
 403 Los archivos @file{.ly} de los directorios @code{Partituras} y
 404 @code{Particellas} obtienen las notas de archivos @file{.ily} que
 405 están en el directorio @code{Notas}:
 406
 407 @example
 408 %%% principio del archivo "sinfonia-cello.ly"
 409 \include ../definicionesSinf.ily
 410 \include ../Notas/cello.ily
 411 @end example
 412
 413 El makefile tendrá los objetivos de @code{partitura} (la pieza
 414 completa en todo su esplendor), @code{movimientos} (partitura
 415 completa de los movimientos individuales) y @code{particellas}
 416 (partes individuales para los atriles). También existe un objetivo
 417 @code{archivo} que produce un tarball de los archivos fuente,
 418 adecuado para compartirlo a través de la web o por correo
 419 electrónico.  A continuación presentamos el makefile para
 420 GNU/Linux o MacOS X.  Se debe guardar con el nombre exacto
 421 @code{Makefile} el el directorio superior del proyecto:
 422
 423 @warning{Cuando se define un objetivo o una regla de patrón, las
 424 líneas siguientes deben comenzar con tabuladores, no con
 425 espacios.}
 426
 427 @example
 428 # nombre principal de los archivos de salida
 429 nombre = sinfonia
 430 # determinar cuántos procesadores existen
 431 CPU_CORES=`cat /proc/cpuinfo | grep -m1 "cpu cores" | sed s/".*: "//`
 432 # La instrucción para ejecutar lilypond
 433 LILY_CMD = lilypond -ddelete-intermediate-files \
 434                     -dno-point-and-click -djob-count=$(CPU_CORES)
 435
 436 # Los sufijos utilizados en este Makefile.
 437 .SUFFIXES: .ly .ily .pdf .midi
 438
 439 # Los archivos de entrada y salida se buscan dentro de los directorios relacionados en
 440 # la variable VPATH.  Todos esllos son subdirectorios del directorio
 441 # en curso (dado por la variable de GNU make `CURDIR').
 442 VPATH = \
 443   $(CURDIR)/Partituras \
 444   $(CURDIR)/PDF \
 445   $(CURDIR)/Particellas \
 446   $(CURDIR)/Notas
 447
 448 # La regla de patrón para crear archivos PDF y MIDI a partir de un archivo de entrada LY.
 449 # Los archivos de salida .pdf se colocan en el subdirectorio `PDF', y los archivos
 450 # .midi van al subdirectorio `MIDI'.
 451 %.pdf %.midi: %.ly
 452         $(LILY_CMD) $<; \           # esta línea comienza con un salto de tabulación
 453         if test -f "$*.pdf"; then \
 454             mv "$*.pdf" PDF/; \
 455         fi; \
 456         if test -f "$*.midi"; then \
 457             mv "$*.midi" MIDI/; \
 458         fi
 459
 460 notas = \
 461   cello.ily \
 462   trompa.ily \
 463   oboe.ily \
 464   viola.ily \
 465   violinUno.ily \
 466   violinDos.ily
 467
 468 # Dependencias de los movimientos.
 469 $(nombre)I.pdf: $(nombre)I.ly $(notas)
 470 $(nombre)II.pdf: $(nombre)II.ly $(notas)
 471 $(nombre)III.pdf: $(nombre)III.ly $(notas)
 472 $(nombre)IV.pdf: $(nombre)IV.ly $(notas)
 473
 474 # Dependencias de la partitura completa.
 475 $(nombre).pdf: $(nombre).ly $(notas)
 476
 477 # Dependencias de las particellas.
 478 $(nombre)-cello.pdf: $(nombre)-cello.ly cello.ily
 479 $(nombre)-trompa.pdf: $(nombre)-trompa.ly trompa.ily
 480 $(nombre)-oboes.pdf: $(nombre)-oboes.ly oboe.ily
 481 $(nombre)-viola.pdf: $(nombre)-viola.ly viola.ily
 482 $(nombre)-violinUno.pdf: $(nombre)-violinUno.ly violinUno.ily
 483 $(nombre)-violinDos.pdf: $(nombre)-violinDos.ly violinDos.ily
 484
 485 # Teclee `make partitura' para generer la partitura completa de los cuatro
 486 # movimientos como un archivo único.
 487 .PHONY: partitura
 488 partitura: $(nombre).pdf
 489
 490 # Teclee `make particellas' para generar todas las particellas.
 491 # Teclee `make fulanito.pdf' para generar la particella del instrumento `fulanito'.
 492 # Ejemplo: `make sinfonia-cello.pdf'.
 493 .PHONY: particellas
 494 particellas: $(nombre)-cello.pdf \
 495        $(nombre)-violinUno.pdf \
 496        $(nombre)-violinDos.pdf \
 497        $(nombre)-viola.pdf \
 498        $(nombre)-oboes.pdf \
 499        $(nombre)-trompa.pdf
 500
 501 # Teclee `make movimientos' para generar los archivos de los
 502 # cuatro movimientos de forma separada.
 503 .PHONY: movimientos
 504 movimientos: $(nombre)I.pdf \
 505            $(nombre)II.pdf \
 506            $(nombre)III.pdf \
 507            $(nombre)IV.pdf
 508
 509 all: partitura particellas movimientos
 510
 511 archivo:
 512         tar -cvvf stamitz.tar \       # esta línea comienza con un salto de tabulación
 513         --exclude=*pdf --exclude=*~ \
 514         --exclude=*midi --exclude=*.tar \
 515         ../Stamitz/*
 516 @end example
 517
 518
 519 Existen ciertas complicaciones en la plataforma Windows. Después
 520 de descargar e instalar el programa GNU Make para Windows, debemos
 521 configurar la ruta adecuada en las variables de entorno del
 522 sistema de forma que el shell del DOS pueda encontrar el programa
 523 Make. Para hacerlo, pulse con el botón derecho sobre "Mi PC",
 524 elija @code{Propiedades} y @code{Avanzadas}. Pulse sobre
 525 @code{Variables de entorno}, y luego en la pestaña @code{Variables
 526 del sistema}, seleccione @code{Ruta}, pulse sobre @code{editar} y
 527 añada la ruta al archivo ejecutable de GNU Make, con lo que
 528 quedará algo parecido a lo siguiente:
 529
 530 @example
 531 C:\Archivos de programa\GnuWin32\bin
 532 @end example
 533
 534 El makefile en sí debe modificarse para que maneje distintas
 535 instrucciones del shell y para que pueda tratar con los espacios
 536 que aparecen en el nombre de algunos directorios del sistema
 537 predeterminados. El objetivo @code{archivo} se elimina porque
 538 Windows no tiene la instrucción @code{tar}, y Windows tiene
 539 también una extensión predeterminada distinta para los archivos
 540 MIDI.
 541
 542
 543 @example
 544 ## VERSIÓN PARA WINDOWS
 545 ##
 546 nombre = sinfonia
 547 LILY_CMD = lilypond -ddelete-intermediate-files \
 548                     -dno-point-and-click \
 549                     -djob-count=$(NUMBER_OF_PROCESSORS)
 550
 551 #obtener el nombre 8.3 de CURDIR (rodeo para los espacios en PATH)
 552 workdir = $(shell for /f "tokens=*" %%b in ("$(CURDIR)") \
 553           do @@echo %%~sb)
 554
 555 .SUFFIXES: .ly .ily .pdf .mid
 556
 557 VPATH = \
 558   $(workdir)/Partituras \
 559   $(workdir)/PDF \
 560   $(workdir)/Particellas \
 561   $(workdir)/Notas
 562
 563 %.pdf %.mid: %.ly
 564         $(LILY_CMD) $<      # esta línea comienza con un salto de tabulación
 565         if exist "$*.pdf"  move /Y "$*.pdf"  PDF/ # comienzo con tab
 566         if exist "$*.mid" move /Y "$*.mid" MIDI/  # comienzo con tab
 567
 568 notas = \
 569   cello.ily \
 570   cifras.ily \
 571   trompa.ily \
 572   oboe.ily \
 573   trioCuerdas.ily \
 574   viola.ily \
 575   violinUno.ily \
 576   violinDos.ily
 577
 578 $(nombre)I.pdf: $(nombre)I.ly $(notas)
 579 $(nombre)II.pdf: $(nombre)II.ly $(notas)
 580 $(nombre)III.pdf: $(nombre)III.ly $(notas)
 581 $(nombre)IV.pdf: $(nombre)IV.ly $(notas)
 582
 583 $(nombre).pdf: $(nombre).ly $(notas)
 584
 585 $(nombre)-cello.pdf: $(nombre)-cello.ly cello.ily
 586 $(nombre)-trompa.pdf: $(nombre)-trompa.ly trompa.ily
 587 $(nombre)-oboes.pdf: $(nombre)-oboes.ly oboe.ily
 588 $(nombre)-viola.pdf: $(nombre)-viola.ly viola.ily
 589 $(nombre)-violinUno.pdf: $(nombre)-violinUno.ly violinUno.ily
 590 $(nombre)-violinDos.pdf: $(nombre)-violinDos.ly violinDos.ily
 591
 592 .PHONY: partitura
 593 partitura: $(nombre).pdf
 594
 595 .PHONY: particellas
 596 particellas: $(nombre)-cello.pdf \
 597        $(nombre)-violinUno.pdf \
 598        $(nombre)-violinDos.pdf \
 599        $(nombre)-viola.pdf \
 600        $(nombre)-oboes.pdf \
 601        $(nombre)-trompa.pdf
 602
 603 .PHONY: movimientos
 604 movimientos: $(nombre)I.pdf \
 605            $(nombre)II.pdf \
 606            $(nombre)III.pdf \
 607            $(nombre)IV.pdf
 608
 609 all: partitura particellas movimientos
 610 @end example
 611
 612
 613 El Makefile siguiente es para un documento de
 614 @command{lilypond-book} hecho en LaTeX.  Este proyecto tiene un
 615 índice, que requiere ejecutar la instrucción @command{latex} dos
 616 veces para actualizar los enlaces.  Todos los archivos de salida
 617 se almacenan en el directorio @code{salida} para los documentos
 618 .pdf y en el directorio @code{salidahtml} para la salida en
 619 formato html.
 620
 621 @example
 622 SHELL=/bin/sh
 623 NOMBRE=miproyecto
 624 DIR_SALIDA=salida
 625 DIR_WEB=salidahtml
 626 VISOR=acroread
 627 NAVEGADOR=firefox
 628 LILYBOOK_PDF=lilypond-book --output=$(DIR_SALIDA) --pdf $(NOMBRE).lytex
 629 LILYBOOK_HTML=lilypond-book --output=$(DIR_WEB) $(NOMBRE).lytex
 630 PDF=cd $(DIR_SALIDA) && pdflatex $(NOMBRE)
 631 HTML=cd $(DIR_WEB) && latex2html $(NOMBRE)
 632 INDICE=cd $(DIR_SALIDA) && makeindex $(NOMBRE)
 633 VISTA_PREVIA=$(VISOR) $(DIR_SALIDA)/$(NOMBRE).pdf &
 634
 635 all: pdf web guardar
 636
 637 pdf:
 638         $(LILYBOOK_PDF)  # comienza con un tab
 639         $(PDF)           # comienza con un tab
 640         $(INDICE)        # comienza con un tab
 641         $(PDF)           # comienza con un tab
 642         $(VISTA_PREVIA)  # comienza con un tab
 643
 644 web:
 645         $(LILYBOOK_HTML) # comienza con un tab
 646         $(HTML)          # comienza con un tab
 647         cp -R $(DIR_WEB)/$(NOMBRE)/ ./  # comienza con un tab
 648         $(NAVEGADOR) $(NOMBRE)/$(NOMBRE).html &  # comienza con un tab
 649
 650 guardar: pdf
 651         cp $(DIR_SALIDA)/$(NOMBRE).pdf $(NOMBRE).pdf  # comienza con un tab
 652
 653 clean:
 654         rm -rf $(DIR_SALIDA) # comienza con un tab
 655
 656 web-clean:
 657         rm -rf $(DIR_WEB) # comienza con un tab
 658
 659 archivo:
 660         tar -cvvf miproyecto.tar \ # comienza con un tab
 661         --exclude=salida/* \
 662         --exclude=salidahtml/* \
 663         --exclude=miproyecto/* \
 664         --exclude=*midi \
 665         --exclude=*pdf \
 666         --exclude=*~ \
 667         ../MiProyecto/*
 668 @end example
 669
 670 HACER: conseguir que funcione en Windows
 671
 672 El makefile anterior no funciona en Windows.  Una alternativa para
 673 los usuarios de Windows sería crear un archivo de lotes sencillo
 674 que contenga las instrucciones de montaje.  Esto no rastrea las
 675 dependencias en la manera en que lo hace un makefile, pero al
 676 menos reduce el proceso de construcción a una sola instrucción.
 677 Guarde el código siguiente como @command{montaje.bat} o
 678 @command{montaje.cmd}.  El archivo de lotes se puede ejecutar en
 679 la línea de comandos del DOS o simplemente haciendo doble click
 680 sobre su icono.
 681
 682 @example
 683 lilypond-book --output=salida --pdf miproyecto.lytex
 684 cd salida
 685 pdflatex miproyecto
 686 makeindex miproyecto
 687 pdflatex miproyecto
 688 cd ..
 689 copy salida\miproyecto.pdf MiProyecto.pdf
 690 @end example
 691
 692
 693 @seealso
 694 Manual de utilización del programa:
 695 @rprogram{Configuración para MacOS X},
 696 @rprogram{Utilización desde la línea de órdenes},
 697 @rprogram{LilyPond-book}