Merge branch 'master' into translation

[lilypond.git] / scm / translation-functions.scm

diff --git a/scm/translation-functions.scm b/scm/translation-functions.scm
index 78defd203f741043f5546eb4b41397c018699c6c..49d8768eb40500c9b1a65c1e9625adfb66e43f9e 100644 (file)
--- a/scm/translation-functions.scm
+++ b/scm/translation-functions.scm
@@ -20,10 +20,10 @@
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; clefs
 
-(define-public (clef-octavation-markup oct style)
-  "The octavation sign formatting function.  @var{oct} is supposed to be
-a string holding the octavation number, @var{style} determines the
-way the octavation number is displayed."
+(define-public (clef-transposition-markup oct style)
+  "The transposition sign formatting function.  @var{oct} is supposed to be
+a string holding the transposition number, @var{style} determines the
+way the transposition number is displayed."
   (let* ((delim (if (symbol? style)
                     (case style
                       ((parenthesized) (cons "(" ")"))
@@ -282,6 +282,12 @@ dot placement entries."
     (length (filter (lambda (x) (not (null? x)))
                     art-list)))
 
+  (define (string-number event)
+    "Get the string-number from @var{event}.  Return @var{#f}
+if no string-number is present."
+    (let ((num (ly:event-property event 'string-number)))
+      (and (integer? num) (positive? num) num)))
+
   (define (determine-frets-and-strings
            notes
            defined-strings
@@ -325,14 +331,6 @@ if no fingering is present."
             articulations)
        finger-found))
 
-    (define (string-number event)
-      "Get the string-number from @var{event}.  Return @var{#f}
-if no string-number is present."
-      (let ((num (ly:event-property event 'string-number)))
-       (if (number? num)
-         num
-         #f)))
-
     (define (delete-free-string string)
       (if (number? string)
        (set! free-strings
@@ -340,25 +338,18 @@ if no string-number is present."
 
     (define (close-enough fret)
       "Decide if @var{fret} is acceptable, given the already used frets."
-      (if (null? specified-frets)
-       #t
-       (reduce
-         (lambda (x y)
-           (and x y))
-         #t
-         (map (lambda (specced-fret)
-                (or (eq? 0 specced-fret)
-                    (and (not restrain-open-strings)
-                    (eq? 0 fret))
-                    (>= maximum-stretch (abs (- fret specced-fret)))))
-              specified-frets))))
+      (every (lambda (specced-fret)
+               (or (zero? specced-fret)
+                   (zero? fret)
+                   (>= maximum-stretch (abs (- fret specced-fret)))))
+             specified-frets))
 
     (define (string-qualifies string pitch)
       "Can @var{pitch} be played on @var{string}, given already placed
 notes?"
       (let* ((fret (calc-fret pitch string tuning)))
        (and (or (and (not restrain-open-strings)
-                     (eq? fret 0))
+                     (zero? fret))
                 (>= fret minimum-fret))
             (integer? fret)
             (close-enough fret))))
@@ -367,7 +358,7 @@ notes?"
       "Is @var{pitch} and open-string note on @var{string}, given
 the current tuning?"
       (let* ((fret (calc-fret pitch string tuning)))
-       (eq? fret 0)))
+       (zero? fret)))
 
     (define (set-fret! pitch-entry string finger)
       (let ((this-fret (calc-fret (car pitch-entry)
@@ -396,22 +387,14 @@ the current tuning?"
                   defined-strings defined-fingers))
 
     ;;; body of determine-frets-and-strings
-    (let* ((pitch-alist (apply (lambda (mylist)
-                                 (let ((index -1))
-                                   (map (lambda (note)
-                                          (begin
-                                            (set! index (1+ index))
-                                            (cons (note-pitch note)
-                                                  index)))
-                                        mylist)))
-                               notes '()))
-           (pitches (map note-pitch notes)))
+    (let* ((pitches (map note-pitch notes))
+           (pitch-alist (map cons pitches (iota (length pitches)))))
 
       ;; handle notes with strings assigned and fingering of 0
       (for-each
         (lambda (pitch-entry string-fret-finger)
          (let* ((string (list-ref string-fret-finger 0))
-                 (finger (if (eq? (length string-fret-finger) 3)
+                 (finger (if (= (length string-fret-finger) 3)
                              (list-ref string-fret-finger 2)
                              '()))
                  (pitch (car pitch-entry))
@@ -419,8 +402,8 @@ the current tuning?"
                            #f
                            finger)))
            (if (or (not (null? string))
-                   (eq? digit 0))
-               (if (eq? digit 0)
+                   (eqv? digit 0))
+               (if (eqv? digit 0)
                     ;; here we handle fingers of 0 -- open strings
                    (let ((fit-string
                            (find (lambda (string)
@@ -469,7 +452,7 @@ the current tuning?"
        (let* ((string-fret-finger (list-ref string-fret-fingers
                                              (cdr pitch-entry)))
                (string (list-ref string-fret-finger 0))
-               (finger (if (eq? (length string-fret-finger) 3)
+               (finger (if (= (length string-fret-finger) 3)
                            (list-ref string-fret-finger 2)
                            '()))
                (pitch (car pitch-entry))
@@ -527,7 +510,7 @@ chords.  Returns a placement-list."
          (defined-strings (map (lambda (x)
                                  (if (null? x)
                                      x
-                                     (ly:event-property x 'string-number)))
+                                     (or (string-number x) '())))
                                (car specified-info)))
          (defined-fingers (map (lambda (x)
                                  (if (null? x)