X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=ly%2Fmusic-functions-init.ly;h=559d9777d5a3f78fe3f5b7611d05e810200650d2;hb=543dc9db58da5e3acaf72dae2478933742fa6e90;hp=3b272121175121e7eec84cbc7af0310155ec1fe0;hpb=b83a541266531ea1d5f10031c62ff37236e063e4;p=lilypond.git

diff --git a/ly/music-functions-init.ly b/ly/music-functions-init.ly
index 3b27212117..559d9777d5 100644
--- a/ly/music-functions-init.ly
+++ b/ly/music-functions-init.ly
@@ -18,7 +18,7 @@
 %%%% You should have received a copy of the GNU General Public License
 %%%% along with LilyPond.  If not, see <http://www.gnu.org/licenses/>.
 
-\version "2.15.18"
+\version "2.17.11"
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -36,7 +36,7 @@ acciaccatura =
    (_i "Create an acciaccatura from the following music expression"))
 
 %% keep these two together
-"instrument-definitions" = #'()
+instrument-definitions = #'()
 addInstrumentDefinition =
 #(define-void-function
    (parser location name lst) (string? list?)
@@ -85,6 +85,40 @@ markups), or inside a score.")
 	       'elements (list (make-music 'PageTurnEvent
 					   'break-permission 'allow))))
 
+alterBroken =
+#(define-music-function (parser location property arg item)
+  (symbol-list-or-symbol? list? symbol-list-or-music?)
+  (_i "Override @var{property} for pieces of broken spanner @var{item}
+with values @var{arg}.  @var{item} may either be music in the form of
+a starting spanner event, or a symbol list in the form
+@samp{Context.Grob} or just @samp{Grob}.  Iff @var{item} is in the
+form of a spanner event, @var{property} may also have the form
+@samp{Grob.property} for specifying a directed tweak.")
+  (if (ly:music? item)
+      (if (eq? (ly:music-property item 'span-direction) START)
+          #{ \tweak #property #(value-for-spanner-piece arg) #item #}
+          (begin
+            (ly:music-warning item (_ "not a spanner"))
+            item))
+      (let* ((p (check-grob-path item parser location
+                                 #:default 'Bottom
+                                 #:min 2
+                                 #:max 2))
+             (name (and p (second p)))
+             (description
+              (and name (assoc-get name all-grob-descriptions))))
+        (if (and description
+                 (member 'spanner-interface
+                         (assoc-get 'interfaces
+                                    (assoc-get 'meta description))))
+            #{
+              \override #item . #property =
+              #(value-for-spanner-piece arg)
+            #}
+            (begin
+              (ly:input-warning location (_ "not a spanner name, `~a'") name)
+              (make-music 'Music))))))
+
 appendToTag =
 #(define-music-function (parser location tag more music)
    (symbol? ly:music? ly:music?)
@@ -144,14 +178,16 @@ balloonGrobText =
    (symbol? number-pair? markup?)
    (_i "Attach @var{text} to @var{grob-name} at offset @var{offset}
  (use like @code{\\once})")
-   (make-music 'AnnotateOutputEvent
-	       'symbol grob-name
-	       'X-offset (car offset)
-	       'Y-offset (cdr offset)
-	       'text text))
+   (make-event-chord
+    (list
+     (make-music 'AnnotateOutputEvent
+                 'symbol grob-name
+                 'X-offset (car offset)
+                 'Y-offset (cdr offset)
+                 'text text))))
 
 balloonText =
-#(define-music-function (parser location offset text) (number-pair? markup?)
+#(define-event-function (parser location offset text) (number-pair? markup?)
    (_i "Attach @var{text} at @var{offset} (use like @code{\\tweak})")
    (make-music 'AnnotateOutputEvent
 	       'X-offset (car offset)
@@ -178,7 +214,7 @@ barNumberCheck =
 					 cbn n))))))
 
 bendAfter =
-#(define-music-function (parser location delta) (real?)
+#(define-event-function (parser location delta) (real?)
    (_i "Create a fall or doit of pitch interval @var{delta}.")
    (make-music 'BendAfterEvent
 	       'delta-step delta))
@@ -226,20 +262,31 @@ as @code{\\compoundMeter #'((3 2 8))} or shorter
          (timesig (cons (ly:moment-main-numerator mlen)
                         (ly:moment-main-denominator mlen))))
   #{
-    \once \override Staff.TimeSignature #'stencil = #(lambda (grob)
-		(grob-interpret-markup grob (format-compound-time args)))
-    \set Timing.timeSignatureFraction = $timesig
-    \set Timing.baseMoment = $beat
-    \set Timing.beatStructure = $beatGrouping
+    \once \override Staff.TimeSignature.stencil = #(lambda (grob)
+      (grob-interpret-markup grob (format-compound-time args)))
+    \set Timing.timeSignatureFraction = #timesig
+    \set Timing.baseMoment = #beat
+    \set Timing.beatStructure = #beatGrouping
     \set Timing.beamExceptions = #'()
-    \set Timing.measureLength = $mlen
+    \set Timing.measureLength = #mlen
   #} ))
 
+crossStaff =
+#(define-music-function (parser location notes) (ly:music?)
+  (_i "Create cross-staff stems")
+  #{
+  \temporary \override Stem.cross-staff = #cross-staff-connect
+  \temporary \override Flag.style = #'no-flag
+  #notes
+  \revert Stem.cross-staff
+  \revert Flag.style
+#})
 
 cueClef =
 #(define-music-function (parser location type) (string?)
   (_i "Set the current cue clef to @var{type}.")
   (make-cue-clef-set type))
+
 cueClefUnset =
 #(define-music-function (parser location) ()
   (_i "Unset the current cue clef.")
@@ -293,27 +340,20 @@ endSpanners =
 #(define-music-function (parser location music) (ly:music?)
    (_i "Terminate the next spanner prematurely after exactly one note
 without the need of a specific end spanner.")
-   (if (memq (ly:music-property music 'name) '(EventChord NoteEvent))
-       (let* ((start-span-evs (filter (lambda (ev)
-					(equal? (ly:music-property ev 'span-direction)
-						START))
-				      (extract-typed-music music 'span-event)))
-	      (stop-span-evs
-	       (map (lambda (m)
-		      (let ((c (music-clone m)))
-			(set! (ly:music-property c 'span-direction) STOP)
-			c))
-		    start-span-evs))
-	      (end-ev-chord (make-music 'EventChord
-					'elements stop-span-evs))
-	      (total (make-music 'SequentialMusic
-				 'elements (list music
-						 end-ev-chord))))
-	 total)
-
-       (begin
-	 (ly:input-message location (_ "argument endSpanners is not an EventChord: ~a") music)
-	 music)))
+   (let* ((start-span-evs (filter (lambda (ev)
+				    (equal? (ly:music-property ev 'span-direction)
+					    START))
+				  (extract-typed-music music 'span-event)))
+	  (stop-span-evs
+	   (map (lambda (m)
+		  (music-clone m 'span-direction STOP))
+                start-span-evs))
+	  (end-ev-chord (make-music 'EventChord
+				    'elements stop-span-evs))
+	  (total (make-music 'SequentialMusic
+			     'elements (list music
+					     end-ev-chord))))
+     total))
 
 eventChords =
 #(define-music-function (parser location music) (ly:music?)
@@ -341,24 +381,45 @@ featherDurations=
 
      argument))
 
-footnote =
-#(define-music-function (parser location text offset grob-name footnote)
-   ((markup?) number-pair? (symbol? '()) markup?)
-   (_i "Attach @var{text} at @var{offset} with @var{text} referring to
-@var{footnote}.  If @var{text} is given as @code{\\default}, use
-autonumbering instead.  Note that, for this to take effect,
-auto-numbering must be turned on in the paper block.  Otherwise, no
-number will appear.  Footnotes are applied like articulations.  If a
-symbol @var{grob-name} is specified, all grobs of that kind at the
-current time step are affected.")
+finger =
+#(define-event-function (parser location finger) (number-or-markup?)
+   (_i "Apply @var{finger} as a fingering indication.")
+
    (make-music
-    'FootnoteEvent
-    'X-offset (car offset)
-    'Y-offset (cdr offset)
-    'automatically-numbered (not text)
-    'text (or text (make-null-markup))
-    'footnote-text footnote
-    'symbol grob-name))
+            'FingeringEvent
+            (if (number? finger) 'digit 'text)
+            finger))
+
+footnote =
+#(define-music-function (parser location mark offset footnote item)
+   ((markup?) number-pair? markup? symbol-list-or-music?)
+   (_i "Make the markup @var{footnote} a footnote on @var{item}.  The
+footnote is marked with a markup @var{mark} moved by @var{offset} with
+respect to the marked music.
+
+If @var{mark} is not given or specified as @var{\\default}, it is
+replaced by an automatically generated sequence number.  If @var{item}
+is a symbol list of form @samp{Grob} or @samp{Context.Grob}, then
+grobs of that type will be marked at the current time step in the
+given context (default @code{Bottom}).
+
+If @var{item} is music, the music will get a footnote attached to a
+grob immediately attached to the event, like @var{\\tweak} does.  For
+attaching a footnote to an @emph{indirectly} caused grob, write
+@code{\\single\\footnote}, use @var{item} to specify the grob, and
+follow it with the music to annotate.
+
+Like with @code{\\tweak}, if you use a footnote on a following
+post-event, the @code{\\footnote} command itself needs to be attached
+to the preceding note or rest as a post-event with @code{-}.")
+   (let ((mus (make-music
+	       'FootnoteEvent
+	       'X-offset (car offset)
+	       'Y-offset (cdr offset)
+	       'automatically-numbered (not mark)
+	       'text (or mark (make-null-markup))
+	       'footnote-text footnote)))
+     #{ \tweak footnote-music #mus #item #}))
 
 grace =
 #(def-grace-function startGraceMusic stopGraceMusic
@@ -374,37 +435,67 @@ in the format of @code{all-grob-descriptions}.")
 	 descriptions)))
 
 harmonicByFret = #(define-music-function (parser location fret music) (number? ly:music?)
-  (_i "Convert @var{music} into harmonics; the resulting notes resemble
-harmonics played on a fretted instrument by touching the strings above @var{fret}.")
-  (let* ((fret (number->string fret))
-         (pitch (fret->pitch fret)))
-        (make-sequential-music
-         (list
-          #{
-            \override TabNoteHead #'stencil = #(tab-note-head::print-custom-fret-label fret)
-          #}
-          (make-harmonic
-            (calc-harmonic-pitch pitch music))
-          #{
-            \revert TabNoteHead #'stencil
-          #}))))
+  (_i "Convert @var{music} into mixed harmonics; the resulting notes resemble
+harmonics played on a fretted instrument by touching the strings at @var{fret}.")
+  #{
+    \set harmonicDots = ##t
+    \temporary \override TabNoteHead.stencil = #(tab-note-head::print-custom-fret-label (number->string fret))
+    \temporary \override NoteHead.Y-extent = #grob::always-Y-extent-from-stencil
+    \temporary \override NoteHead.stencil = #(lambda (grob) (ly:grob-set-property! grob 'style 'harmonic-mixed)
+                                            (ly:note-head::print grob))
+    #(make-harmonic
+       (calc-harmonic-pitch (fret->pitch (number->string fret)) music))
+    \unset harmonicDots
+    \revert TabNoteHead.stencil
+    \revert NoteHead.Y-extent
+    \revert NoteHead.stencil
+  #})
 
 harmonicByRatio = #(define-music-function (parser location ratio music) (number? ly:music?)
-    (_i "Convert @var{music} into harmonics; the resulting notes resemble
-harmonics played on a fretted instrument by touching the strings above the point
+    (_i "Convert @var{music} into mixed harmonics; the resulting notes resemble
+harmonics played on a fretted instrument by touching the strings at the point
 given through @var{ratio}.")
-  (let ((pitch (ratio->pitch ratio))
-        (fret (ratio->fret ratio)))
-       (make-sequential-music
-        (list
-         #{
-           \override TabNoteHead #'stencil = #(tab-note-head::print-custom-fret-label fret)
-         #}
-         (make-harmonic
-           (calc-harmonic-pitch pitch music))
-         #{
-            \revert TabNoteHead #'stencil
-         #}))))
+  #{
+    \set harmonicDots = ##t
+    \temporary \override TabNoteHead.stencil = #(tab-note-head::print-custom-fret-label (ratio->fret ratio))
+    \temporary \override NoteHead.Y-extent = #(ly:make-unpure-pure-container ly:grob::stencil-height
+                                       (lambda (grob start end)
+                                               (ly:grob::stencil-height grob)))
+    \temporary \override NoteHead.stencil = #(lambda (grob) (ly:grob-set-property! grob 'style 'harmonic-mixed)
+                                            (ly:note-head::print grob))
+    #(make-harmonic
+      (calc-harmonic-pitch (ratio->pitch ratio) music))
+    \unset harmonicDots
+    \revert TabNoteHead.stencil
+    \revert NoteHead.Y-extent
+    \revert NoteHead.stencil
+  #})
+
+hide =
+#(define-music-function (parser location item) (symbol-list-or-music?)
+   (_i "Set @var{item}'s @samp{transparent} property to @code{#t},
+making it invisible while still retaining its dimensions.
+
+If @var{item} is a symbol list of form @code{GrobName} or
+@code{Context.GrobName}, the result is an override for the grob name
+specified by it.  If @var{item} is a music expression, the result is
+the same music expression with an appropriate tweak applied to it.")
+   (if (ly:music? item)
+       #{ \tweak transparent ##t #item #}
+       #{ \override #item . transparent = ##t #}))
+
+inStaffSegno =
+#(define-music-function (parser location) ()
+   (_i "Put the segno variant 'varsegno' at this position into the staff,
+compatible with the repeat command.")
+   (make-music 'ApplyContext
+               'procedure
+               (lambda (ctx)
+                 (let ((score-ctx (ly:context-find ctx 'Score)))
+                   (if (ly:context? score-ctx)
+                     (let ((old-rc (ly:context-property score-ctx 'repeatCommands '())))
+                       (if (eq? (memq 'segno-display old-rc) #f)
+                         (ly:context-set-property! score-ctx 'repeatCommands (cons 'segno-display old-rc)))))))))
 
 instrumentSwitch =
 #(define-music-function
@@ -429,15 +520,21 @@ instrumentSwitch =
 
 
 keepWithTag =
-#(define-music-function (parser location tag music) (symbol? ly:music?)
-   (_i "Include only elements of @var{music} that are tagged with @var{tag}.")
+#(define-music-function (parser location tag music)
+   (symbol-list-or-symbol? ly:music?)
+   (_i "Include only elements of @var{music} that are either untagged
+or tagged with one of the tags in @var{tag}.  @var{tag} may be either
+a single symbol or a list of symbols.")
    (music-filter
-    (lambda (m)
-      (let* ((tags (ly:music-property m 'tags))
-	     (res (memq tag tags)))
-	(or
-	 (eq? tags '())
-	 res)))
+    (if (symbol? tag)
+        (lambda (m)
+          (let ((music-tags (ly:music-property m 'tags)))
+            (or (null? music-tags)
+                (memq tag music-tags))))
+        (lambda (m)
+          (let ((music-tags (ly:music-property m 'tags)))
+            (or (null? music-tags)
+                (any (lambda (t) (memq t music-tags)) tag)))))
     music))
 
 key =
@@ -582,6 +679,19 @@ octaveCheck =
    (make-music 'RelativeOctaveCheck
                'pitch pitch))
 
+omit =
+#(define-music-function (parser location item) (symbol-list-or-music?)
+   (_i "Set @var{item}'s @samp{stencil} property to @code{#f},
+effectively omitting it without taking up space.
+
+If @var{item} is a symbol list of form @code{GrobName} or
+@code{Context.GrobName}, the result is an override for the grob name
+specified by it.  If @var{item} is a music expression, the result is
+the same music expression with an appropriate tweak applied to it.")
+   (if (ly:music? item)
+       #{ \tweak stencil ##f #item #}
+       #{ \override #item . stencil = ##f #}))
+
 once =
 #(define-music-function (parser location music) (ly:music?)
    (_i "Set @code{once} to @code{#t} on all layout instruction events in @var{music}.")
@@ -615,31 +725,30 @@ of @var{base-moment}, @var{beat-structure}, and @var{beam-exceptions}.")
     (override-time-signature-setting time-signature setting)))
 
 overrideProperty =
-#(define-music-function (parser location name property value)
-   (string? symbol? scheme?)
+#(define-music-function (parser location grob-property-path value)
+   (symbol-list? scheme?)
 
-   (_i "Set @var{property} to @var{value} in all grobs named @var{name}.
-The @var{name} argument is a string of the form @code{\"Context.GrobName\"}
-or @code{\"GrobName\"}.")
+   (_i "Set the grob property specified by @var{grob-property-path} to
+@var{value}.  @var{grob-property-path} is a symbol list of the form
+@code{Context.GrobName.property} or @code{GrobName.property}, possibly
+with subproperties given as well.")
+   (let ((p (check-grob-path grob-property-path parser location
+                             #:default 'Bottom
+                             #:min 3)))
+     (if p
+         (make-music 'ApplyOutputEvent
+                     'context-type (first p)
+                     'procedure
+                     (lambda (grob orig-context context)
+                       (if (equal?
+                            (cdr (assoc 'name (ly:grob-property grob 'meta)))
+                            (second p))
+                           (ly:grob-set-nested-property!
+                            grob (cddr p) value))))
+         (make-music 'Music))))
 
-   (let ((name-components (string-split name #\.))
-	 (context-name 'Bottom)
-	 (grob-name #f))
 
-     (if (> 2 (length name-components))
-	 (set! grob-name (string->symbol (car name-components)))
-	 (begin
-	   (set! grob-name (string->symbol (list-ref name-components 1)))
-	   (set! context-name (string->symbol (list-ref name-components 0)))))
 
-     (make-music 'ApplyOutputEvent
-		 'context-type context-name
-		 'procedure
-		 (lambda (grob orig-context context)
-		   (if (equal?
-			(cdr (assoc 'name (ly:grob-property grob 'meta)))
-			grob-name)
-		       (set! (ly:grob-property grob property) value))))))
 
 
 
@@ -695,93 +804,102 @@ Example:
   C = { e e | f f | }
 @end verbatim
 ")
-   (let* ((voices (apply circular-list (make-list (length voice-ids) (list))))
-	  (current-voices voices)
-	  (current-sequence (list))
-	  (original music)
-	  (wrapper #f))
-     ;;
-     ;; utilities
-     (define (push-music m)
-       "Push the music expression into the current sequence"
-       (set! current-sequence (cons m current-sequence)))
-     (define (change-voice)
-       "Stores the previously built sequence into the current voice and
+   (define (bar-check? m)
+     "Checks whether m is a bar check."
+     (eq? (ly:music-property m 'name) 'BarCheck))
+   (define (recurse-and-split music)
+     "This returns either a list of music split along barchecks, or
+@code{#f}."
+     (let ((elt (ly:music-property music 'element))
+           (elts (ly:music-property music 'elements)))
+       (cond ((ly:music? elt)
+              (let ((lst (recurse-and-split elt)))
+                (and lst
+                     (map
+                      (lambda (x)
+                        (let ((res (music-clone music 'element x)))
+                          (if (ly:input-location?
+                               (ly:music-property x 'origin))
+                              (set! (ly:music-property res 'origin)
+                                    (ly:music-property x 'origin)))
+                          res))
+                      lst))))
+             ((any bar-check? elts)
+              (let* ((voices (apply circular-list
+                                    (make-list (length voice-ids)
+                                               '())))
+                     (current-voices voices)
+                     (current-sequence '()))
+                ;;
+                ;; utilities
+                (define (push-music m)
+                  "Push the music expression into the current sequence"
+                  (set! current-sequence (cons m current-sequence)))
+                (define (change-voice)
+                  "Stores the previously built sequence into the current voice and
        change to the following voice."
-       (list-set! current-voices 0 (cons (make-music 'SequentialMusic
-						     'elements (reverse! current-sequence))
-					 (car current-voices)))
-       (set! current-sequence (list))
-       (set! current-voices (cdr current-voices)))
-     (define (bar-check? m)
-       "Checks whether m is a bar check."
-       (eq? (ly:music-property m 'name) 'BarCheck))
-     (define (music-origin music)
-       "Recursively search an origin location stored in music."
-       (cond ((null? music) #f)
-	     ((not (null? (ly:music-property music 'origin)))
-	      (ly:music-property music 'origin))
-	     (else (or (music-origin (ly:music-property music 'element))
-		       (let ((origins (remove not (map music-origin
-						       (ly:music-property music 'elements)))))
-			 (and (not (null? origins)) (car origins)))))))
-     (while (music-is-of-type? music 'music-wrapper-music)
-	    (set! wrapper music)
-	    (set! music (ly:music-property wrapper 'element)))
-     (if wrapper
-	 (set! (ly:music-property wrapper 'element)
-				  (make-music 'SequentialMusic
-					      'origin location))
-	 (set! original
-	       (make-music 'SequentialMusic
-			   'origin location)))
-     ;;
-     ;; first, split the music and fill in voices
-     ;; We flatten direct layers of SequentialMusic since they are
-     ;; pretty much impossible to avoid when writing music functions.
-     (let rec ((music music))
-       (for-each (lambda (m)
-		   (if (eq? (ly:music-property m 'name) 'SequentialMusic)
-		       (rec m)
-		       (begin
-			 (push-music m)
-			 (if (bar-check? m) (change-voice)))))
-		 (ly:music-property music 'elements)))
-     (if (not (null? current-sequence)) (change-voice))
-     ;; un-circularize `voices' and reorder the voices
-     (set! voices (map-in-order (lambda (dummy seqs)
-				  (reverse! seqs))
-				voice-ids voices))
-     ;;
-     ;; set origin location of each sequence in each voice
-     ;; for better type error tracking
-     (for-each (lambda (voice)
-		 (for-each (lambda (seq)
-			     (set! (ly:music-property seq 'origin)
-				   (or (music-origin seq) location)))
-			   voice))
-	       voices)
-     ;;
-     ;; check sequence length
-     (apply for-each (lambda* (#:rest seqs)
-			      (let ((moment-reference (ly:music-length (car seqs))))
-				(for-each (lambda (seq moment)
-					    (if (not (equal? moment moment-reference))
-						(ly:music-warning seq
-								  "Bars in parallel music don't have the same length")))
-					  seqs (map-in-order ly:music-length seqs))))
-	    voices)
-     ;;
-     ;; bind voice identifiers to the voices
-     (for-each (lambda (voice-id voice)
-	    (ly:parser-define! parser voice-id
-			       (let ((v (ly:music-deep-copy original)))
-				 (set! (ly:music-property
-					(car (extract-named-music
-					      v 'SequentialMusic))
-					'elements) voice)
-				 v)))
-	  voice-ids voices)))
+                  (set-car! current-voices
+                            (cons (reverse! current-sequence)
+                                  (car current-voices)))
+                  (set! current-sequence '())
+                  (set! current-voices (cdr current-voices)))
+                (for-each (lambda (m)
+                            (let ((split? (recurse-and-split m)))
+                              (if split?
+                                  (for-each
+                                   (lambda (m)
+                                     (push-music m)
+                                     (change-voice))
+                                   split?)
+                                  (begin
+                                    (push-music m)
+                                    (if (bar-check? m) (change-voice))))))
+                          elts)
+                (if (pair? current-sequence) (change-voice))
+                ;; un-circularize `voices' and reorder the voices
+
+                (set! voices (map reverse!
+                                  (list-head voices (length voice-ids))))
+
+                ;; check sequence length
+                (apply for-each (lambda seqs
+                                  (define (seq-len seq)
+                                    (reduce ly:moment-add
+                                            (ly:make-moment 0)
+                                            (map ly:music-length seq)))
+                                  (let ((moment-reference (seq-len (car seqs))))
+                                    (for-each (lambda (seq)
+                                                (if (not (equal? (seq-len seq)
+                                                                 moment-reference))
+                                                    (ly:music-warning
+                                                     (if (pair? seq)
+                                                         (last seq)
+                                                         (caar seqs))
+                                                     (_ "Bars in parallel music don't have the same length"))))
+                                              seqs)))
+                       voices)
+                (map
+                 (lambda (lst)
+                   (set! lst (concatenate! lst))
+                   (let ((res (music-clone music 'elements lst)))
+                     (if (and (pair? lst)
+                              (ly:input-location? (ly:music-property
+                                                   (car lst)
+                                                   'origin)))
+                         (set! (ly:music-property res 'origin)
+                               (ly:music-property (car lst) 'origin)))
+                     res))
+                 voices)))
+             (else #f))))
+   (let ((voices (recurse-and-split music)))
+     (if voices
+         ;;
+         ;; bind voice identifiers to the voices
+         (for-each (lambda (voice-id voice)
+                     (ly:parser-define! parser voice-id voice))
+	  voice-ids voices)
+         (ly:music-warning music
+                           (_ "ignoring parallel music without barchecks")))))
 
 parenthesize =
 #(define-music-function (parser loc arg) (ly:music?)
@@ -913,13 +1031,19 @@ relative =
 	       'element music))
 
 removeWithTag =
-#(define-music-function (parser location tag music) (symbol? ly:music?)
-   (_i "Remove elements of @var{music} that are tagged with @var{tag}.")
+#(define-music-function (parser location tag music)
+   (symbol-list-or-symbol? ly:music?)
+   (_i "Remove elements of @var{music} that are tagged with one of the
+tags in @var{tag}.  @var{tag} may be either a single symbol or a list
+of symbols.")
    (music-filter
-    (lambda (m)
-      (let* ((tags (ly:music-property m 'tags))
-	     (res (memq tag tags)))
-	(not res)))
+    (if (symbol? tag)
+        (lambda (m)
+          (not (memq tag (ly:music-property m 'tags))))
+        (lambda (m)
+          (let ((music-tags (ly:music-property m 'tags)))
+            (or (null? music-tags)
+                (not (any (lambda (t) (memq t music-tags)) tag))))))
     music))
 
 resetRelativeOctave =
@@ -946,13 +1070,12 @@ for time signatures of @var{time-signature}.")
    (revert-time-signature-setting time-signature))
 
 rightHandFinger =
-#(define-music-function (parser location finger) (number-or-string?)
+#(define-event-function (parser location finger) (number-or-markup?)
    (_i "Apply @var{finger} as a fingering indication.")
 
    (make-music
             'StrokeFingerEvent
-            'origin location
-            (if (string? finger) 'text 'digit)
+            (if (number? finger) 'digit 'text)
             finger))
 
 scaleDurations =
@@ -982,24 +1105,79 @@ a context modification duplicating their effect.")
 	       (list 'unset
 		     (ly:music-property m 'symbol)))
 	      ((OverrideProperty)
-	       (list 'push
-		     (ly:music-property m 'symbol)
-		     (ly:music-property m 'grob-value)
-		     (ly:music-property m 'grob-property-path)))
+	       (cons* 'push
+		      (ly:music-property m 'symbol)
+		      (ly:music-property m 'grob-value)
+                      (cond
+                       ((ly:music-property m 'grob-property #f) => list)
+                       (else
+                        (ly:music-property m 'grob-property-path)))))
 	      ((RevertProperty)
-	       (list 'pop
-		     (ly:music-property m 'symbol)
-		     (ly:music-property m 'grob-property-path)))))
+	       (cons* 'pop
+		      (ly:music-property m 'symbol)
+                      (cond
+                       ((ly:music-property m 'grob-property #f) => list)
+                       (else
+                        (ly:music-property m 'grob-property-path)))))))
 	   (case (ly:music-property m 'name)
-	     ((SequentialMusic SimultaneousMusic)
-	      (for-each musicop (ly:music-property m 'elements)))
+	     ((ApplyContext)
+	      (ly:add-context-mod mods
+				  (list 'apply
+					(ly:music-property m 'procedure))))
 	     ((ContextSpeccedMusic)
 	      (if (or (not ctx)
 		      (eq? ctx (ly:music-property m 'context-type)))
-		  (musicop (ly:music-property m 'element)))))))
+		  (musicop (ly:music-property m 'element))))
+	     (else
+	      (let ((callback (ly:music-property m 'elements-callback)))
+		(if (procedure? callback)
+		    (for-each musicop (callback m))))))))
      (musicop music)
      mods))
 
+shape =
+#(define-music-function (parser location offsets item)
+   (list? symbol-list-or-music?)
+   (_i "Offset control-points of @var{item} by @var{offsets}.  The
+argument is a list of number pairs or list of such lists.  Each
+element of a pair represents an offset to one of the coordinates of a
+control-point.  If @var{item} is a string, the result is
+@code{\\once\\override} for the specified grob type.  If @var{item} is
+a music expression, the result is the same music expression with an
+appropriate tweak applied.")
+   (define (shape-curve grob)
+     (let* ((orig (ly:grob-original grob))
+            (siblings (if (ly:spanner? grob)
+                          (ly:spanner-broken-into orig) '()))
+            (total-found (length siblings))
+            (function (assoc-get 'control-points
+                                 (reverse (ly:grob-basic-properties grob))))
+            (coords (function grob)))
+
+       (define (offset-control-points offsets)
+         (if (null? offsets)
+             coords
+             (map
+               (lambda (x y) (coord-translate x y))
+               coords offsets)))
+
+       (define (helper sibs offs)
+         (if (pair? offs)
+             (if (eq? (car sibs) grob)
+                 (offset-control-points (car offs))
+                 (helper (cdr sibs) (cdr offs)))
+             coords))
+
+       ;; we work with lists of lists
+       (if (or (null? offsets)
+               (not (list? (car offsets))))
+           (set! offsets (list offsets)))
+
+       (if (>= total-found 2)
+           (helper siblings offsets)
+           (offset-control-points (car offsets)))))
+   #{ \tweak control-points #shape-curve #item #})
+
 shiftDurations =
 #(define-music-function (parser location dur dots arg)
    (integer? integer? ly:music?)
@@ -1010,6 +1188,30 @@ shiftDurations =
     (lambda (x)
       (shift-one-duration-log x dur dots)) arg))
 
+single =
+#(define-music-function (parser location overrides music)
+   (ly:music? ly:music?)
+   (_i "Convert @var{overrides} to tweaks and apply them to @var{music}.
+This does not convert @code{\\revert}, @code{\\set} or @code{\\unset}.")
+   (set! (ly:music-property music 'tweaks)
+         (fold-some-music
+          (lambda (m) (eq? (ly:music-property m 'name)
+                           'OverrideProperty))
+          (lambda (m tweaks)
+            (let ((p (cond
+                      ((ly:music-property m 'grob-property #f) => list)
+                      (else
+                       (ly:music-property m 'grob-property-path)))))
+              (acons (cons (ly:music-property m 'symbol) ;grob name
+                           (if (pair? (cdr p))
+                               p ;grob property path
+                               (car p))) ;grob property
+                     (ly:music-property m 'grob-value)
+                     tweaks)))
+          (ly:music-property music 'tweaks)
+          overrides))
+   music)
+
 skip =
 #(define-music-function (parser location dur) (ly:duration?)
   (_i "Skip forward by @var{dur}.")
@@ -1027,28 +1229,70 @@ spacingTweaks =
    (_i "Set the system stretch, by reading the 'system-stretch property of
 the `parameters' assoc list.")
    #{
-     \overrideProperty #"Score.NonMusicalPaperColumn"
-     #'line-break-system-details
+     \overrideProperty Score.NonMusicalPaperColumn.line-break-system-details
      #(list (cons 'alignment-extra-space (cdr (assoc 'system-stretch parameters)))
 	     (cons 'system-Y-extent (cdr (assoc 'system-Y-extent parameters))))
    #})
 
 styledNoteHeads =
 #(define-music-function (parser location style heads music)
-   (symbol? list-or-symbol? ly:music?)
+   (symbol? symbol-list-or-symbol? ly:music?)
    (_i "Set @var{heads} in @var{music} to @var{style}.")
    (style-note-heads heads style music))
 
 tag =
-#(define-music-function (parser location tag arg) (symbol? ly:music?)
-
-   (_i "Add @var{tag} to the @code{tags} property of @var{arg}.")
+#(define-music-function (parser location tag music) (symbol-list-or-symbol? ly:music?)
+   (_i "Tag the following @var{music} with @var{tag} and return the
+result, by adding the single symbol or symbol list @var{tag} to the
+@code{tags} property of @var{music}.")
 
    (set!
-    (ly:music-property arg 'tags)
-    (cons tag
-	  (ly:music-property arg 'tags)))
-   arg)
+    (ly:music-property music 'tags)
+    ((if (symbol? tag) cons append)
+     tag
+     (ly:music-property music 'tags)))
+   music)
+
+temporary =
+#(define-music-function (parser location music)
+   (ly:music?)
+   (_i "Make any @code{\\override} in @var{music} replace an existing
+grob property value only temporarily, restoring the old value when a
+corresponding @code{\\revert} is executed.  This is achieved by
+clearing the @samp{pop-first} property normally set on
+@code{\\override}s.
+
+An @code{\\override}/@/@code{\\revert} sequence created by using
+@code{\\temporary} and @code{\\undo} on the same music containing
+overrides will cancel out perfectly or cause a@tie{}warning.
+
+Non-property-related music is ignored, warnings are generated for any
+property-changing music that isn't an @code{\\override}.")
+   (define warned #f)
+   (for-some-music
+    (lambda (m)
+      (and (or (music-is-of-type? m 'layout-instruction-event)
+               (music-is-of-type? m 'context-specification)
+               (music-is-of-type? m 'apply-context)
+               (music-is-of-type? m 'time-signature-music))
+           (case (ly:music-property m 'name)
+             ((OverrideProperty)
+              (if (ly:music-property m 'pop-first #f)
+                  (set! (ly:music-property m 'pop-first) '()))
+              (if (ly:music-property m 'once #f)
+                  (set! (ly:music-property m 'once) '()))
+              #t)
+             ((ContextSpeccedMusic)
+              #f)
+             (else
+              (if (not warned)
+                  (begin
+                    (ly:input-warning location (_ "Cannot make ~a revertible")
+                                      (ly:music-property m 'name))
+                    (set! warned #t)))
+              #t))))
+    music)
+   music)
 
 time =
 #(define-music-function (parser location beat-structure fraction)
@@ -1095,6 +1339,8 @@ as a first or second voice.")
 	       'quoted-context-id "cue"
 	       'quoted-music-name what
 	       'quoted-voice-direction dir
+               ;; following is inverse of instrumentTransposition for
+               ;; historical reasons
 	       'quoted-transposition pitch))
 
 transposition =
@@ -1102,26 +1348,145 @@ transposition =
    (_i "Set instrument transposition")
 
    (context-spec-music
-    (make-property-set 'instrumentTransposition
-                       (ly:pitch-negate pitch))
+    (make-property-set 'instrumentTransposition pitch)
     'Staff))
 
-tweak =
-#(define-music-function (parser location sym val arg)
-   (symbol? scheme? ly:music?)
-   (_i "Add @code{sym . val} to the @code{tweaks} property of @var{arg}.")
-
-   (if (equal? (object-property sym 'backend-type?) #f)
-       (begin
-	 (ly:input-warning location (_ "cannot find property type-check for ~a") sym)
-	 (ly:warning (_ "doing assignment anyway"))))
-   (set!
-    (ly:music-property arg 'tweaks)
-    (acons sym val
-	   (ly:music-property arg 'tweaks)))
-   arg)
-
+tuplet =
+#(define-music-function (parser location ratio tuplet-span music)
+   (fraction? (ly:duration? '()) ly:music?)
+   (_i "Scale the given @var{music} to tuplets.  @var{ratio} is a
+fraction that specifies how many notes are played in place of the
+nominal value: it will be @samp{3/2} for triplets, namely three notes
+being played in place of two.  If the optional duration
+@var{tuplet-span} is specified, it is used instead of
+@code{tupletSpannerDuration} for grouping the tuplets.
+For example,
+@example
+\\tuplet 3/2 4 @{ c8 c c c c c @}
+@end example
+will result in two groups of three tuplets, each group lasting for a
+quarter note.")
+   (make-music 'TimeScaledMusic
+               'element (ly:music-compress
+                         music
+                         (ly:make-moment (cdr ratio) (car ratio)))
+               'numerator (cdr ratio)
+               'denominator (car ratio)
+               'duration tuplet-span))
+
+tupletSpan =
+#(define-music-function (parser location tuplet-span)
+   ((ly:duration?))
+   (_i "Set @code{tupletSpannerDuration}, the length into which
+@code{\\tuplet} without an explicit @samp{tuplet-span} argument of its
+own will group its tuplets, to the duration @var{tuplet-span}.  To
+revert to the default of not subdividing the contents of a @code{\\tuplet}
+command without explicit @samp{tuplet-span}, use
+@example
+\\tupletSpan \\default
+@end example
+")
+   (if tuplet-span
+       #{ \set tupletSpannerDuration = #(ly:duration-length tuplet-span) #}
+       #{ \unset tupletSpannerDuration #}))
 
+tweak =
+#(define-music-function (parser location prop value item)
+   (symbol-list-or-symbol? scheme? symbol-list-or-music?)
+   (_i "Add a tweak to the following @var{item}, usually music.
+Layout objects created by @var{item} get their property @var{prop}
+set to @var{value}.  If @var{prop} has the form @samp{Grob.property}, like with
+@example
+\\tweak Accidental.color #red cis'
+@end example
+an indirectly created grob (@samp{Accidental} is caused by
+@samp{NoteHead}) can be tweaked; otherwise only directly created grobs
+are affected.
+
+As a special case, @var{item} may be a symbol list specifying a grob
+path, in which case @code{\\once\\override} is called on it instead of
+creating tweaked music.  This is mainly useful when using
+@code{\\tweak} as as a component for building other functions.
+
+@var{prop} can contain additional elements in which case a nested
+property (inside of an alist) is tweaked.")
+   (if (ly:music? item)
+       (let ((p (check-grob-path prop parser location
+                                 #:start 1
+                                 #:default #t
+                                 #:min 2)))
+         (if p
+             (set! (ly:music-property item 'tweaks)
+                   (acons (cond ((pair? (cddr p)) p)
+                                ((symbol? (car p))
+                                 (cons (car p) (cadr p)))
+                                (else (cadr p)))
+                          value
+                          (ly:music-property item 'tweaks))))
+         item)
+       ;; We could just throw this at \override and let it sort this
+       ;; out on its own, but this way we should get better error
+       ;; diagnostics.
+       (let ((a (check-grob-path item parser location
+                                 #:default 'Bottom #:min 2 #:max 2))
+             (b (check-grob-path prop parser location
+                                 #:start 2)))
+         (if (and a b)
+             #{ \once\override #(append a b) = #value #}
+             (make-music 'Music)))))
+
+undo =
+#(define-music-function (parser location music)
+   (ly:music?)
+   (_i "Convert @code{\\override} and @code{\\set} in @var{music} to
+@code{\\revert} and @code{\\unset}, respectively.  Any reverts and
+unsets already in @var{music} cause a warning.  Non-property-related music is ignored.")
+   (define warned #f)
+   (let loop
+       ((music music))
+     (let
+         ((lst
+           (fold-some-music
+            (lambda (m) (or (music-is-of-type? m 'layout-instruction-event)
+                            (music-is-of-type? m 'context-specification)
+                            (music-is-of-type? m 'apply-context)
+                            (music-is-of-type? m 'time-signature-music)))
+            (lambda (m overrides)
+              (case (ly:music-property m 'name)
+                ((OverrideProperty)
+                 (cons
+                  (make-music 'RevertProperty
+                              'symbol (ly:music-property m 'symbol)
+                              'grob-property-path
+                              (cond
+                               ((ly:music-property m 'grob-property #f) => list)
+                               (else
+                                (ly:music-property m 'grob-property-path))))
+                  overrides))
+                ((PropertySet)
+                 (cons
+                  (make-music 'PropertyUnset
+                              'symbol (ly:music-property m 'symbol))
+                  overrides))
+                ((ContextSpeccedMusic)
+                 (cons
+                  (make-music 'ContextSpeccedMusic
+                              'element (loop (ly:music-property m 'element))
+                              'context-type (ly:music-property m 'context-type))
+                  overrides))
+                (else
+                 (if (not warned)
+                     (begin
+                       (ly:input-warning location (_ "Cannot revert ~a")
+                                         (ly:music-property m 'name))
+                       (set! warned #t)))
+                 overrides)))
+            '()
+            music)))
+       (cond
+        ((null? lst) (make-music 'Music))
+        ((null? (cdr lst)) (car lst))
+        (else (make-sequential-music lst))))))
 
 unfoldRepeats =
 #(define-music-function (parser location music) (ly:music?)