Handling of open strings in tablature

scm/translation-functions.scm

 ;;;; This file is part of LilyPond, the GNU music typesetter.
 ;;;;
 ;;;; (c) 1998--2012 Han-Wen Nienhuys <hanwen@xs4all.nl>
 ;;;;                 Jan Nieuwenhuizen <janneke@gnu.org>
 ;;;;
 ;;;; LilyPond is free software: you can redistribute it and/or modify
 ;;;; it under the terms of the GNU General Public License as published by
 ;;;; the Free Software Foundation, either version 3 of the License, or
 ;;;; (at your option) any later version.
 ;;;;
@@ skipping 260 matching lines @@
             minimum-fret
             maximum-stretch
             tuning)
     "Determine the frets and strings used to play the notes in
 @var{notes}, given @var{defined-strings} and @var{defined-fingers}
 along with @var{minimum-fret}, @var{maximum-stretch}, and
 @var{tuning}.  Returns a list of @code{(string fret finger) lists."
 
 
     (define restrain-open-strings (ly:context-property context
-                                                     'restrainOpenStrings
-                                                     #f))
+                                                       'restrainOpenStrings
+                                                       #f))
     (define specified-frets '())
     (define free-strings (iota (length tuning) 1))
 
     (define (calc-fret pitch string tuning)
       "Calculate the fret to play @var{pitch} on @var{string} with
 @var{tuning}."
       (- (ly:pitch-semitones pitch) (ly:pitch-semitones (list-ref tuning (1- string)))))
 
     (define (note-pitch note)
       "Get the pitch (in semitones) from @var{note}."
@@ skipping 30 matching lines @@
     (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))
+                     (and (not restrain-open-strings)
+                     (eq? 0 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))
-             (>= fret minimum-fret))
+                      (eq? fret 0))
+                 (>= fret minimum-fret))
              (close-enough fret))))
 
     (define (open-string string pitch)
       "Is @var{pitch} and open-string note on @var{string}, given
 the current tuning?"
       (let* ((fret (calc-fret pitch string tuning)))
         (eq? fret 0)))
 
     (define (set-fret! pitch-entry string finger)
       (let ((this-fret (calc-fret (car pitch-entry)
@@ skipping 339 matching lines @@
 with the subordinate symbols being interfaces."
   (let loop ((forms forms))
     (if (cheap-list? forms)
         `(list
           ,@(map (lambda (form)
                    (if (pair? (car form))
                        `(cons ',(caar form) (lambda ,(cdar form) ,@(cdr form)))
                        `(cons ',(car form) ,(loop (cdr form)))))
                  forms))
         forms)))