;;;; lily-library.scm -- utilities
;;;;
;;;; source file of the GNU LilyPond music typesetter
-;;;;
+;;;;
;;;; (c) 1998--2009 Jan Nieuwenhuizen <janneke@gnu.org>
;;;; Han-Wen Nienhuys <hanwen@xs4all.nl>
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; moments
-(define-public ZERO-MOMENT (ly:make-moment 0 1))
+(define-public ZERO-MOMENT (ly:make-moment 0 1))
(define-public (moment-min a b)
(if (ly:moment<? a b) a b))
+(define-public (moment<=? a b)
+ (or (equal? a b)
+ (ly:moment<? a b)))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; arithmetic
(define-public (average x . lst)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; parser <-> output hooks.
-
+
(define-public (collect-bookpart-for-book parser book-part)
"Toplevel book-part handler"
(define (add-bookpart book-part)
(define-public (scorify-music music parser)
"Preprocess MUSIC."
-
+
(for-each (lambda (func)
(set! music (func music parser)))
toplevel-music-functions)
(hash-fold (lambda (k v acc) (acons k v acc))
'() t))
-;; todo: code dup with C++.
+;; todo: code dup with C++.
(define-safe-public (alist->hash-table lst)
"Convert alist to table"
(let ((m (make-hash-table (length lst))))
(define (split-list lst n)
"Split LST in N equal sized parts"
-
+
(define (helper todo acc-vector k)
(if (null? todo)
acc-vector
(begin
(if (< k 0)
(set! k (+ n k)))
-
+
(vector-set! acc-vector k (cons (car todo) (vector-ref acc-vector k)))
(helper (cdr todo) acc-vector (1- k)))))
(reverse (helper lst '() 1)))
-
+
(define-public (list-join lst intermediate)
"put INTERMEDIATE between all elts of LST."
(define (flatten-list lst)
- "Unnest LST"
+ "Unnest LST"
(if (null? lst)
'()
(if (pair? (car lst))
(define-public (uniq-list lst)
"Uniq LST, assuming that it is sorted. Uses equal? for comparisons."
- (reverse!
+ (reverse!
(fold (lambda (x acc)
(if (null? acc)
(list x)
Example: (split-at-predicate < '(1 2 3 2 1)) ==> ((1 2 3) . (2 1))"
(if (null? lst)
(list lst)
- (let ((i (list-index predicate (cdr lst) lst)))
+ (let ((i (list-index pred (cdr lst) lst)))
(if i
(cons (take lst (1+ i)) (drop lst (1+ i)))
(list lst)))))
(define-public (offset-add a b)
(cons (+ (car a) (car b))
- (+ (cdr a) (cdr b))))
+ (+ (cdr a) (cdr b))))
(define-public (offset-flip-y o)
(cons (car o) (- (cdr o))))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; intervals
+(define-public empty-interval '(+inf.0 . -inf.0))
+
(define-public (interval-length x)
"Length of the number-pair X, when an interval"
(max 0 (- (cdr x) (car x))))
(define-public (interval-index interval dir)
"Interpolate INTERVAL between between left (DIR=-1) and right (DIR=+1)"
-
+
(* (+ (interval-start interval) (interval-end interval)
(* dir (- (interval-end interval) (interval-start interval))))
0.5))
(inf? (cdr i))
(> (car i) (cdr i)))))
+(define-public (add-point interval p)
+ (cons (min (interval-start interval) p)
+ (max (interval-end interval) p)))
+
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; string
(equal? suffix (substring s
(max 0 (- (string-length s) (string-length suffix)))
(string-length s))))
-
+
(define-public (string-startswith s prefix)
(equal? prefix (substring s 0 (min (string-length s) (string-length prefix)))))
-
+
(define-public (string-encode-integer i)
(cond
((= i 0) "o")
(fold-right conc #f lst))
(define-public (string-regexp-substitute a b str)
- (regexp-substitute/global #f a str 'pre b 'post))
+ (regexp-substitute/global #f a str 'pre b 'post))
(define (regexp-split str regex)
(define matches '())
(reverse matches))
;;;;;;;;;;;;;;;;
-; other
+;; other
+
(define (sign x)
(if (= x 0)
0
(if (< x 0) -1 1)))
+(define-public (binary-search start end getter target-val)
+ (_i "Find the index between @var{start} and @var{end} (an integer)
+which will produce the closest match to @var{target-val} when
+applied to function @var{getter}.")
+ (if (<= end start)
+ start
+ (let* ((compare (quotient (+ start end) 2))
+ (get-val (getter compare)))
+ (cond
+ ((< target-val get-val)
+ (set! end (1- compare)))
+ ((< get-val target-val)
+ (set! start (1+ compare))))
+ (binary-search start end getter target-val))))
(define-public (car< a b)
(< (car a) (car b)))
(string<? (symbol->string (car lst)) (symbol->string (car r))))
;;
-;; don't confuse users with #<procedure .. > syntax.
-;;
+;; don't confuse users with #<procedure .. > syntax.
+;;
(define-public (scm->string val)
(if (and (procedure? val)
(symbol? (procedure-name val)))
;;; FONT may be font smob, or pango font string...
(define-public (font-name-style font)
- ;; FIXME: ughr, (ly:font-name) sometimes also has Style appended.
+ ;; FIXME: ughr, barf: feta-alphabet is actually emmentaler
+ (if (and (string? font)
+ (string-prefix? "feta-alphabet" font))
+ (string-append "emmentaler"
+ "-"
+ (substring font
+ (string-length "feta-alphabet")
+ (string-length font)))
(let* ((font-name (ly:font-name font))
- (full-name (if font-name font-name (ly:font-file-name font)))
- (name-style (string-split full-name #\-)))
- ;; FIXME: ughr, barf: feta-alphabet is actually emmentaler
- (if (string-prefix? "feta-alphabet" full-name)
- (list "emmentaler"
- (substring full-name (string-length "feta-alphabet")))
- (if (not (null? (cdr name-style)))
- name-style
- (append name-style '("Regular"))))))
+ (full-name (if font-name font-name (ly:font-file-name font))))
+ (if (string-prefix? "Aybabtu" full-name)
+ "aybabtu"
+ (string-downcase full-name)))))
(define-public (modified-font-metric-font-scaling font)
(let* ((designsize (ly:font-design-size font))
(define-public (version-not-seen-message input-file-name)
(ly:message
- "~a:0: ~a ~a"
+ "~a:0: ~a ~a"
input-file-name
(_ "warning:")
(format #f
(define-public (old-relative-not-used-message input-file-name)
(ly:message
- "~a:0: ~a ~a"
+ "~a:0: ~a ~a"
input-file-name
(_ "warning:")
(_ "old relative compatibility not used")))