(use-modules (srfi srfi-39)
(scm display-lily))
-(define*-public (display-lily-music expr parser #:optional (port (current-output-port))
+(define*-public (display-lily-music expr #:optional (port (current-output-port))
#:key force-duration)
"Display the music expression using LilyPond syntax"
(memoize-clef-names supported-clefs)
(parameterize ((*indent* 0)
- (*previous-duration* (ly:make-duration 2))
- (*force-duration* force-duration))
- (display (music->lily-string expr parser) port)
+ (*omit-duration* #f))
+ (display (music->lily-string expr) port)
(newline port)))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(body (ly:music-property tremolo 'element))
(children (if (music-is-of-type? body 'sequential-music)
;; \repeat tremolo n { ... }
- (length (extract-named-music body '(EventChord
- NoteEvent)))
+ (count duration-of-note ; do not count empty <>
+ (extract-named-music body
+ '(EventChord NoteEvent)))
;; \repeat tremolo n c4
1))
(tremolo-type (if (positive? children)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; property setting music objs.
-(define-safe-public (check-grob-path path #:optional parser location
+(define-safe-public (check-grob-path path #:optional location
#:key
(start 0)
default
res
(begin
(if parser
- (ly:parser-error parser
+ (ly:parser-error
(format #f (_ "bad grob property path ~a")
path)
location))
(defmacro-public def-grace-function (start stop . docstring)
"Helper macro for defining grace music"
- `(define-music-function (parser location music) (ly:music?)
+ `(define-music-function (music) (ly:music?)
,@docstring
(make-music 'GraceMusic
- 'origin location
'element (make-music 'SequentialMusic
'elements (list (ly:music-deep-copy ,start)
music
(defmacro-public define-syntax-function (type args signature . body)
"Helper macro for `ly:make-music-function'.
Syntax:
- (define-syntax-function result-type? (parser location arg1 arg2 ...) (arg1-type arg2-type ...)
+ (define-syntax-function result-type? (arg1 arg2 ...) (arg1-type arg2-type ...)
...function body...)
argX-type can take one of the forms @code{predicate?} for mandatory
predicates, to be used in case of a type error in arguments or
result."
+ (define (has-parser/location? arg where)
+ (let loop ((arg arg))
+ (if (list? arg)
+ (any loop arg)
+ (memq arg where))))
(define (currying-lambda args doc-string? body)
(if (and (pair? args)
(pair? (car args)))
(currying-lambda (car args) doc-string?
`((lambda ,(cdr args) ,@body)))
- `(lambda ,args
- ,(format #f "~a\n~a" (cddr args) (or doc-string? ""))
- ,@body)))
-
- (set! signature (map (lambda (pred)
- (if (pair? pred)
- `(cons ,(car pred)
- ,(and (pair? (cdr pred)) (cadr pred)))
- pred))
- (cons type signature)))
+ (let* ((compatibility? (if (list? args)
+ (= (length args) (+ 2 (length signature)))
+ (and (pair? args) (pair? (cdr args))
+ (eq? (car args) 'parser))))
+ (realargs (if compatibility? (cddr args) args)))
+ `(lambda ,realargs
+ ,(format #f "~a\n~a" realargs (or doc-string? ""))
+ ,@(if (and compatibility?
+ (has-parser/location? body (take args 2)))
+ `((let ((,(car args) (*parser*)) (,(cadr args) (*location*)))
+ ,@body))
+ body)))))
(let ((docstring
(and (pair? body) (pair? (cdr body))
;; When the music function definition contains an i10n doc string,
;; (_i "doc string"), keep the literal string only
`(ly:make-music-function
- (list ,@signature)
+ (list ,@(map (lambda (pred)
+ (if (pair? pred)
+ `(cons ,(car pred)
+ ,(and (pair? (cdr pred)) (cadr pred)))
+ pred))
+ (cons type signature)))
,(currying-lambda args docstring (if docstring (cdr body) body)))))
(defmacro-public define-music-function rest
"Defining macro returning music functions.
Syntax:
- (define-music-function (parser location arg1 arg2 ...) (arg1-type? arg2-type? ...)
+ (define-music-function (arg1 arg2 ...) (arg1-type? arg2-type? ...)
...function body...)
argX-type can take one of the forms @code{predicate?} for mandatory
(defmacro-public define-scheme-function rest
"Defining macro returning Scheme functions.
Syntax:
- (define-scheme-function (parser location arg1 arg2 ...) (arg1-type? arg2-type? ...)
+ (define-scheme-function (arg1 arg2 ...) (arg1-type? arg2-type? ...)
...function body...)
argX-type can take one of the forms @code{predicate?} for mandatory
(defmacro-public define-event-function rest
"Defining macro returning event functions.
Syntax:
- (define-event-function (parser location arg1 arg2 ...) (arg1-type? arg2-type? ...)
+ (define-event-function (arg1 arg2 ...) (arg1-type? arg2-type? ...)
...function body...)
argX-type can take one of the forms @code{predicate?} for mandatory
the 'length property of the music is
overridden to speed up compiling."
(let*
- ((show-last (ly:parser-lookup parser 'showLastLength))
- (show-first (ly:parser-lookup parser 'showFirstLength))
+ ((show-last (ly:parser-lookup 'showLastLength))
+ (show-first (ly:parser-lookup 'showFirstLength))
(show-last-length (and (ly:music? show-last)
(ly:music-length show-last)))
(show-first-length (and (ly:music? show-first)
(list
(lambda (music parser) (expand-repeat-chords!
(cons 'rhythmic-event
- (ly:parser-lookup parser '$chord-repeat-events))
+ (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 precompute-music-length x))
(lambda (music parser)
- (music-map (quote-substitute (ly:parser-lookup parser 'musicQuotes)) music))
+ (music-map (quote-substitute (ly:parser-lookup 'musicQuotes)) music))
;; switch-on-debugging
(lambda (x parser) (music-map cue-substitute x))
(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 parser)
+(define*-public (event-chord-wrap! music #:optional)
"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
(if parser
(expand-repeat-chords!
(cons 'rhythmic-event
- (ly:parser-lookup parser '$chord-repeat-events))
+ (ly:parser-lookup '$chord-repeat-events))
music)
music)))
projects / lilypond.git / blobdiff