X-Git-Url: https://git.donarmstrong.com/?a=blobdiff_plain;f=ly%2Fmusic-functions-init.ly;h=d41da5b5b6c925c8332ba498875d8b6deaffbdb0;hb=97a0169312a260933246ab224e4f8b0969871dd5;hp=cbba26a65256a366e3c2793cebb641e91d18266b;hpb=3740ac23c9e222602cec4ddc6c38b58504f17673;p=lilypond.git

diff --git a/ly/music-functions-init.ly b/ly/music-functions-init.ly
index cbba26a652..d41da5b5b6 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.17.11"
+\version "2.19.25"
 
 
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
@@ -29,14 +29,12 @@
 #(use-modules (srfi srfi-1)
               (ice-9 optargs))
 
-%% TODO: using define-music-function in a .scm causes crash.
-
 absolute =
-#(define-music-function (parser location music)
+#(define-music-function (music)
    (ly:music?)
    (_i "Make @var{music} absolute.  This does not actually change the
 music itself but rather hides it from surrounding @code{\\relative}
-commands.")
+and @code{\\fixed} commands.")
    (make-music 'RelativeOctaveMusic 'element music))
 
 acciaccatura =
@@ -47,44 +45,48 @@ acciaccatura =
 instrument-definitions = #'()
 addInstrumentDefinition =
 #(define-void-function
-   (parser location name lst) (string? list?)
+   (name lst) (string? list?)
    (_i "Create instrument @var{name} with properties @var{list}.")
    (set! instrument-definitions (acons name lst instrument-definitions)))
 
 addQuote =
-#(define-void-function (parser location name music) (string? ly:music?)
+#(define-void-function (name music) (string? ly:music?)
    (_i "Define @var{music} as a quotable music expression named
 @var{name}")
-   (add-quotable parser name music))
+   (add-quotable name music))
 
 %% keep these two together
-afterGraceFraction = #(cons 6 8)
+afterGraceFraction = 3/4
 afterGrace =
-#(define-music-function (parser location main grace) (ly:music? ly:music?)
-   (_i "Create @var{grace} note(s) after a @var{main} music expression.")
+#(define-music-function (fraction main grace) ((fraction?) ly:music? ly:music?)
+   (_i "Create @var{grace} note(s) after a @var{main} music expression.
+
+The musical position of the grace expression is after a
+given fraction of the main note's duration has passed.  If
+@var{fraction} is not specified as first argument, it is taken from
+@code{afterGraceFraction} which has a default value of @code{3/4}.")
    (let ((main-length (ly:music-length main))
-         (fraction  (ly:parser-lookup parser 'afterGraceFraction)))
-     (make-simultaneous-music
-      (list
-       main
-       (make-sequential-music
-        (list
-
-         (make-music 'SkipMusic
-                     'duration (ly:make-duration
-                                0 0
-                                (* (ly:moment-main-numerator main-length)
-                                   (car fraction))
-                                (* (ly:moment-main-denominator main-length)
-                                   (cdr fraction))))
-         (make-music 'GraceMusic
-                     'element grace)))))))
+         (fraction (or fraction (ly:parser-lookup 'afterGraceFraction))))
+     (descend-to-context
+      (make-simultaneous-music
+       (list
+        main
+        (make-sequential-music
+         (list
+          (make-music 'SkipMusic
+                      'duration (ly:make-duration
+                                 0 0
+                                 (* (ly:moment-main main-length)
+                                    (/ (car fraction) (cdr fraction)))))
+          (make-music 'GraceMusic
+                      'element grace)))))
+      'Bottom)))
 
 
 %% music identifiers not allowed at top-level,
 %% so this is a music-function instead.
 allowPageTurn =
-#(define-music-function (location parser) ()
+#(define-music-function () ()
    (_i "Allow a page turn. May be used at toplevel (ie between scores or
 markups), or inside a score.")
    (make-music 'EventChord
@@ -94,8 +96,8 @@ markups), or inside a score.")
                                            'break-permission 'allow))))
 
 alterBroken =
-#(define-music-function (parser location property arg item)
-  (symbol-list-or-symbol? list? symbol-list-or-music?)
+#(define-music-function (property arg item)
+  (key-list-or-symbol? list? key-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
@@ -103,12 +105,13 @@ a starting spanner event, or a symbol list in the form
 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 #}
+      (if (or (eqv? (ly:music-property item 'span-direction) START)
+              (music-is-of-type? item 'tie-event))
+          (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
+      (let* ((p (check-grob-path item (*location*)
                                  #:default 'Bottom
                                  #:min 2
                                  #:max 2))
@@ -119,16 +122,16 @@ form of a spanner event, @var{property} may also have the form
                  (member 'spanner-interface
                          (assoc-get 'interfaces
                                     (assoc-get 'meta description))))
-            #{
-              \override #item . #property =
-              #(value-for-spanner-piece arg)
-            #}
+            (propertyOverride (append item (if (symbol? property)
+                                       (list property)
+                                       property))
+                      (value-for-spanner-piece arg))
             (begin
-              (ly:input-warning location (_ "not a spanner name, `~a'") name)
+              (ly:input-warning (*location*) (_ "not a spanner name, `~a'") name)
               (make-music 'Music))))))
 
 appendToTag =
-#(define-music-function (parser location tag more music)
+#(define-music-function (tag more music)
    (symbol? ly:music? ly:music?)
    (_i "Append @var{more} to the @code{elements} of all music
 expressions in @var{music} that are tagged with @var{tag}.")
@@ -141,22 +144,29 @@ expressions in @var{music} that are tagged with @var{tag}.")
               music))
 
 applyContext =
-#(define-music-function (parser location proc) (procedure?)
+#(define-music-function (proc) (procedure?)
    (_i "Modify context properties with Scheme procedure @var{proc}.")
    (make-music 'ApplyContext
                'procedure proc))
 
 applyMusic =
-#(define-music-function (parser location func music) (procedure? ly:music?)
+#(define-music-function (func music) (procedure? ly:music?)
    (_i"Apply procedure @var{func} to @var{music}.")
    (func music))
 
 applyOutput =
-#(define-music-function (parser location ctx proc) (symbol? procedure?)
-   (_i "Apply function @code{proc} to every layout object in context @code{ctx}")
-   (make-music 'ApplyOutputEvent
-               'procedure proc
-               'context-type ctx))
+#(define-music-function (target proc) (symbol-list-or-symbol? procedure?)
+   (_i "Apply function @code{proc} to every layout object matched by
+@var{target} which takes the form @code{Context} or @code{Context.Grob}.")
+   (let ((p (check-grob-path target (*location*) #:max 2)))
+     (if p
+         (make-music 'ApplyOutputEvent
+                     'procedure proc
+                     'context-type (car p)
+                     (if (pair? (cdr p))
+                         (list (cons 'symbol (cadr p)))
+                         '()))
+         (make-music 'Music))))
 
 appoggiatura =
 #(def-grace-function startAppoggiaturaMusic stopAppoggiaturaMusic
@@ -164,25 +174,38 @@ appoggiatura =
 
 % for regression testing purposes.
 assertBeamQuant =
-#(define-music-function (parser location l r) (pair? pair?)
+#(define-music-function (l r) (pair? pair?)
    (_i "Testing function: check whether the beam quants @var{l} and @var{r} are correct")
    (make-grob-property-override 'Beam 'positions (check-quant-callbacks l r)))
 
 % for regression testing purposes.
 assertBeamSlope =
-#(define-music-function (parser location comp) (procedure?)
+#(define-music-function (comp) (procedure?)
    (_i "Testing function: check whether the slope of the beam is the same as @code{comp}")
    (make-grob-property-override 'Beam 'positions (check-slope-callbacks comp)))
 
 autochange =
-#(define-music-function (parser location music) (ly:music?)
-   (_i "Make voices that switch between staves automatically")
-   (make-autochange-music parser music))
-
-
+#(define-music-function (pitch clef-1 clef-2 music)
+  ((ly:pitch? (ly:make-pitch 0 0)) (ly:context-mod?)(ly:context-mod?) ly:music?)
+  (_i "Make voices that switch between staves automatically.  As an option the
+pitch where to switch staves may be specified.  The clefs for the staves are
+optional as well.  Setting clefs  works only for implicitly instantiated
+staves.")
+  (let ;; keep the contexts alive for the full duration
+       ((skip (make-duration-of-length (ly:music-length music)))
+        (clef-1 (or clef-1 #{ \with { \clef "treble" } #}))
+        (clef-2 (or clef-2 #{ \with { \clef "bass" } #})))
+    (make-simultaneous-music
+     (list
+      (descend-to-context (make-autochange-music pitch music) 'Staff
+                          "up" clef-1)
+      (context-spec-music (make-skip-music skip) 'Staff
+                          "up" clef-1)
+      (context-spec-music (make-skip-music skip) 'Staff
+                          "down" clef-2)))))
 
 balloonGrobText =
-#(define-music-function (parser location grob-name offset text)
+#(define-music-function (grob-name offset text)
    (symbol? number-pair? markup?)
    (_i "Attach @var{text} to @var{grob-name} at offset @var{offset}
  (use like @code{\\once})")
@@ -195,7 +218,7 @@ balloonGrobText =
                  'text text))))
 
 balloonText =
-#(define-event-function (parser location offset text) (number-pair? markup?)
+#(define-event-function (offset text) (number-pair? markup?)
    (_i "Attach @var{text} at @var{offset} (use like @code{\\tweak})")
    (make-music 'AnnotateOutputEvent
                'X-offset (car offset)
@@ -203,26 +226,26 @@ balloonText =
                'text text))
 
 bar =
-#(define-music-function (parser location type) (string?)
+#(define-music-function (type) (string?)
    (_i "Insert a bar line of type @var{type}")
    (context-spec-music
     (make-property-set 'whichBar type)
     'Timing))
 
 barNumberCheck =
-#(define-music-function (parser location n) (integer?)
+#(define-music-function (n) (integer?)
    (_i "Print a warning if the current bar number is not @var{n}.")
    (make-music 'ApplyContext
                'procedure
                (lambda (c)
                  (let ((cbn (ly:context-property c 'currentBarNumber)))
                    (if (and  (number? cbn) (not (= cbn n)))
-                       (ly:input-warning location
+                       (ly:input-warning (*location*)
                                          "Barcheck failed got ~a expect ~a"
                                          cbn n))))))
 
 beamExceptions =
-#(define-scheme-function (parser location music) (ly:music?)
+#(define-scheme-function (music) (ly:music?)
    (_i "Extract a value suitable for setting
 @code{Timing.beamExceptions} from the given pattern with explicit
 beams in @var{music}.  A bar check @code{|} has to be used between
@@ -230,39 +253,39 @@ bars of patterns in order to reset the timing.")
    (extract-beam-exceptions music))
 
 bendAfter =
-#(define-event-function (parser location delta) (real?)
+#(define-event-function (delta) (real?)
    (_i "Create a fall or doit of pitch interval @var{delta}.")
    (make-music 'BendAfterEvent
                'delta-step delta))
 
 bookOutputName =
-#(define-void-function (parser location newfilename) (string?)
+#(define-void-function (newfilename) (string?)
    (_i "Direct output for the current book block to @var{newfilename}.")
-   (set! (paper-variable parser #f 'output-filename) newfilename))
+   (set! (paper-variable #f 'output-filename) newfilename))
 
 bookOutputSuffix =
-#(define-void-function (parser location newsuffix) (string?)
+#(define-void-function (newsuffix) (string?)
    (_i "Set the output filename suffix for the current book block to
 @var{newsuffix}.")
-   (set! (paper-variable parser #f 'output-suffix) newsuffix))
+   (set! (paper-variable #f 'output-suffix) newsuffix))
 
 %% \breathe is defined as a music function rather than an event identifier to
 %% ensure it gets useful input location information: as an event identifier,
 %% it would have to be wrapped in an EventChord to prevent it from being
 %% treated as a post_event by the parser
 breathe =
-#(define-music-function (parser location) ()
+#(define-music-function () ()
    (_i "Insert a breath mark.")
    (make-music 'BreathingEvent))
 
 clef =
-#(define-music-function (parser location type) (string?)
+#(define-music-function (type) (string?)
    (_i "Set the current clef to @var{type}.")
    (make-clef-set type))
 
 
 compoundMeter =
-#(define-music-function (parser location args) (pair?)
+#(define-music-function (args) (pair?)
   (_i "Create compound time signatures. The argument is a Scheme list of
 lists. Each list describes one fraction, with the last entry being the
 denominator, while the first entries describe the summands in the
@@ -287,8 +310,19 @@ as @code{\\compoundMeter #'((3 2 8))} or shorter
     \set Timing.measureLength = #mlen
   #} ))
 
+compressMMRests =
+#(define-music-function (music) (ly:music?)
+  (_i "Remove the empty bars created by multi-measure rests,
+leaving just the first bar containing the MM rest itself.")
+   (music-map
+    (lambda (m)
+      (if (eq? 'MultiMeasureRestMusic (ly:music-property m 'name))
+          #{ \once \set Score.skipBars = ##t #m #}
+          #{ #m #} ))
+    music))
+
 crossStaff =
-#(define-music-function (parser location notes) (ly:music?)
+#(define-music-function (notes) (ly:music?)
   (_i "Create cross-staff stems")
   #{
   \temporary \override Stem.cross-staff = #cross-staff-connect
@@ -299,18 +333,18 @@ crossStaff =
 #})
 
 cueClef =
-#(define-music-function (parser location type) (string?)
+#(define-music-function (type) (string?)
   (_i "Set the current cue clef to @var{type}.")
   (make-cue-clef-set type))
 
 cueClefUnset =
-#(define-music-function (parser location) ()
+#(define-music-function () ()
   (_i "Unset the current cue clef.")
   (make-cue-clef-unset))
 
 cueDuring =
 #(define-music-function
-   (parser location what dir main-music) (string? ly:dir? ly:music?)
+   (what dir main-music) (string? ly:dir? ly:music?)
    (_i "Insert contents of quote @var{what} corresponding to @var{main-music},
 in a CueVoice oriented by @var{dir}.")
    (make-music 'QuoteMusic
@@ -322,7 +356,7 @@ in a CueVoice oriented by @var{dir}.")
 
 cueDuringWithClef =
 #(define-music-function
-   (parser location what dir clef main-music) (string? ly:dir? string? ly:music?)
+   (what dir clef main-music) (string? ly:dir? string? ly:music?)
    (_i "Insert contents of quote @var{what} corresponding to @var{main-music},
 in a CueVoice oriented by @var{dir}.")
    (make-music 'QuoteMusic
@@ -336,16 +370,16 @@ in a CueVoice oriented by @var{dir}.")
 
 
 displayLilyMusic =
-#(define-music-function (parser location port music) ((output-port?) ly:music?)
+#(define-music-function (port music) ((output-port?) ly:music?)
    (_i "Display the LilyPond input representation of @var{music}
 to @var{port}, defaulting to the console.")
    (let ((port (or port (current-output-port))))
      (newline port)
-     (display-lily-music music parser port))
+     (display-lily-music music port))
    music)
 
 displayMusic =
-#(define-music-function (parser location port music) ((output-port?) ly:music?)
+#(define-music-function (port music) ((output-port?) ly:music?)
    (_i "Display the internal representation of @var{music} to
 @var{port}, default to the console.")
    (let ((port (or port (current-output-port))))
@@ -354,7 +388,7 @@ displayMusic =
    music)
 
 displayScheme =
-#(define-scheme-function (parser location port expr) ((output-port?) scheme?)
+#(define-scheme-function (port expr) ((output-port?) scheme?)
    (_i "Display the internal representation of @var{expr} to
 @var{port}, default to the console.")
    (let ((port (or port (current-output-port))))
@@ -365,7 +399,7 @@ displayScheme =
 
 
 endSpanners =
-#(define-music-function (parser location music) (ly:music?)
+#(define-music-function (music) (ly:music?)
    (_i "Terminate the next spanner prematurely after exactly one note
 without the need of a specific end spanner.")
    (let* ((start-span-evs (filter (lambda (ev)
@@ -384,14 +418,14 @@ without the need of a specific end spanner.")
      total))
 
 eventChords =
-#(define-music-function (parser location music) (ly:music?)
+#(define-music-function (music) (ly:music?)
    (_i "Compatibility function wrapping @code{EventChord} around
 isolated rhythmic events occuring since version 2.15.28, after
 expanding repeat chords @samp{q}.")
-   (event-chord-wrap! music parser))
+   (event-chord-wrap! music))
 
 featherDurations=
-#(define-music-function (parser location factor argument) (ly:moment? ly:music?)
+#(define-music-function (factor argument) (ly:moment? ly:music?)
    (_i "Adjust durations of music in @var{argument} by rational @var{factor}.")
    (let ((orig-duration (ly:music-length argument))
          (multiplier (ly:make-moment 1 1)))
@@ -410,7 +444,7 @@ featherDurations=
      argument))
 
 finger =
-#(define-event-function (parser location finger) (number-or-markup?)
+#(define-event-function (finger) (number-or-markup?)
    (_i "Apply @var{finger} as a fingering indication.")
 
    (make-music
@@ -418,8 +452,22 @@ finger =
             (if (number? finger) 'digit 'text)
             finger))
 
+fixed =
+#(define-music-function (pitch music)
+   (ly:pitch? ly:music?)
+   (_i "Use the octave of @var{pitch} as the default octave for @var{music}.")
+   (let ((octave-marks (1+ (ly:pitch-octave pitch))))
+     (cond ((not (= 0 octave-marks))
+            (ly:music-transpose music (ly:make-pitch octave-marks 0 0))
+            ;;In order to leave unchanged the notes in any enclosed
+            ;; \absolute or \fixed or \relative, make a cancelling shift
+            (map (lambda (m)
+                   (ly:music-transpose m (ly:make-pitch (- octave-marks) 0 0)))
+                 (extract-named-music music 'RelativeOctaveMusic)))))
+   (make-music 'RelativeOctaveMusic 'element music))
+
 footnote =
-#(define-music-function (parser location mark offset footnote item)
+#(define-music-function (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
@@ -447,14 +495,14 @@ to the preceding note or rest as a post-event with @code{-}.")
                'automatically-numbered (not mark)
                'text (or mark (make-null-markup))
                'footnote-text footnote)))
-     #{ \once \tweak footnote-music #mus #item #}))
+     (once (propertyTweak 'footnote-music mus item))))
 
 grace =
 #(def-grace-function startGraceMusic stopGraceMusic
    (_i "Insert @var{music} as grace notes."))
 
 grobdescriptions =
-#(define-scheme-function (parser location descriptions) (list?)
+#(define-scheme-function (descriptions) (list?)
    (_i "Create a context modification from @var{descriptions}, a list
 in the format of @code{all-grob-descriptions}.")
    (ly:make-context-mod
@@ -462,7 +510,7 @@ in the format of @code{all-grob-descriptions}.")
            (list 'assign (car p) (ly:make-grob-properties (cdr p))))
          descriptions)))
 
-harmonicByFret = #(define-music-function (parser location fret music) (number? ly:music?)
+harmonicByFret = #(define-music-function (fret music) (number? ly:music?)
   (_i "Convert @var{music} into mixed harmonics; the resulting notes resemble
 harmonics played on a fretted instrument by touching the strings at @var{fret}.")
   #{
@@ -479,16 +527,14 @@ harmonics played on a fretted instrument by touching the strings at @var{fret}."
     \revert NoteHead.stencil
   #})
 
-harmonicByRatio = #(define-music-function (parser location ratio music) (number? ly:music?)
+harmonicByRatio = #(define-music-function (ratio music) (number? ly:music?)
     (_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}.")
   #{
     \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.Y-extent = #(ly:make-unpure-pure-container ly:grob::stencil-height)
     \temporary \override NoteHead.stencil = #(lambda (grob) (ly:grob-set-property! grob 'style 'harmonic-mixed)
                                             (ly:note-head::print grob))
     #(make-harmonic
@@ -500,7 +546,7 @@ given through @var{ratio}.")
   #})
 
 hide =
-#(define-music-function (parser location item) (symbol-list-or-music?)
+#(define-music-function (item) (symbol-list-or-music?)
    (_i "Set @var{item}'s @samp{transparent} property to @code{#t},
 making it invisible while still retaining its dimensions.
 
@@ -508,10 +554,10 @@ 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.")
-   #{ \tweak transparent ##t #item #})
+   (propertyTweak 'transparent #t item))
 
 inStaffSegno =
-#(define-music-function (parser location) ()
+#(define-music-function () ()
    (_i "Put the segno variant 'varsegno' at this position into the staff,
 compatible with the repeat command.")
    (make-music 'ApplyContext
@@ -525,14 +571,14 @@ compatible with the repeat command.")
 
 instrumentSwitch =
 #(define-music-function
-   (parser location name) (string?)
+   (name) (string?)
    (_i "Switch instrument to @var{name}, which must be predefined with
 @code{\\addInstrumentDefinition}.")
    (let* ((handle (assoc name instrument-definitions))
           (instrument-def (if handle (cdr handle) '())))
 
      (if (not handle)
-         (ly:input-warning location "No such instrument: ~a" name))
+         (ly:input-warning (*location*) "No such instrument: ~a" name))
      (context-spec-music
       (make-music 'SimultaneousMusic
                   'elements
@@ -546,7 +592,7 @@ instrumentSwitch =
 
 
 keepWithTag =
-#(define-music-function (parser location tags music)
+#(define-music-function (tags music)
    (symbol-list-or-symbol? ly:music?)
    (_i "Include only elements of @var{music} that are tagged with one
 of the tags in @var{tags}.  @var{tags} may be either a single symbol
@@ -561,14 +607,14 @@ retained.")
     music))
 
 key =
-#(define-music-function (parser location tonic pitch-alist)
+#(define-music-function (tonic pitch-alist)
    ((ly:pitch? '()) (list? '()))
    (_i "Set key to @var{tonic} and scale @var{pitch-alist}.
 If both are null, just generate @code{KeyChangeEvent}.")
    (cond ((null? tonic) (make-music 'KeyChangeEvent))
          ((null? pitch-alist)
-          (ly:parser-error parser (_ "second argument must be pitch list")
-                           location)
+          (ly:parser-error (_ "second argument must be pitch list")
+                           (*location*))
           (make-music 'SequentialMusic 'void #t))
          (else
           (ly:music-transpose
@@ -578,7 +624,7 @@ If both are null, just generate @code{KeyChangeEvent}.")
            tonic))))
 
 killCues =
-#(define-music-function (parser location music) (ly:music?)
+#(define-music-function (music) (ly:music?)
    (_i "Remove cue notes from @var{music}.")
    (music-map
     (lambda (mus)
@@ -591,7 +637,7 @@ killCues =
 
 
 label =
-#(define-music-function (parser location label) (symbol?)
+#(define-music-function (label) (symbol?)
    (_i "Create @var{label} as a bookmarking label.")
    (make-music 'EventChord
                'page-marker #t
@@ -601,28 +647,28 @@ label =
 
 
 language =
-#(define-void-function (parser location language) (string?)
+#(define-void-function (language) (string?)
    (_i "Set note names for language @var{language}.")
-   (note-names-language parser language))
+   (note-names-language language))
 
 languageSaveAndChange =
-#(define-void-function (parser location language) (string?)
+#(define-void-function (language) (string?)
   (_i "Store the previous pitchnames alist, and set a new one.")
   (set! previous-pitchnames pitchnames)
-  (note-names-language parser language))
+  (note-names-language language))
 
 languageRestore =
-#(define-void-function (parser location) ()
+#(define-void-function () ()
    (_i "Restore a previously-saved pitchnames alist.")
    (if previous-pitchnames
        (begin
         (set! pitchnames previous-pitchnames)
-        (ly:parser-set-note-names parser pitchnames))
-      (ly:input-warning location (_ "No other language was defined previously. Ignoring."))))
+        (ly:parser-set-note-names pitchnames))
+      (ly:input-warning (*location*) (_ "No other language was defined previously. Ignoring."))))
 
 
 magnifyMusic =
-#(define-music-function (parser location mag music) (positive? ly:music?)
+#(define-music-function (mag music) (positive? ly:music?)
    (_i "Magnify the notation of @var{music} without changing the
 staff-size, using @var{mag} as a size factor.  Stems, beams,
 slurs, ties, and horizontal spacing are adjusted automatically.")
@@ -696,7 +742,7 @@ slurs, ties, and horizontal spacing are adjusted automatically.")
    #})
 
 magnifyStaff =
-#(define-music-function (parser location mag) (positive?)
+#(define-music-function (mag) (positive?)
    (_i "Change the size of the staff, adjusting notation size and
 horizontal spacing automatically, using @var{mag} as a size factor.")
 
@@ -754,12 +800,12 @@ horizontal spacing automatically, using @var{mag} as a size factor.")
    #})
 
 makeClusters =
-#(define-music-function (parser location arg) (ly:music?)
+#(define-music-function (arg) (ly:music?)
    (_i "Display chords in @var{arg} as clusters.")
    (music-map note-to-cluster arg))
 
 modalInversion =
-#(define-music-function (parser location around to scale music)
+#(define-music-function (around to scale music)
     (ly:pitch? ly:pitch? ly:music? ly:music?)
     (_i "Invert @var{music} about @var{around} using @var{scale} and
 transpose from @var{around} to @var{to}.")
@@ -768,7 +814,7 @@ transpose from @var{around} to @var{to}.")
       music))
 
 modalTranspose =
-#(define-music-function (parser location from to scale music)
+#(define-music-function (from to scale music)
     (ly:pitch? ly:pitch? ly:music? ly:music?)
     (_i "Transpose @var{music} from pitch @var{from} to pitch @var{to}
 using @var{scale}.")
@@ -778,36 +824,58 @@ using @var{scale}.")
 
 inversion =
 #(define-music-function
-   (parser location around to music) (ly:pitch? ly:pitch? ly:music?)
+   (around to music) (ly:pitch? ly:pitch? ly:music?)
    (_i "Invert @var{music} about @var{around} and
 transpose from @var{around} to @var{to}.")
    (music-invert around to music))
 
 mark =
-#(define-music-function
-   (parser location label) ((scheme? '()))
-  "Make the music for the \\mark command."
-  (let* ((set (and (integer? label)
-                   (context-spec-music (make-property-set 'rehearsalMark label)
-                                      'Score)))
-         (ev (make-music 'MarkEvent
-                         'origin location)))
-
-    (if set
-        (make-sequential-music (list set ev))
-        (begin
-          (set! (ly:music-property ev 'label) label)
-          ev))))
+#(define-music-function (label) ((number-or-markup?))
+   "Make the music for the \\mark command."
+   (if label
+       (make-music 'MarkEvent 'label label)
+       (make-music 'MarkEvent)))
+
+markupMap =
+#(define-music-function (path markupfun music)
+   (symbol-list-or-symbol? markup-function? ly:music?)
+   (_i "This applies the given markup function @var{markupfun} to all markup
+music properties matching @var{path} in @var{music}.
+
+For example,
+@example
+\\new Voice @{ g'2 c'' @}
+\\addlyrics @{
+  \\markupMap LyricEvent.text
+             \\markup \\with-color #red \\etc
+             @{ Oh yes! @}
+@}
+@end example
+")
+   (let* ((p (check-music-path path (*location*)))
+          (name (and p (car p)))
+          (prop (and p (cadr p))))
+     (if p
+         (for-some-music
+          (lambda (m)
+            (if (or (not name) (eq? (ly:music-property m 'name) name))
+                (let ((text (ly:music-property m prop)))
+                  (if (markup? text)
+                      (set! (ly:music-property m prop)
+                            (list markupfun text)))))
+            #f)
+          music)))
+   music)
 
 musicMap =
-#(define-music-function (parser location proc mus) (procedure? ly:music?)
+#(define-music-function (proc mus) (procedure? ly:music?)
    (_i "Apply @var{proc} to @var{mus} and all of the music it contains.")
    (music-map proc mus))
 
 %% noPageBreak and noPageTurn are music functions (not music indentifiers),
 %% because music identifiers are not allowed at top-level.
 noPageBreak =
-#(define-music-function (location parser) ()
+#(define-music-function () ()
    (_i "Forbid a page break.  May be used at toplevel (i.e., between scores or
 markups), or inside a score.")
    (make-music 'EventChord
@@ -817,7 +885,7 @@ markups), or inside a score.")
                                            'break-permission '()))))
 
 noPageTurn =
-#(define-music-function (location parser) ()
+#(define-music-function () ()
    (_i "Forbid a page turn.  May be used at toplevel (i.e., between scores or
 markups), or inside a score.")
    (make-music 'EventChord
@@ -829,14 +897,14 @@ markups), or inside a score.")
 
 
 octaveCheck =
-#(define-music-function (parser location pitch) (ly:pitch?)
+#(define-music-function (pitch) (ly:pitch?)
    (_i "Octave check.")
    (make-music 'RelativeOctaveCheck
                'pitch pitch))
 
 offset =
-#(define-music-function (parser location property offsets item)
-  (symbol-list-or-symbol? scheme? symbol-list-or-music?)
+#(define-music-function (property offsets item)
+  (symbol-list-or-symbol? scheme? key-list-or-music?)
    (_i "Offset the default value of @var{property} of @var{item} by
 @var{offsets}.  If @var{item} is a string, the result is
 @code{\\override} for the specified grob type.  If @var{item} is
@@ -847,37 +915,31 @@ appropriate tweak applied.")
       (let ((prop-path (check-grob-path
                          (if (symbol? property)
                              (list property)
-                             property)
-                         parser location
+                             property) (*location*)
                          #:start 1 #:default #t #:min 2 #:max 2)))
         (if prop-path
             ; If the head of the grob property path is a symbol--i.e.,
             ; a grob name, produce a directed tweak.  Otherwise, create
             ; an ordinary tweak.
             (if (symbol? (car prop-path))
-                #{
-                  \tweak #prop-path #(offsetter (second prop-path) offsets) #item
-                #}
-                #{
-                  \tweak #(second prop-path) #(offsetter (second prop-path) offsets) #item
-                #})
+                (tweak prop-path (offsetter (second prop-path) offsets) item)
+                (tweak (second prop-path)
+                       (offsetter (second prop-path) offsets)
+                       item))
             item))
       ; In case of an override, grob property path is Context.Grob.property.
       (let ((prop-path (check-grob-path
                          (append item
                                  (if (symbol? property)
                                      (list property)
-                                     property))
-                         parser location
+                                     property)) (*location*)
                          #:default 'Bottom #:min 3 #:max 3)))
         (if prop-path
-            #{
-              \override #prop-path = #(offsetter (third prop-path) offsets)
-            #}
+            (propertyOverride prop-path (offsetter (third prop-path) offsets))
             (make-music 'Music)))))
 
 omit =
-#(define-music-function (parser location item) (symbol-list-or-music?)
+#(define-music-function (item) (symbol-list-or-music?)
    (_i "Set @var{item}'s @samp{stencil} property to @code{#f},
 effectively omitting it without taking up space.
 
@@ -885,15 +947,15 @@ 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.")
-   #{ \tweak stencil ##f #item #})
+   (propertyTweak 'stencil #f item))
 
 once =
-#(define-music-function (parser location music) (ly:music?)
+#(define-music-function (music) (ly:music?)
    (_i "Set @code{once} to @code{#t} on all layout instruction events
 in @var{music}.  This will complain about music with an actual
 duration.  As a special exception, if @var{music} contains
 @samp{tweaks} it will be silently ignored in order to allow for
-@code{\\once \\tweak} to work as both one-time override and proper
+@code{\\once \\propertyTweak} to work as both one-time override and proper
 tweak.")
    (if (not (pair? (ly:music-property music 'tweaks)))
        (for-some-music
@@ -909,14 +971,14 @@ tweak.")
    music)
 
 ottava =
-#(define-music-function (parser location octave) (integer?)
+#(define-music-function (octave) (integer?)
    (_i "Set the octavation.")
    (make-music 'OttavaMusic
                'ottava-number octave))
 
 overrideTimeSignatureSettings =
 #(define-music-function
-   (parser location time-signature base-moment beat-structure beam-exceptions)
+   (time-signature base-moment beat-structure beam-exceptions)
    (fraction? fraction? list? list?)
 
    (_i "Override @code{timeSignatureSettings}
@@ -929,26 +991,29 @@ of @var{base-moment}, @var{beat-structure}, and @var{beam-exceptions}.")
     (override-time-signature-setting time-signature setting)))
 
 overrideProperty =
-#(define-music-function (parser location grob-property-path value)
-   (symbol-list? scheme?)
+#(define-music-function (grob-property-path value)
+   (key-list? scheme?)
 
    (_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
+with subproperties given as well.
+
+As opposed to @code{\\override} which overrides the context-dependent
+defaults with which a grob is created, this command uses
+@code{Output_property_engraver} at the grob acknowledge stage.  This
+may be necessary for overriding values set after the initial grob
+creation.")
+   (let ((p (check-grob-path grob-property-path (*location*)
                              #:default 'Bottom
                              #:min 3)))
      (if p
          (make-music 'ApplyOutputEvent
                      'context-type (first p)
+                     'symbol (second 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))))
+                       (ly:grob-set-nested-property! grob (cddr p) value)))
          (make-music 'Music))))
 
 
@@ -959,7 +1024,7 @@ with subproperties given as well.")
 %% pageBreak and pageTurn are music functions (iso music indentifiers),
 %% because music identifiers are not allowed at top-level.
 pageBreak =
-#(define-music-function (location parser) ()
+#(define-music-function () ()
    (_i "Force a page break.  May be used at toplevel (i.e., between scores or
 markups), or inside a score.")
    (make-music 'EventChord
@@ -972,7 +1037,7 @@ markups), or inside a score.")
                                            'break-permission 'force))))
 
 pageTurn =
-#(define-music-function (location parser) ()
+#(define-music-function () ()
    (_i "Force a page turn between two scores or top-level markups.")
    (make-music 'EventChord
                'page-marker #t
@@ -987,7 +1052,7 @@ pageTurn =
                                            'break-permission 'force))))
 
 parallelMusic =
-#(define-void-function (parser location voice-ids music) (list? ly:music?)
+#(define-void-function (voice-ids music) (list? ly:music?)
    (_i "Define parallel music sequences, separated by '|' (bar check signs),
 and assign them to the identifiers provided in @var{voice-ids}.
 
@@ -1003,10 +1068,13 @@ Example:
     d d | e e | f f |
   }
 <==>
-  A = { c c | d d | }
-  B = { d d | e e | }
-  C = { e e | f f | }
+  A = { c c | d d }
+  B = { d d | e e }
+  C = { e e | f f }
 @end verbatim
+
+The last bar checks in a sequence are not copied to the result in
+order to facilitate ending the last entry at non-bar boundaries.
 ")
    (define voice-count (length voice-ids))
    (define (bar-check? m)
@@ -1027,7 +1095,7 @@ Example:
              "Store the previously built sequence into the current voice and
 change to the following voice."
              (set-car! current-voices
-                       (cons (reverse! current-sequence)
+                       (cons current-sequence
                              (car current-voices)))
              (set! current-sequence '())
              (set! current-voices (cdr current-voices)))
@@ -1044,9 +1112,21 @@ change to the following voice."
                                (if (bar-check? m) (change-voice))))))
                      lst)
            (if (pair? current-sequence) (change-voice))
-           ;; un-circularize `voices' and reorder the voices
-           (set! voices (map reverse!
-                             (list-head voices voice-count)))
+           ;; Un-circularize voices
+           (set! voices (list-head voices voice-count))
+
+           ;; Remove trailing bar checks to facilitate ending a
+           ;; sequence on a non-bar, reverse partial sequences and sequences
+           (set! voices (map!
+                         (lambda (l)
+                           (map! reverse!
+                                 (reverse!
+                                  (if (and (pair? l) (pair? (car l))
+                                           (bar-check? (caar l)))
+                                      (cons (cdar l) (cdr l))
+                                      l))))
+                         voices))
+
            ;; check sequence length
            (apply for-each (lambda seqs
                              (define (seq-len seq)
@@ -1082,18 +1162,17 @@ change to the following voice."
        (and (or split-elt split-elts)
             (map
              (lambda (e es)
-               (apply music-clone music
-                      (append
-                       ;; reassigning the origin of the parent only
-                       ;; makes sense if the first expression in the
-                       ;; result is from a distributed origin
-                       (let ((origin
-                              (if (ly:music? elt)
-                                  (and (ly:music? e) (ly:music-property e 'origin #f))
-                                  (and (pair? es) (ly:music-property (car es) 'origin #f)))))
-                         (if origin (list 'origin origin) '()))
-                       (if (ly:music? e) (list 'element e) '())
-                       (if (pair? es) (list 'elements es) '()))))
+               (let ((m (ly:music-deep-copy music
+                       ;;; reassigning the origin of the parent only
+                       ;;; makes sense if the first expression in the
+                       ;;; result is from a distributed origin
+                                            (or (and (ly:music? e) e)
+                                                (and (pair? es) (car es))))))
+                 (if (ly:music? e)
+                     (set! (ly:music-property m 'element) e))
+                 (if (pair? es)
+                     (set! (ly:music-property m 'elements) es))
+                 m))
              (or split-elt (circular-list #f))
              (or split-elts (circular-list #f))))))
    (let ((voices (recurse-and-split music)))
@@ -1101,13 +1180,13 @@ change to the following voice."
          ;;
          ;; bind voice identifiers to the voices
          (for-each (lambda (voice-id voice)
-                     (ly:parser-define! parser voice-id voice))
+                     (ly:parser-define! voice-id voice))
                    voice-ids voices)
          (ly:music-warning music
                            (_ "ignoring parallel music without barchecks")))))
 
 parenthesize =
-#(define-music-function (parser loc arg) (ly:music?)
+#(define-music-function (arg) (ly:music?)
    (_i "Tag @var{arg} to be parenthesized.")
 
    (if (memq 'event-chord (ly:music-property arg 'types))
@@ -1123,81 +1202,109 @@ parenthesize =
        (set! (ly:music-property arg 'parenthesize) #t))
    arg)
 
+#(define (make-directed-part-combine-music direction chord-range part1 part2
+          one-context-settings
+          two-context-settings
+          shared-context-settings)
+
+   (let* ((pc-music (make-music 'PartCombineMusic))
+          (m1 (context-spec-music (make-non-relative-music part1) 'Voice "one"))
+          (m2 (context-spec-music (make-non-relative-music part2) 'Voice "two"))
+          (listener (ly:parser-lookup 'partCombineListener))
+          (evs2 (recording-group-emulate m2 listener))
+          (evs1 (recording-group-emulate m1 listener))
+          (split-list
+           (if (and (assoc "one" evs1) (assoc "two" evs2))
+               (determine-split-list (reverse! (assoc-get "one" evs1) '())
+                                     (reverse! (assoc-get "two" evs2) '())
+                                     chord-range)
+               '()))
+          (L1 (ly:music-length part1))
+          (L2 (ly:music-length part2))
+          ;; keep the contexts alive for the full duration
+          (skip (make-skip-music (make-duration-of-length
+                                  (if (ly:moment<? L1 L2) L2 L1)))))
+
+     (set! (ly:music-property pc-music 'elements)
+           (list (make-music
+                  'PartCombinePartMusic
+                  'element m1
+                  'context-change-list
+                  (make-part-combine-context-changes
+                   default-part-combine-context-change-state-machine-one
+                   split-list))
+                 (make-music
+                  'PartCombinePartMusic
+                  'element m2
+                  'context-change-list
+                  (make-part-combine-context-changes
+                   default-part-combine-context-change-state-machine-two
+                   split-list))))
+
+     (set! (ly:music-property pc-music 'direction) direction)
+
+     #{ \context Staff <<
+          \context Voice = "one" \with #one-context-settings { #skip }
+          \context Voice = "two" \with #two-context-settings { #skip }
+          \context Voice = "shared" \with #shared-context-settings { #skip }
+          \context Voice = "solo" { #skip }
+          \context NullVoice = "null" { #skip }
+          #pc-music
+          #(make-part-combine-marks
+            default-part-combine-mark-state-machine split-list)
+        >> #} ))
+
 partcombine =
-#(define-music-function (parser location chord-range part1 part2)
+#(define-music-function (chord-range part1 part2)
    ((number-pair? '(0 . 8)) ly:music? ly:music?)
    (_i "Take the music in @var{part1} and @var{part2} and return
 a music expression containing simultaneous voices, where @var{part1}
 and @var{part2} are combined into one voice where appropriate.
 Optional @var{chord-range} sets the distance in steps between notes
 that may be combined into a chord or unison.")
-   #{ \context Staff <<
-        \context Voice = "one" \with { \voiceOne } {}
-        \context Voice = "two" \with { \voiceTwo } {}
-        \context Voice = "shared" {}
-        #(make-part-combine-music parser (list part1 part2) #f chord-range)
-      >> #} )
+   (make-directed-part-combine-music #f chord-range part1 part2
+    #{ \with { \voiceOne \override DynamicLineSpanner.direction = #UP } #}
+    #{ \with { \voiceTwo \override DynamicLineSpanner.direction = #DOWN } #}
+    #{ #} ))
 
 partcombineUp =
-#(define-music-function (parser location chord-range part1 part2)
+#(define-music-function (chord-range part1 part2)
    ((number-pair? '(0 . 8)) ly:music? ly:music?)
    (_i "Take the music in @var{part1} and @var{part2} and typeset so
 that they share a staff with stems directed upward.")
-   #{ \context Staff <<
-        \context Voice = "one" \with { \voiceOne } {}
-        \context Voice = "two" \with { \voiceThree } {}
-        \context Voice = "shared" \with { \voiceOne } {}
-        #(make-part-combine-music parser (list part1 part2) UP chord-range)
-      >> #} )
+   (make-directed-part-combine-music UP chord-range part1 part2
+    #{ \with { \voiceOne \override DynamicLineSpanner.direction = #UP } #}
+    #{ \with { \voiceThree \override DynamicLineSpanner.direction = #UP } #}
+    #{ \with { \voiceOne \override DynamicLineSpanner.direction = #UP } #} ))
 
 partcombineDown =
-#(define-music-function (parser location chord-range part1 part2)
+#(define-music-function (chord-range part1 part2)
    ((number-pair? '(0 . 8)) ly:music? ly:music?)
    (_i "Take the music in @var{part1} and @var{part2} and typeset so
 that they share a staff with stems directed downward.")
-   #{ \context Staff <<
-        \context Voice = "one" \with { \voiceFour } {}
-        \context Voice = "two" \with { \voiceTwo } {}
-        \context Voice = "shared" \with { \voiceTwo } {}
-        #(make-part-combine-music parser (list part1 part2) DOWN chord-range)
-      >> #} )
-
-partcombineForce =
-#(define-music-function (location parser type once) (boolean-or-symbol? boolean?)
-   (_i "Override the part-combiner.")
-   (make-music 'EventChord
-               'elements (list (make-music 'PartCombineForceEvent
-                                           'forced-type type
-                                           'once once))))
-partcombineApart = \partcombineForce #'apart ##f
-partcombineApartOnce = \partcombineForce #'apart ##t
-partcombineChords = \partcombineForce #'chords ##f
-partcombineChordsOnce = \partcombineForce #'chords ##t
-partcombineUnisono = \partcombineForce #'unisono ##f
-partcombineUnisonoOnce = \partcombineForce #'unisono ##t
-partcombineSoloI = \partcombineForce #'solo1 ##f
-partcombineSoloIOnce = \partcombineForce #'solo1 ##t
-partcombineSoloII = \partcombineForce #'solo2 ##f
-partcombineSoloIIOnce = \partcombineForce #'solo2 ##t
-partcombineAutomatic = \partcombineForce ##f ##f
-partcombineAutomaticOnce = \partcombineForce ##f ##t
+   (make-directed-part-combine-music DOWN chord-range part1 part2
+    #{ \with { \voiceFour \override DynamicLineSpanner.direction = #DOWN } #}
+    #{ \with { \voiceTwo \override DynamicLineSpanner.direction = #DOWN } #}
+    #{ \with { \voiceTwo \override DynamicLineSpanner.direction = #DOWN } #} ))
+
+%% Part combine forcing to be found in ly/property-init.ly
 
 partial =
-#(define-music-function (parser location dur) (ly:duration?)
+#(define-music-function (dur) (ly:duration?)
   (_i "Make a partial measure.")
 
   ;; We use `descend-to-context' here instead of `context-spec-music' to
   ;; ensure \partial still works if the Timing_translator is moved
     (descend-to-context
      (context-spec-music (make-music 'PartialSet
-                                     'origin location
+                                     'origin (*location*)
                                      'duration dur)
                          'Timing)
      'Score))
 
 pitchedTrill =
 #(define-music-function
-   (parser location main-note secondary-note)
+   (main-note secondary-note)
    (ly:music? ly:music?)
    (_i "Print a trill with @var{main-note} as the main note of the trill and
 print @var{secondary-note} as a stemless note head in parentheses.")
@@ -1214,7 +1321,7 @@ print @var{secondary-note} as a stemless note head in parentheses.")
                  (for-each (lambda (m)
                              (ly:music-set-property! m 'pitch trill-pitch)) trill-events)
                  (begin
-                   (ly:input-warning location (_ "Second argument of \\pitchedTrill should be single note: "))
+                   (ly:input-warning (*location*) (_ "Second argument of \\pitchedTrill should be single note: "))
                    (display sec-note-events)))
 
              (if (eq? forced #t)
@@ -1223,8 +1330,155 @@ print @var{secondary-note} as a stemless note head in parentheses.")
                            trill-events)))))
      main-note))
 
+propertyOverride =
+#(define-music-function (grob-property-path value)
+   (key-list? scheme?)
+   (_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.  This music function is mostly intended
+for use from Scheme as a substitute for the built-in @code{\\override}
+command.")
+   (let ((p (check-grob-path grob-property-path (*location*)
+                             #:default 'Bottom
+                             #:min 3)))
+     (if p
+         (context-spec-music
+          (make-music 'OverrideProperty
+                      'symbol (cadr p)
+                      'origin (*location*)
+                      'grob-value value
+                      'grob-property-path (cddr p)
+                      'pop-first #t)
+          (car p))
+         (make-music 'Music))))
+
+propertyRevert =
+#(define-music-function (grob-property-path)
+   (key-list?)
+   (_i "Revert the grob property specified by @var{grob-property-path} to
+its previous 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.  This music function is mostly intended
+for use from Scheme as a substitute for the built-in @code{\\revert}
+command.")
+   (let ((p (check-grob-path grob-property-path (*location*)
+                             #:default 'Bottom
+                             #:min 3)))
+     (if p
+         (context-spec-music
+          (make-music 'RevertProperty
+                      'symbol (cadr p)
+                      'origin (*location*)
+                      'grob-property-path (cddr p))
+          (car p))
+         (make-music 'Music))))
+
+propertySet =
+#(define-music-function (property-path value)
+   (symbol-list-or-symbol? scheme?)
+   (_i "Set the context property specified by @var{property-path} to
+@var{value}.  This music function is mostly intended for use from
+Scheme as a substitute for the built-in @code{\\set} command.")
+   (let ((p (check-context-path property-path (*location*))))
+     (if p
+         (context-spec-music
+          (make-music 'PropertySet
+                      'symbol (cadr p)
+                      'value value
+                      'origin (*location*))
+          (car p))
+         (make-music 'Music))))
+
+propertyTweak =
+#(define-music-function (prop value item)
+   (key-list-or-symbol? scheme? key-list-or-music?)
+   (_i "Add a tweak to the following @var{item}, usually music.
+This generally behaves like @code{\\tweak} but will turn into an
+@code{\\override} when @var{item} is a symbol list.
+
+In that case, @var{item} specifies the grob path to override.  This is
+mainly useful when using @code{\\propertyTweak} as as a component for
+building other functions like @code{\\omit}.  It is not the default
+behavior for @code{\\tweak} since many input strings in
+@code{\\lyricmode} can serve equally as music or as symbols which
+causes surprising behavior when tweaking lyrics using the less
+specific semantics of @code{\\propertyTweak}.
+
+@var{prop} can contain additional elements in which case a nested
+property (inside of an alist) is tweaked.")
+   ;; Why not instead make the parser treat strings preferably as
+   ;; music in lyrics mode rather than as symbol?  Because then
+   ;;
+   ;; \tweak text "whatever" mylyrics
+   ;;
+   ;; will try putting a lyric event with text "whatever" in the text
+   ;; property of lyrics.  So we want expressions allowing both
+   ;; strings and lyrics to deliver strings: more complex conversions
+   ;; should only be attempted when the simple uses don't match the
+   ;; given predicate.
+   (if (ly:music? item)
+       (if (music-is-of-type? item 'context-specification)
+           ;; This is essentially dealing with the case
+           ;; \propertyTweak color #red \propertyTweak font-size #3 NoteHead
+           ;; namely when stacked tweaks end in a symbol list
+           ;; rather than a music expression.
+           ;;
+           ;; We have a tweak here to convert into an override,
+           ;; so we need to know the grob to apply it to.  That's
+           ;; easy if we have a directed tweak, and otherwise we
+           ;; need to find the symbol in the expression itself.
+           (let* ((p (check-grob-path prop (*location*)
+                                      #:start 1
+                                      #:default #t
+                                      #:min 2))
+                  (elt (ly:music-property item 'element))
+                  (seq (if (music-is-of-type? elt 'sequential-music)
+                           elt
+                           (make-sequential-music (list elt))))
+                  (elts (ly:music-property seq 'elements))
+                  (symbol (if (symbol? (car p))
+                              (car p)
+                              (and (pair? elts)
+                                   (ly:music-property (car elts)
+                                                      'symbol)))))
+             (if (symbol? symbol)
+                 (begin
+                   (set! (ly:music-property seq 'elements)
+                         (cons (make-music 'OverrideProperty
+                                           'symbol symbol
+                                           'grob-property-path (cdr p)
+                                           'pop-first #t
+                                           'grob-value value
+                                           'origin (*location*))
+                               elts))
+                   (set! (ly:music-property item 'element) seq))
+                 (begin
+                   (ly:parser-error (_ "Cannot \\propertyTweak")
+                                    (*location*))
+                   (ly:music-message item (_ "untweakable"))))
+             item)
+           (tweak prop value item))
+       (propertyOverride (append item (if (symbol? prop) (list prop) prop))
+                         value)))
+
+propertyUnset =
+#(define-music-function (property-path)
+   (symbol-list-or-symbol?)
+   (_i "Unset the context property specified by @var{property-path}.
+This music function is mostly intended for use from Scheme as a
+substitute for the built-in @code{\\unset} command.")
+   (let ((p (check-context-path property-path (*location*))))
+     (if p
+         (context-spec-music
+          (make-music 'PropertyUnset
+                      'symbol (cadr p)
+                      'origin (*location*))
+          (car p))
+         (make-music 'Music))))
+
 pushToTag =
-#(define-music-function (parser location tag more music)
+#(define-music-function (tag more music)
    (symbol? ly:music? ly:music?)
    (_i "Add @var{more} to the front of @code{elements} of all music
 expressions in @var{music} that are tagged with @var{tag}.")
@@ -1236,7 +1490,7 @@ expressions in @var{music} that are tagged with @var{tag}.")
               music))
 
 quoteDuring =
-#(define-music-function (parser location what main-music) (string? ly:music?)
+#(define-music-function (what main-music) (string? ly:music?)
    (_i "Indicate a section of music to be quoted.  @var{what} indicates the name
 of the quoted voice, as specified in an @code{\\addQuote} command.
 @var{main-music} is used to indicate the length of music to be quoted;
@@ -1245,8 +1499,15 @@ usually contains spacers or multi-measure rests.")
                'element main-music
                'quoted-music-name what))
 
+reduceChords =
+#(define-music-function (music) (ly:music?)
+   (_i "Reduce chords contained in @var{music} to single notes,
+intended mainly for reusing music in RhythmicStaff.  Does not
+reduce parallel music.")
+   (event-chord-reduce music))
+
 relative =
-#(define-music-function (parser location pitch music)
+#(define-music-function (pitch music)
    ((ly:pitch?) ly:music?)
    (_i "Make @var{music} relative to @var{pitch}.  If @var{pitch} is
 omitted, the first note in @var{music} is given in absolute pitch.")
@@ -1268,7 +1529,7 @@ omitted, the first note in @var{music} is given in absolute pitch.")
                'element music))
 
 removeWithTag =
-#(define-music-function (parser location tags music)
+#(define-music-function (tags music)
    (symbol-list-or-symbol? ly:music?)
    (_i "Remove elements of @var{music} that are tagged with one of the
 tags in @var{tags}.  @var{tags} may be either a single symbol or a list
@@ -1278,7 +1539,7 @@ of symbols.")
     music))
 
 resetRelativeOctave =
-#(define-music-function (parser location pitch) (ly:pitch?)
+#(define-music-function (pitch) (ly:pitch?)
    (_i "Set the octave inside a \\relative section.")
 
    (make-music 'SequentialMusic
@@ -1286,14 +1547,19 @@ resetRelativeOctave =
                (lambda (music last-pitch) pitch)))
 
 retrograde =
-#(define-music-function (parser location music)
+#(define-music-function (music)
     (ly:music?)
     (_i "Return @var{music} in reverse order.")
-    (retrograde-music music))
+    (retrograde-music
+     (expand-repeat-notes!
+      (expand-repeat-chords!
+       (cons 'rhythmic-event
+             (ly:parser-lookup '$chord-repeat-events))
+       music))))
 
 revertTimeSignatureSettings =
 #(define-music-function
-   (parser location time-signature)
+   (time-signature)
    (pair?)
 
    (_i "Revert @code{timeSignatureSettings}
@@ -1301,7 +1567,7 @@ for time signatures of @var{time-signature}.")
    (revert-time-signature-setting time-signature))
 
 rightHandFinger =
-#(define-event-function (parser location finger) (number-or-markup?)
+#(define-event-function (finger) (number-or-markup?)
    (_i "Apply @var{finger} as a fingering indication.")
 
    (make-music
@@ -1310,14 +1576,14 @@ rightHandFinger =
             finger))
 
 scaleDurations =
-#(define-music-function (parser location fraction music)
+#(define-music-function (fraction music)
    (fraction? ly:music?)
    (_i "Multiply the duration of events in @var{music} by @var{fraction}.")
    (ly:music-compress music
                       (ly:make-moment (car fraction) (cdr fraction))))
 
 settingsFrom =
-#(define-scheme-function (parser location ctx music)
+#(define-scheme-function (ctx music)
    ((symbol?) ly:music?)
    (_i "Take the layout instruction events from @var{music}, optionally
 restricted to those applying to context type @var{ctx}, and return
@@ -1367,8 +1633,8 @@ a context modification duplicating their effect.")
      mods))
 
 shape =
-#(define-music-function (parser location offsets item)
-   (list? symbol-list-or-music?)
+#(define-music-function (offsets item)
+   (list? key-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
@@ -1376,21 +1642,15 @@ 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)
+   (define (shape-curve grob coords)
      (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)))
-
+            (total-found (length siblings)))
        (define (offset-control-points offsets)
          (if (null? offsets)
              coords
-             (map
-               (lambda (x y) (coord-translate x y))
-               coords offsets)))
+             (map coord-translate coords offsets)))
 
        (define (helper sibs offs)
          (if (pair? offs)
@@ -1407,10 +1667,12 @@ appropriate tweak applied.")
        (if (>= total-found 2)
            (helper siblings offsets)
            (offset-control-points (car offsets)))))
-   #{ \once \tweak control-points #shape-curve #item #})
+   (once (propertyTweak 'control-points
+                        (grob-transformer 'control-points shape-curve)
+                        item)))
 
 shiftDurations =
-#(define-music-function (parser location dur dots arg)
+#(define-music-function (dur dots arg)
    (integer? integer? ly:music?)
    (_i "Change the duration of @var{arg} by adding @var{dur} to the
 @code{durlog} of @var{arg} and @var{dots} to the @code{dots} of @var{arg}.")
@@ -1418,7 +1680,7 @@ shiftDurations =
    (shift-duration-log arg dur dots))
 
 single =
-#(define-music-function (parser location overrides music)
+#(define-music-function (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}.")
@@ -1442,7 +1704,7 @@ This does not convert @code{\\revert}, @code{\\set} or @code{\\unset}.")
    music)
 
 skip =
-#(define-music-function (parser location dur) (ly:duration?)
+#(define-music-function (dur) (ly:duration?)
   (_i "Skip forward by @var{dur}.")
   (make-music 'SkipMusic
               'duration dur))
@@ -1454,23 +1716,22 @@ slashedGrace =
 the following music expression"))
 
 spacingTweaks =
-#(define-music-function (parser location parameters) (list?)
+#(define-music-function (parameters) (list?)
    (_i "Set the system stretch, by reading the 'system-stretch property of
 the `parameters' assoc list.")
-   #{
-     \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))))
-   #})
+   (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)
+#(define-music-function (style heads 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 tags music) (symbol-list-or-symbol? ly:music?)
+#(define-music-function (tags music) (symbol-list-or-symbol? ly:music?)
    (_i "Tag the following @var{music} with @var{tags} and return the
 result, by adding the single symbol or symbol list @var{tags} to the
 @code{tags} property of @var{music}.")
@@ -1483,14 +1744,14 @@ result, by adding the single symbol or symbol list @var{tags} to the
    music)
 
 tagGroup =
-#(define-void-function (parser location tags) (symbol-list?)
+#(define-void-function (tags) (symbol-list?)
    (_i "Define a tag group comprising the symbols in the symbol list
 @var{tags}.  Tag groups must not overlap.")
    (let ((err (define-tag-group tags)))
-     (if err (ly:parser-error parser err location))))
+     (if err (ly:parser-error err (*location*)))))
 
 temporary =
-#(define-music-function (parser location music)
+#(define-music-function (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
@@ -1523,7 +1784,7 @@ property-changing music that isn't an @code{\\override}.")
              (else
               (if (not warned)
                   (begin
-                    (ly:input-warning location (_ "Cannot make ~a revertible")
+                    (ly:input-warning (*location*) (_ "Cannot make ~a revertible")
                                       (ly:music-property m 'name))
                     (set! warned #t)))
               #t))))
@@ -1531,7 +1792,7 @@ property-changing music that isn't an @code{\\override}.")
    music)
 
 time =
-#(define-music-function (parser location beat-structure fraction)
+#(define-music-function (beat-structure fraction)
    ((number-list? '()) fraction?)
    (_i "Set @var{fraction} as time signature, with optional
 number list @var{beat-structure} before it.")
@@ -1541,7 +1802,7 @@ number list @var{beat-structure} before it.")
               'beat-structure beat-structure))
 
 times =
-#(define-music-function (parser location fraction music)
+#(define-music-function (fraction music)
    (fraction? ly:music?)
    (_i "Scale @var{music} in time by @var{fraction}.")
   (make-music 'TimeScaledMusic
@@ -1551,7 +1812,7 @@ times =
 
 transpose =
 #(define-music-function
-   (parser location from to music)
+   (from to music)
    (ly:pitch? ly:pitch? ly:music?)
 
    (_i "Transpose @var{music} from pitch @var{from} to pitch @var{to}.")
@@ -1560,7 +1821,7 @@ transpose =
 
 transposedCueDuring =
 #(define-music-function
-   (parser location what dir pitch main-music)
+   (what dir pitch main-music)
    (string? ly:dir? ly:pitch? ly:music?)
 
    (_i "Insert notes from the part @var{what} into a voice called @code{cue},
@@ -1580,7 +1841,7 @@ as a first or second voice.")
                'quoted-transposition pitch))
 
 transposition =
-#(define-music-function (parser location pitch) (ly:pitch?)
+#(define-music-function (pitch) (ly:pitch?)
    (_i "Set instrument transposition")
 
    (context-spec-music
@@ -1588,7 +1849,7 @@ transposition =
     'Staff))
 
 tuplet =
-#(define-music-function (parser location ratio tuplet-span music)
+#(define-music-function (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
@@ -1611,7 +1872,7 @@ quarter note.")
                'duration tuplet-span))
 
 tupletSpan =
-#(define-music-function (parser location tuplet-span)
+#(define-music-function (tuplet-span)
    ((ly:duration?))
    (_i "Set @code{tupletSpannerDuration}, the length into which
 @code{\\tuplet} without an explicit @samp{tuplet-span} argument of its
@@ -1627,10 +1888,10 @@ command without explicit @samp{tuplet-span}, use
        #{ \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}
+#(define-music-function (prop value music)
+   (key-list-or-symbol? scheme? ly:music?)
+   (_i "Add a tweak to the following @var{music}.
+Layout objects created by @var{music} 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'
@@ -1639,44 +1900,29 @@ 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{\\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.
-
-If this use case would call for @code{\\once \\override} rather than a
-plain @code{\\override}, writing @code{\\once \\tweak @dots{}} can be
-convenient.
-
 @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 ((p (check-grob-path
-                 (append item (if (symbol? prop) (list prop) prop))
-                 parser location
-                 #:default 'Bottom #:min 3)))
-         (if p
-             #{ \override #p = #value #}
-             (make-music 'Music)))))
+   (let ((p (check-grob-path prop (*location*)
+                             #:start 1
+                             #:default #t
+                             #:min 2)))
+     (cond ((not p))
+           ;; p now contains at least two elements.  The first
+           ;; element is #t when no grob has been explicitly
+           ;; specified, otherwise it is a grob name.
+           (else
+            (set! (ly:music-property music 'tweaks)
+                  (acons (cond ((pair? (cddr p)) p)
+                               ((symbol? (car p))
+                                (cons (car p) (cadr p)))
+                               (else (cadr p)))
+                         value
+                         (ly:music-property music 'tweaks)))))
+     music))
+
 
 undo =
-#(define-music-function (parser location music)
+#(define-music-function (music)
    (ly:music?)
    (_i "Convert @code{\\override} and @code{\\set} in @var{music} to
 @code{\\revert} and @code{\\unset}, respectively.  Any reverts and
@@ -1687,10 +1933,10 @@ unsets already in @var{music} cause a warning.  Non-property-related music is ig
      (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)))
+            (music-type-predicate '(layout-instruction-event
+                                    context-specification
+                                    apply-context
+                                    time-signature-music))
             (lambda (m overrides)
               (case (ly:music-property m 'name)
                 ((OverrideProperty)
@@ -1717,7 +1963,7 @@ unsets already in @var{music} cause a warning.  Non-property-related music is ig
                 (else
                  (if (not warned)
                      (begin
-                       (ly:input-warning location (_ "Cannot revert ~a")
+                       (ly:input-warning (*location*) (_ "Cannot revert ~a")
                                          (ly:music-property m 'name))
                        (set! warned #t)))
                  overrides)))
@@ -1729,20 +1975,47 @@ unsets already in @var{music} cause a warning.  Non-property-related music is ig
         (else (make-sequential-music lst))))))
 
 unfoldRepeats =
-#(define-music-function (parser location music) (ly:music?)
-   (_i "Force any @code{\\repeat volta}, @code{\\repeat tremolo} or
+#(define-music-function (types music)
+   ((symbol-list-or-symbol? '()) ly:music?)
+   (_i "Force @code{\\repeat volta}, @code{\\repeat tremolo} or
 @code{\\repeat percent} commands in @var{music} to be interpreted
-as @code{\\repeat unfold}.")
-   (unfold-repeats music))
+as @code{\\repeat unfold}, if specified in the optional symbol-list @var{types}.
+The default for @var{types} is an empty list, which will force any of those
+commands in @var{music} to be interpreted as @code{\\repeat unfold}.  Possible
+entries are @code{volta}, @code{tremolo} or @code{percent}.  Multiple entries
+are possible.")
+   (unfold-repeats types music))
+
+voices =
+#(define-music-function (ids music) (key-list? ly:music?)
+   (_i "Take the given key list of numbers (indicating the use of
+@samp{\\voiceOne}@dots{}) or symbols (indicating voice names,
+typically converted from strings by argument list processing)
+and assign the following @code{\\\\}-separated music to
+contexts according to that list.  Named rather than numbered
+contexts can be used for continuing one voice (for the sake of
+spanners and lyrics), usually requiring a @code{\\voiceOne}-style
+override at the beginning of the passage and a @code{\\oneVoice}
+override at its end.
+
+The default
+@example
+<< @dots{} \\\\ @dots{} \\\\ @dots{} >>
+@end example
+construct would correspond to
+@example
+\\voices 1,2,3 << @dots{} \\\\ @dots{} \\\\ @dots{} >>
+@end example")
+   (voicify-music music ids))
 
 void =
-#(define-void-function (parser location arg) (scheme?)
+#(define-void-function (arg) (scheme?)
    (_i "Accept a scheme argument, return a void expression.
 Use this if you want to have a scheme expression evaluated
 because of its side-effects, but its value ignored."))
 
 withMusicProperty =
-#(define-music-function (parser location sym val music)
+#(define-music-function (sym val music)
    (symbol? scheme? ly:music?)
    (_i "Set @var{sym} to @var{val} in @var{music}.")