Issue 4442/5: Fix the rest of removal of parser/(*parser*) manually

diff --git a/input/regression/display-lily-tests.ly b/input/regression/display-lily-tests.ly
index 128c237d6d8375d2b7fe52885a9c049b04a09cd0..b85deff6896d5e4906bac22c3883eefa84c814fd 100644 (file)
--- a/input/regression/display-lily-tests.ly
+++ b/input/regression/display-lily-tests.ly
@@ -18,7 +18,7 @@
     `(let* ((parser-clone (ly:parser-clone))
             (input-str (string-trim-both ,lily-string))
             (music (ly:parse-string-expression parser-clone input-str))
-            (result-str (string-trim-both (music->lily-string music parser-clone))))
+            (result-str (string-trim-both (music->lily-string music))))
        (cons input-str result-str))))
 
 #(read-hash-extend #\[ parse-lily-and-compute-lily-string) %{ ] %}

diff --git a/ly/init.ly b/ly/init.ly
index f906273c7f470b00a066439465c035c890359eed..394b122f3168a0b4f2b2880ba6500fa4029a8fe7 100644 (file)
--- a/ly/init.ly
+++ b/ly/init.ly
@@ -68,12 +68,12 @@ $(if (ly:get-option 'include-settings)
                             (ly:book-add-score! book score))
                           (reverse! toplevel-scores)))
             (set! toplevel-scores (list))
-            (book-handler (*parser*) book)))
+            (book-handler book)))
          ((or (pair? toplevel-scores) output-empty-score-list)
           (let ((book (apply ly:make-book $defaultpaper
                              $defaultheader toplevel-scores)))
             (set! toplevel-scores (list))
-            (book-handler (*parser*) book)))))
+            (book-handler book)))))
 
 #(if (eq? expect-error (ly:parser-has-error?))
   (ly:parser-clear-error)

diff --git a/scm/define-music-display-methods.scm b/scm/define-music-display-methods.scm
index 6a428dd5d35218020f84b5b623eabd0780800c1a..718c501e77d69a43df3d94cf1a01282c79ce922b 100644 (file)
--- a/scm/define-music-display-methods.scm
+++ b/scm/define-music-display-methods.scm
@@ -89,9 +89,7 @@ expression."
   (define (pitch= pitch1 pitch2)
     (and (= (ly:pitch-notename pitch1) (ly:pitch-notename pitch2))
          (= (ly:pitch-alteration pitch1) (ly:pitch-alteration pitch2))))
-  (let* ((pitches (if parser (ly:parser-lookup 'pitchnames)
-                      (assoc-get (string->symbol default-language)
-                                 language-pitch-names '())))
+  (let* ((pitches (ly:parser-lookup 'pitchnames))
          (result (rassoc ly-pitch pitches pitch=)))
     (and result (car result))))
 
@@ -153,23 +151,23 @@ expression."
                  ,str-start
                  ,str-stop))))
 
-(define-display-method HyphenEvent (event parser)
+(define-display-method HyphenEvent (event)
   " --")
-(define-display-method ExtenderEvent (event parser)
+(define-display-method ExtenderEvent (event)
   " __")
-(define-display-method TieEvent (event parser)
+(define-display-method TieEvent (event)
   " ~")
-(define-display-method BeamForbidEvent (event parser)
+(define-display-method BeamForbidEvent (event)
   "\\noBeam")
-(define-display-method StringNumberEvent (event parser)
+(define-display-method StringNumberEvent (event)
   (format #f "\\~a" (ly:music-property event 'string-number)))
 
 
-(define-display-method TremoloEvent (event parser)
+(define-display-method TremoloEvent (event)
   (let ((tremolo-type (ly:music-property event 'tremolo-type 8)))
     (format #f ":~a" tremolo-type)))
 
-(define-display-method ArticulationEvent (event parser) #t
+(define-display-method ArticulationEvent (event) #t
   (let* ((articulation  (ly:music-property event 'articulation-type))
          (shorthand
           (case (string->symbol articulation)
@@ -186,46 +184,46 @@ expression."
             shorthand
             (or shorthand articulation))))
 
-(define-post-event-display-method FingeringEvent (event parser) #t
+(define-post-event-display-method FingeringEvent (event) #t
   (ly:music-property event 'digit))
 
-(define-post-event-display-method TextScriptEvent (event parser) #t
+(define-post-event-display-method TextScriptEvent (event) #t
   (markup->lily-string (ly:music-property event 'text)))
 
-(define-post-event-display-method MultiMeasureTextEvent (event parser) #t
+(define-post-event-display-method MultiMeasureTextEvent (event) #t
   (markup->lily-string (ly:music-property event 'text)))
 
-(define-post-event-display-method BendAfterEvent (event parser) #f
+(define-post-event-display-method BendAfterEvent (event) #f
   (format #f "\\bendAfter #~a " (ly:music-property event 'delta-step)))
 
-(define-post-event-display-method HarmonicEvent (event parser) #f "\\harmonic")
-(define-post-event-display-method GlissandoEvent (event parser) #f "\\glissando")
-(define-post-event-display-method ArpeggioEvent (event parser) #f "\\arpeggio")
-(define-post-event-display-method AbsoluteDynamicEvent (event parser) #f
+(define-post-event-display-method HarmonicEvent (event) #f "\\harmonic")
+(define-post-event-display-method GlissandoEvent (event) #f "\\glissando")
+(define-post-event-display-method ArpeggioEvent (event) #f "\\arpeggio")
+(define-post-event-display-method AbsoluteDynamicEvent (event) #f
   (format #f "\\~a" (ly:music-property event 'text)))
 
-(define-post-event-display-method StrokeFingerEvent (event parser) #f
+(define-post-event-display-method StrokeFingerEvent (event) #f
   (format #f "\\rightHandFinger #~a " (ly:music-property event 'digit)))
 
-(define-span-event-display-method BeamEvent (event parser) #f "[" "]")
-(define-span-event-display-method SlurEvent (event parser) #f "(" ")")
-(define-span-event-display-method CrescendoEvent (event parser) #f "\\<" "\\!")
-(define-span-event-display-method DecrescendoEvent (event parser) #f "\\>" "\\!")
-(define-span-event-display-method EpisemaEvent (event parser) #f "\\episemInitium" "\\episemFinis")
-(define-span-event-display-method PhrasingSlurEvent (event parser) #f "\\(" "\\)")
-(define-span-event-display-method SustainEvent (event parser) #f "\\sustainOn" "\\sustainOff")
-(define-span-event-display-method SostenutoEvent (event parser) #f "\\sostenutoOn" "\\sostenutoOff")
-(define-span-event-display-method TextSpanEvent (event parser) #f "\\startTextSpan" "\\stopTextSpan")
-(define-span-event-display-method TrillSpanEvent (event parser) #f "\\startTrillSpan" "\\stopTrillSpan")
-(define-span-event-display-method StaffSpanEvent (event parser) #f "\\startStaff" "\\stopStaff")
-(define-span-event-display-method NoteGroupingEvent (event parser) #f "\\startGroup" "\\stopGroup")
-(define-span-event-display-method UnaCordaEvent (event parser) #f "\\unaCorda" "\\treCorde")
+(define-span-event-display-method BeamEvent (event) #f "[" "]")
+(define-span-event-display-method SlurEvent (event) #f "(" ")")
+(define-span-event-display-method CrescendoEvent (event) #f "\\<" "\\!")
+(define-span-event-display-method DecrescendoEvent (event) #f "\\>" "\\!")
+(define-span-event-display-method EpisemaEvent (event) #f "\\episemInitium" "\\episemFinis")
+(define-span-event-display-method PhrasingSlurEvent (event) #f "\\(" "\\)")
+(define-span-event-display-method SustainEvent (event) #f "\\sustainOn" "\\sustainOff")
+(define-span-event-display-method SostenutoEvent (event) #f "\\sostenutoOn" "\\sostenutoOff")
+(define-span-event-display-method TextSpanEvent (event) #f "\\startTextSpan" "\\stopTextSpan")
+(define-span-event-display-method TrillSpanEvent (event) #f "\\startTrillSpan" "\\stopTrillSpan")
+(define-span-event-display-method StaffSpanEvent (event) #f "\\startStaff" "\\stopStaff")
+(define-span-event-display-method NoteGroupingEvent (event) #f "\\startGroup" "\\stopGroup")
+(define-span-event-display-method UnaCordaEvent (event) #f "\\unaCorda" "\\treCorde")
 
 ;;;
 ;;; Graces
 ;;;
 
-(define-display-method GraceMusic (expr parser)
+(define-display-method GraceMusic (expr)
   (format #f "\\grace ~a"
           (music->lily-string (ly:music-property expr 'element))))
 
@@ -233,7 +231,7 @@ expression."
 ;; TODO: it would be better to compare ?start and ?stop
 ;; with startAppoggiaturaMusic and stopAppoggiaturaMusic,
 ;; using a custom music equality predicate.
-(define-extra-display-method GraceMusic (expr parser)
+(define-extra-display-method GraceMusic (expr)
   "Display method for appoggiatura."
   (with-music-match (expr (music
                            'GraceMusic
@@ -264,7 +262,7 @@ expression."
                                            (format #f "\\appoggiatura ~a" (music->lily-string ?music))))))
 
 
-(define-extra-display-method GraceMusic (expr parser)
+(define-extra-display-method GraceMusic (expr)
   "Display method for acciaccatura."
   (with-music-match (expr (music
                            'GraceMusic
@@ -308,7 +306,7 @@ expression."
                                                                 span-direction STOP))))))
                                            (format #f "\\acciaccatura ~a" (music->lily-string ?music))))))
 
-(define-extra-display-method GraceMusic (expr parser)
+(define-extra-display-method GraceMusic (expr)
   "Display method for grace."
   (with-music-match (expr (music
                            'GraceMusic
@@ -327,7 +325,7 @@ expression."
 ;;; Music sequences
 ;;;
 
-(define-display-method SequentialMusic (seq parser)
+(define-display-method SequentialMusic (seq)
   (let ((force-line-break (and (*force-line-break*)
                                ;; hm
                                (> (length (ly:music-property seq 'elements))
@@ -382,14 +380,14 @@ expression."
             (if force-line-break 1 0)
             (if force-line-break (*indent*) 1))))
 
-(define-display-method SimultaneousMusic (sim parser)
+(define-display-method SimultaneousMusic (sim)
   (parameterize ((*indent* (+ 3 (*indent*))))
                 (format #f "<< ~{~a ~}>>"
                         (map-in-order (lambda (music)
                                         (music->lily-string music))
                                       (ly:music-property sim 'elements)))))
 
-(define-extra-display-method SimultaneousMusic (expr parser)
+(define-extra-display-method SimultaneousMusic (expr)
   "If `sim' is an \afterGrace expression, return \"\\afterGrace ...\".
 Otherwise, return #f."
   ;; TODO: do something with afterGraceFraction?
@@ -407,7 +405,7 @@ Otherwise, return #f."
 ;;; Chords
 ;;;
 
-(define-display-method EventChord (chord parser)
+(define-display-method EventChord (chord)
   ;; event_chord : command_element
   ;;               | note_chord_element
 
@@ -464,24 +462,24 @@ Otherwise, return #f."
                                         (music->lily-string music)))
                                      other-elements))))))))
 
-(define-display-method MultiMeasureRestMusic (mmrest parser)
+(define-display-method MultiMeasureRestMusic (mmrest)
   (format #f "R~a~{~a~^ ~}"
           (duration->lily-string (ly:music-property mmrest 'duration))
           (map-in-order (lambda (music)
                           (music->lily-string music))
                         (ly:music-property mmrest 'articulations))))
 
-(define-display-method SkipMusic (skip parser)
+(define-display-method SkipMusic (skip)
   (format #f "\\skip ~a" (duration->lily-string (ly:music-property skip 'duration) #:force-duration #t)))
 
-(define-display-method OttavaMusic (ottava parser)
+(define-display-method OttavaMusic (ottava)
   (format #f "\\ottava #~a" (ly:music-property ottava 'ottava-number)))
 
 ;;;
 ;;; Notes, rests, skips...
 ;;;
 
-(define (simple-note->lily-string event parser)
+(define (simple-note->lily-string event)
   (format #f "~a~a~a~a~a~a~:{~:[-~;~]~a~}" ; pitchname octave !? octave-check duration optional_rest articulations
           (note-name->lily-string (ly:music-property event 'pitch))
           (octave->lily-string (ly:music-property event 'pitch))
@@ -511,9 +509,9 @@ Otherwise, return #f."
                            (music->lily-string event)))
                         (ly:music-property event 'articulations))))
 
-(define-display-method NoteEvent (note parser)
+(define-display-method NoteEvent (note)
   (cond ((not (null? (ly:music-property note 'pitch))) ;; note
-         (simple-note->lily-string note parser))
+         (simple-note->lily-string note))
         ((not (null? (ly:music-property note 'drum-type))) ;; drum
          (format #f "~a~a~{~a~}" (ly:music-property note 'drum-type)
                  (duration->lily-string (ly:music-property note 'duration))
@@ -529,38 +527,38 @@ Otherwise, return #f."
                                  (music->lily-string event))
                                (ly:music-property note 'articulations))))))
 
-(define-display-method ClusterNoteEvent (note parser)
-  (simple-note->lily-string note parser))
+(define-display-method ClusterNoteEvent (note)
+  (simple-note->lily-string note))
 
-(define-display-method RestEvent (rest parser)
+(define-display-method RestEvent (rest)
   (if (not (null? (ly:music-property rest 'pitch)))
-      (simple-note->lily-string rest parser)
+      (simple-note->lily-string rest)
       (format #f "r~a~{~a~}"
               (duration->lily-string (ly:music-property rest 'duration))
               (map-in-order (lambda (event)
                               (music->lily-string event))
                             (ly:music-property rest 'articulations)))))
 
-(define-display-method MultiMeasureRestEvent (rest parser)
+(define-display-method MultiMeasureRestEvent (rest)
   (string-append "R" (duration->lily-string (ly:music-property rest 'duration))))
 
-(define-display-method SkipEvent (rest parser)
+(define-display-method SkipEvent (rest)
   (format #f "s~a~{~a~}"
           (duration->lily-string (ly:music-property rest 'duration))
           (map-in-order (lambda (event)
                           (music->lily-string event))
                         (ly:music-property rest 'articulations))))
 
-(define-display-method RepeatedChord (chord parser)
+(define-display-method RepeatedChord (chord)
   (music->lily-string (ly:music-property chord 'element)))
 
-(define-display-method MarkEvent (mark parser)
+(define-display-method MarkEvent (mark)
   (let ((label (ly:music-property mark 'label)))
     (if (null? label)
         "\\mark \\default"
         (format #f "\\mark ~a" (markup->lily-string label)))))
 
-(define-display-method KeyChangeEvent (key parser)
+(define-display-method KeyChangeEvent (key)
   (let ((pitch-alist (ly:music-property key 'pitch-alist))
         (tonic (ly:music-property key 'tonic)))
     (if (or (null? pitch-alist)
@@ -571,34 +569,32 @@ Otherwise, return #f."
           (format #f "\\key ~a \\~a~a"
                   (note-name->lily-string (ly:music-property key 'tonic))
                   (any (lambda (mode)
-                         (if (and parser
-                                  (equal? (ly:parser-lookup mode) c-pitch-alist))
-                             (symbol->string mode)
-                             #f))
+                         (and (equal? (ly:parser-lookup mode) c-pitch-alist)
+                              (symbol->string mode)))
                        '(major minor ionian locrian aeolian mixolydian lydian phrygian dorian))
                   (new-line->lily-string))))))
 
-(define-display-method RelativeOctaveCheck (octave parser)
+(define-display-method RelativeOctaveCheck (octave)
   (let ((pitch (ly:music-property octave 'pitch)))
     (format #f "\\octaveCheck ~a~a"
             (note-name->lily-string pitch)
             (octave->lily-string pitch))))
 
-(define-display-method VoiceSeparator (sep parser)
+(define-display-method VoiceSeparator (sep)
   "\\\\")
 
-(define-display-method LigatureEvent (ligature parser)
+(define-display-method LigatureEvent (ligature)
   (if (= START (ly:music-property ligature 'span-direction))
       "\\["
       "\\]"))
 
-(define-display-method BarCheck (check parser)
+(define-display-method BarCheck (check)
   (format #f "|~a" (new-line->lily-string)))
 
-(define-display-method PesOrFlexaEvent (expr parser)
+(define-display-method PesOrFlexaEvent (expr)
   "\\~")
 
-(define-display-method BassFigureEvent (figure parser)
+(define-display-method BassFigureEvent (figure)
   (let ((alteration (ly:music-property figure 'alteration))
         (fig (ly:music-property figure 'figure))
         (bracket-start (ly:music-property figure 'bracket-start))
@@ -620,7 +616,7 @@ Otherwise, return #f."
                  (else "")))
             (if (null? bracket-stop) "" "]"))))
 
-(define-display-method LyricEvent (lyric parser)
+(define-display-method LyricEvent (lyric)
   (format #f "~a~{~a~^ ~}"
           (let ((text (ly:music-property lyric 'text)))
             (if (or (string? text)
@@ -637,25 +633,25 @@ Otherwise, return #f."
           (map-in-order (lambda (m) (music->lily-string m))
                         (ly:music-property lyric 'articulations))))
 
-(define-display-method BreathingEvent (event parser)
+(define-display-method BreathingEvent (event)
   "\\breathe")
 
 ;;;
 ;;; Staff switches
 ;;;
 
-(define-display-method AutoChangeMusic (m parser)
+(define-display-method AutoChangeMusic (m)
   (format #f "\\autochange ~a"
           (music->lily-string (ly:music-property m 'element))))
 
-(define-display-method ContextChange (m parser)
+(define-display-method ContextChange (m)
   (format #f "\\change ~a = \"~a\""
           (ly:music-property m 'change-to-type)
           (ly:music-property m 'change-to-id)))
 
 ;;;
 
-(define-display-method TimeScaledMusic (times parser)
+(define-display-method TimeScaledMusic (times)
   (let* ((num (ly:music-property times 'numerator))
          (den (ly:music-property times 'denominator))
          (span (ly:music-property times 'duration #f))
@@ -674,19 +670,19 @@ Otherwise, return #f."
                                  (music->lily-string (ly:music-property times 'element))))))
       result)))
 
-(define-display-method RelativeOctaveMusic (m parser)
+(define-display-method RelativeOctaveMusic (m)
   (music->lily-string (ly:music-property m 'element)))
 
-(define-display-method TransposedMusic (m parser)
+(define-display-method TransposedMusic (m)
   (music->lily-string (ly:music-property m 'element)))
 
 ;;;
 ;;; Repeats
 ;;;
 
-(define-display-method AlternativeEvent (alternative parser) "")
+(define-display-method AlternativeEvent (alternative) "")
 
-(define (repeat->lily-string expr repeat-type parser)
+(define (repeat->lily-string expr repeat-type)
   (let* ((main (music->lily-string (ly:music-property expr 'element))))
     (format #f "\\repeat ~a ~a ~a ~a"
             repeat-type
@@ -700,23 +696,23 @@ Otherwise, return #f."
                                           (music->lily-string music))
                                         alternatives)))))))
 
-(define-display-method VoltaRepeatedMusic (expr parser)
-  (repeat->lily-string expr "volta" parser))
+(define-display-method VoltaRepeatedMusic (expr)
+  (repeat->lily-string expr "volta"))
 
-(define-display-method UnfoldedRepeatedMusic (expr parser)
-  (repeat->lily-string expr "unfold" parser))
+(define-display-method UnfoldedRepeatedMusic (expr)
+  (repeat->lily-string expr "unfold"))
 
-(define-display-method PercentRepeatedMusic (expr parser)
-  (repeat->lily-string expr "percent" parser))
+(define-display-method PercentRepeatedMusic (expr)
+  (repeat->lily-string expr "percent"))
 
-(define-display-method TremoloRepeatedMusic (expr parser)
-  (repeat->lily-string expr "tremolo" parser))
+(define-display-method TremoloRepeatedMusic (expr)
+  (repeat->lily-string expr "tremolo"))
 
 ;;;
 ;;; Contexts
 ;;;
 
-(define-display-method ContextSpeccedMusic (expr parser)
+(define-display-method ContextSpeccedMusic (expr)
   (let ((id    (ly:music-property expr 'context-id))
         (create-new (ly:music-property expr 'create-new))
         (music (ly:music-property expr 'element))
@@ -745,7 +741,7 @@ Otherwise, return #f."
                           (music->lily-string music)))))
 
 ;; special cases: \figures \lyrics \drums
-(define-extra-display-method ContextSpeccedMusic (expr parser)
+(define-extra-display-method ContextSpeccedMusic (expr)
   (with-music-match (expr (music 'ContextSpeccedMusic
                                  create-new #t
                                  property-operations ?op
@@ -766,7 +762,7 @@ Otherwise, return #f."
 
 ;;; Context properties
 
-(define-extra-display-method ContextSpeccedMusic (expr parser)
+(define-extra-display-method ContextSpeccedMusic (expr)
   (let ((element (ly:music-property expr 'element))
         (property-tuning? (make-music-type-predicate 'PropertySet
                                                      'PropertyUnset
@@ -797,7 +793,7 @@ Otherwise, return #f."
         (else
          (format #f "#~a" (scheme-expr->lily-string arg)))))
 
-(define-display-method PropertySet (expr parser)
+(define-display-method PropertySet (expr)
   (let ((property (ly:music-property expr 'symbol))
         (value (ly:music-property expr 'value))
         (once (ly:music-property expr 'once)))
@@ -812,7 +808,7 @@ Otherwise, return #f."
             (value->lily-string value)
             (new-line->lily-string))))
 
-(define-display-method PropertyUnset (expr parser)
+(define-display-method PropertyUnset (expr)
   (format #f "\\unset ~a~a~a"
           (if (eqv? (*current-context*) 'Bottom)
               ""
@@ -822,7 +818,7 @@ Otherwise, return #f."
 
 ;;; Layout properties
 
-(define-display-method OverrideProperty (expr parser)
+(define-display-method OverrideProperty (expr)
   (let* ((symbol          (ly:music-property expr 'symbol))
          (properties   (ly:music-property expr 'grob-property-path
                                           (list (ly:music-property expr 'grob-property))))
@@ -840,7 +836,7 @@ Otherwise, return #f."
             (value->lily-string value)
             (new-line->lily-string))))
 
-(define-display-method RevertProperty (expr parser)
+(define-display-method RevertProperty (expr)
   (let* ((symbol (ly:music-property expr 'symbol))
          (properties (ly:music-property expr 'grob-property-path
                                         (list (ly:music-property expr 'grob-property)))))
@@ -850,7 +846,7 @@ Otherwise, return #f."
                 (cons* (*current-context*) symbol properties))
             (new-line->lily-string))))
 
-(define-display-method TimeSignatureMusic (expr parser)
+(define-display-method TimeSignatureMusic (expr)
   (let* ((num (ly:music-property expr 'numerator))
          (den (ly:music-property expr 'denominator))
          (structure (ly:music-property expr 'beat-structure)))
@@ -865,7 +861,7 @@ Otherwise, return #f."
                 (new-line->lily-string)))))
 
 ;;; \melisma and \melismaEnd
-(define-extra-display-method ContextSpeccedMusic (expr parser)
+(define-extra-display-method ContextSpeccedMusic (expr)
   "If expr is a melisma, return \"\\melisma\", otherwise, return #f."
   (with-music-match (expr (music 'ContextSpeccedMusic
                                  element (music 'PropertySet
@@ -873,7 +869,7 @@ Otherwise, return #f."
                                                 symbol 'melismaBusy)))
                     "\\melisma"))
 
-(define-extra-display-method ContextSpeccedMusic (expr parser)
+(define-extra-display-method ContextSpeccedMusic (expr)
   "If expr is a melisma end, return \"\\melismaEnd\", otherwise, return #f."
   (with-music-match (expr (music 'ContextSpeccedMusic
                                  element (music 'PropertyUnset
@@ -881,7 +877,7 @@ Otherwise, return #f."
                     "\\melismaEnd"))
 
 ;;; \tempo
-(define-extra-display-method SequentialMusic (expr parser)
+(define-extra-display-method SequentialMusic (expr)
   (with-music-match (expr (music 'SequentialMusic
                                  elements ((music 'TempoChangeEvent
                                                   text ?text
@@ -900,7 +896,7 @@ Otherwise, return #f."
                                 ?count)
                             (new-line->lily-string))))
 
-(define-display-method TempoChangeEvent (expr parser)
+(define-display-method TempoChangeEvent (expr)
   (let ((text (ly:music-property expr 'text)))
     (format #f "\\tempo ~a~a"
             (markup->lily-string text)
@@ -917,7 +913,7 @@ Otherwise, return #f."
                          (car name+vals)))
                  clefs))))
 
-(define-extra-display-method ContextSpeccedMusic (expr parser)
+(define-extra-display-method ContextSpeccedMusic (expr)
   "If @var{expr} is a clef change, return \"\\clef ...\".
 Otherwise, return @code{#f}."
   (with-music-match (expr (music 'ContextSpeccedMusic
@@ -956,7 +952,7 @@ Otherwise, return @code{#f}."
                                    (new-line->lily-string))))))
 
 ;;; \bar
-(define-extra-display-method ContextSpeccedMusic (expr parser)
+(define-extra-display-method ContextSpeccedMusic (expr)
   "If `expr' is a bar, return \"\\bar ...\".
 Otherwise, return #f."
   (with-music-match (expr (music 'ContextSpeccedMusic
@@ -967,7 +963,7 @@ Otherwise, return #f."
                     (format #f "\\bar \"~a\"~a" ?bar-type (new-line->lily-string))))
 
 ;;; \partial
-(define-extra-display-method ContextSpeccedMusic (expr parser)
+(define-extra-display-method ContextSpeccedMusic (expr)
   "If `expr' is a partial measure, return \"\\partial ...\".
 Otherwise, return #f."
   (with-music-match (expr (music
@@ -986,7 +982,7 @@ Otherwise, return #f."
 ;;;
 ;;;
 
-(define-display-method ApplyOutputEvent (applyoutput parser)
+(define-display-method ApplyOutputEvent (applyoutput)
   (let ((proc (ly:music-property applyoutput 'procedure))
         (ctx  (ly:music-property applyoutput 'context-type)))
     (format #f "\\applyOutput #'~a #~a"
@@ -996,7 +992,7 @@ Otherwise, return #f."
                   (lambda ()
                     (pretty-print (procedure-source proc))))))))
 
-(define-display-method ApplyContext (applycontext parser)
+(define-display-method ApplyContext (applycontext)
   (let ((proc (ly:music-property applycontext 'procedure)))
     (format #f "\\applyContext #~a"
             (or (procedure-name proc)
@@ -1005,13 +1001,13 @@ Otherwise, return #f."
                     (pretty-print (procedure-source proc))))))))
 
 ;;; \partcombine
-(define-display-method PartCombineMusic (expr parser)
+(define-display-method PartCombineMusic (expr)
   (format #f "\\partcombine ~{~a ~}"
           (map-in-order (lambda (music)
                           (music->lily-string music))
                         (ly:music-property expr 'elements))))
 
-(define-extra-display-method PartCombineMusic (expr parser)
+(define-extra-display-method PartCombineMusic (expr)
   (with-music-match (expr (music 'PartCombineMusic
                                  direction ?dir
                                  elements ((music 'UnrelativableMusic
@@ -1032,7 +1028,7 @@ Otherwise, return #f."
                             (new-line->lily-string)
                             (music->lily-string ?sequence2))))
 
-(define-extra-display-method ContextSpeccedMusic (expr parser)
+(define-extra-display-method ContextSpeccedMusic (expr)
   "If `expr' is a \\partcombine expression, return \"\\partcombine ...\".
 Otherwise, return #f."
   (with-music-match
@@ -1059,11 +1055,11 @@ Otherwise, return #f."
     (?pc-music (music 'PartCombineMusic))
     (format #f "~a" (music->lily-string ?pc-music)))))
 
-(define-display-method UnrelativableMusic (expr parser)
+(define-display-method UnrelativableMusic (expr)
   (music->lily-string (ly:music-property expr 'element)))
 
 ;;; Cue notes
-(define-display-method QuoteMusic (expr parser)
+(define-display-method QuoteMusic (expr)
   (or (with-music-match (expr (music
                                'QuoteMusic
                                quoted-voice-direction ?quoted-voice-direction
@@ -1082,22 +1078,22 @@ Otherwise, return #f."
 ;;;
 ;;; Breaks
 ;;;
-(define-display-method LineBreakEvent (expr parser)
+(define-display-method LineBreakEvent (expr)
   (if (null? (ly:music-property expr 'break-permission))
       "\\noBreak"
       "\\break"))
 
-(define-display-method PageBreakEvent (expr parser)
+(define-display-method PageBreakEvent (expr)
   (if (null? (ly:music-property expr 'break-permission))
       "\\noPageBreak"
       "\\pageBreak"))
 
-(define-display-method PageTurnEvent (expr parser)
+(define-display-method PageTurnEvent (expr)
   (if (null? (ly:music-property expr 'break-permission))
       "\\noPageTurn"
       "\\pageTurn"))
 
-(define-extra-display-method EventChord (expr parser)
+(define-extra-display-method EventChord (expr)
   (with-music-match (expr (music 'EventChord
                                  elements ((music 'LineBreakEvent
                                                   break-permission 'force)
@@ -1105,7 +1101,7 @@ Otherwise, return #f."
                                                   break-permission 'force))))
                     "\\pageBreak"))
 
-(define-extra-display-method EventChord (expr parser)
+(define-extra-display-method EventChord (expr)
   (with-music-match (expr (music 'EventChord
                                  elements ((music 'LineBreakEvent
                                                   break-permission 'force)
@@ -1120,7 +1116,7 @@ Otherwise, return #f."
 ;;;
 
 ;;; \lyricsto
-(define-display-method LyricCombineMusic (expr parser)
+(define-display-method LyricCombineMusic (expr)
   (format #f "\\lyricsto ~s ~a"
           (ly:music-property expr 'associated-context)
           (parameterize ((*explicit-mode* #f)
@@ -1128,7 +1124,7 @@ Otherwise, return #f."
                         (music->lily-string (ly:music-property expr 'element)))))
 
 ;; \addlyrics
-(define-extra-display-method SimultaneousMusic (expr parser)
+(define-extra-display-method SimultaneousMusic (expr)
   (with-music-match (expr (music 'SimultaneousMusic
                                  elements ((music 'ContextSpeccedMusic
                                                   context-id ?id
@@ -1150,5 +1146,5 @@ Otherwise, return #f."
                         #f)))
 
 ;; Silence internal event sent at end of each lyrics block
-(define-display-method CompletizeExtenderEvent (expr parser)
+(define-display-method CompletizeExtenderEvent (expr)
   "")

diff --git a/scm/display-lily.scm b/scm/display-lily.scm
index 668678146f0f2b3dfbb69792652430bfc126649a..e591d50b1d47fe7744e643a0924e48be6759a4d6 100644 (file)
--- a/scm/display-lily.scm
+++ b/scm/display-lily.scm
@@ -41,7 +41,7 @@
 `display-methods' property of the music type entry found in the
 `music-name-to-property-table' hash table.  Print methods previously
 defined for that music type are lost.
-Syntax: (define-display-method MusicType (expression parser)
+Syntax: (define-display-method MusicType (expression)
           ...body...))"
   `(let ((type-props (hashq-ref music-name-to-property-table
                                 ',music-type '()))
@@ -107,7 +107,7 @@ display method will be called."
                                           music-type '())
                                'display-methods))
              (result-string (and procs (any (lambda (proc)
-                                              (proc expr parser))
+                                              (proc expr))
                                             procs))))
         (if result-string
             (format #f "~a~a~a"

diff --git a/scm/lily-library.scm b/scm/lily-library.scm
index d1a91127658d01358026cdaac0ba10a4197e8e84..7f05be2bdf32c350341286fb90388c332749c52c 100644 (file)
--- a/scm/lily-library.scm
+++ b/scm/lily-library.scm
@@ -197,17 +197,17 @@ This supports historic use of @code{Completion_heads_engraver} to split
 (define-public (scorify-music music)
   "Preprocess @var{music}."
   (ly:make-score
-   (fold (lambda (f m) (f m parser))
+   (fold (lambda (f m) (f m))
          music
          toplevel-music-functions)))
 
-(define (get-current-filename parser book)
+(define (get-current-filename book)
   "return any suffix value for output filename allowing for settings by
 calls to bookOutputName function"
   (or (paper-variable book 'output-filename)
       (ly:parser-output-name)))
 
-(define (get-current-suffix parser book)
+(define (get-current-suffix book)
   "return any suffix value for output filename allowing for settings by calls to
 bookoutput function"
   (let ((book-output-suffix (paper-variable book 'output-suffix)))
@@ -217,13 +217,13 @@ bookoutput function"
 
 (define-public current-outfile-name #f)  ; for use by regression tests
 
-(define (get-outfile-name parser book)
+(define (get-outfile-name book)
   "return current filename for generating backend output files"
   ;; user can now override the base file name, so we have to use
   ;; the file-name concatenated with any potential output-suffix value
   ;; as the key to out internal a-list
-  (let* ((base-name (get-current-filename parser book))
-         (output-suffix (get-current-suffix parser book))
+  (let* ((base-name (get-current-filename book))
+         (output-suffix (get-current-suffix book))
          (alist-key (format #f "~a~a" base-name output-suffix))
          (counter-alist (ly:parser-lookup 'counter-alist))
          (output-count (assoc-get alist-key counter-alist 0))
@@ -247,17 +247,17 @@ bookoutput function"
     (set! current-outfile-name result)
     result))
 
-(define (print-book-with parser book process-procedure)
+(define (print-book-with book process-procedure)
   (let* ((paper (ly:parser-lookup '$defaultpaper))
          (layout (ly:parser-lookup '$defaultlayout))
-         (outfile-name (get-outfile-name parser book)))
+         (outfile-name (get-outfile-name book)))
     (process-procedure book paper layout outfile-name)))
 
 (define-public (print-book-with-defaults book)
-  (print-book-with parser book ly:book-process))
+  (print-book-with book ly:book-process))
 
 (define-public (print-book-with-defaults-as-systems book)
-  (print-book-with parser book ly:book-process-to-systems))
+  (print-book-with book ly:book-process-to-systems))
 
 ;; Add a score to the current bookpart, book or toplevel
 (define-public (add-score score)
@@ -269,24 +269,24 @@ bookoutput function"
     ((ly:parser-lookup 'book-score-handler)
      (ly:parser-lookup '$current-book) score))
    (else
-    ((ly:parser-lookup 'toplevel-score-handler) parser score))))
+    ((ly:parser-lookup 'toplevel-score-handler) score))))
 
 (define-public paper-variable
   (let
       ((get-papers
-        (lambda (parser book)
+        (lambda (book)
           (append (if (and book (ly:output-def? (ly:book-paper book)))
                       (list (ly:book-paper book))
                       '())
                   (ly:parser-lookup '$papers)
                   (list (ly:parser-lookup '$defaultpaper))))))
     (make-procedure-with-setter
-     (lambda (parser book symbol)
+     (lambda (book symbol)
        (any (lambda (p) (ly:output-def-lookup p symbol #f))
-            (get-papers parser book)))
-     (lambda (parser book symbol value)
+            (get-papers book)))
+     (lambda (book symbol value)
        (ly:output-def-set-variable!
-        (car (get-papers parser book))
+        (car (get-papers book))
         symbol value)))))
 
 (define-public (add-text text)

diff --git a/scm/music-functions.scm b/scm/music-functions.scm
index 176f08efcf98ca11cf185903e312a5f3c346892d..88b87f3519b0eeff37523b78b2a949296267a79b 100644 (file)
--- a/scm/music-functions.scm
+++ b/scm/music-functions.scm
@@ -475,11 +475,10 @@ respectively."
                    (<= min (length res))))
           res
           (begin
-            (if parser
-                (ly:parser-error
-                                 (format #f (_ "bad grob property path ~a")
-                                         path)
-                                 location))
+            (ly:parser-error
+             (format #f (_ "bad grob property path ~a")
+                     path)
+             location)
             #f)))))
 
 (define-public (make-grob-property-set grob gprop val)
@@ -1287,7 +1286,7 @@ then revert skipTypesetting."
     (context-spec-music (make-property-set 'skipTypesetting (not bool))
                         'Score))))
 
-(define (skip-as-needed music parser)
+(define (skip-as-needed music)
   "Replace MUSIC by
  << {  \\set skipTypesetting = ##f
  LENGTHOF(\\showFirstLength)
@@ -1351,24 +1350,21 @@ then revert skipTypesetting."
 
 (define-session-public toplevel-music-functions
   (list
-   (lambda (music parser) (expand-repeat-chords!
-                           (cons 'rhythmic-event
-                                 (ly:parser-lookup '$chord-repeat-events))
-                           music))
-   (lambda (music parser) (expand-repeat-notes! music))
-   (lambda (music parser) (voicify-music music))
-   (lambda (x parser) (music-map music-check-error x))
-   (lambda (x parser) (music-map precompute-music-length x))
-   (lambda (music parser)
-
+   (lambda (music) (expand-repeat-chords!
+                    (cons 'rhythmic-event
+                          (ly:parser-lookup '$chord-repeat-events))
+                    music))
+   expand-repeat-notes!
+   voicify-music
+   (lambda (x) (music-map music-check-error x))
+   (lambda (x) (music-map precompute-music-length x))
+   (lambda (music)
      (music-map (quote-substitute (ly:parser-lookup 'musicQuotes))  music))
 
    ;; switch-on-debugging
-   (lambda (x parser) (music-map cue-substitute x))
+   (lambda (x) (music-map cue-substitute x))
 
-   (lambda (x parser)
-     (skip-as-needed x parser)
-     )))
+   skip-as-needed))
 
 ;;;;;;;;;;
 ;;; general purpose music functions
@@ -1984,12 +1980,10 @@ recursing into matches themselves."
          (any (lambda (t) (music-is-of-type? m t)) type))
        (lambda (m) (music-is-of-type? m type)))))
 
-(define*-public (event-chord-wrap! music #:optional)
+(define*-public (event-chord-wrap! music)
   "Wrap isolated rhythmic events and non-postevent events in
-@var{music} inside of an @code{EventChord}.  If the optional
-@var{parser} argument is given, chord repeats @samp{q} are expanded
-using the default settings.  Otherwise, you need to cater for them
-yourself."
+@var{music} inside of an @code{EventChord}.  Chord repeats @samp{q}
+are expanded using the default settings of the parser."
   (map-some-music
    (lambda (m)
      (cond ((music-is-of-type? m 'event-chord)
@@ -2006,12 +2000,11 @@ yourself."
                   (set! (ly:music-property m 'articulations) '()))
               (make-event-chord (cons m arts))))
            (else #f)))
-   (if parser
-       (expand-repeat-chords!
-        (cons 'rhythmic-event
-              (ly:parser-lookup '$chord-repeat-events))
-        music)
-       music)))
+   (expand-repeat-chords!
+    (cons 'rhythmic-event
+          (ly:parser-lookup '$chord-repeat-events))
+    music)
+   music))
 
 (define-public (event-chord-notes event-chord)
   "Return a list of all notes from @var{event-chord}."

diff --git a/scm/paper.scm b/scm/paper.scm
index 55932e46ebd3397492f5297d23dc2290d0e0fa8e..438cf80975d65f41a63fa0459e44219f6cd6f576 100644 (file)
--- a/scm/paper.scm
+++ b/scm/paper.scm
@@ -106,7 +106,6 @@
 (define-safe-public (set-global-staff-size sz)
   "Set the default staff size, where SZ is thought to be in PT."
   (let* ((current-mod (current-module))
-         (parser (eval 'parser current-mod))
          (pap (ly:parser-lookup '$defaultpaper))
          (in-layout? (or (module-defined? current-mod 'is-paper)
                          (module-defined? current-mod 'is-layout)))

diff --git a/scm/parser-ly-from-scheme.scm b/scm/parser-ly-from-scheme.scm
index 37bc4fcbc695c6896c6f47d82741a56fe6a2b65c..3a73e28c3558edf40c458dff821d82bcdc45c832 100644 (file)
--- a/scm/parser-ly-from-scheme.scm
+++ b/scm/parser-ly-from-scheme.scm
@@ -65,7 +65,7 @@ from @var{port} and return the corresponding Scheme music expression.
                                        (set! closures
                                              (cons `(cons ,p (lambda () ,expr))
                                                    closures)))))))))))
-    (define (embedded-lilypond parser lily-string filename line
+    (define (embedded-lilypond lily-string filename line
                                closures location)
       (let* ((clone (ly:parser-clone closures location))
              (result (ly:parse-string-expression clone lily-string
@@ -74,7 +74,7 @@ from @var{port} and return the corresponding Scheme music expression.
             (ly:parser-error (_ "error in #{ ... #}")))
         result))
     (list embedded-lilypond
-          (list *parser*) lily-string filename line
+          lily-string filename line
           (cons 'list (reverse! closures))
           (list *location*))))